C1001 mmWave Sensor Integration

c1001_esphome.yaml

Main ESPHome configuration file that sets up the device, sensors, and communication.

# ESPHome configuration for DFRobot C1001 mmWave
# Human Detection Sensor with ESP32-S3-DevKitC-1

# Basic device configuration
esphome:
  name: c1001_mmwave_sensor
  friendly_name: C1001 mmWave Sensor
  comment: "DFRobot C1001 mmWave Human Detection Sensor"
  includes:
    - c1001_parser.h

# ESP32-S3 configuration
esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: arduino

# Enable logging
logger:
  level: INFO
  baud_rate: 0 # Disable UART logging as we're using UART for the sensor

# Enable Home Assistant API
api:
  encryption:
    key: !secret api_encryption_key

# Enable OTA updates
ota:
  password: !secret ota_password

# WiFi credentials
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  
  # Enable fallback hotspot (captive portal) in case WiFi connection fails
  ap:
    ssid: "C1001-Fallback"
    password: !secret fallback_password

# Enable web server for debugging
web_server:
  port: 80

# Enable captive portal for initial setup
captive_portal:

# Status LED (RGB LED on ESP32-S3-DevKitC-1)
light:
  - platform: fastled_clockless
    chipset: WS2812
    pin: GPIO48
    num_leds: 1
    rgb_order: GRB
    name: "Status LED"
    id: status_led
    effects:
      - pulse:
          name: "Slow Pulse"
          transition_length: 2s
          update_interval: 2s
      - pulse:
          name: "Fast Pulse"
          transition_length: 0.5s
          update_interval: 0.5s

# UART configuration for C1001 sensor
uart:
  id: uart_bus
  tx_pin: GPIO4
  rx_pin: GPIO5
  baud_rate: 115200
  parity: NONE
  stop_bits: 1

# Custom component for C1001 sensor
custom_component:
  - lambda: |-
      auto c1001 = new C1001UARTComponent(id(uart_bus));
      return {c1001};
  - id: c1001_component

# Binary sensors for human presence and fall detection
binary_sensor:
  # Human presence sensor (connected to IO2 pin on C1001)
  - platform: gpio
    pin:
      number: GPIO14
      mode: INPUT_PULLUP
      inverted: true
    name: "Human Presence"
    device_class: occupancy
    filters:
      - delayed_off: 5s
    
  # Fall detection sensor (connected to IO1 pin on C1001)
  - platform: gpio
    pin:
      number: GPIO12
      mode: INPUT_PULLUP
      inverted: true
    name: "Fall Detection"
    device_class: motion
    filters:
      - delayed_off: 2s

  # Human presence from UART data
  - platform: template
    name: "Human Presence Status"
    id: presence_status
    device_class: occupancy

  # Movement detection from UART data
  - platform: template
    name: "Movement Status"
    id: movement_status
    device_class: motion

# Sensors for respiration and heart rate data
sensor:
  # Respiration rate sensor
  - platform: template
    name: "Respiration Rate"
    id: respiration_rate
    unit_of_measurement: "bpm"
    accuracy_decimals: 0
    icon: "mdi:lungs"
    
  # Heart rate sensor
  - platform: template
    name: "Heart Rate"
    id: heart_rate
    unit_of_measurement: "bpm"
    accuracy_decimals: 0
    icon: "mdi:heart-pulse"

  # WiFi signal strength
  - platform: wifi_signal
    name: "WiFi Signal"
    update_interval: 60s

# Text sensors for sleep state
text_sensor:
  - platform: template
    name: "Sleep State"
    id: sleep_state
    icon: "mdi:sleep"

# On boot automation to configure the sensor
on_boot:
  priority: 600
  then:
    - light.turn_on:
        id: status_led
        brightness: 100%
        red: 100%
        green: 0%
        blue: 0%
        effect: "Fast Pulse"
    - delay: 5s
    - light.turn_on:
        id: status_led
        brightness: 100%
        red: 0%
        green: 100%
        blue: 0%

c1001_parser.h

Custom component that handles UART communication with the C1001 sensor.

#include "esphome.h"

using namespace esphome;

class C1001UARTComponent : public Component, public UARTDevice {
 public:
  C1001UARTComponent(UARTComponent *parent) : UARTDevice(parent) {}

  // Expose these to ESPHome
  BinarySensor *presence_sensor = new BinarySensor();
  BinarySensor *movement_sensor = new BinarySensor();
  Sensor *respiration_rate_sensor = new Sensor();
  Sensor *heart_rate_sensor = new Sensor();
  TextSensor *sleep_state_sensor = new TextSensor();

  void setup() override {
    // Configure the sensor in sleep detection mode
    configWorkMode(2);  // 2 = Sleep detection mode
    delay(100);
    // Enable the LED for human presence
    configLEDLight(4, 1);  // 4 = HP LED, 1 = On
    delay(100);
    // Reset the sensor to apply settings
    sensorReset();
  }

