MR24HPC1 Human Static Presence Radar Sensor

The MR24HPC1 is a high-sensitivity 24GHz radar sensor capable of detecting human presence and motion. It communicates via UART and is ideal for smart home and security applications.

MR24HPC1 Human Static Presence Radar Sensor image
MR24HPC1 · UART
UART
Interface
4pins
Connections
5V DC
Supply
Up to 5 meter s
Range
-20 to +85 °C
Operating temp
$9.40
Typical price
On this page

MR24HPC1 pinout

4 pins · UART

The MR24HPC1 is a 24GHz mmWave radar sensor with 4 pins: 5V power, GND, and UART TX/RX for communication.

View:
MR24HPC1 Human Static Presence Radar Sensor pinout
PinTypeDescriptionNotes
5VPowerPower supply input (5V DC). Powers the radar chipset and MCU.Stable voltage essential for consistent performance.
GNDPowerGround reference. Shared with ESP32 for signal integrity.Proper grounding prevents voltage offset errors.
TXUARTUART transmit line. Outputs motion speed and presence strength data.Connect to ESP32 RX pin (e.g., GPIO 16). Typically 5V logic.
RXUARTUART receive line. Receives configuration commands from ESP32.Connect to ESP32 TX pin (e.g., GPIO 17).
  • 24GHz mmWave radar technology

  • Detection range: up to 5 meters

  • Field of view: ±45° horizontal, ±25° vertical

  • Detects static and moving human presence

  • 5V logic levels - verify ESP32 compatibility or use level shifter

Wiring the MR24HPC1 to ESP32

4 connections · all required

To interface the MR24HPC1 with an ESP32 via UART, connect 5V to power (or external supply), GND to ground, TX to ESP32 GPIO 16 (RX2), and RX to ESP32 GPIO 17 (TX2).

MR24HPC1 Human Static Presence Radar Sensor wiring with ESP32
MR24HPC1 pinESP32 pinPurpose
5V (red)5V or External SupplyPower supply (5V, ~80mA typical). Use regulated supply.
GND (black)GNDGround connection. Must be shared with ESP32.
TX (green)GPIO 16 (RX2)Radar transmits presence/motion data to ESP32.
RX (blue)GPIO 17 (TX2)ESP32 sends setup commands to radar.
  • UART baud rate: 115200 bps (8N1 format)

  • Use hardware UART2 (GPIO 16/17) - avoid conflicts with USB serial

  • 5V logic levels: Most ESP32 boards tolerate 5V on RX, verify or use level shifter

  • Current consumption: ~80mA typical

  • Mount sensor away from vibration sources

  • Ensure clear field of view - no obstructions

  • For testing: connect TX to USB-Serial adapter to verify output

  • Similar to LD series - reference LD2410C/LD2450 configurations

MR24HPC1 code examples

5 platforms
Platform:

MR24HPC1 Arduino example

Copy
// Requires library: install Seeed's humanstaticLite library from
// https://github.com/limengdu/Seeed_24GHz_Human_Static_Presence_Module_Lite
// (Sketch > Include Library > Add .ZIP Library)
#include <humanstaticLite.h>

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

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

void loop() {
  radar.recvRadarBytes();       // Read a frame from the radar
  radar.HumanStatic_func(true); // Parse and print presence, motion and body-sign data
  delay(200);
}

The example uses Seeed's official humanstaticLite library (add it as a ZIP from limengdu/Seeed_24GHz_Human_Static_Presence_Module_Lite - it is not in the Library Manager). recvRadarBytes() reads each frame from UART2 (115200 baud) and HumanStatic_func(true) parses and prints presence, motion and body-sign data.

MR24HPC1 ESP-IDF example

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

// MR24HPC1 on UART2: module TX -> GPIO16 (RX2), RX -> GPIO17 (TX2), 115200 baud
#define RADAR_UART UART_NUM_2

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, 17, 16, 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];
    while (1) {
        int len = uart_read_bytes(RADAR_UART, buf, sizeof(buf), pdMS_TO_TICKS(200));
        if (len > 0) {
            for (int i = 0; i < len; i++)
                printf("%02X ", buf[i]);
            printf("\n");
        }
    }
}

There is no established library for the MR24HPC1, so this example reads its UART stream (115200 baud on UART2) and prints each burst as hex - decode it with the frame tables in Seeed's MR24HPC1 protocol documentation (frames run from 0x53 0x59 to 0x54 0x43) - or use ESPHome, which has native support (see the ESPHome tab).

MR24HPC1 ESPHome example

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

seeed_mr24hpc1:
  id: my_mr24hpc1

binary_sensor:
  - platform: seeed_mr24hpc1
    has_target:
      name: "Presence Detected"

