Build a Precision DIY Movement Sensor with the HLK-LD2410 mmWave Radar

If you are building a diy movement sensor for a smart home, desk occupancy tracker, or security rig in 2026, legacy PIR sensors will only get you so far. The definitive upgrade is the HLK-LD2410B 24GHz mmWave radar breakout board. Unlike passive infrared sensors that lose track of you when you sit still, this module detects micro-movements like breathing and outputs exact target distances via a digital UART stream. Priced around $6 to $9 per unit, it offers industrial-grade presence detection at a hobbyist price point, provided you know how to parse its high-speed data frames.

The Sensing Principle: 24GHz FMCW Radar

The HLK-LD2410B operates on Frequency-Modulated Continuous Wave (FMCW) radar principles. It continuously transmits a 24GHz microwave signal whose frequency increases linearly over time. When this signal strikes an object, the reflected wave mixes with the transmitted wave, creating a 'beat frequency.' By analyzing the phase shift and frequency difference between the transmitted and received signals, the onboard DSP calculates both the distance to the target and its radial velocity.

Because 24GHz waves easily penetrate plastics, drywall, and wood, the sensor does not require line-of-sight. More importantly, the phase resolution is sensitive enough to detect sub-millimeter displacements. This means it can distinguish between an empty room and a room containing a motionless, breathing human—a physical feat that standard Doppler microwave sensors (like the RCWL-0516) and PIR modules fundamentally cannot achieve.

Decision Path: Choosing the Right Movement Sensor

Not every project needs millimeter-wave radar. Use this decision matrix to select the correct hardware for your specific constraints, terminating in the optimal pick for high-fidelity presence tracking.

Hardware Wiring and Pinout Specifications

The raw HLK-LD2410 module is strictly 3.3V, but the widely available HLK-LD2410B breakout board includes an onboard LDO regulator and a 5V input pin, making it vastly easier to interface with standard maker boards. We will use an ESP32 DevKit V1 for this build, leveraging its native 3.3V logic and hardware UART capabilities.

Wiring Steps:

1. Disconnect power from your ESP32 and breadboard.
2. Connect the LD2410B VCC to the ESP32 5V pin, and GND to GND.
3. Cross the UART lines: Sensor TX to ESP32 GPIO 16; Sensor RX to ESP32 GPIO 17.
4. Connect the OUT pin to ESP32 GPIO 4 (configure as INPUT_PULLDOWN in code).
5. Verify all connections with a multimeter in continuity mode before applying power.

Output Signal Math: Raw UART Bytes to Physical Units

A common mistake in DIY radar projects is assuming the sensor outputs an analog voltage proportional to distance. It does not. The HLK-LD2410B outputs digital UART packets at a blistering 256,000 baud. To get physical units, you must parse the hexadecimal byte stream.

Every reporting frame begins with the header F4 F3 F2 F1 and ends with F8 F7 F6 F5. The payload contains the target state, moving distance, moving energy, static distance, and static energy.

Raw-to-Unit Conversion Math

The sensor reports distance in centimeters using little-endian byte ordering. If the UART buffer yields 0x64 in the lower byte and 0x00 in the higher byte for the moving target distance, the math is:

Raw_Little_Endian = (Byte_High << 8) | Byte_Low
Raw_Little_Endian = (0x00 << 8) | 0x64 = 100
Physical Distance = 100 cm (1.0 meters)

For configuration, the sensor divides its 6-meter range into 9 'gates'. Each gate represents exactly 0.75 meters. If you want to configure the sensor to ignore movement beyond 3 meters, you set the maximum gate index using this formula:

Gate_Index = Target_Distance_m / 0.75
Gate_Index = 3.0 / 0.75 = 4 (Set max gate to 4)

Calibration, Interference, and Real-World Tuning

Out of the box, the LD2410B is highly sensitive. In a real-world environment, you must calibrate the gate sensitivities and mitigate environmental interference to prevent 'ghost' triggers.

Common Interference Sources

• Metal Enclosures: 24GHz waves cannot penetrate sheet metal or aluminum foil tape. If you mount this in an aluminum project box, it will be entirely blind. Use ABS plastic or PETG enclosures.
• Water and Liquids: Water heavily absorbs 24GHz frequencies. Do not mount the sensor behind an aquarium, and avoid placing it near humidifiers where water droplets in the air can scatter the beam.
• Ceiling Fans and HVAC: Moving fan blades create massive Doppler shifts. If the sensor points upward, it will register the fan as a moving target. Use the UART configuration commands to lower the sensitivity of the specific distance gates covering the fan.

Complete ESP32 Arduino Parsing Code

Software serial will drop frames at 256,000 baud. You must use the ESP32's hardware UART. The following code initializes HardwareSerial(2), reads the frame, validates the header, and extracts the exact distance in centimeters.

#include <HardwareSerial.h>

// Use UART2 on ESP32 (GPIO 16 = RX, GPIO 17 = TX)
HardwareSerial radarSerial(2);

const int OUT_PIN = 4;

void setup() {
  Serial.begin(115200); // Debug monitor
  radarSerial.begin(256000, SERIAL_8N1, 16, 17);
  pinMode(OUT_PIN, INPUT_PULLDOWN);
  Serial.println('HLK-LD2410B Initialized...');
}

void loop() {
  // Quick check using the hardware OUT pin
  bool targetPresent = digitalRead(OUT_PIN) == HIGH;
  
  if (radarSerial.available() > 0) {
    uint8_t buffer[40];
    int bytesRead = radarSerial.readBytes(buffer, sizeof(buffer));
    
    // Look for the frame header: F4 F3 F2 F1
    for (int i = 0; i < bytesRead - 3; i++) {
      if (buffer[i] == 0xF4 && buffer[i+1] == 0xF3 && 
          buffer[i+2] == 0xF2 && buffer[i+3] == 0xF1) {
        
        // Data starts after header (4 bytes) and length bytes (2 bytes)
        // Target state is at offset +6
        uint8_t state = buffer[i + 6];
        
        // Moving distance is at offset +7 (Low byte) and +8 (High byte)
        uint16_t moveDist = (buffer[i + 8] << 8) | buffer[i + 7];
        uint8_t moveEnergy = buffer[i + 9];
        
        if (state == 0x01 || state == 0x03) {
          Serial.print('Moving Target | Distance: ');
          Serial.print(moveDist);
          Serial.print(' cm | Energy: ');
          Serial.println(moveEnergy);
        }
        break; // Processed one frame, exit loop
      }
    }
  }
}

By relying on the HLK-LD2410B and properly parsing its UART frames, your DIY movement sensor will transition from a basic binary trigger to a precision spatial awareness tool. Stick to the 5V breakout board, respect the 3.3V logic levels, and tune your distance gates to your specific room geometry for flawless static and dynamic presence detection.