O Sensor de Presença Humana mmWave C4002 é um módulo baseado em radar projetado para detecção precisa de pessoas. Utiliza tecnologia FMCW de ondas milimétricas a 24 GHz para detectar tanto movimento quanto micro-movimentos, como a respiração, permitindo identificar pessoas mesmo quando estão completamente paradas.
Ao contrário dos sensores tradicionais PIR, este módulo oferece detecção de presença. Pode distinguir entre ausência de alvo, alvos em movimento e presença humana estacionária num alcance de até 10 metros. Neste tutorial, aprenderás a ligar o sensor mmWave C4002 a um Arduino ou ESP32 para deteção de presença e movimento.
Peças Necessárias
Podes adquirir o Sensor mmWave C4002 na DFRobot. Também vais precisar de um Arduino ou um ESP32. Neste tutorial, uso um Arduino UNO e um ESP32-C3 SuperMini, mas qualquer outro Arduino, ESP32 ou ESP8266 serve, desde que tenha um pino de saída de 5V. Por fim, uma breadboard e alguns cabos Dupont para as ligações serão úteis.
Sensor Radar mmWave C4002
ESP32-C3 SuperMini
Cabo USB C
Arduino Uno
Cabo USB para Arduino UNO
Conjunto de Cabos 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 do Sensor mmWave C4002
O mmWave C4002 baseia-se na tecnologia radar FMCW (Frequency Modulated Continuous Wave) a 24 GHz. Emite continuamente ondas eletromagnéticas na faixa de 24.0 GHz a 24.25 GHz e mede os sinais refletidos pelos objetos no ambiente. A imagem abaixo mostra a parte frontal e traseira do módulo, onde se podem ver as duas antenas douradas de radar na frente da placa.
Também podes ver um LED rotulado “RUN” e outro “OUT” na frente da placa. O LED verde RUN pisca quando o sensor está a detetar ativamente e o LED azul OUT acende-se se uma pessoa for detetada.
A técnica de modulação FMCW permite ao sensor extrair distância, velocidade e características de movimento do sinal refletido. O sensor pode detetar mudanças muito pequenas na posição, como o movimento do peito durante a respiração. Isto possibilita a deteção de pessoas estacionárias, algo que não é possível com sensores infravermelhos passivos.
O radar opera independentemente da luz ambiente e da temperatura. Não é afetado por condições ambientais como escuridão, poeira ou variações de calor. Isto melhora a estabilidade em aplicações domésticas inteligentes interiores.
Capacidades de Deteção e Processamento de Sinal
O C4002 suporta deteção humana em múltiplos modos, incluindo movimento, micro-movimento e imobilidade completa. Pode classificar o estado do alvo em categorias como ausência de alvo, alvo em movimento e presença estacionária.
O alcance máximo de deteção é até 11 metros para movimento e 10 metros para presença estacionária. A área de deteção cobre aproximadamente um espaço de 10 × 10 metros, dependendo das condições de instalação.
O sensor utiliza processamento interno de sinal para extrair parâmetros adicionais. Pode reportar distância ao alvo, energia do sinal, velocidade e direção do movimento. Estes valores são derivados do efeito Doppler e das mudanças de frequência no sinal radar refletido.
Um algoritmo adaptativo de filtragem de fundo é implementado para reduzir falsas deteções. O sensor aprende o ambiente estático e suprime interferências de fontes não humanas, como cortinas em movimento ou fluxo de ar.
Campo de Visão e Cobertura Espacial
O módulo oferece um amplo ângulo de deteção de 120° horizontal e verticalmente. Isto permite que um único sensor cubra grandes áreas interiores com pontos cegos mínimos.
O alcance de deteção pode ser configurado por software. Isto permite aos desenvolvedores limitar a distância de deteção a uma zona específica dentro de uma divisão, ajudando a evitar deteções indesejadas através de paredes ou em áreas adjacentes.
A posição de montagem afeta a cobertura efetiva. A montagem no teto proporciona um padrão de deteção de cima para baixo, enquanto a montagem na parede resulta num cone de deteção voltado para a frente.
Características Elétricas e Interfaces
O sensor opera com uma alimentação de 3.6 V a 5.5 V, tornando-o compatível com plataformas comuns de microcontroladores como Arduino e ESP32.
Fornece duas interfaces principais de saída. Uma interface UART com baud rate de 9600 para comunicação detalhada de dados, incluindo medições completas do radar e comandos de configuração. Um pino digital OUT pode ser configurado como sinal simples de presença para aplicações de baixa complexidade.
A imagem abaixo mostra o pinout do módulo com pinos para alimentação (VIN), terra (GND), transmissão serial (TX), receção serial (RX) e sinal digital de saída (OUT):
Funcionalidades Adicionais de Sensores e Ambiente
O C4002 inclui um sensor de intensidade luminosa com alcance de 0 a 50 lux. Isto permite deteção combinada de presença e luz ambiente num único módulo.
O módulo suporta calibração ambiental automática. Durante a operação, pode adaptar-se ao ambiente circundante para melhorar a precisão da deteção, reduzindo o esforço de ajuste manual durante a instalação.
Especificações Técnicas
A tabela seguinte resume as especificações técnicas do Sensor mmWave C4004.
| Parâmetro | Especificação |
|---|---|
| Tensão de Operação | 3.6 V a 5.5 V |
| Frequência de Operação | 24.0 GHz a 24.25 GHz |
| Capacidade de Deteção | Movimento, micro-movimento e deteção humana estacionária |
| Distância Máxima de Deteção | 11 m (movimento), 10 m (presença estacionária) |
| Ângulo de Deteção | 120° × 120° |
| Área de Deteção | Cobertura até 10 m × 10 m |
| Interfaces de Saída | UART e pino digital OUT configurável |
| Alcance de Deteção de Luz | 0 a 50 lux |
| Temperatura de Operação | −20 °C a 85 °C |
| Dimensões do Módulo | 22 mm × 26 mm |
Usar o Sensor mmWave C4002 sem Microcontrolador
É necessário usar um microcontrolador (ou computador) para programar configurações específicas do Sensor mmWave C4002. Por exemplo, podes definir a distância de deteção ou a sensibilidade. Mas, uma vez configurado, podes usar o C4002 sem microcontrolador.
O diagrama de ligações abaixo mostra como ligar um LED que acende se o sensor detetar uma pessoa. Basta fornecer energia (5V) aos pinos VIN e GND e depois ligar um LED com um resistor ao pino OUT:
Para a maioria das aplicações práticas, provavelmente quererás ligar um Relé em vez de um LED para controlar dispositivos de maior tensão ou corrente. Isto é possível, mas precisarás de um Relay Module com circuito amplificador integrado, pois o pino OUT não pode acionar diretamente a bobina do relé. Abaixo está um circuito de exemplo:
Para mais informações sobre módulos relé, vê os How To Use A Relay With Arduino, Interfacing a Relay Module With ESP32 e o Control AC devices with Solid State Relay tutoriais.
Nas próximas secções, vou mostrar como ligar o Sensor mmWave C4002 a um Arduino ou ESP32.
Ligação do Sensor mmWave C4002 ao Arduino
Ligar o Sensor mmWave C4002 a um Arduino UNO é fácil. Começa por ligar o VIN ao 5V do Arduino. Depois liga o GND ao GND. Finalmente, liga a interface UART ligando RX ao GPIO 5 e TX ao GPIO 4. A imagem abaixo mostra a ligação completa:
Para conveniência, aqui está uma tabela com as ligações que precisas de fazer:
| C4002 | Arduino Uno |
|---|---|
| VIN | 5V |
| GND | GND |
| RX | GPIO 5 |
| TX | GPIO 4 |
Nem precisas de uma breadboard para ligar o sensor a um Arduino UNO. Quatro cabos Dupont são suficientes. A foto abaixo mostra a minha ligação:
Ligação do Sensor mmWave C4002 ao ESP32
O ESP32 tem três interfaces seriais e podes configurar os pinos e a interface que queres usar. Aqui ligo o TX ao GPIO 3 e o RX ao GPIO 4. Precisamos de lembrar isto ao escrever o código. Finalmente, ligamos o VIN ao 5V e o GND ao G. A imagem abaixo mostra a ligação completa:
Nota que precisas de um ESP32 com um pino de saída de 5V e que deves ligar o VIN do C4002 ao pino 5V e não ao comum pino de 3.3V! A imagem abaixo mostra o pinout do ESP32-C3 Supermini que estou a usar aqui.
Lembra que o C4002 precisa de 3.6V … 5V no VIN, portanto 3.3V não é suficiente. Para conveniência, aqui está uma tabela com as ligações que precisas de fazer.
| C4002 | ESP32-C3 Supermini |
|---|---|
| VIN | 5V |
| GND | G |
| RX | 4 |
| TX | 3 |
Instalar a biblioteca DFRobot_C4002
Antes de escrever código, precisas instalar a biblioteca DFRobot_C4002. Para instalar esta biblioteca, vai ao repositório DFRobot_C4002, clica no botão verde “<> Code” e depois em “Download ZIP” para descarregar a biblioteca como um ficheiro ZIP, como mostrado abaixo:
Depois cria um novo Sketch no Arduino, vai a Sketch -> Include Library -> Add .ZIP Library … para instalar a biblioteca ZIP descarregada (DFRobot_C4002-master.zip):
Código: Calibrar o C4002
O C4002 requer um processo de calibração que estabelece uma linha base do ambiente circundante para que objetos estáticos, como paredes ou móveis, não sejam falsamente detetados como alvos. Como o sensor depende de reflexões de radar, deve primeiro aprender o que é “normal” num dado espaço antes de detetar com fiabilidade presença humana ou movimento.
A calibração é iniciada usando a função c4002.startEnvCalibration(delay, duration), onde o atraso permite tempo para desocupar a área e a duração define quanto tempo o sensor mede o ambiente. Durante este período, o sensor regista reflexões de fundo e constrói um modelo interno. É importante que não haja pessoas presentes, pois movimento ou presença estacionária podem afetar negativamente a precisão.
Quando a calibração termina, o sensor compara os dados em tempo real com esta linha base e só reporta mudanças significativas. Isto permite deteção precisa de movimento e presença estática. Para melhores resultados, a recalibração deve ser repetida sempre que o ambiente mudar significativamente. O código seguinte executa este processo de calibração:
// 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);
}
Importações
O sketch começa por incluir a biblioteca necessária para o sensor. Esta biblioteca fornece a classe DFRobot_C4002, que abstrai a comunicação e controlo do sensor.
#include "DFRobot_C4002.h"
Comunicação Serial
A secção seguinte configura como o sensor comunica com o microcontrolador, dependendo da plataforma usada. O código verifica para que placa está a ser compilado e seleciona a interface serial apropriada.
#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
Em placas como Arduino Uno ou ESP8266, as portas seriais de hardware são limitadas, por isso é criada uma instância SoftwareSerial nos pinos 4 (RX) e 5 (TX). Esta interface serial é então passada ao objeto DFRobot_C4002 juntamente com um baud rate de 115200.
No ESP32, o código usa Serial1, que é um UART de hardware. Além disso, os pinos 3 e 4 são definidos para RX e TX.
Para outras placas, é usada a interface Serial1 padrão sem especificar pinos, assumindo que a configuração de hardware já os define.
Função Setup
A função setup() é responsável por inicializar a comunicação serial e preparar o sensor para operação.
void setup() {
Serial.begin(115200);
O monitor serial é iniciado a 115200 baud para que mensagens de estado possam ser impressas para depuração e monitorização.
A parte seguinte garante que o sensor está corretamente ligado e responde.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
A função begin() tenta inicializar a comunicação com o sensor. Se o sensor não for detetado, o loop continua a imprimir uma mensagem de erro a cada segundo, bloqueando efetivamente a execução até o sensor ser encontrado.
Após a inicialização bem-sucedida, o código configura os LEDs a bordo do sensor.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
A função setRunLedState() controla o LED indicador interno de funcionamento, enquanto setOutLedState() controla o LED de saída. Ambos são ligados aqui para fornecer feedback visual de que o sensor está ativo.
São adicionados pequenos atrasos para garantir comunicação estável entre comandos.
O código pausa então por alguns segundos antes de continuar.
delay(3000);
De seguida, o intervalo de reporte é configurado.
c4002.setReportPeriod(10);
A função setReportPeriod() define com que frequência o sensor reporta dados. Neste caso, o período é definido para 10 unidades, o que resulta num ciclo de reporte de 10 * 0.1 = 1 segundo. Finalmente, a calibração ambiental é iniciada.
c4002.startEnvCalibration(10, 30); // Delay time：10s，Calibration time：30s
Serial.println("Start calibration:");
}
A função startEnvCalibration() inicia a calibração com dois parâmetros. O primeiro especifica um atraso antes do início da calibração e o segundo define a duração do processo. Aqui, a calibração começa após 10 segundos e dura 30 segundos.
Função Loop
A função loop() monitora continuamente o estado do sensor, especialmente o processo de calibração.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
A função getNoteInfo() obtém a informação de estado mais recente do sensor. A estrutura retornada sRetResult_t contém vários campos que descrevem o estado atual.
O código verifica se o sensor está atualmente em modo de calibração.
if (retResult.noteType == eCalibration) {
O campo noteType indica o tipo de notificação recebida. Quando é igual a eCalibration, significa que o sensor está na fase de calibração. Se a calibração estiver em curso, o tempo restante é impresso.
Serial.print(retResult.calibCountdown);
Serial.println(" s");
O campo calibCountdown contém o número de segundos restantes até a calibração terminar. Finalmente, o código deteta quando a calibração termina.
if (retResult.calibCountdown == 0) {
Serial.println("Calibration Complete!");
}
}
delay(10);
}
Quando a contagem regressiva chega a zero, é impressa uma mensagem a indicar que a calibração está completa.
Exemplo de Saída
A imagem abaixo mostra o que será impresso no Monitor Serial enquanto o processo de calibração está a decorrer. Como mencionado, não deves estar perto do sensor durante a calibração.
Código: Deteção de Movimento e Presença com C4002
Uma vez calibrado, o sensor pode ser usado para deteção. O exemplo de código seguinte mostra que tipo de deteções e medições o sensor pode realizar:
// 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);
}
Importações
O sketch começa por incluir a biblioteca necessária para o sensor. Esta biblioteca define a classe DFRobot_C4002 e vários tipos de dados relacionados, como sRetResult_t, sPresenceTarget_t e sMotionTarget_t.
#include "DFRobot_C4002.h"
Compilação Condicional e Inicialização do Objeto
De seguida, configuramos a interface serial para comunicação UART como antes. A configuração depende do 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
Em placas como Arduino Uno ou ESP8266, é criada uma instância SoftwareSerial usando os pinos 4 e 5. No ESP32, usamos os pinos 3 e 4, mas podes escolher outros. Só certifica-te que a ligação física corresponde aos pinos na configuração.
Função Setup
A função setup() inicializa a comunicação e configura os parâmetros do sensor em detalhe.
void setup() {
Serial.begin(115200);
A comunicação serial é iniciada para permitir depuração e saída de dados via monitor serial. A secção seguinte garante que o sensor está ligado e responde.
while (!c4002.begin()) {
Serial.println("Can't find C4002!");
delay(1000);
}
A função begin() inicializa o sensor. Se a inicialização falhar, o código imprime repetidamente uma mensagem de erro e tenta novamente a cada segundo.
Após a inicialização bem-sucedida, os LEDs do sensor são ativados.
c4002.setRunLedState(eLedOn); delay(50); c4002.setOutLedState(eLedOn); delay(50);
Estes LEDs fornecem feedback visual sobre o funcionamento do sensor. O LED “Run” pisca com luz verde enquanto as deteções estão ativas. O LED “Out” acende-se se uma pessoa for detetada.
De seguida, configuramos o pino de saída (OUT).
c4002.setOutPinMode(eOutpinMode1); // Motion detected delay(50);
A função setOutPinMode() determina qual a condição que ativa o pino OUT do sensor. Neste caso, eOutpinMode1 configura-o para indicar deteção de movimento. Para outros modos, vê o 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;
De seguida, define-se o alcance de deteção.
c4002.setDetectRange(0, 1100); // 0-1100 cm delay(50);
A função setDetectRange() define as distâncias mínima e máxima de deteção em centímetros. Aqui, o sensor está configurado para detetar alvos entre 0 cm e 1100 cm (11 metros).
O limiar de luz ambiente é configurado a seguir.
c4002.setLightThresh(0); //0-50 lux delay(50);
A função setLightThresh() define o nível mínimo de luz necessário para deteção. Um valor de 0 desativa efetivamente o filtro baseado em luz, permitindo deteção em todas as condições de iluminação.
O atraso antes de considerar que um alvo desapareceu é então definido.
c4002.setTargetDisappearDelay(1); // 0-65535s delay(50);
A função setTargetDisappearDelay() define quanto tempo o sensor espera antes de declarar que um alvo detetado desapareceu. Neste caso, o atraso é de 1 segundo.
Por fim, configura-se o intervalo de reporte.
c4002.setReportPeriod(10); // 10 * 0.1s = 1s delay(50); }
A função setReportPeriod() determina com que frequência o sensor envia dados. Um valor de 10 corresponde a intervalos de 1 segundo.
Pequenos atrasos entre comandos de configuração garantem comunicação estável com o sensor.
Função Loop
A função loop() lê e processa continuamente os dados do sensor.
void loop() {
sRetResult_t retResult = c4002.getNoteInfo();
A função getNoteInfo() obtém a notificação mais recente do sensor. A estrutura retornada contém informação sobre o tipo de dados disponíveis.
O código verifica se os dados recebidos contêm resultados de deteção.
if (retResult.noteType == eResult) {
O campo noteType indica o tipo de mensagem. Quando é igual a eResult, o sensor forneceu dados de medição.
É impresso um cabeçalho para separar os blocos de saída.
Serial.println("---------- RESULTS ------------");
De seguida, é lida a intensidade da luz ambiente.
float light = c4002.getLightIntensity();
Serial.print("Light: ");
Serial.print(light);
Serial.println(" lux");
A função getLightIntensity() retorna o nível de luz medido em lux.
Depois, determina-se o estado do alvo.
eTargetState_t targetState = c4002.getTargetState();
Serial.print("Target state: ");
A função getTargetState() indica se um alvo está presente e se está em movimento ou estacionário.
if (targetState == eNoTarget) {
Serial.println("No Target");
} else if (targetState == ePresence) {
Serial.println("Static Presence");
} else if (targetState == eMotion) {
Serial.println("Motion");
}
O código distingue entre ausência de alvo, pessoa estacionária e pessoa em movimento.
De seguida, obtém-se a informação do alvo de presença.
sPresenceTarget_t presenceTarget = c4002.getPresenceTargetInfo();
Serial.print("Presence distance: ");
Serial.print(presenceTarget.distance);
Serial.println(" m");
Serial.print("Presence energy: ");
Serial.println(presenceTarget.energy);
A função getPresenceTargetInfo() retorna uma estrutura contendo a distância e energia do sinal de um alvo estacionário. O valor da energia reflete a força do sinal detetado.
Depois, obtêm-se dados do alvo em 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);
A função getMotionTargetInfo() fornece dados semelhantes para alvos em movimento.
Parâmetros adicionais de movimento também são impressos.
Serial.print("Motion speed: ");
Serial.print(motionTarget.speed);
Serial.println(" m/s");
A velocidade do alvo em movimento é dada em metros por segundo.
Por fim, avalia-se a direção do 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!");
}
O sensor pode determinar se o alvo está a afastar-se, a aproximar-se ou se não há direção clara detectada.
No final do loop, é adicionado um pequeno atraso.
} delay(50); }
Este atraso evita polling excessivo e garante comunicação estável.
Exemplo de Saída
A imagem seguinte mostra a informação de deteção impressa no Monitor Serial:
Conclusões
Neste tutorial aprendeste a ligar o sensor mmWave C4002 a um Arduino ou ESP32 para deteção de movimento e presença. Em comparação com sensores de movimento por infravermelhos passivos (PIR), o C4002 baseado em radar é mais fiável e pode detetar pessoas estacionárias em faixas de distância específicas.
Se só precisares de um sinal binário de deteção (detetado, não detetado), podes programar o sensor uma vez (por exemplo, definir a distância de deteção) via microcontrolador e depois usar o pino OUT. Para ações de controlo mais complexas, podes programar o microcontrolador para reagir às medições do sensor.
Note que existe também o muito semelhante mmWave C4001, que tem um alcance maior de 16–25 metros mas menos inteligência incorporada. Isto significa que normalmente precisas de tratar mais lógica no microcontrolador, como filtragem, interpretação de estados ou construção de comportamentos de nível superior, ao usar o C4001.
Para mais informações sobre o sensor mmWave C4002, vê a página Wiki e o repo que tem outros exemplos de código.
Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.
Boas experiências a criar ; )
