Sensor de Gestos Gravity & Detecção Facial

O Gravity Offline Edge AI Gesture & Face Detection Sensor é um módulo de visão compacto que realiza deteção de gestos e faces em tempo real diretamente no dispositivo. Integra uma pequena câmara e um processador AI onboard capaz de reconhecer cinco gestos de mão predefinidos e detetar até 10 faces ou alvos de parte superior do corpo a distâncias de vários metros. Como toda a inferência é feita localmente, o sensor oferece baixa latência e evita qualquer dependência de cloud ou rede.

O sensor suporta interfaces I2C e UART e funciona com uma alimentação de 3,3 V a 5 V, tornando-o compatível com plataformas como Arduino, ESP32 e Raspberry Pi. Isto torna o módulo útil para controlo sem toque, deteção de presença e outras aplicações de edge-AI que preservam a privacidade.

A seguir, vai aprender como ligar o módulo sensor a um Arduino UNO ou a um ESP32, como programá-lo para deteção de gestos e faces e como construir um contador de ocupação de sala com ele.

Peças Necessárias

Para este tutorial vai precisar do Gravity Gesture & Face Detection Sensor da DFRobot. Além disso, vai precisar de um microcontrolador. Eu estou a usar um Arduino UNO e um ESP32-C3 SuperMini, mas outras placas Arduino ou ESP32 também funcionam bem. O único requisito é suporte para uma interface I2C (ou UART).

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 Gravity Gesture & Face Detection Sensor

O sensor Gravity integra uma câmara compacta e um processador AI embutido que trata toda a deteção de gestos e presença humana localmente. Isto significa que não é necessário computador externo nem ligação à cloud: o sensor realiza a inferência em tempo real, diretamente no módulo. A imagem abaixo mostra a frente e o verso do módulo sensor:

Capacidades de Reconhecimento de Gestos

O módulo é capaz de reconhecer cinco gestos de mão predefinidos num alcance de deteção de cerca de 0,5 a 3 metros. Os gestos suportados incluem o polegar para cima 👍, o sinal “OK” 👌, o gesto de palma aberta “pare” ✋, o sinal de “vitória” ✌️ e o gesto “liga para mim” 🤙.

Após o reconhecimento bem-sucedido de um gesto, o sensor fornece uma saída digital (via interrupção) e uma indicação visual: um LED RGB muda de cor dependendo do gesto reconhecido. Pode ver os gestos e as cores correspondentes impressas na placa:

Deteção de Faces e Parte Superior do Corpo / Presença

Para além dos gestos de mão, o sensor suporta a deteção de faces humanas ou presença da parte superior do corpo (cabeça e ombros). Pode detetar e seguir até 10 faces ou corpos distintos simultaneamente. Para cada pessoa detetada, o módulo pode fornecer coordenadas posicionais (X/Y dentro do quadro da câmara) e um índice de confiança, permitindo aplicações mais avançadas como contagem de pessoas, automação baseada em presença ou interações sensíveis à localização.

Campo de Visão, Óptica e Alcance de Deteção

A câmara onboard tem um campo de visão diagonal (FOV) de aproximadamente 85°, o que oferece uma cobertura relativamente ampla da cena, adequada para detetar pessoas ou gestos numa sala inteira em vez de apenas num ponto central estreito. O alcance efetivo especificado para deteção de gestos e presença/faces varia de cerca de 0,5 m até 3 m. A distância focal da câmara é de 1,56 mm, otimizada para deteção de ângulo largo em curtas a médias distâncias.

Interfaces Elétricas e de Comunicação

O sensor foi projetado para ampla compatibilidade com plataformas embutidas típicas. Funciona com uma tensão de alimentação entre 3,3 V e 5 V, com nível lógico de 3,3 V. O seu consumo típico é cerca de 100 mA, tornando-o adequado mesmo para sistemas de baixa potência ou alimentados por bateria.

Para saída de dados e integração, o módulo suporta duas interfaces de comunicação: I2C e UART. O utilizador pode selecionar a interface através de um interruptor na placa. O endereço I2C padrão é 0x72. Se usar UART, a taxa de transmissão padrão é 9600 bps usando protocolo Modbus-RTU.

Note que há um interruptor na placa que deve ser ajustado para a comunicação escolhida (I2C ou UART):

Além disso, o módulo oferece um pino de saída de interrupção INT (num conector de 2,54 mm) que fica em nível baixo quando um gesto é reconhecido. Isto é útil para disparar ações externas ou do microcontrolador sem necessidade de polling contínuo.

