LD2412 Human Presence Sensor

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"

// LD2412 on UART2: radar TX -> GPIO16 (RX2), RX -> GPIO17 (TX2), 115200 baud
#define RADAR_UART UART_NUM_2
#define RADAR_RX_PIN 16
#define RADAR_TX_PIN 17

static const uint8_t FRAME_HEAD[4] = {0xF4, 0xF3, 0xF2, 0xF1};

void app_main(void)
{
    uart_config_t config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
    };
    ESP_ERROR_CHECK(uart_param_config(RADAR_UART, &config));
    ESP_ERROR_CHECK(uart_set_pin(RADAR_UART, RADAR_TX_PIN, RADAR_RX_PIN,
                                 UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
    ESP_ERROR_CHECK(uart_driver_install(RADAR_UART, 1024, 0, 0, NULL, 0));

    uint8_t buf[64];
    int matched = 0;

    while (1) {
        uint8_t byte;
        if (uart_read_bytes(RADAR_UART, &byte, 1, pdMS_TO_TICKS(100)) != 1)
            continue;

        // Sync on the F4 F3 F2 F1 data-frame header
        if (matched < 4) {
            matched = (byte == FRAME_HEAD[matched]) ? matched + 1 : (byte == FRAME_HEAD[0]);
            continue;
        }

        // Read length (2 bytes, little-endian), then the payload + 4-byte tail
        uint8_t len_bytes[2];
        len_bytes[0] = byte;
        uart_read_bytes(RADAR_UART, &len_bytes[1], 1, pdMS_TO_TICKS(100));
        int length = len_bytes[0] | (len_bytes[1] << 8);
        matched = 0;
        if (length < 11 || length > (int)sizeof(buf))
            continue; // implausible - resync

        if (uart_read_bytes(RADAR_UART, buf, length + 4, pdMS_TO_TICKS(100)) != length + 4)
            continue;

        // Basic-mode report: [0]=0x02, [1]=0xAA, [2]=state, then little-endian values
        if (buf[0] != 0x02 || buf[1] != 0xAA)
            continue; // engineering-mode or config frame - ignore here

        uint8_t state = buf[2]; // 0 none, 1 moving, 2 still, 3 both
        int moving_cm = buf[3] | (buf[4] << 8);
        int still_cm = buf[6] | (buf[7] << 8);
        int detect_cm = buf[9] | (buf[10] << 8);

        static const char *STATES[] = {"no target", "moving", "still", "moving + still"};
        printf("%s | moving %d cm (energy %d) | still %d cm (energy %d) | detect %d cm\n",
               STATES[state & 0x03], moving_cm, buf[5], still_cm, buf[8], detect_cm);
    }
}

external_components:
  - source: github://Rihan9/LD2412
    components: [ld2412]

uart:
  id: uart_bus
  tx_pin: GPIO17
  rx_pin: GPIO16
  baud_rate: 115200
  parity: NONE
  stop_bits: 1

ld2412:
  id: ld2412_radar

binary_sensor:
  - platform: ld2412
    has_target:
      name: "Presence"
    has_moving_target:
      name: "Moving Target"
    has_still_target:
      name: "Still Target"

sensor:
  - platform: ld2412
    moving_distance:
      name: "Moving Distance"
    still_distance:
      name: "Still Distance"

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
build_unflags = -std=gnu++11
build_flags = -std=gnu++17  ; the LD2412 library requires C++17
lib_deps =
    tobiastl/LD2412 @ ^1.0.2

#include <Arduino.h>
#include <LD2412.h>

// UART2: sensor TX -> GPIO16 (RX2), sensor RX -> GPIO17 (TX2)
LD2412 radar(Serial2);

void setup() {
  Serial.begin(115200);
  Serial2.begin(115200, SERIAL_8N1, 16, 17);
}

void loop() {

  int state = radar.targetState(); // 0 none, 1 moving, 2 stationary, 3 both
  if (state > 0) {
    Serial.print("Presence detected (");
    Serial.print(state == 1 ? "moving" : state == 2 ? "stationary" : "moving + stationary");
    Serial.print("), moving at ");
    Serial.print(radar.movingDistance());
    Serial.print(" cm, static at ");
    Serial.print(radar.staticDistance());
    Serial.println(" cm");
  } else {
    Serial.println("No presence");
  }
  delay(1000);
}

from machine import UART
import time

# LD2412: radar TX -> GPIO16 (RX2), RX -> GPIO17 (TX2), 115200 baud
uart = UART(2, baudrate=115200, tx=17, rx=16)
STATES = ("no target", "moving", "still", "moving + still")

buf = b""
while True:
    data = uart.read()
    if data:
        buf += data
        while True:
            i = buf.find(b"\xf4\xf3\xf2\xf1")  # data-frame header
            if i < 0 or len(buf) < i + 6:
                break
            length = buf[i + 4] | (buf[i + 5] << 8)
            if len(buf) < i + 6 + length + 4:
                break
            payload = buf[i + 6 : i + 6 + length]
            buf = buf[i + 6 + length + 4 :]
            if length >= 11 and payload[0] == 0x02 and payload[1] == 0xAA:
                state = payload[2] & 0x03
                moving = payload[3] | (payload[4] << 8)
                still = payload[6] | (payload[7] << 8)
                print("{} | moving {} cm | still {} cm".format(STATES[state], moving, still))
    time.sleep(0.1)