El sensor de presencia humana mmWave C4002 es un módulo basado en radar diseñado para una detección precisa de personas. Utiliza tecnología de onda milimétrica FMCW de 24 GHz para detectar tanto movimiento como micro-movimientos como la respiración, lo que le permite identificar personas incluso cuando están completamente quietas.
A diferencia de los tradicionales PIR sensores, este módulo ofrece detección de presencia. Puede distinguir entre ausencia de objetivo, objetivos en movimiento y presencia humana estacionaria en un rango de hasta 10 metros. En este tutorial aprenderás cómo conectar el sensor mmWave C4002 a un Arduino o un ESP32 para detección de presencia y movimiento.
Partes necesarias
Puedes adquirir el sensor mmWave C4002 en DFRobot. También necesitarás un Arduino o un ESP32. En este tutorial uso un Arduino UNO y un ESP32-C3 SuperMini, pero cualquier otro Arduino, ESP32 o ESP8266 funcionará siempre que tenga un pin de salida de 5V. Finalmente, una protoboard y algunos cables Dupont serán útiles para el cableado.
Sensor Radar mmWave C4002
ESP32-C3 SuperMini
Cable USB C
Arduino Uno
Cable USB para Arduino UNO
Juego de cables Dupont
Protoboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware del sensor mmWave C4002
El mmWave C4002 está basado en tecnología radar FMCW (onda continua modulada en frecuencia) de 24 GHz. Emite continuamente ondas electromagnéticas en la banda de 24.0 GHz a 24.25 GHz y mide las señales reflejadas por objetos en el entorno. La imagen a continuación muestra la parte trasera y frontal del módulo. Se pueden ver las dos antenas doradas de radar en la parte frontal de la placa.
También puedes ver un LED etiquetado como «RUN» y otro como «OUT» en la parte frontal de la placa. El LED verde RUN parpadea cuando el sensor está detectando activamente y el LED azul OUT se enciende si se detecta una persona.
La técnica de modulación FMCW permite al sensor extraer distancia, velocidad y características de movimiento de la señal reflejada. El sensor puede detectar cambios muy pequeños en la posición, como el movimiento del pecho durante la respiración. Esto permite la detección de personas estacionarias, algo que no es posible con sensores infrarrojos pasivos.
El radar funciona independientemente de la luz ambiental y la temperatura. No se ve afectado por condiciones ambientales como oscuridad, polvo o variaciones de calor. Esto mejora la estabilidad en aplicaciones de domótica interior.
Capacidades de detección y procesamiento de señal
El C4002 soporta detección humana en múltiples modos, incluyendo movimiento, micro-movimiento y completa inmovilidad. Puede clasificar el estado del objetivo en categorías como sin objetivo, objetivo en movimiento y presencia estacionaria.
El rango máximo de detección es de hasta 11 metros para movimiento y 10 metros para presencia estacionaria. El área de detección cubre aproximadamente un espacio de 10 × 10 metros, dependiendo de las condiciones de instalación.
El sensor utiliza procesamiento interno de señal para extraer parámetros adicionales. Puede reportar la distancia al objetivo, energía de la señal, velocidad de movimiento y dirección. Estos valores se derivan del desplazamiento Doppler y cambios de frecuencia en la señal radar reflejada.
Se implementa un algoritmo adaptativo de filtrado de fondo para reducir falsas detecciones. El sensor aprende el entorno estático y suprime interferencias de fuentes no humanas como cortinas en movimiento o corrientes de aire.
Campo de visión y cobertura espacial
El módulo ofrece un amplio ángulo de detección de 120° horizontal y verticalmente. Esto permite que un solo sensor cubra grandes áreas interiores con mínimos puntos ciegos.
El rango de detección puede configurarse por software. Esto permite a los desarrolladores limitar la distancia de detección a una zona específica dentro de una habitación. Ayuda a evitar detecciones no deseadas a través de paredes o en áreas adyacentes.
La posición de montaje afecta la cobertura efectiva. El montaje en techo proporciona un patrón de detección desde arriba hacia abajo, mientras que el montaje en pared genera un cono de detección hacia adelante.
Características eléctricas e interfaces
El sensor funciona con un suministro de 3.6 V a 5.5 V, haciéndolo compatible con plataformas comunes de microcontroladores como Arduino y ESP32.
Proporciona dos interfaces de salida principales. Una interfaz UART con una velocidad de 9600 baudios se usa para comunicación de datos detallados, incluyendo mediciones completas de radar y comandos de configuración. Un pin digital OUT puede configurarse como señal simple de presencia para aplicaciones de baja complejidad.
La imagen a continuación muestra el pinout del módulo con pines para alimentación (VIN), tierra (GND), transmisión serial (TX), recepción serial (RX) y la señal digital de salida (OUT):
Características adicionales de detección y ambientales
El C4002 incluye un sensor de intensidad lumínica con un rango de 0 a 50 lux. Esto permite detección combinada de presencia y luz ambiental en un solo módulo.
El módulo soporta calibración ambiental automática. Durante la operación, puede adaptarse al entorno para mejorar la precisión de detección. Esto reduce el esfuerzo de ajuste manual durante el despliegue.
Especificaciones técnicas
La siguiente tabla resume las especificaciones técnicas del sensor mmWave C4004.
| Parámetro | Especificación |
|---|---|
| Voltaje de operación | 3.6 V a 5.5 V |
| Frecuencia de operación | 24.0 GHz a 24.25 GHz |
| Capacidad de detección | Detección de movimiento, micro-movimiento y presencia humana estacionaria |
| Distancia máxima de detección | 11 m (movimiento), 10 m (presencia estacionaria) |
| Ángulo de detección | 120° × 120° |
| Área de detección | Cobertura de hasta 10 m × 10 m |
| Interfaces de salida | UART y pin digital OUT configurable |
| Rango de detección de luz | 0 a 50 lux |
| Temperatura de operación | −20 °C a 85 °C |
| Dimensiones del módulo | 22 mm × 26 mm |
Uso del sensor mmWave C4002 sin microcontrolador
Necesitas usar un microcontrolador (o computadora) para programar configuraciones específicas del sensor mmWave C4002. Por ejemplo, puedes establecer la distancia de detección o la sensibilidad. Pero una vez configurado, puedes usar el C4002 sin microcontrolador.
El diagrama de cableado a continuación muestra cómo conectar un LED que se enciende si el sensor detecta una persona. Solo necesitas suministrar energía (5V) a los pines VIN y GND y luego conectar un LED con una resistencia al pin OUT:
Para la mayoría de aplicaciones prácticas probablemente querrás conectar un relé en lugar de un LED para controlar un dispositivo de mayor voltaje o corriente. Esto es posible pero necesitarás usar un Relay Module con un circuito amplificador integrado, ya que el pin OUT no puede accionar directamente la bobina del relé. A continuación un circuito de ejemplo:
Para más información sobre módulos relé consulta el How To Use A Relay With Arduino, Interfacing a Relay Module With ESP32 y el Control AC devices with Solid State Relay tutoriales.
En las siguientes secciones te mostraré cómo conectar el sensor mmWave C4002 a un Arduino o un ESP32.
Conexión del sensor mmWave C4002 a Arduino
Conectar el sensor mmWave C4002 a un Arduino UNO es sencillo. Comienza conectando VIN al pin 5V del Arduino. Luego conecta GND a GND. Finalmente, conectamos la interfaz UART cableando RX a GPIO 5 y TX a GPIO 4. La imagen a continuación muestra el cableado completo:
Para mayor comodidad, aquí tienes una tabla con las conexiones que debes hacer:
| C4002 | Arduino Uno |
|---|---|
| VIN | 5V |
| GND | GND |
| RX | GPIO 5 |
| TX | GPIO 4 |
Ni siquiera necesitarás una protoboard para conectar el sensor a un Arduino UNO. Cuatro cables Dupont son suficientes. La foto a continuación muestra mi cableado:
Conexión del sensor mmWave C4002 a ESP32
El ESP32 tiene tres interfaces seriales y puedes configurar los pines e interfaz que deseas usar. Aquí conecto TX a GPIO 3 y RX a GPIO 4. Debemos recordar esto al escribir el código. Finalmente, conectamos VIN a 5V y GND a G. La imagen a continuación muestra el cableado completo:
Ten en cuenta que necesitas un ESP32 con un pin de salida de 5V y que debes conectar VIN del C4002 al pin de 5V y no al común pin de 3.3V. La imagen a continuación muestra el pinout del ESP32-C3 Supermini que estoy usando aquí.
Recuerda que el C4002 necesita entre 3.6V y 5V en VIN, por lo que 3.3V no es suficiente. Para mayor comodidad, aquí tienes una tabla con las conexiones que debes hacer.
| C4002 | ESP32-C3 Supermini |
|---|---|
| VIN | 5V |
| GND | G |
| RX | 4 |
| TX | 3 |
Instalación de la librería DFRobot_C4002
Antes de poder escribir código, necesitaremos instalar la librería DFRobot_C4002. Para instalar esta librería, ve al repositorio DFRobot_C4002, haz clic en el botón verde «<> Code» y luego en «Download ZIP» para descargar la librería como un archivo ZIP, como se muestra a continuación:
Luego crea un nuevo sketch de Arduino, ve a Sketch -> Include Library -> Add .ZIP Library … para instalar la librería ZIP descargada (DFRobot_C4002-master.zip):
Código: Calibrando el C4002
El C4002 requiere un proceso de calibración que establece una línea base del entorno para que objetos estáticos como paredes o muebles no sean detectados erróneamente como objetivos. Dado que el sensor se basa en reflexiones de radar, primero debe aprender cómo es el “normal” en un espacio dado antes de detectar con fiabilidad presencia humana o movimiento.
La calibración se inicia usando la función c4002.startEnvCalibration(delay, duration), donde el retardo permite tiempo para despejar el área y la duración define cuánto tiempo mide el sensor el entorno. Durante este período, el sensor registra las reflexiones de fondo y construye un modelo interno. Es importante que no haya personas presentes, ya que el movimiento o incluso la presencia estacionaria pueden afectar negativamente la precisión.
Una vez completada la calibración, el sensor compara los datos en tiempo real con esta línea base y solo reporta cambios significativos. Esto permite una detección precisa tanto de movimiento como de presencia estática. Para mejores resultados, la recalibración debe repetirse siempre que el entorno cambie significativamente. El siguiente código realiza este proceso de calibración:
// Libraries:
// - DFRobot_C4002 V 1.0.0
// https://github.com/DFRobot/DFRobot_C4002
// - ESP32 Core V 3.3.8
#include "DFRobot_C4002.h"
#if defined(ESP8266) || defined(ARDUINO_AVR_UNO)
SoftwareSerial mySerial(4, 5);
DFRobot_C4002 c4002(&mySerial, 115200);
#elif defined(ESP32)
DFRobot_C4002 c4002(&Serial1, 115200, 3, 4);
#else
DFRobot_C4002 c4002(&Serial1, 115200);
#endif
void setup() {
Serial.begin(115200);
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
c4002.setRunLedState(eLedOn);
delay(50);
c4002.setOutLedState(eLedOn);
delay(50);
delay(3000);
c4002.setReportPeriod(10);
c4002.startEnvCalibration(10, 30); // Delay time：10s，Calibration time：30s
Serial.println("Start calibration:");
}
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
if (retResult.noteType == eCalibration) {
Serial.print(retResult.calibCountdown);
Serial.println(" s");
if (retResult.calibCountdown == 0) {
Serial.println("Calibration Complete!");
}
}
delay(10);
}
Importaciones
El sketch comienza incluyendo la librería requerida para el sensor. Esta librería proporciona la clase DFRobot_C4002, que abstrae la comunicación y control del sensor.
#include "DFRobot_C4002.h"
Comunicación serial
La siguiente sección de código configura cómo el sensor se comunica con el microcontrolador según la plataforma usada. El código verifica para qué placa se compila y selecciona la interfaz serial adecuada.
#if defined(ESP8266) || defined(ARDUINO_AVR_UNO) SoftwareSerial mySerial(4, 5); DFRobot_C4002 c4002(&mySerial, 115200); #elif defined(ESP32) DFRobot_C4002 c4002(&Serial1, 115200, 3, 4); #else DFRobot_C4002 c4002(&Serial1, 115200); #endif
En placas como Arduino Uno o ESP8266, los puertos seriales hardware son limitados, por lo que se crea una instancia SoftwareSerial en los pines 4 (RX) y 5 (TX). Esta interfaz serial se pasa luego al objeto DFRobot_C4002 junto con una velocidad de 115200 baudios.
En el ESP32, el código usa Serial1, que es un UART hardware. Además, se definen los pines 3 y 4 para RX y TX.
Para otras placas, se usa la interfaz Serial1 por defecto sin especificar pines, asumiendo que la configuración hardware ya los define.
Función setup
La función setup() es responsable de inicializar la comunicación serial y preparar el sensor para su operación.
void setup() {
Serial.begin(115200);
El monitor serial se inicializa a 115200 baudios para imprimir mensajes de estado para depuración y monitoreo.
La siguiente parte asegura que el sensor esté correctamente conectado y respondiendo.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
La función begin() intenta inicializar la comunicación con el sensor. Si no se detecta, el bucle continúa imprimiendo un mensaje de error cada segundo. Esto bloquea la ejecución hasta que se encuentra el sensor.
Tras la inicialización exitosa, el código configura los LEDs a bordo del sensor.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
La función setRunLedState() controla el LED indicador interno de funcionamiento, mientras que setOutLedState() controla el LED de salida. Ambos se encienden aquí para proporcionar retroalimentación visual de que el sensor está activo.
Se añaden breves retardos para asegurar comunicación estable entre comandos.
Luego el código pausa unos segundos antes de continuar.
delay(3000);
A continuación se configura el intervalo de reporte.
c4002.setReportPeriod(10);
La función setReportPeriod() establece la frecuencia con la que el sensor reporta datos. En este caso, el período se fija en 10 unidades, lo que resulta en un ciclo de reporte de 10 * 0.1 = 1 segundo. Finalmente, se inicia la calibración ambiental.
c4002.startEnvCalibration(10, 30); // Delay time：10s，Calibration time：30s
Serial.println("Start calibration:");
}
La función startEnvCalibration() inicia la calibración con dos parámetros. El primero especifica un retardo antes de comenzar la calibración y el segundo define la duración del proceso. Aquí, la calibración comienza tras 10 segundos y dura 30 segundos.
Función loop
La función loop() monitorea continuamente el estado del sensor, especialmente el proceso de calibración.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
La función getNoteInfo() obtiene la información de estado más reciente del sensor. La estructura devuelta sRetResult_t contiene varios campos que describen el estado actual.
El código verifica si el sensor está en modo calibración.
if (retResult.noteType == eCalibration) {
El campo noteType indica el tipo de notificación recibida. Cuando es igual a eCalibration, significa que el sensor está en fase de calibración. Si la calibración está en curso, se imprime el tiempo restante.
Serial.print(retResult.calibCountdown);
Serial.println(" s");
El campo calibCountdown contiene el número de segundos restantes hasta que la calibración finalice. Finalmente, el código detecta cuando la calibración ha terminado.
if (retResult.calibCountdown == 0) {
Serial.println("Calibration Complete!");
}
}
delay(10);
}
Cuando la cuenta regresiva llega a cero, se imprime un mensaje indicando que la calibración está completa.
Ejemplo de salida
La imagen a continuación muestra lo que se imprimirá en el Monitor Serial mientras se ejecuta la calibración. Como se mencionó, no debes estar cerca del sensor durante la calibración.
Código: Detección de movimiento y presencia con C4002
Una vez calibrado, el sensor puede usarse para detección. El siguiente ejemplo de código muestra qué tipo de detecciones y mediciones puede realizar el sensor:
// Libraries:
// - DFRobot_C4002 V 1.0.0
// https://github.com/DFRobot/DFRobot_C4002
// - ESP32 Core V 3.3.8
#include "DFRobot_C4002.h"
#if defined(ESP8266) || defined(ARDUINO_AVR_UNO)
SoftwareSerial mySerial(4, 5);
DFRobot_C4002 c4002(&mySerial, 115200);
#elif defined(ESP32)
DFRobot_C4002 c4002(&Serial1, 115200, 3, 4);
#else
DFRobot_C4002 c4002(&Serial1, 115200);
#endif
void setup() {
Serial.begin(115200);
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
c4002.setRunLedState(eLedOn);
delay(50);
c4002.setOutLedState(eLedOn);
delay(50);
c4002.setOutPinMode(eOutpinMode1); // Motion detected
delay(50);
c4002.setDetectRange(0, 1100); // 0-1100 cm
delay(50);
c4002.setLightThresh(0); //0-50 lux
delay(50);
c4002.setTargetDisappearDelay(1); // 0-65535s
delay(50);
c4002.setReportPeriod(10); // 10 * 0.1s = 1s
delay(50);
}
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
if (retResult.noteType == eResult) {
Serial.println("---------- RESULTS ------------");
float light = c4002.getLightIntensity();
Serial.print("Light: ");
Serial.print(light);
Serial.println(" lux");
eTargetState_t targetState = c4002.getTargetState();
Serial.print("Target state: ");
if (targetState == eNoTarget) {
Serial.println("No Target");
} else if (targetState == ePresence) {
Serial.println("Static Presence");
} else if (targetState == eMotion) {
Serial.println("Motion");
}
sPresenceTarget_t presenceTarget = c4002.getPresenceTargetInfo();
Serial.print("Presence distance: ");
Serial.print(presenceTarget.distance);
Serial.println(" m");
Serial.print("Presence energy: ");
Serial.println(presenceTarget.energy);
sMotionTarget_t motionTarget = c4002.getMotionTargetInfo();
Serial.print("Motion distance: ");
Serial.print(motionTarget.distance);
Serial.println(" m");
Serial.print("Motion energy: ");
Serial.println(motionTarget.energy);
Serial.print("Motion speed: ");
Serial.print(motionTarget.speed);
Serial.println(" m/s");
Serial.print("Motion direction: ");
if (motionTarget.direction == eAway) {
Serial.println("Away!");
} else if (motionTarget.direction == eNoDirection) {
Serial.println("No Direction!");
} else if (motionTarget.direction == eApproaching) {
Serial.println("Approaching!");
}
}
delay(50);
}
Importaciones
El sketch comienza incluyendo la librería requerida para el sensor. Esta librería define la clase DFRobot_C4002 y varios tipos de datos relacionados como sRetResult_t, sPresenceTarget_t y sMotionTarget_t.
#include "DFRobot_C4002.h"
Compilación condicional e inicialización del objeto
Luego configuramos la interfaz serial para comunicación UART como antes. La configuración depende del microcontrolador.
#if defined(ESP8266) || defined(ARDUINO_AVR_UNO) SoftwareSerial mySerial(4, 5); DFRobot_C4002 c4002(&mySerial, 115200); #elif defined(ESP32) DFRobot_C4002 c4002(&Serial1, 115200, 3, 4); #else DFRobot_C4002 c4002(&Serial1, 115200); #endif
En placas como Arduino Uno o ESP8266, se crea una instancia SoftwareSerial usando los pines 4 y 5. En el ESP32 usamos los pines 3 y 4, pero puedes elegir otros. Solo asegúrate de que el cableado hardware coincida con los pines en la configuración.
Función setup
La función setup() inicializa la comunicación y configura los parámetros del sensor en detalle.
void setup() {
Serial.begin(115200);
Se inicia la comunicación serial para permitir depuración y salida de datos vía monitor serial. La siguiente sección asegura que el sensor esté conectado y respondiendo.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
La función begin() inicializa el sensor. Si falla, el código imprime repetidamente un mensaje de error y reintenta cada segundo.
Tras la inicialización exitosa, se habilitan los LEDs del sensor.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
Estos LEDs proporcionan retroalimentación visual sobre la operación del sensor. El LED «Run» parpadea en verde mientras se realizan detecciones. El LED «Out» se enciende si se detecta una persona.
Luego configuramos el pin de salida (OUT).
c4002.setOutPinMode(eOutpinMode1); // Motion detected delay(50);
La función setOutPinMode() determina qué condición activa el pin OUT del sensor. En este caso, eOutpinMode1 lo configura para indicar detección de movimiento. Para otros modos, consulta el tipo eOutpinMode_t:
typedef enum {
eOutpinMode1 = 0x01, /* Only when motion is detected will a high level be output */
eOutpinMode2 = 0x02, /* A high level is output only when its presence is detected */
eOutpinMode3 = 0x03, /* A high level only appears when motion or presence is detected */
eOutpinModex = 0xFF /* reserved */
} eOutpinMode_t;
A continuación se define el rango de detección.
c4002.setDetectRange(0, 1100); // 0-1100 cm delay(50);
La función setDetectRange() establece las distancias mínima y máxima de detección en centímetros. Aquí, el sensor está configurado para detectar objetivos entre 0 cm y 1100 cm (11 metros).
Luego se configura el umbral de luz ambiental.
c4002.setLightThresh(0); //0-50 lux delay(50);
La función setLightThresh() establece el nivel mínimo de luz requerido para la detección. Un valor de 0 desactiva efectivamente el filtrado basado en luz, permitiendo detección en todas las condiciones de iluminación.
Después se establece el retardo antes de considerar que un objetivo ha desaparecido.
c4002.setTargetDisappearDelay(1); // 0-65535s delay(50);
La función setTargetDisappearDelay() define cuánto tiempo espera el sensor antes de declarar que un objetivo detectado ha desaparecido. En este caso, el retardo es de 1 segundo.
Finalmente, se configura el intervalo de reporte.
c4002.setReportPeriod(10); // 10 * 0.1s = 1s delay(50); }
La función setReportPeriod() determina la frecuencia con la que el sensor envía datos. Un valor de 10 corresponde a intervalos de 1 segundo.
Breves retardos entre comandos de configuración aseguran comunicación estable con el sensor.
Función loop
La función loop() lee y procesa continuamente los datos del sensor.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
La función getNoteInfo() obtiene la última notificación del sensor. La estructura devuelta contiene información sobre el tipo de datos disponibles.
El código verifica si los datos recibidos contienen resultados de detección.
if (retResult.noteType == eResult) {
El campo noteType indica el tipo de mensaje. Cuando es igual a eResult, el sensor ha proporcionado datos de medición.
Se imprime un encabezado para separar bloques de salida.
Serial.println("---------- RESULTS ------------");
Luego se lee la intensidad de luz ambiental.
float light = c4002.getLightIntensity();
Serial.print("Light: ");
Serial.print(light);
Serial.println(" lux");
La función getLightIntensity() devuelve el nivel de luz medido en lux.
A continuación se determina el estado del objetivo.
eTargetState_t targetState = c4002.getTargetState();
Serial.print("Target state: ");
La función getTargetState() indica si hay un objetivo presente y si está en movimiento o estacionario.
if (targetState == eNoTarget) {
Serial.println("No Target");
} else if (targetState == ePresence) {
Serial.println("Static Presence");
} else if (targetState == eMotion) {
Serial.println("Motion");
}
El código distingue entre sin objetivo, persona estacionaria y persona en movimiento.
Luego se obtiene la información del objetivo de presencia.
sPresenceTarget_t presenceTarget = c4002.getPresenceTargetInfo();
Serial.print("Presence distance: ");
Serial.print(presenceTarget.distance);
Serial.println(" m");
Serial.print("Presence energy: ");
Serial.println(presenceTarget.energy);
La función getPresenceTargetInfo() devuelve una estructura con la distancia y energía de señal de un objetivo estacionario. El valor de energía refleja la intensidad de la señal detectada.
A continuación se obtienen datos del objetivo en movimiento.
sMotionTarget_t motionTarget = c4002.getMotionTargetInfo();
Serial.print("Motion distance: ");
Serial.print(motionTarget.distance);
Serial.println(" m");
Serial.print("Motion energy: ");
Serial.println(motionTarget.energy);
La función getMotionTargetInfo() proporciona datos similares para objetivos en movimiento.
También se imprimen parámetros adicionales de movimiento.
Serial.print("Motion speed: ");
Serial.print(motionTarget.speed);
Serial.println(" m/s");
La velocidad del objetivo en movimiento se da en metros por segundo.
Finalmente, se evalúa la dirección del movimiento.
Serial.print("Motion direction: ");
if (motionTarget.direction == eAway) {
Serial.println("Away!");
} else if (motionTarget.direction == eNoDirection) {
Serial.println("No Direction!");
} else if (motionTarget.direction == eApproaching) {
Serial.println("Approaching!");
}
El sensor puede determinar si el objetivo se aleja, se acerca o si no se detecta una dirección clara.
Al final del bucle se añade un breve retardo.
} delay(50); }
Este retardo previene consultas excesivas y asegura comunicación estable.
Ejemplo de salida
La siguiente imagen muestra la información de detección que se imprime en el Monitor Serial:
Conclusiones
En este tutorial aprendiste cómo conectar el sensor mmWave C4002 a un Arduino o un ESP32 para detección de movimiento y presencia. En comparación con sensores de movimiento infrarrojos pasivos (PIR), el C4002 basado en radar es más fiable y puede detectar personas estacionarias en rangos de distancia específicos.
Si solo necesitas una señal binaria de detección (detectado, no detectado), puedes programar el sensor una vez (por ejemplo, establecer distancia de detección) mediante un microcontrolador y luego usar el pin OUT. Para acciones de control más complejas, puedes programar el microcontrolador para reaccionar a las mediciones del sensor.
Ten en cuenta que también existe el muy similar mmWave C4001, que tiene un rango mayor de 16–25 metros pero menos inteligencia integrada. Esto significa que normalmente necesitas manejar más lógica en el microcontrolador, como filtrado, interpretación de estados o construcción de comportamientos de alto nivel, al usar el C4001.
Para información adicional sobre el sensor mmWave C4002 consulta la página Wiki y el repo que contiene otros ejemplos de código.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