Dimensões Físicas e Formato

A placa do sensor mede 42 mm × 32 mm, sendo compacta o suficiente para integrar em projetos ou caixas pequenas. Possui furos de montagem: o espaçamento para montagem é 25 mm × 35 mm, e os furos têm diâmetro de 3,1 mm. A placa usa um conector PH2.0-4P (ou opcionalmente furos para header padrão de 2,54 mm) para linhas de alimentação e dados.

Especificações Técnicas

A tabela seguinte resume as características técnicas do Gravity Offline Edge AI Gesture & Face Detection Sensor

Parâmetro	Descrição
Modelo	Gravity Offline Edge AI Gesture & Face Detection Sensor (V1.0)
Método de processamento	Inferência AI onboard para deteção de gestos, faces e parte superior do corpo
Campo de visão da câmara	Aproximadamente 85° diagonal
Distância focal	1,56 mm
Alcance de deteção	0,5 m a 3 m para gestos e deteção de faces/presença
Reconhecimento de gestos	Cinco gestos predefinidos (OK, polegar para cima, vitória, pare, hang-loose)
Deteção de face / presença	Até 10 faces ou alvos de parte superior do corpo simultaneamente com saída de posição e confiança
Interfaces	I2C (endereço padrão 0x72) e UART (9600 bps, Modbus-RTU)
Saída de interrupção	Pino de interrupção ativo em nível baixo disparado no reconhecimento de gestos
Tensão de operação	3,3 V a 5 V (nível lógico 3,3 V)
Corrente de operação	~100 mA típico
Indicação de estado	LED RGB com feedback de cor dependente do gesto
Conector	PH2.0-4P ou pads para header de 2,54 mm
Dimensões da placa	42 mm × 32 mm
Montagem	Furos de 3,1 mm com espaçamento de 25 mm × 35 mm
Suporte de software	Bibliotecas Arduino / ESP32, MakeCode, Mind+

Ligação do Gravity Gesture & Face Detection Sensor ao Arduino

Pode ligar o Gravity Gesture & Face Detection Sensor via I2C ou UART. Vamos usar a interface I2C, pois é mais rápida e permite ligar múltiplos dispositivos ao mesmo barramento. O diagrama de ligação seguinte mostra como ligar o sensor a um Arduino UNO:

Comece por ligar o GND do Arduino ao GND do Sensor. Depois ligue a saída 5V (ou a saída 3,3V) ao pino VCC do Sensor. Finalmente, ligue SDA/A4 a D/T e SCL/A5 a C/R.

Certifique-se de que o interruptor de comunicação na placa do Sensor está na posição I2C e não UART!

Instalar Bibliotecas

Antes de poder usar o Gravity Gesture & Face Detection Sensor precisa de instalar a DFRobot_GestureFaceDetection biblioteca. Abra o LIBRARY MANAGER, escreva “DFRobot_GestureFaceDetection” na barra de pesquisa e pressione INSTALL para instalar a biblioteca conforme mostrado abaixo:

Provavelmente verá um diálogo a pedir para instalar dependências da biblioteca. Basta pressionar INSTALL ALL:

Agora está pronto para experimentar alguns exemplos de código.

Exemplo de Código: Reconhecimento de Gestos

Este primeiro exemplo de código mostra como funciona o reconhecimento de gestos:

#include "DFRobot_GestureFaceDetection.h"

DFRobot_GestureFaceDetection_I2C gfd(0x72);

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);
  gfd.setGestureDetectThres(60);
  gfd.setDetectThres(100);
  Serial.println("running...");
}

void loop() {
  static char text[100];

  uint16_t gestureType = gfd.getGestureType();
  uint16_t gestureScore = gfd.getGestureScore();

  if (gestureType > 0) {
    sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
    Serial.print(text);
    delay(1000);
  }
   delay(100);
}

Inclusões

Começamos por incluir a DFRobot_GestureFaceDetection biblioteca que fornece a funcionalidade de deteção de gestos e faces.

Objetos

De seguida, criamos uma instância da classe de deteção de gestos e faces. Este objeto será usado para inicializar a comunicação, configurar os limiares e obter os resultados da deteção.

DFRobot_GestureFaceDetection_I2C gfd(0x72);

O construtor recebe o endereço I2C do sensor DFRobot. O endereço padrão é 0x72, mas pode configurar o endereço I2C no intervalo 0x01 – 0xF6 chamando a função setDeviceAddr(addr).

Função Setup

