Building a Reliable Arduino Movement Sensor with 24GHz mmWave Radar

Why Standard PIR Fails: The Case for mmWave

If you have ever sat perfectly still on the couch reading a book, only to have your smart lights snap off because the room "empty" triggered, you have experienced the fundamental limitation of Passive Infrared (PIR) sensors. PIR modules like the ubiquitous HC-SR501 do not detect presence; they detect changes in infrared radiation across their Fresnel lens array. For a truly reliable arduino movement sensor that registers both active motion and stationary human presence, you need Frequency-Modulated Continuous Wave (FMCW) mmWave radar.

According to Texas Instruments' mmWave radar whitepaper, 24GHz and 60GHz FMCW radars measure the phase shift of reflected RF waves, allowing them to detect micro-movements like breathing or typing, even when the target is entirely stationary. Below is a data-dense comparison of the most common movement sensor modules available to makers in 2026.

Hardware BOM and Pin Mapping

For this build, we are bypassing the classic Arduino Uno R3. The HLK-LD2410 operates at a default UART baud rate of 256,000 bps. The Uno's ATmega328P cannot reliably handle this speed via SoftwareSerial, and using its hardware serial pins (0 and 1) conflicts with the USB debug monitor. Furthermore, the LD2410 uses 3.3V logic; feeding it 5V from an Uno's TX pin will permanently brick the sensor's internal ESP32-C3 chip.

Instead, we will use the ESP32 DevKit V1 (ESP32-WROOM-32 variant). It natively operates at 3.3V (no logic level shifters required), features multiple hardware UARTs via SERCOM, and has ample processing headroom for frame parsing.

Step-by-Step Wiring Procedure

1. De-energize the workspace: Unplug the ESP32 USB cable before inserting it into the breadboard to prevent accidental shorting of the 5V rail.
2. Seat the ESP32: Insert the ESP32 DevKit V1 across the breadboard's center trench. Ensure the 3.3V and 5V rails are clearly marked with tape to avoid cross-wiring.
3. Power the Radar: Connect the HLK-LD2410 VCC to the ESP32 VIN pin. Connect the sensor GND to the breadboard ground rail.
4. Route UART Lines: Connect Sensor TX to ESP32 GPIO 16. Connect Sensor RX to ESP32 GPIO 17. Remember: TX always goes to RX, never TX to TX.
5. Verify Voltages: Before plugging in USB, use a multimeter in continuity mode to verify there is no short between VCC and GND on the sensor header.

Complete UART Code with Frame Parsing

The HLK-LD2410 streams data in structured frames. A standard reporting frame begins with the header F4 F3 F2 F1, followed by the data length, the payload (which includes target state, moving distance, and stationary distance), a checksum, and the footer 04 03 02 01. The code below targets the ESP32 DevKit V1 and uses Hardware Serial 1 to parse these frames natively without relying on third-party libraries.

#include <HardwareSerial.h>

// Pin Definitions for ESP32 DevKit V1
#define RADAR_RX 16
#define RADAR_TX 17
#define RADAR_BAUD 256000

// Frame Markers
const uint8_t FRAME_HEADER[4] = {0xF4, 0xF3, 0xF2, 0xF1};
const uint8_t FRAME_FOOTER[4] = {0x04, 0x03, 0x02, 0x01};

HardwareSerial radarSerial(1);

uint8_t buffer[64];
int bufferIndex = 0;
unsigned long lastFrameTime = 0;

void setup() {
  Serial.begin(115200); // Debug monitor
  radarSerial.begin(RADAR_BAUD, SERIAL_8N1, RADAR_RX, RADAR_TX);
  Serial.println("[SYS] ESP32 UART Initialized. Waiting for LD2410...");
}

void loop() {
  while (radarSerial.available()) {
    uint8_t b = radarSerial.read();
    
    // Simple state machine to catch the header
    if (bufferIndex < 4) {
      if (b == FRAME_HEADER[bufferIndex]) {
        buffer[bufferIndex++] = b;
      } else {
        bufferIndex = 0; // Reset if header breaks
      }
    } else {
      buffer[bufferIndex++] = b;
      
      // Prevent buffer overflow
      if (bufferIndex >= 64) {
        Serial.println("[ERR] UART Buffer Overflow: Frame exceeded 64 bytes.");
        bufferIndex = 0;
        continue;
      }
      
      // Check for footer
      if (bufferIndex >= 8 && 
          buffer[bufferIndex-4] == FRAME_FOOTER[0] && 
          buffer[bufferIndex-3] == FRAME_FOOTER[1] && 
          buffer[bufferIndex-2] == FRAME_FOOTER[2] && 
          buffer[bufferIndex-1] == FRAME_FOOTER[3]) {
        
        parseFrame();
        bufferIndex = 0;
        lastFrameTime = millis();
      }
    }
  }
  
  // Timeout check
  if (millis() - lastFrameTime > 2000 && lastFrameTime != 0) {
    Serial.println("[ERR] No UART data received after 2000ms. Check wiring.");
    lastFrameTime = 0;
  }
}

