LD2410B Human Presence Sensor

View on Amazon
Overview
About LD2410B Human Presence Sensor
The LD2410B is an upgraded version of the popular LD2410 millimeter-wave radar sensor. It includes all the presence detection features of the original model-such as stationary and moving human detection using 24GHz radar technology-while adding integrated Bluetooth Low Energy (BLE) for wireless configuration. This eliminates the need for wired UART access during setup, simplifying installation and tuning. Like its predecessor, the LD2410B is ideal for smart home applications such as lighting automation, security, and HVAC systems. Learn more about the original sensor at LD2410.
Get Your LD2410B
💡 Prices are subject to change. We earn from qualifying purchases as an Amazon Associate.
LD2410B Specifications
Complete technical specification details for LD2410B Human Presence Sensor
📊 Technical Parameters
LD2410B Pinout
The **LD2410B** is a 5-pin 24GHz mmWave radar sensor with Bluetooth configuration:
Visual Pinout Diagram

Pin Types
Quick Tips
**Interface**: UART (256000 baud) + Bluetooth LE,📡 **Technology**: 24GHz FMCW radar with integrated BLE,👤 **Detection**: Both stationary and moving human targets,📏 **Range**: Up to 6 meters (improved from LD2410)
**Field of View**: ±60° detection angle,📱 **Bluetooth**: BLE for wireless configuration (HiLink app),🎚️ **Gates**: Configurable distance gates (0.2m or 0.75m resolution)
**Power**: 5V DC, stable power required,📊 **Pin Spacing**: 1.27mm (compact design),🎯 **Applications**: Smart lighting, occupancy sensing, HVAC control, security systems
Pin Descriptions
| Pin Name | Type | Description | Notes |
|---|---|---|---|
1 VCC | Power | Power input | 5V DC |
2 GND | Power | Ground connection | |
3 TX | Communication | UART transmit | Sends data from sensor (connect to ESP32 RX) |
4 RX | Communication | UART receive | Receives commands (connect to ESP32 TX) |
5 OUT | Communication | Digital presence output | HIGH when presence detected (optional) |
Wiring LD2410B to ESP32
To interface the **LD2410B** with an **ESP32** for human presence detection via UART:
Visual Wiring Diagram