O bloco setup inicializa a porta serial, inicia a comunicação com o sensor de gestos e configura o limiar de deteção. Tudo dentro do setup é executado uma vez quando a placa é ligada ou reiniciada.

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);
  gfd.setGestureDetectThres(60);
  Serial.println("running...");
}

O limiar de deteção de gestos varia entre 0..100 e determina a sensibilidade para detetar gestos. Um valor mais baixo aumenta a sensibilidade mas pode resultar em mais falsos positivos, enquanto um valor mais alto exige gestos mais claros mas reduz o número de falsos positivos.

Função Loop

A função loop executa continuamente, consultando o sensor para nova informação de gestos e imprimindo resultados quando algo é detetado.

O programa solicita ao sensor o tipo de gesto atual.

uint16_t gestureType = gfd.getGestureType();

O valor retornado identifica qual gesto, se algum, foi detetado pelo sensor. Um valor zero significa que nenhum gesto foi reconhecido. A tabela seguinte mostra os IDs para os diferentes tipos de gestos retornados pela função getGestureType() e a cor correspondente do LED onboard:

ID	Gesto	Ícone	Cor do LED
1	Polegar para cima	👍	Azul
2	OK	👌	Verde
3	Pare	🤚	Vermelho
4	Vitória	✌️	Amarelo
5	Liga para mim	🤙	Roxo

Para cada gesto, obtemos depois a pontuação do gesto chamando:

uint16_t gestureScore = gfd.getGestureScore();

Esta pontuação indica o quão confiante o sensor está no gesto detetado. Pontuações mais altas representam deteções mais confiantes. A pontuação de confiança varia entre 0…100.

Se um gesto foi detetado, o sketch formata uma mensagem de texto e imprime-a no Monitor Serial.

if (gestureType > 0) {
  sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
  Serial.print(text);
  delay(1000);
}

A instrução condicional verifica se gestureType é maior que zero. A função sprintf escreve a informação do gesto num buffer de caracteres, que é depois impresso. Um atraso de um segundo dá tempo ao utilizador para ler a saída e evita mensagens repetidas excessivas.

Saída no Monitor Serial

Se executar o programa e fizer gestos em frente da câmara, deverá ver os resultados da deteção impressos no Monitor Serial:

Exemplo de Código: Deteção de Faces

O exemplo de código seguinte demonstra como realizar a deteção de faces:

#include "DFRobot_GestureFaceDetection.h"

DFRobot_GestureFaceDetection_I2C gfd(0x72);

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);  
  gfd.setFaceDetectThres(60);
}

void loop() {
  static char text[100];
  
  if (gfd.getFaceNumber() > 0) {
    uint16_t faceScore = gfd.getFaceScore();
    uint16_t faceX = gfd.getFaceLocationX();
    uint16_t faceY = gfd.getFaceLocationY();

    sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
    Serial.print(text);
    delay(1000);
  }
  delay(100);
}

Inclusões e Objetos

Como antes, começamos por incluir a biblioteca DFRobot_GestureFaceDetection e criar o objeto de deteção de gestos e faces gfd:

#include "DFRobot_GestureFaceDetection.h"

DFRobot_GestureFaceDetection_I2C gfd(0x72);

Função Setup

O bloco setup inicializa a porta serial, inicia a comunicação com o sensor e configura o limiar de deteção para faces:

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);  
  gfd.setFaceDetectThres(60);
}

O limiar de deteção varia entre 0..100 e valores mais baixos facilitam a deteção de faces, mas ao custo de mais falsos positivos.

Função Loop