sensor:
  - platform: seeed_mr24hpc1
    custom_presence_of_detection:
      name: "Static Distance"
    movement_signs:
      name: "Body Movement Parameter"
    custom_motion_distance:
      name: "Motion Distance"
    custom_spatial_static_value:
      name: "Existence Energy"
    custom_spatial_motion_value:
      name: "Motion Energy"
    custom_motion_speed:
      name: "Motion Speed"
    custom_mode_num:
      name: "Mode Number"

This ESPHome configuration sets up the MR24HPC1 sensor using the seeed_mr24hpc1 platform. The UART interface is configured with a baud rate of 115200, no parity, and 1 stop bit. The binary_sensor detects presence, while the sensor entries provide detailed information on static distance, body movement, motion distance, existence energy, motion energy, motion speed, and mode number. Ensure that the UART pins are correctly connected and that the sensor is powered with a stable 5V supply.

MR24HPC1 PlatformIO example

Copy
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    https://github.com/limengdu/Seeed_24GHz_Human_Static_Presence_Module_Lite.git
src/main.cppCopy
#include <Arduino.h>
#include <humanstaticLite.h>

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

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

void loop() {
  radar.recvRadarBytes();       // Read a frame from the radar
  radar.HumanStatic_func(true); // Parse and print presence, motion and body-sign data
  delay(200);
}

This PlatformIO example uses Seeed's official humanstaticLite library, pulled straight from GitHub in lib_deps (limengdu/Seeed_24GHz_Human_Static_Presence_Module_Lite - it is not published on the PlatformIO registry). The radar talks 115200 baud on UART2 (TX to GPIO16, RX to GPIO17 per the wiring above); recvRadarBytes() reads each frame and HumanStatic_func(true) parses and prints presence, motion and body-sign data to the Serial Monitor.

MR24HPC1 MicroPython example

Copy
from machine import UART
import time

# MR24HPC1: module TX -> GPIO16 (RX2), RX -> GPIO17 (TX2), 115200 baud
uart = UART(2, baudrate=115200, tx=17, rx=16)

while True:
    data = uart.read()
    if data:
        print(" ".join("{:02X}".format(b) for b in data))
    time.sleep(0.2)

There is no established library for the MR24HPC1, so this example reads its UART stream (115200 baud on UART2) and prints each burst as hex - decode it with the frame tables in Seeed's MR24HPC1 protocol documentation (frames run from 0x53 0x59 to 0x54 0x43) - or use ESPHome, which has native support (see the ESPHome tab).

MR24HPC1 specifications

From the datasheet
Interface
UART (115200 baud)
Detection Range
Up to 5 meters
Detection Field
±45° horizontal, ±25° vertical
Power Supply
5V DC
Output
UART
Operating Temperature
-20°C to +85°C
Dimensions
35mm × 30mm × 9mm
Pin Width
2.54mm

About the MR24HPC1

The MR24HPC1 is Seeed’s 24GHz mmWave Human Static Presence Lite module, and despite the budget name it is the better-supported of Seeed’s two radars for ESP32 work: ESPHome ships a native seeed_mr24hpc1 component, no external repository needed, that exposes static and motion distance, existence and motion energy, a breathing-derived movement-signs value, and the sensor’s operating mode as entities. Detection tops out around 5 meters over a 115200-baud UART, both numbers matching this page’s spec table with no correction needed.

Seeed sells the MR24HPC1 alongside its XIAO ESP32C3 in a bundled mmWave human-detection kit, and the pairing shows in the price - at under $10 it is the cheapest radar in this entire family, undercutting even the base LD2410.

Where the pricier MR24HPB1 buys extra range (12 meters of motion detection versus 5), the MR24HPC1 buys the smoother ESPHome path and the lower price. For a typical room-sized deployment with Home Assistant as the target, the MR24HPC1 is the easier and cheaper of the two; reach for the MR24HPB1 only when the space is bigger than a single room.

MR24HPC1 troubleshooting

4 common issues

No Data Received

Issue: The ESP32 receives no data from the sensor.

Ensure correct wiring: verify that TX and RX lines are properly connected, and confirm that the UART baud rate is set to 115200 bps. Also, ensure that the sensor is powered with a stable 5V supply.

Presence Not Detected

Issue: The sensor does not detect presence even when someone is in range.

Check the sensor's field of view and ensure there are no obstructions. Verify that the sensor's configuration parameters are set correctly for the desired detection range and sensitivity.

Intermittent Detection

Issue: Sensor intermittently detects presence or fails to maintain detection.

Ensure that the sensor is securely mounted and not subject to vibrations. Check for sources of interference in the environment that may affect radar performance.

UART Initialization Fails

Issue: UART component in ESPHome reports failure to initialize.

Verify that the UART pins specified in the configuration match the physical connections. Ensure that no other devices are using the same UART bus, and that the baud rate is correctly set to 115200 bps.

Resources