void parseFrame() {
  // Data type byte is at index 4 (after 4-byte header and 2-byte length)
  // For simplicity, we extract the Target State byte (index 9 in standard engineering mode frame)
  // Note: Exact indices depend on reporting mode. This assumes basic target reporting.
  if (buffer[8] == 0x02) { // Engineering mode data frame identifier
    uint8_t targetState = buffer[9]; // 0x00=Empty, 0x01=Moving, 0x02=Stationary, 0x03=Both
    
    // Distances are 16-bit little-endian integers starting at index 10 and 13
    uint16_t moveDist = buffer[10] | (buffer[11] << 8);
    uint16_t staticDist = buffer[13] | (buffer[14] << 8);
    
    Serial.print("[DATA] State: ");
    if (targetState == 0x00) Serial.print("Empty ");
    else if (targetState == 0x01) Serial.print("Moving ");
    else if (targetState == 0x02) Serial.print("Stationary ");
    else Serial.print("Moving+Static ");
    
    Serial.print("| Move Dist: "); Serial.print(moveDist); Serial.print("cm ");
    Serial.print("| Static Dist: "); Serial.print(staticDist); Serial.println("cm");
  }
}

Debugging: The First Three Things to Check

When working with high-speed UART and RF modules, silent failures are common. If your serial monitor outputs [ERR] LD2410 Frame Header Missing or Corrupt or simply hangs, follow this ranked diagnostic path.

1. Verify the Baud Rate Mismatch (Most Common): The factory default baud rate for the HLK-LD2410 is 256,000. If you previously connected the sensor to your phone via the HiLink Bluetooth app and changed the baud rate to 115200, the code above will fail to sync. Fix: Open the app and reset the sensor to factory defaults, or change #define RADAR_BAUD 256000 to match your custom setting.
2. Check for Power Brownouts: The ESP32's onboard AMS1117-3.3 voltage regulator can overheat if the radar pulls 150mA peaks while the ESP32 is transmitting WiFi. Fix: Put your multimeter in DC Voltage mode across the sensor's VCC and GND pins. If you read < 4.5V during a sweep, your USB cable is suffering from voltage drop. Switch to a shorter, thicker USB cable or power the ESP32 via the barrel jack with a 7V 2A supply.
3. Audit the TX/RX Cross: It sounds elementary, but UART requires a crossover. Fix: Trace the wires. ESP32 GPIO 16 (RX) must physically connect to the sensor's TX pin. If you see a solid 3.3V on the ESP32 RX pin with a multimeter but no data in the serial monitor, you have likely wired TX to TX, causing a bus collision.

Extending and Simplifying the Build

Once your arduino movement sensor is reliably parsing UART frames on the bench, you have two distinct paths for deployment depending on your end goal.

How to Extend: Home Assistant Integration

To push this from a bench toy to a production smart home node, flash the ESP32 with ESPHome. ESPHome has a native C++ component for the LD2410 that handles the UART parsing, Bluetooth configuration, and MQTT publishing automatically. You will gain access to granular "gates" (the radar divides the room into 0.75m zones) and can trigger automations based on exactly where in the room the movement is occurring, rather than just a binary presence flag.

How to Simplify: The Low-Power Alternative

If your project is a battery-powered intrusion alarm rather than a smart lighting controller, the LD2410 is overkill. Its 150mA current draw will drain a 2000mAh 18650 cell in less than 14 hours. Simplify the build by swapping to an AM312 Mini PIR. It draws a mere 10 microamps, operates on 3.3V natively, and outputs a simple GPIO HIGH on motion. You lose stationary detection, but you gain months of battery life and eliminate UART parsing entirely.

Safety & Compliance Note: While the HLK-LD2410 transmits at a very low power (~10dBm) and is generally exempt from strict FCC Part 15 licensing for hobbyist use, always ensure the radar's RF window is not covered by metal or conductive paint, which can detune the antenna array and cause localized RF reflections.