  void loop() override {
    static uint8_t buffer[64];
    static int buffer_index = 0;
    
    while (available()) {
      uint8_t byte = read();
      
      // Store byte in buffer
      if (buffer_index < sizeof(buffer)) {
        buffer[buffer_index++] = byte;
      }
      
      // Check for end of frame marker (0x54, 0x43)
      if (buffer_index >= 2 && buffer[buffer_index - 2] == 0x54 && buffer[buffer_index - 1] == 0x43) {
        processFrame(buffer, buffer_index);
        buffer_index = 0;
      }
    }
  }

  void processFrame(uint8_t *buffer, int length) {
    // Minimum frame length check
    if (length < 10) return;
    
    // Check frame header (0x53, 0x59)
    if (buffer[0] != 0x53 || buffer[1] != 0x59) return;
    
    // Process different frame types based on the command bytes
    
    // Human presence information (0x80, 0x01)
    if (buffer[2] == 0x80 && buffer[3] == 0x01 && buffer[4] == 0x00 && buffer[5] == 0x01) {
      bool presence = buffer[6] > 0;
      presence_sensor->publish_state(presence);
      ESP_LOGD("C1001", "Human presence: %s", presence ? "detected" : "not detected");
    }
    
    // Movement information (0x80, 0x02)
    else if (buffer[2] == 0x80 && buffer[3] == 0x02 && buffer[4] == 0x00 && buffer[5] == 0x01) {
      // 0x01 = stationary, 0x02 = active
      bool movement = buffer[6] == 0x02;
      movement_sensor->publish_state(movement);
      ESP_LOGD("C1001", "Movement status: %s", movement ? "active" : "stationary");
    }
    
    // Sleep state information (0x81, 0x01)
    else if (buffer[2] == 0x81 && buffer[3] == 0x01 && buffer[4] == 0x00 && buffer[5] == 0x01) {
      uint8_t state = buffer[6];
      std::string state_str;
      
      switch (state) {
        case 0:
          state_str = "Deep Sleep";
          break;
        case 1:
          state_str = "Light Sleep";
          break;
        case 2:
          state_str = "Awake";
          break;
        case 3:
          state_str = "None";
          break;
        default:
          state_str = "Unknown";
      }
      
      sleep_state_sensor->publish_state(state_str);
      ESP_LOGD("C1001", "Sleep state: %s", state_str.c_str());
    }
    
    // Respiratory rate value (0x81, 0x02)
    else if (buffer[2] == 0x81 && buffer[3] == 0x02 && buffer[4] == 0x00 && buffer[5] == 0x01) {
      uint8_t rate = buffer[6];
      respiration_rate_sensor->publish_state(rate);
      ESP_LOGD("C1001", "Respiration rate: %d bpm", rate);
    }
    
    // Heart rate value (0x85, 0x02)
    else if (buffer[2] == 0x85 && buffer[3] == 0x02 && buffer[4] == 0x00 && buffer[5] == 0x01) {
      uint8_t rate = buffer[6];
      heart_rate_sensor->publish_state(rate);
      ESP_LOGD("C1001", "Heart rate: %d bpm", rate);
    }
  }

  // Helper functions to send commands to the sensor
  void configWorkMode(uint8_t mode) {
    // mode: 1 = Fall detection mode, 2 = Sleep detection mode
    uint8_t cmd[] = {0x53, 0x59, 0x01, 0x01, 0x00, 0x01, mode, 0x00, 0x54, 0x43};
    write_array(cmd, sizeof(cmd));
    ESP_LOGI("C1001", "Setting work mode to %d", mode);
  }
  
  void configLEDLight(uint8_t led, uint8_t state) {
    // led: 3 = FALL LED, 4 = HP LED
    // state: 0 = Off, 1 = On
    uint8_t cmd[] = {0x53, 0x59, 0x01, led, 0x00, 0x01, state, 0x00, 0x54, 0x43};
    write_array(cmd, sizeof(cmd));
    ESP_LOGI("C1001", "Setting LED %d to %s", led, state ? "ON" : "OFF");
  }
  
  void sensorReset() {
    uint8_t cmd[] = {0x53, 0x59, 0x01, 0x07, 0x00, 0x00, 0x00, 0x54, 0x43};
    write_array(cmd, sizeof(cmd));
    ESP_LOGI("C1001", "Resetting sensor");
  }
  
  void write_array(const uint8_t *data, size_t len) {
    for (size_t i = 0; i < len; i++) {
      write(data[i]);
    }
  }
};

Fall Detection Alert

alias: Fall Detection Alert
description: Send a notification when a fall is detected
trigger:
  - platform: state
    entity_id: binary_sensor.fall_detection
    to: "on"
condition: []
action:
  - service: notify.mobile_app
    data:
      title: "⚠️ Fall Detected!"
      message: "A fall has been detected. Please check immediately."
      data:
        priority: high
        ttl: 0
        channel: "Fall Detection Alerts"
  - service: light.turn_on
    target:
      entity_id: light.status_led
    data:
      brightness: 255
      rgb_color: [255, 0, 0]
      effect: "Fast Pulse"
mode: single