Il sensore di presenza umana mmWave C4002 è un modulo radar progettato per un rilevamento umano preciso. Utilizza la tecnologia millimetrica FMCW a 24 GHz per rilevare sia il movimento che i micro-movimenti come la respirazione, permettendo di identificare le persone anche quando sono completamente immobili.
A differenza dei tradizionali PIR sensori, questo modulo fornisce il rilevamento della presenza. Può distinguere tra assenza di bersaglio, bersagli in movimento e presenza umana stazionaria entro un raggio fino a 10 metri. In questo tutorial imparerai come collegare il sensore mmWave C4002 a un Arduino o a un ESP32 per il rilevamento di presenza e movimento.
Parti necessarie
Puoi acquistare il sensore mmWave C4002 da DFRobot. Ti servirà anche un Arduino o un ESP32. In questo tutorial uso un Arduino UNO e un ESP32-C3 SuperMini, ma qualsiasi altro Arduino, ESP32 o ESP8266 funzionerà purché abbia un pin di uscita a 5V. Infine, una breadboard e alcuni cavi Dupont per i collegamenti saranno utili.
Sensore Radar mmWave C4002
ESP32-C3 SuperMini
Cavo USB C
Arduino Uno
Cavo USB per Arduino UNO
Set di cavi Dupont
Breadboard
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 sensore mmWave C4002
Il mmWave C4002 si basa sulla tecnologia radar FMCW (Frequency Modulated Continuous Wave) a 24 GHz. Emette continuamente onde elettromagnetiche nella banda da 24,0 GHz a 24,25 GHz e misura i segnali riflessi dagli oggetti nell’ambiente. L’immagine sotto mostra il retro e il fronte del modulo. Si possono vedere le due antenne radar dorate sul davanti della scheda.
Sul fronte della scheda si trovano anche un LED etichettato “RUN” e un LED etichettato “OUT”. Il LED verde RUN lampeggia quando il sensore è attivo nel rilevamento, mentre il LED blu OUT si accende se viene rilevata una persona.
La tecnica di modulazione FMCW permette al sensore di estrarre distanza, velocità e caratteristiche di movimento dal segnale riflesso. Il sensore può rilevare variazioni molto piccole di posizione, come il movimento del torace durante la respirazione. Questo consente il rilevamento di persone immobili, cosa non possibile con i sensori a infrarossi passivi.
Il radar funziona indipendentemente dalla luce ambientale e dalla temperatura. Non è influenzato da condizioni ambientali come oscurità, polvere o variazioni di calore. Questo migliora la stabilità nelle applicazioni smart home indoor.
Capacità di rilevamento e elaborazione del segnale
Il C4002 supporta il rilevamento umano multimodale, inclusi movimento, micro-movimento e completa immobilità. Può classificare lo stato del bersaglio in categorie come nessun bersaglio, bersaglio in movimento e presenza stazionaria.
La distanza massima di rilevamento è fino a 11 metri per il movimento e 10 metri per la presenza stazionaria. L’area di rilevamento copre circa uno spazio di 10 × 10 metri, a seconda delle condizioni di installazione.
Il sensore utilizza un’elaborazione interna del segnale per estrarre parametri aggiuntivi. Può riportare la distanza dal bersaglio, l’energia del segnale, la velocità e la direzione del movimento. Questi valori derivano dallo spostamento Doppler e dalle variazioni di frequenza nel segnale radar riflesso.
È implementato un algoritmo adattivo di filtraggio dello sfondo per ridurre i falsi rilevamenti. Il sensore impara l’ambiente statico e sopprime interferenze da fonti non umane come tende in movimento o flussi d’aria.
Campo visivo e copertura spaziale
Il modulo offre un ampio angolo di rilevamento di 120° orizzontalmente e verticalmente. Questo permette a un singolo sensore di coprire grandi aree interne con minime zone d’ombra.
La distanza di rilevamento può essere configurata via software. Questo consente agli sviluppatori di limitare la distanza di rilevamento a una zona specifica all’interno di una stanza. Aiuta a prevenire rilevamenti indesiderati attraverso pareti o in aree adiacenti.
La posizione di montaggio influisce sulla copertura effettiva. Il montaggio a soffitto fornisce un pattern di rilevamento dall’alto verso il basso, mentre il montaggio a parete genera un cono di rilevamento frontale.
Caratteristiche elettriche e interfacce
Il sensore funziona con alimentazione da 3,6 V a 5,5 V, rendendolo compatibile con piattaforme microcontrollore comuni come Arduino e ESP32.
Fornisce due interfacce di uscita principali. Un’interfaccia UART con baud rate 9600 è usata per la comunicazione dati dettagliata, inclusi misurazioni radar complete e comandi di configurazione. Un pin digitale OUT può essere configurato come segnale di presenza semplice per applicazioni a bassa complessità.
L’immagine sotto mostra il pinout del modulo con i pin per alimentazione (VIN), massa (GND), trasmissione seriale (TX), ricezione seriale (RX) e segnale di uscita digitale (OUT):
Funzionalità aggiuntive di rilevamento e ambientali
Il C4002 include un sensore di intensità luminosa con un intervallo da 0 a 50 lux. Questo permette il rilevamento combinato di presenza e luce ambientale in un unico modulo.
Il modulo supporta la calibrazione ambientale automatica. Durante il funzionamento può adattarsi all’ambiente circostante per migliorare la precisione del rilevamento. Questo riduce lo sforzo di taratura manuale durante l’installazione.
Specifiche tecniche
La tabella seguente riassume le specifiche tecniche del sensore mmWave C4004.
| Parametro | Specifiche |
|---|---|
| Tensione di funzionamento | 3,6 V a 5,5 V |
| Frequenza di funzionamento | 24,0 GHz a 24,25 GHz |
| Capacità di rilevamento | Rilevamento di movimento, micro-movimento e presenza umana stazionaria |
| Distanza massima di rilevamento | 11 m (movimento), 10 m (presenza stazionaria) |
| Angolo di rilevamento | 120° × 120° |
| Area di rilevamento | Copertura fino a 10 m × 10 m |
| Interfacce di uscita | UART e pin digitale OUT configurabile |
| Intervallo di rilevamento luce | 0 a 50 lux |
| Temperatura di funzionamento | −20 °C a 85 °C |
| Dimensioni modulo | 22 mm × 26 mm |
Uso del sensore mmWave C4002 senza microcontrollore
È necessario usare un microcontrollore (o un computer) per programmare impostazioni specifiche del sensore mmWave C4002. Ad esempio, puoi impostare la distanza di rilevamento o la sensibilità. Ma una volta configurato, puoi usare il C4002 senza microcontrollore.
Lo schema di collegamento sotto mostra come connettere un LED che si accende se il sensore rileva una persona. Basta fornire alimentazione (5V) ai pin VIN e GND e poi collegare un LED con una resistenza al pin OUT:
Per la maggior parte delle applicazioni pratiche probabilmente vorrai collegare un relè invece di un LED per commutare dispositivi a tensione o corrente più elevata. Questo è possibile ma dovrai usare un Relay Module con circuito amplificatore integrato, poiché il pin OUT non può pilotare direttamente la bobina del relè. Di seguito un esempio di circuito:
Per maggiori informazioni sui moduli relè vedi il How To Use A Relay With Arduino, Interfacing a Relay Module With ESP32 e il Control AC devices with Solid State Relay tutorial.
Nelle sezioni successive ti mostrerò come collegare il sensore mmWave C4002 a un Arduino o a un ESP32.
Collegamento del sensore mmWave C4002 ad Arduino
Collegare il sensore mmWave C4002 a un Arduino UNO è semplice. Inizia collegando VIN al 5V dell’Arduino. Poi collega GND a GND. Infine, colleghiamo l’interfaccia UART cablando RX a GPIO 5 e TX a GPIO 4. L’immagine sotto mostra il cablaggio completo:
Per comodità, ecco una tabella con i collegamenti da effettuare:
| C4002 | Arduino Uno |
|---|---|
| VIN | 5V |
| GND | GND |
| RX | GPIO 5 |
| TX | GPIO 4 |
Non ti servirà nemmeno una breadboard per collegare il sensore a un Arduino UNO. Quattro cavi Dupont sono sufficienti. La foto sotto mostra il mio cablaggio:
Collegamento del sensore mmWave C4002 a ESP32
L’ESP32 ha tre interfacce seriali e puoi configurare i pin e l’interfaccia che vuoi usare. Qui collego TX a GPIO 3 e RX a GPIO 4. Dovremo ricordarlo quando scriviamo il codice. Infine, colleghiamo VIN a 5V e GND a G. L’immagine sotto mostra il cablaggio completo:
Nota che ti serve un ESP32 con un pin di uscita a 5V e che devi collegare VIN del C4002 al pin 5V e non al comune pin 3.3V! L’immagine sotto mostra il pinout dell’ESP32-C3 Supermini che sto usando qui.
Ricorda che il C4002 necessita di 3,6V … 5V su VIN e 3,3V quindi non sono sufficienti. Per comodità, ecco una tabella con i collegamenti da effettuare.
| C4002 | ESP32-C3 Supermini |
|---|---|
| VIN | 5V |
| GND | G |
| RX | 4 |
| TX | 3 |
Installazione della libreria DFRobot_C4002
Prima di poter scrivere codice, dobbiamo installare la libreria DFRobot_C4002. Per installarla vai al repository DFRobot_C4002, clicca sul pulsante verde “<> Code” e poi su “Download ZIP” per scaricare la libreria come file ZIP, come mostrato sotto:
Poi crea un nuovo sketch Arduino, vai su Sketch -> Include Library -> Add .ZIP Library … per installare la libreria ZIP scaricata (DFRobot_C4002-master.zip):
Codice: Calibrazione del C4002
Il C4002 richiede un processo di calibrazione che stabilisce una baseline dell’ambiente circostante in modo che oggetti statici come muri o mobili non vengano rilevati erroneamente come bersagli. Poiché il sensore si basa sulle riflessioni radar, deve prima imparare cosa è “normale” in uno spazio dato prima di poter rilevare con affidabilità la presenza o il movimento umano.
La calibrazione si avvia con la funzione c4002.startEnvCalibration(delay, duration), dove il ritardo consente di liberare l’area e la durata definisce per quanto tempo il sensore misura l’ambiente. Durante questo periodo, il sensore registra le riflessioni di fondo e costruisce un modello interno. È importante che non ci siano persone presenti, poiché il movimento o anche la presenza statica possono influire negativamente sulla precisione.
Una volta completata la calibrazione, il sensore confronta i dati in tempo reale con questa baseline e riporta solo cambiamenti significativi. Questo consente un rilevamento preciso sia del movimento che della presenza statica. Per risultati ottimali, la calibrazione dovrebbe essere ripetuta ogni volta che l’ambiente cambia significativamente. Il codice seguente esegue questo processo di calibrazione:
// 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);
}
Importazioni
Lo sketch inizia includendo la libreria necessaria per il sensore. Questa libreria fornisce la classe DFRobot_C4002, che astrae la comunicazione e il controllo del sensore.
#include "DFRobot_C4002.h"
Comunicazione seriale
La sezione di codice successiva configura come il sensore comunica con il microcontrollore a seconda della piattaforma usata. Il codice verifica per quale scheda viene compilato e seleziona l’interfaccia seriale appropriata.
#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
Su schede come Arduino Uno o ESP8266, le porte seriali hardware sono limitate, quindi viene creato un oggetto SoftwareSerial sui pin 4 (RX) e 5 (TX). Questa interfaccia seriale viene poi passata all’oggetto DFRobot_C4002 insieme a un baud rate di 115200.
Sull’ESP32, il codice usa Serial1, che è una UART hardware. Inoltre, i pin 3 e 4 sono definiti per RX e TX.
Per altre schede, si usa l’interfaccia Serial1 di default senza specificare pin, assumendo che la configurazione hardware li definisca già.
Funzione Setup
La funzione setup() è responsabile di inizializzare la comunicazione seriale e preparare il sensore all’uso.
void setup() {
Serial.begin(115200);
Il monitor seriale viene inizializzato a 115200 baud per poter stampare messaggi di stato per debug e monitoraggio.
La parte successiva assicura che il sensore sia correttamente collegato e risponda.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
La funzione begin() tenta di inizializzare la comunicazione con il sensore. Se il sensore non viene rilevato, il ciclo continua a stampare un messaggio di errore ogni secondo. Questo blocca effettivamente l’esecuzione finché il sensore non viene trovato.
Dopo l’inizializzazione riuscita, il codice configura i LED a bordo del sensore.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
La funzione setRunLedState() controlla il LED indicatore di funzionamento interno, mentre setOutLedState() controlla il LED di uscita. Entrambi vengono accesi qui per fornire un feedback visivo che il sensore è attivo.
Vengono aggiunti brevi ritardi per garantire una comunicazione stabile tra i comandi.
Il codice poi si ferma per alcuni secondi prima di continuare.
delay(3000);
Successivamente viene configurato l’intervallo di segnalazione.
c4002.setReportPeriod(10);
La funzione setReportPeriod() imposta la frequenza con cui il sensore invia i dati. In questo caso, il periodo è impostato a 10 unità, che corrisponde a un ciclo di segnalazione di 10 * 0,1 = 1 secondo. Infine, viene avviata la calibrazione ambientale.
c4002.startEnvCalibration(10, 30); // Delay time：10s，Calibration time：30s
Serial.println("Start calibration:");
}
La funzione startEnvCalibration() avvia la calibrazione con due parametri. Il primo specifica un ritardo prima dell’inizio della calibrazione, il secondo definisce la durata del processo. Qui la calibrazione inizia dopo 10 secondi e dura 30 secondi.
Funzione Loop
La funzione loop() monitora continuamente lo stato del sensore, in particolare il processo di calibrazione.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
La funzione getNoteInfo() recupera le ultime informazioni di stato dal sensore. La struttura restituita sRetResult_t contiene vari campi che descrivono lo stato corrente.
Il codice verifica se il sensore è attualmente in modalità calibrazione.
if (retResult.noteType == eCalibration) {
Il campo noteType indica il tipo di notifica ricevuta. Quando è uguale a eCalibration, significa che il sensore è nella fase di calibrazione. Se la calibrazione è in corso, viene stampato il tempo rimanente.
Serial.print(retResult.calibCountdown);
Serial.println(" s");
Il campo calibCountdown contiene il numero di secondi rimanenti fino al completamento della calibrazione. Infine, il codice rileva quando la calibrazione è terminata.
if (retResult.calibCountdown == 0) {
Serial.println("Calibration Complete!");
}
}
delay(10);
}
Quando il conto alla rovescia arriva a zero, viene stampato un messaggio che indica il completamento della calibrazione.
Esempio di output
L’immagine sotto mostra cosa verrà stampato sul monitor seriale durante il processo di calibrazione. Come detto, non dovresti essere vicino al sensore durante la calibrazione.
Codice: Rilevamento di movimento e presenza con C4002
Una volta calibrato, il sensore può essere usato per il rilevamento. Il seguente esempio di codice mostra che tipo di rilevamenti e misurazioni il sensore può effettuare:
// 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);
}
Importazioni
Lo sketch inizia includendo la libreria necessaria per il sensore. Questa libreria definisce la classe DFRobot_C4002 e diversi tipi di dati correlati come sRetResult_t, sPresenceTarget_t e sMotionTarget_t.
#include "DFRobot_C4002.h"
Compilazione condizionale e inizializzazione dell’oggetto
Successivamente configuriamo l’interfaccia seriale per la comunicazione UART come prima. La configurazione dipende dal microcontrollore.
#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
Su schede come Arduino Uno o ESP8266, viene creato un oggetto SoftwareSerial usando i pin 4 e 5. Sull’ESP32 usiamo i pin 3 e 4 ma puoi sceglierne altri. Assicurati solo che il cablaggio hardware corrisponda ai pin nella configurazione.
Funzione Setup
La funzione setup() inizializza la comunicazione e configura in dettaglio i parametri del sensore.
void setup() {
Serial.begin(115200);
La comunicazione seriale viene avviata per permettere il debug e l’output dati tramite il monitor seriale. La sezione successiva assicura che il sensore sia collegato e risponda.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
La funzione begin() inizializza il sensore. Se l’inizializzazione fallisce, il codice stampa ripetutamente un messaggio di errore e riprova ogni secondo.
Dopo l’inizializzazione riuscita, i LED del sensore vengono abilitati.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
Questi LED forniscono un feedback visivo sul funzionamento del sensore. Il LED “Run” lampeggia con luce verde durante il rilevamento. Il LED “Out” si accende se viene rilevata una persona.
Successivamente configuriamo il pin di uscita (OUT).
c4002.setOutPinMode(eOutpinMode1); // Motion detected delay(50);
La funzione setOutPinMode() determina quale condizione attiva il pin OUT del sensore. In questo caso, eOutpinMode1 lo configura per indicare il rilevamento di movimento. Per altre modalità, vedi il 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;
Poi viene definito il raggio di rilevamento.
c4002.setDetectRange(0, 1100); // 0-1100 cm delay(50);
La funzione setDetectRange() imposta la distanza minima e massima di rilevamento in centimetri. Qui il sensore è configurato per rilevare bersagli tra 0 cm e 1100 cm (11 metri).
La soglia di luce ambientale viene configurata successivamente.
c4002.setLightThresh(0); //0-50 lux delay(50);
La funzione setLightThresh() imposta il livello minimo di luce richiesto per il rilevamento. Un valore di 0 disabilita di fatto il filtro basato sulla luce, permettendo il rilevamento in tutte le condizioni di illuminazione.
Viene poi impostato il ritardo prima che un bersaglio sia considerato scomparso.
c4002.setTargetDisappearDelay(1); // 0-65535s delay(50);
La funzione setTargetDisappearDelay() definisce quanto tempo il sensore aspetta prima di dichiarare che un bersaglio rilevato è sparito. In questo caso, il ritardo è impostato a 1 secondo.
L’intervallo di segnalazione viene configurato per ultimo.
c4002.setReportPeriod(10); // 10 * 0.1s = 1s delay(50); }
La funzione setReportPeriod() determina con quale frequenza il sensore invia i dati. Un valore di 10 corrisponde a intervalli di 1 secondo.
Brevi ritardi tra i comandi di configurazione assicurano una comunicazione stabile con il sensore.
Funzione Loop
La funzione loop() legge e processa continuamente i dati del sensore.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
La funzione getNoteInfo() recupera l’ultima notifica dal sensore. La struttura restituita contiene informazioni sul tipo di dati disponibili.
Il codice verifica se i dati ricevuti contengono risultati di rilevamento.
if (retResult.noteType == eResult) {
Il campo noteType indica il tipo di messaggio. Quando è uguale a eResult, il sensore ha fornito dati di misurazione.
Viene stampato un’intestazione per separare i blocchi di output.
Serial.println("---------- RESULTS ------------");
Viene quindi letta l’intensità della luce ambientale.
float light = c4002.getLightIntensity();
Serial.print("Light: ");
Serial.print(light);
Serial.println(" lux");
La funzione getLightIntensity() restituisce il livello di luce misurato in lux.
Successivamente viene determinato lo stato del bersaglio.
eTargetState_t targetState = c4002.getTargetState();
Serial.print("Target state: ");
La funzione getTargetState() indica se un bersaglio è presente e se si muove o è fermo.
if (targetState == eNoTarget) {
Serial.println("No Target");
} else if (targetState == ePresence) {
Serial.println("Static Presence");
} else if (targetState == eMotion) {
Serial.println("Motion");
}
Il codice distingue tra nessun bersaglio, persona ferma e persona in movimento.
Vengono poi recuperate le informazioni sul bersaglio di presenza.
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 funzione getPresenceTargetInfo() restituisce una struttura contenente la distanza e l’energia del segnale di un bersaglio stazionario. Il valore di energia riflette la forza del segnale rilevato.
Successivamente si ottengono i dati sul bersaglio in movimento.
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 funzione getMotionTargetInfo() fornisce dati simili per i bersagli in movimento.
Vengono stampati anche parametri aggiuntivi sul movimento.
Serial.print("Motion speed: ");
Serial.print(motionTarget.speed);
Serial.println(" m/s");
La velocità del bersaglio in movimento è espressa in metri al secondo.
Infine viene valutata la direzione del movimento.
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!");
}
Il sensore può determinare se il bersaglio si sta allontanando, avvicinando o se non è rilevata una direzione chiara.
Alla fine del ciclo viene aggiunto un breve ritardo.
} delay(50); }
Questo ritardo previene un polling eccessivo e garantisce una comunicazione stabile.
Esempio di output
L’immagine seguente mostra quali informazioni di rilevamento vengono stampate sul monitor seriale:
Conclusioni
In questo tutorial hai imparato come collegare il sensore mmWave C4002 a un Arduino o a un ESP32 per il rilevamento di movimento e presenza. Rispetto ai sensori di movimento a infrarossi passivi (PIR), il C4002 basato su radar è più affidabile e può rilevare persone immobili a distanze specifiche.
Se ti serve solo un segnale di rilevamento binario (rilevato, non rilevato), puoi programmare il sensore una volta (ad esempio impostare la distanza di rilevamento) tramite un microcontrollore e poi usare il pin OUT. Per azioni di controllo più complesse puoi programmare il microcontrollore per reagire alle misurazioni del sensore.
Nota che esiste anche il molto simile mmWave C4001, che ha un raggio maggiore di 16–25 metri ma meno intelligenza integrata. Questo significa che di solito devi gestire più logica sul microcontrollore, come filtraggio, interpretazione degli stati o costruzione di comportamenti di livello superiore, quando usi il C4001.
Per ulteriori informazioni sul sensore mmWave C4002 vedi la pagina Wiki e il repo che contiene altri esempi di codice.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering ; )