Connection Status
Protocol
Pin Connections
| LD2410B Pin | Connection | ESP32 Pin | Description |
|---|---|---|---|
1 VCC Required | 5V | Power supply (5V) | |
2 GND Required | GND | Ground | |
3 TX Required | GPIO16 (RX2) | Sensor transmit to ESP32 receive | |
4 RX Required | GPIO17 (TX2) | Sensor receive from ESP32 transmit | |
5 OUT Optional | GPIO18 | Digital presence output (optional) |
**UART2**: Use UART2 on ESP32 (GPIO16/17 are default UART2 pins)
**Baud Rate**: 256000 bps - must match in firmware configuration
**Power**: Requires stable 5V supply (power even when using BLE)
**TX/RX**: Connect sensor TX to ESP32 RX, sensor RX to ESP32 TX
**OUT Pin**: Optional digital output goes HIGH on presence detection
**Bluetooth Setup**: Use HiLink/HLK Radar BLE app for wireless configuration
**BLE vs UART**: BLE and UART cannot operate simultaneously on most firmware
**Workflow**: Configure via BLE, then use UART for continuous operation
LD2410B Troubleshooting
Common issues and solutions to help you get your sensor working
Common Issues
Issue: The sensor does not appear in the BLE scanner app during setup.
Ensure the module is powered and not actively communicating via UART. BLE is typically disabled during UART operation. Power cycle the sensor without a UART connection and scan again.
Issue: ESP32 receives no UART data from the sensor.
Confirm correct wiring of TX/RX and check that BLE mode is not interfering. BLE and UART should not operate simultaneously in some firmware versions.
Issue: Presence detection is delayed or inconsistent.
Use the Bluetooth configuration app to adjust sensitivity gates and energy thresholds. Ensure no large obstacles block the radar field.
Issue: Neither BLE nor UART configuration is working.
Reset the device using a hardware reset if available, or power cycle while holding a configuration button (if present). Consult the datasheet for boot behavior.
Debugging Tips
Use the Serial Monitor to check for error messages and verify the sensor's output. Add debug prints in your code to track the sensor's state.
Use a multimeter to verify voltage levels and check for continuity in your connections. Ensure the power supply is stable and within the sensor's requirements.
Additional Resources
LD2410B Programming Examples
Ready-to-use code examples for different platforms and frameworks
#if defined(ARDUINO_SAMD_NANO_33_IOT) || defined(ARDUINO_AVR_LEONARDO)
//ARDUINO_SAMD_NANO_33_IOT RX_PIN is D1, TX_PIN is D0
//ARDUINO_AVR_LEONARDO RX_PIN(RXI) is D0, TX_PIN(TXO) is D1
#define sensorSerial Serial1
#elif defined(ARDUINO_XIAO_ESP32C3) || defined(ARDUINO_XIAO_ESP32C6)
//RX_PIN is D7, TX_PIN is D6
#define sensorSerial Serial0
#elif defined(ESP32)
//Other ESP32 device - choose available GPIO pins
#define sensorSerial Serial1
#if defined(ARDUINO_ESP32S3_DEV)
#define RX_PIN 18
#define TX_PIN 17
#else
#define RX_PIN 16
#define TX_PIN 17
#endif
#else
#error "This sketch only works on ESP32, Arduino Nano 33IoT, and Arduino Leonardo (Pro-Micro)"
#endif
// User defines
// #define DEBUG_MODE
#define ENHANCED_MODE
#define SERIAL_BAUD_RATE 115200
//Change the communication baud rate here, if necessary
//#define LD2410_BAUD_RATE 256000
#include "MyLD2410.h"
#ifdef DEBUG_MODE
MyLD2410 sensor(sensorSerial, true);
#else
MyLD2410 sensor(sensorSerial);
#endif
unsigned long nextPrint = 0, printEvery = 1000; // print every second
void printValue(const byte &val) {
Serial.print(' ');
Serial.print(val);
}
void printData() {
Serial.print(sensor.statusString());
if (sensor.presenceDetected()) {
Serial.print(", distance: ");
Serial.print(sensor.detectedDistance());
Serial.print("cm");
}
Serial.println();
if (sensor.movingTargetDetected()) {
Serial.print(" MOVING = ");
Serial.print(sensor.movingTargetSignal());
Serial.print("@");
Serial.print(sensor.movingTargetDistance());
Serial.print("cm ");
if (sensor.inEnhancedMode()) {
Serial.print("
signals->[");
sensor.getMovingSignals().forEach(printValue);
Serial.print(" ] thresholds:[");
sensor.getMovingThresholds().forEach(printValue);
Serial.print(" ]");
}
Serial.println();
}
if (sensor.stationaryTargetDetected()) {
Serial.print(" STATIONARY= ");
Serial.print(sensor.stationaryTargetSignal());
Serial.print("@");
Serial.print(sensor.stationaryTargetDistance());
Serial.print("cm ");
if (sensor.inEnhancedMode()) {
Serial.print("
signals->[");
sensor.getStationarySignals().forEach(printValue);
Serial.print(" ] thresholds:[");
sensor.getStationaryThresholds().forEach(printValue);
Serial.print(" ]");
}
Serial.println();
}
if (sensor.inEnhancedMode() && (sensor.getFirmwareMajor() > 1)) {
Serial.print("Light level: ");
Serial.println(sensor.getLightLevel());
Serial.print("Output level: ");
Serial.println((sensor.getOutLevel()) ? "HIGH" : "LOW");
}
Serial.println();
}
void setup() {
Serial.begin(SERIAL_BAUD_RATE);
#if defined(ARDUINO_XIAO_ESP32C3) || defined(ARDUINO_XIAO_ESP32C6) || defined(ARDUINO_SAMD_NANO_33_IOT) || defined(ARDUINO_AVR_LEONARDO)
sensorSerial.begin(LD2410_BAUD_RATE);
#else
sensorSerial.begin(LD2410_BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
#endif
delay(2000);
Serial.println(__FILE__);
if (!sensor.begin()) {
Serial.println("Failed to communicate with the sensor.");
while (true) {}
}
#ifdef ENHANCED_MODE
sensor.enhancedMode();
#else
sensor.enhancedMode(false);
#endif
delay(nextPrint);
}
void loop() {
if ((sensor.check() == MyLD2410::Response::DATA) && (millis() > nextPrint)) {
nextPrint = millis() + printEvery;
printData();
}
}The LD2410B is fully compatible with the same Arduino code used for the LD2410 sensor. You can refer to the MyLD2410 library and use identical UART wiring and commands. No code changes are required aside from ensuring BLE is disabled or inactive during UART communication. See LD2410 Arduino Example for implementation details.
esphome:
name: ld2410_sensor
platform: ESP32
board: esp32dev
logger:
uart:
id: uart_bus
tx_pin: GPIO17
rx_pin: GPIO16
baud_rate: 256000
ld2410:
uart_id: uart_bus
binary_sensor:
- platform: ld2410
has_target:
name: "Presence Detected"
has_moving_target:
name: "Moving Target Detected"
has_still_target:
name: "Still Target Detected"
sensor:
- platform: ld2410
moving_distance:
name: "Moving Distance"
still_distance:
name: "Still Distance"
moving_energy:
name: "Moving Energy"
still_energy:
name: "Still Energy"
detection_distance:
name: "Detection Distance"
text_sensor:
- platform: ld2410
version:
name: "LD2410 Firmware Version"
mac_address:
name: "LD2410 MAC Address"ESPHome configurations for the LD2410B are identical to those used for the LD2410. You can use the same UART settings, component definitions, and binary/sensor blocks. Just make sure BLE is not active during UART communication to avoid conflicts. Refer to the LD2410 ESPHome Integration for YAML examples.
platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps =
iavorvel/MyLD2410@^1.0.2
monitor_speed = 115200main.cpp
#include <MyLD2410.h>
MyLD2410 radar;
void setup() {
Serial.begin(115200);
Serial2.begin(256000, SERIAL_8N1, 16, 17); // RX=16, TX=17
if (!radar.begin(&Serial2)) {
Serial.println("Failed to initialize LD2410 sensor");
while (true) {}
}
Serial.println("LD2410 initialized successfully");
}
void loop() {
radar.read();
if (radar.presenceDetected()) {
Serial.println("Presence detected");
Serial.print("Still distance: ");
Serial.println(radar.stillDistance());
Serial.print("Moving distance: ");
Serial.println(radar.movingDistance());
} else {
Serial.println("No presence");
}
delay(1000);
}The LD2410B is fully compatible with the same MyLD2410 PlatformIO library and example code used for the LD2410. You can use identical UART wiring (TX=17, RX=16) and no code changes are necessary to support LD2410B functionality. The sensor will operate normally over UART as long as Bluetooth is not actively connected. Refer to the LD2410 PlatformIO Example for a complete implementation using the PlatformIO environment.
from machine import UART
import time
# Initialize UART2: TX=17, RX=16, baud rate 256000
uart = UART(2, baudrate=256000, tx=17, rx=16)
# Function to read and print data from LD2410
def read_ld2410():
while True:
if uart.any():
data = uart.read()
if data:
print(data)
time.sleep(0.1)
read_ld2410()LD2410B supports the same UART communication protocol as the original LD2410, making it fully compatible with existing MicroPython code. You can use the same UART setup (TX=17, RX=16, baudrate=256000) and raw data reading scripts. Note that BLE should not be active while using UART. For the base script and driver link, see the MicroPython section of the LD2410 documentation.
Wrapping Up LD2410B
The ESP32 LD2410B Human Presence Sensor is a powerful Human Presence sensor that offers excellent performance and reliability. With support for multiple development platforms including Arduino, ESP-IDF, ESPHome, PlatformIO, and MicroPython, it's a versatile choice for your IoT projects.
Best Practices
For optimal performance, ensure proper wiring and follow the recommended configuration for your chosen development platform.
Safety First
Always verify power supply requirements and pin connections before powering up your project to avoid potential damage.
Ready to Start Building?
Now that you have all the information you need, it's time to integrate the LD2410B into your ESP32 project and bring your ideas to life!
Explore Alternative Sensors
Looking for alternatives to the LD2410B? Check out these similar sensors that might fit your project needs.

LD2450 Human Presence Sensor
The LD2450 is a 24GHz mmWave radar sensor designed for precise human presence detection and tracking. It supports both UART and BLE...

LD2410S Human Presence Sensor
The LD2410S is an ultra-low-power 24GHz mmWave radar sensor for human presence detection, supporting both stationary and moving target...

LD2410C Human Presence Sensor
The LD2410C is a millimeter-wave radar sensor for human presence detection, supporting both stationary and moving target detection. It uses...