A função loop corre continuamente e verifica a deteção de faces. Se o número de faces detetadas for maior que zero, obtemos a pontuação de confiança e a localização x,y da face detetada:

  if (gfd.getFaceNumber() > 0) {
    uint16_t faceScore = gfd.getFaceScore();
    uint16_t faceX = gfd.getFaceLocationX();
    uint16_t faceY = gfd.getFaceLocationY();

De seguida, imprimimos esta informação no Monitor Serial:

    sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
    Serial.print(text);

Se apontar a câmara do sensor para o seu rosto, deverá ver os resultados da deteção impressos:

Exemplo de Código: Contador de Ocupação de Sala

Neste último exemplo, vamos construir um sensor de ocupação de sala que conta as pessoas numa sala e mostra o contador num OLED. Poderia construir isto com um Arduino também, mas vou usar um ESP32-C3 SuperMini para variar.

O diagrama de ligação seguinte mostra como ligar o sensor de deteção de faces e o OLED ao ESP32:

Tanto o sensor de deteção de faces como o OLED estão ligados ao barramento I2C, que está nos pinos 8 (SDA) e 9 (SCL) do ESP32 SuperMini. De forma semelhante, VCC e GND do Sensor e do OLED estão ligados a 3,3V e GND do SuperMini. A imagem abaixo mostra esta ligação numa breadboard:

E aqui está o código para contar o número de pessoas numa sala:

#include "DFRobot_GestureFaceDetection.h"
#include "Adafruit_SSD1306.h"

DFRobot_GestureFaceDetection_I2C gfd(0x72);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void setup() {
  Wire.begin();
  gfd.begin(&Wire);
  gfd.setFaceDetectThres(60);

  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setRotation(3);
  oled.setTextSize(6);
  oled.setTextColor(WHITE);
}

void loop() {
  uint16_t nFaces = gfd.getFaceNumber();
  oled.clearDisplay();
  oled.setCursor(10, 20);
  oled.printf("%d", nFaces);
  oled.display();
  delay(100);
}

Inclusões

O código começa por incluir as bibliotecas para o sensor de deteção de faces e para o OLED. Se ainda não usou a biblioteca Adafruit_SSD1306, terá de a instalar via LIBRARY MANAGER:

Objetos

De seguida, criamos os objetos para o sensor e para o OLED:

DFRobot_GestureFaceDetection_I2C gfd(0x72);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

Como ambos os dispositivos estão ligados ao barramento I2C, precisam de ter endereços I2C diferentes. O sensor tem o endereço 0x72 e o OLED normalmente tem o endereço 0x3C, por isso não há conflito. Mas se nada aparecer no ecrã ou o sensor não funcionar, verifique os endereços I2C e certifique-se de que não são iguais.

Função Setup

Na função setup inicializamos o sensor e o OLED: Note que o endereço I2C do OLED é definido aqui e não no construtor:

void setup() {
  Wire.begin();
  gfd.begin(&Wire);
  gfd.setFaceDetectThres(60);

  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setRotation(3);
  oled.setTextSize(6);
  oled.setTextColor(WHITE);
}

Função Loop

O Gravity Gesture & Face Detection Sensor torna muito simples contar pessoas. Simplesmente chamamos a função getFaceNumber() para obter o número de faces/pessoas detetadas. Note, no entanto, que o reconhecimento de faces está limitado a 10 faces. Depois de termos o número de faces (nFaces), mostramos-no no OLED.

void loop() {
  uint16_t nFaces = gfd.getFaceNumber();
  oled.clearDisplay();
  oled.setCursor(10, 20);
  oled.printf("%d", nFaces);
  oled.display();
  delay(100);
}

O tamanho pequeno do OLED, do ESP32 SuperMini e do sensor de deteção de faces permite construir um contador de ocupação de sala muito compacto. E como o ESP32 suporta Wi-Fi, pode enviar facilmente o contador de pessoas para um servidor, por exemplo, para controlar a temperatura numa sala.

Conclusões

Neste tutorial aprendeu como ligar o Gravity Gesture & Face Detection Sensor a um Arduino UNO ou a um ESP32. Também aprendeu a reconhecer gestos, a detetar faces e a construir um sensor de ocupação de sala.

Recomendo que leia o DFRobot Wiki para mais informações sobre o Gravity Gesture & Face Detection Sensor. Veja também o seu repositório github para mais exemplos de código.

A deteção de gestos do sensor é bastante fiável e rápida. Em contraste com sensores de gestos mais simples que detetam gestos básicos como deslizar para cima ou para baixo, o Gravity Gesture Sensor deteta gestos mais complexos, mas é também um pouco maior e tem uma câmara com maior consumo de energia.

Para informações sobre sensores de gestos mais pequenos e simples, veja os nossos tutoriais PAJ7620U2 Gesture Sensor with Arduino e APDS-9960 Gesture and Color Sensor with Arduino.

Se quiser detetar objetos em vez de faces, veja os tutoriais Train an Object Detection Model with Edge Impulse for ESP32-CAM, Object Detection with ESP32-CAM and YOLO e Getting Started with HUSKYLENS 2 and Arduino/ESP32 .

Finalmente, para outra solução de sensor de ocupação, sugiro o tutorial Edge AI Room Occupancy Sensor with ESP32 and Person Detection.

Se tiver alguma dúvida ou sugestão, sinta-se à vontade para deixar nos comentários.

Boas experiências ; )