Interligar o SenseCAP Watcher W1-B com ESP32

O SenseCAP Watcher é um assistente com IA da Seeed Studio. Utiliza o microcontrolador ESP32-S3 para fornecer processamento local de visão e voz.

O Watcher possui um ecrã tátil circular de 1,2 polegadas, uma câmara integrada, um microfone e um altifalante incorporado. Oferece conectividade Wi-Fi e Bluetooth e é expansível através de um conector Grove, um cabeçalho de expansão com ligação serial e um slot para cartão microSD.

Neste tutorial, aprenderás a ligar o SenseCAP Watcher a um ESP32 para receber resultados de deteção via interface serial e reagir a eles. Vamos construir um Monitor de Inatividade na Secretária que te incentiva a exercitar-te se estiveres na secretária por mais de 60 minutos.

Peças Necessárias

Vais precisar de um SenseCAP Watcher, que podes adquirir na Seeed Studio. Vem com um cabo USB-C, um suporte e um adaptador fêmea de 1/4″. Também precisarás de um ESP32. Eu escolhi um XIAO ESP32-C5, mas qualquer outro ESP32 também funciona. Por fim, precisarás de um buzzer ativo para o projeto do Monitor de Inatividade na Secretária, além de alguns fios e uma breadboard para ligar tudo.

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.

O que é o SenseCAP Watcher W1-B?

O SenseCAP Watcher W1-B é um nó de deteção AI compacto e autónomo que combina visão computacional, interação áudio e automação de tarefas num único dispositivo.

Ao nível do hardware, o dispositivo integra um microcontrolador ESP32-S3 juntamente com um acelerador AI dedicado, uma câmara grande angular, microfone, altifalante, ecrã tátil e conectividade sem fios via Wi-Fi e Bluetooth.

Esta combinação permite ao Watcher realizar inferência em tempo real no dispositivo, como deteção de objetos ou reconhecimento de eventos, sem depender totalmente da cloud, o que melhora a latência e a privacidade.

SenseCraft platform — Plataforma SenseCraft (source)

Um conceito chave do Watcher é a sua arquitetura híbrida de IA. A visão e a lógica básica podem correr localmente no dispositivo, enquanto o processamento mais avançado pode ser delegado a serviços externos ou grandes modelos de linguagem via a plataforma SenseCraft.

Operação baseada em tarefas e interação do utilizador

Em vez da lógica tradicional de firmware, o Watcher opera usando um modelo de fluxo de tarefas. Internamente, as funções são organizadas em “blocos” modulares que podem produzir ou consumir dados, semelhante ao funcionamento do Node-RED. Estes blocos são ligados para definir comportamentos, por exemplo: detetar uma pessoa → analisar condição → enviar notificação → ativar sistema externo.

A interação com o dispositivo é multimodal. A câmara incorporada permite gatilhos baseados em visão, enquanto o microfone e o altifalante suportam comandos de voz através de uma interface push-to-talk. O ecrã tátil e o controlo rotativo fornecem controlo local e feedback.

Integração IoT

O Watcher foi desenhado para atuar como uma ponte entre a perceção AI e a infraestrutura IoT existente. Expõe os seus dados e eventos através de múltiplas interfaces, incluindo HTTP, UART e integrações baseadas em mensagens, permitindo a ligação a frameworks como Node-RED e Home Assistant.

Numa configuração Node-RED, o Watcher funciona tipicamente como uma fonte inteligente de eventos. Eventos detetados, como “pessoa detetada” ou “objeto em falta”, podem ser enviados via HTTP ou MQTT para um fluxo Node-RED, onde podem ser processados adicionalmente.

Quando integrado com o Home Assistant, o Watcher torna-se um sensor de alto nível que complementa sensores binários tradicionais. Em vez de apenas reportar movimento, pode fornecer informação semântica como identificar objetos ou situações específicas. Isto permite automações mais avançadas, como ativar ações diferentes dependendo de quem entra numa divisão ou que atividade é detetada.

Para projetos maker, o Watcher pode ser usado como um módulo de perceção de alto nível ligado a microcontroladores como placas ESP32. Por exemplo, pode detetar pessoas ou gestos e enviar dados estruturados via UART ou HTTP para ativar LEDs, buzzers, motores ou outro hardware.

Cenários típicos de aplicação

A flexibilidade de combinar IA no dispositivo com orquestração externa permite uma vasta gama de aplicações. Num ambiente doméstico inteligente, o Watcher pode detetar presença e contexto, por exemplo reconhecendo quando uma pessoa entra numa divisão e ajustando automaticamente a iluminação ou mostrando informação relevante. Pode também monitorizar animais de estimação ou detetar situações invulgares como uma queda.

Em cenários de segurança, o dispositivo pode atuar como um nó de vigilância inteligente que distingue entre atividade normal e anomalias, reduzindo falsos alarmes comparado com sensores de movimento tradicionais. Como o processamento pode ocorrer localmente, dados sensíveis de imagem não precisam sair do dispositivo.

Neste tutorial, usaremos o Watcher para construir um Monitor de Inatividade na Secretária. O Watcher monitoriza a presença de uma pessoa sentada numa secretária. A informação de deteção de pessoa é enviada via UART para um ESP32 ligado, que controla o tempo. Se a pessoa não sair da secretária por mais de 60 minutos, o ESP32 ativa um buzzer como lembrete para exercitar.

Hardware do SenseCAP Watcher

O SenseCAP Watcher é alimentado por um microcontrolador ESP32-S3 a 240MHz. Este chip oferece processamento dual-core e suporte nativo para Wi-Fi e Bluetooth. Inclui 8MB de PSRAM dedicada para suportar aplicações que exigem muita memória. O sistema também possui 32MB de armazenamento flash para firmware e dados do utilizador.

Arquitetura do SenseCAP Watcher (source)

Um processador AI Himax HX6538 separado trata de cálculos avançados de visão e vetores. Este processador secundário inclui 16MB adicionais de memória flash para modelos AI.

Capacidades Visuais e Áudio

A frente do dispositivo tem um ecrã tátil circular de 1,45 polegadas com resolução de 412×412 pixels. Um sensor de câmara OV5647 oferece um campo de visão grande angular de 120 graus. A câmara está focada fixamente a uma distância de três metros.

O áudio é captado por um microfone integrado na placa. Um altifalante incorporado de 1W fornece feedback áudio e respostas de voz. A imagem abaixo mostra a frente e a traseira do SenseCAP Watcher:

Front and Back of the SenseCAP Watcher — Frente e Traseira do SenseCAP Watcher (source)

Ferramentas de Interação e Indicadores

Os utilizadores podem navegar no software interno usando uma roda digital localizada na lateral. Esta roda suporta scroll e função de botão para seleções. Um LED RGB único indica estados como energia ou conectividade. Um botão de reset dedicado está acessível através de um pequeno orifício na parte inferior da caixa. O dispositivo inclui também um slot para cartão microSD para armazenamento expansível até 32GB.

Conectividade e Alimentação

A comunicação sem fios é feita via Wi-Fi 2.4GHz e Bluetooth 5.0. A unidade possui duas portas USB-C para diferentes cenários de montagem e alimentação. A porta inferior suporta alimentação 5V e programação serial para desenvolvimento. A porta traseira é reservada apenas para alimentação 5V. Uma bateria de lítio de 400mAh serve como fonte de energia de reserva para uso a curto prazo.

Para hardware externo, o Watcher inclui uma porta Grove I2C e um cabeçalho fêmea 2×4 para expansão GPIO. A imagem abaixo mostra os diferentes conectores na traseira do SenseCAP Watcher:

Note que o pino 5V é um pino de entrada, enquanto o pino 3V3 é de saída. Não ligues o pino de entrada 5V e ao mesmo tempo forneças energia ao Watcher via a porta USB.

Especificações Técnicas

A tabela seguinte resume as especificações técnicas do SenseCAP Watcher:

Hardware	Descrição
MCU	ESP32-S3 @240MHz 8MB PSRAM
Processador AI Integrado	Himax HX6538 (Cortex M55 + Ethos-U55)
Câmara	OV5647 120° FOV Foco Fixo a 3 metros
Wi-Fi	Compatível com IEEE 802.11b/g/n Banda 2.4GHz Alcance sem fios: até 100 metros (teste em espaço aberto)
Bluetooth LE	Bluetooth 5
Antena	Antena integrada Wi-Fi e BLE
Ecrã	Ecrã tátil de 1,45 polegadas, resolução 412×412
Microfone	Microfone único
Altifalante	Saída de altifalante de 1W
Roda	Suporta scroll para cima e para baixo e botão
LED	1 LED RGB para indicação
Slot para cartão microSD	Suporta cartão microSD FAT32 até 32GB
Flash	32MB Flash para ESP32-S3 16MB Flash para Himax HX6538
Interface de Expansão	1 interface Grove IIC Cabeçalho fêmea 2×4 (1xIIC, 2xGPIO, 2xGND, 1×3.3V_OUT, 1x5V_IN)
USB-C	1 USB-C na traseira (apenas alimentação) 1 USB-C na parte inferior (alimentação e programação)
Botão Reset	1 botão RST no orifício inferior
Alimentação	Alimentação DC 5V
Bateria	Bateria Li-ion 3.7V 400mAh como fonte de reserva
Temperatura de Operação	0 ~ 45°C

Ligação do SenseCAP Watcher a um ESP32

O SenseCAP Watcher oferece vários métodos para transmitir informação de deteção a outros sistemas para processamento, como Node-RED ou Home Assistant. No entanto, isso requer que tenhas um servidor Node-RED ou Home Assistant a correr.

Para um sistema de deteção pequeno e local, uma opção melhor é ligar o SenseCAP Watcher a outro microcontrolador que avalie os resultados da deteção e depois execute ações, por exemplo, ativar um alarme. Isto pode ser feito usando a interface serial (UART) do Watcher.

Na traseira do Watcher encontrarás um conector de 8 pinos com interfaces I2C (SCL, SDA), UART (RX, TX) e alimentação. O diagrama de ligação abaixo mostra como ligar o SenseCAP Watcher a uma placa XIAO ESP32-C5 via UART:

Connecting SenseCAP Watcher to an ESP32 — Ligação do SenseCAP Watcher a um XIAO ESP32-C5

Começa por ligar o TX do Watcher ao pino D7 (RX) do XIAO ESP32-C5. Depois liga o RX do Watcher ao pino D6 (TX) do ESP32-C5. Vamos alimentar o Watcher a partir do ESP32-C5 ligando os pinos 5V e GND. A tabela seguinte mostra as ligações que precisas de fazer:

Watcher	ESP32-C5
RX	D6/TX
TX	D7/RX
5V	5V
GND	GND

Certifica-te de usar a porta USB-C no ESP32-C5 para alimentar o circuito. Isto fornecerá energia para o ESP32-C5 e o Watcher em conjunto. Não ligues a porta USB-C do Watcher.

Criar uma Tarefa com notificação UART

O envio dos resultados de deteção do Watcher via UART para um ESP32 ligado precisa de ser ativado para cada tarefa na SenseCraft APP. Nesta secção, vais aprender a fazer isso, mas precisas de ter a SenseCraft APP instalada no teu telemóvel e ligada ao teu SenseCAP Watcher. Caso contrário, lê primeiro a Quick Start Guide e segue as instruções lá.

Criar uma tarefa de deteção na SenseCraft APP é fácil. Por exemplo, escreve “Notify via uart if person detected” para criar uma tarefa de deteção de pessoa:

Create Task with UART notification — Criar Tarefa com notificação UART

Depois de criar a tarefa, clica no botão “Detail Configs” para abrir o diálogo de Configuração Manual. Lá encontrarás várias caixas de seleção. Certifica-te que “Serial Port / UART Output” está assinalado:

A maioria das outras caixas estará assinalada por defeito, mas para usar a comunicação serial não precisaremos delas. Para mais informações detalhadas, consulta a UART Output da documentação da Seeed Studio para o SenseCAP Watcher.

Finalmente, pressiona o botão “Run Task” na parte inferior do diálogo para iniciar a tarefa.

Exemplo de Código: Ler resultados de deteção

Com a tarefa a correr e o Watcher ligado via UART ao ESP32-C5, podemos testar a transmissão dos resultados de deteção. Carrega o seguinte código no teu ESP32-C5, que deve estar ligado ao PC via cabo USB-C. Não ligues o Watcher via USB!

#include <ArduinoJson.h>

DynamicJsonDocument doc(1024 * 100); // 100K

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, D7, D6);  // RX, TX
  while (!Serial)
    ;
  delay(100);
  Serial.println("Ready.");
}

void loop() {
  if (Serial1.available()) {
    deserializeJson(doc, Serial1);
    if (doc.containsKey("inference")) {
      Serial.println(doc["inference"].as<String>());
    }
  }
}

O código acima recebe os dados de deteção em formato JSON enviados pelo Watcher pela ligação serial e imprime a informação no Monitor Serial.

Importações

O código começa por incluir a biblioteca ArduinoJson, essencial para analisar dados JSON recebidos do Watcher. Esta biblioteca simplifica o manuseio de dados estruturados em formato JSON.

#include <ArduinoJson.h>

Objeto Documento JSON

De seguida, é declarado um DynamicJsonDocument chamado doc com capacidade para 100 kilobytes (1024 * 100 bytes). Este objeto irá conter os dados JSON analisados recebidos da câmara. O tamanho foi escolhido para acomodar o tamanho máximo das mensagens JSON enviadas pelo Watcher.

DynamicJsonDocument doc(1024 * 100); // 100K

Função Setup

Na função setup(), são inicializadas duas interfaces seriais. A primeira, Serial, é iniciada a 115200 baud para comunicação com o Monitor Serial do Arduino IDE. A segunda, Serial1, também é iniciada a 115200 baud mas configurada com os pinos específicos D7 (RX) e D6 (TX) para comunicar com a câmara SenseCAP Watcher.

O código espera até a ligação serial USB estar estabelecida antes de continuar, garantindo que as mensagens de debug podem ser vistas imediatamente. Após um curto atraso de 100 milissegundos, imprime “Ready.” para indicar que o ESP32 está pronto para receber dados.

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, D7, D6);  // RX, TX
  while (!Serial)
    ;
  delay(100);
  Serial.println("Ready.");
}

Função Loop

A função loop() verifica continuamente se há dados disponíveis em Serial1, que está ligado ao Watcher. Quando são detetados dados, tenta desserializar o fluxo JSON recebido para o objeto doc.

Se o JSON analisado contiver a chave "inference", o valor correspondente é extraído como string e impresso no Monitor Serial.

void loop() {
  if (Serial1.available()) {
    deserializeJson(doc, Serial1);
    if (doc.containsKey("inference")) {
      Serial.println(doc["inference"].as<String>());
    }
  }
}

Exemplo de Saída

Ao executar este código no ESP32-C5, deverás ver resultados de deteção semelhantes aos seguintes no Monitor Serial:

Se não, verifica as ligações e certifica-te que “Serial port / UART output” está ativado para a tarefa de deteção.

Os dados enviados dependem do modelo de deteção. Para a tarefa de deteção de pessoas, recebes sempre as caixas delimitadoras das pessoas detetadas, o valor de confiança, o ID da classe e a lista de nomes das classes, neste caso apenas [“person”].

Se executares o modelo de deteção de Gestos que deteta gestos de Pedra, Papel ou Tesoura, os dados enviados pelo Watcher serão, por exemplo:

{"boxes":[[176,208,144,218,83,0]],"classes_name":["Paper","Rock","Scissors"]}

Exemplo de Código: Extrair dados de deteção

No exemplo de código anterior interpretámos e imprimimos os dados de deteção transmitidos pelo Watcher como uma string. No entanto, em muitos casos queres extrair informação específica como dados numéricos, por exemplo a largura e altura da caixa delimitadora.

O código seguinte mostra como fazer isso. Extrai os dados do documento JSON e imprime-os como valores numéricos:

#include <ArduinoJson.h>

DynamicJsonDocument doc(1024 * 100); // 100K

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, D7, D6);  // RX, TX
  while (!Serial)
    ;
  delay(100);
  Serial.println("Ready.");
}

void loop() {
  if (Serial1.available()) {
    deserializeJson(doc, Serial1);

    if (doc.containsKey("inference")) {
      JsonArray b = doc["inference"]["boxes"][0].as<JsonArray>();
      Serial.printf("x:%d y:%d w:%d h:%d | score:%d cls_id:%d\n",
                    b[0].as<int>(), b[1].as<int>(), b[2].as<int>(), b[3].as<int>(), 
                    b[4].as<int>(), b[5].as<int>());
    }
  }
}

O código é idêntico ao exemplo anterior, exceto pela forma de imprimir os dados de deteção. Em vez de imprimir como string (doc["inference"].as()), extrai a primeira caixa delimitadora do array "boxes" dentro dos dados de inferência.

Esta caixa delimitadora é um array JSON contendo seis inteiros que representam as coordenadas e metadados do objeto detetado: x, y, width, height, score (confiança), e cls_id (ID da classe). Estes valores são impressos numa string formatada. Aqui está um exemplo de saída.

x:131 y:290 w:240 h:208 | score:71 cls_id:0

Depois de teres os resultados de deteção como dados numéricos, podes fazer cálculos. Por exemplo, poderias aproximar a distância de uma pessoa ao Watcher calculando

distance = c * b[2].as<int>() * b[3].as<int>();

onde b[2] e b[3] contêm a largura e altura da caixa delimitadora, e c é uma constante para converter a medida numa unidade de distância.

Exemplo de Código: Monitor de Inatividade na Secretária

No exemplo final de código, vamos construir um Monitor de Inatividade na Secretária. O SenseCAP Watcher será colocado numa secretária e executará continuamente a tarefa de deteção de pessoas. Os dados de deteção são enviados periodicamente para o ESP32-C5 ligado, que executa um temporizador. Se a pessoa estiver na secretária por mais de 60 minutos sem interrupção, o ESP32-C5 ativa um buzzer para incentivar a pessoa a fazer uma pausa.

Como o ESP32-C5 não tem buzzer incorporado, precisamos de ligar um externo. É fácil. Basta ligar o polo negativo do buzzer ao GND e o polo positivo ao pino D0, como mostrado abaixo.

Connecting SenseCAP Watcher to an XIAO ESP32-C5 with a buzzer — Ligação do SenseCAP Watcher a um XIAO ESP32-C5 com buzzer

As outras ligações mantêm-se como antes. A tabela abaixo lista todas as ligações que precisas de fazer.

Watcher	ESP32-C5	Buzzer
RX	D6/TX
TX	D7/RX
5V	5V
GND	GND	GND
	D0	+

Se precisares de mais ajuda com o buzzer, dá uma vista de olhos ao nosso Active and Passive Piezo Buzzers with Arduino tutorial.

Assegura-te de ligar o buzzer com a polaridade correta e que é um buzzer ativo – caso contrário, o código seguinte para o Monitor de Inatividade na Secretária não funcionará.

#include <ArduinoJson.h>

DynamicJsonDocument doc(1024 * 100);  // 100K

const int BUZZER_PIN = D0; // GPIO 1
const unsigned long MAX_SIT_TIME_MS = 1000 * 60 * 60;

unsigned long tPerson = 0;
unsigned long tSitting = 0;
bool personDetected = false;

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, D7, D6);  // RX, TX
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  while (!Serial)
    ;
  delay(100);
  tPerson = millis();
  tSitting = millis();
  Serial.println("running...");
}

void loop() {
  unsigned long tCurrent = millis();

  if (Serial1.available()) {
    deserializeJson(doc, Serial1);
    if (doc.containsKey("inference")) {
      Serial.printf("person sitting %d sec\n", (tCurrent - tSitting)/1000);
      tPerson = tCurrent;
      if (!personDetected)
        tSitting = tCurrent;
      personDetected = true;
    }
  }

  if ((tCurrent - tPerson) > 1000 * 10) {
    personDetected = false;
    tSitting = tCurrent;
  }

  if (personDetected && ((tCurrent - tSitting) >= MAX_SIT_TIME_MS)) {
    tSitting = tCurrent;
    digitalWrite(BUZZER_PIN, HIGH);
    Serial.println("Take a break now!");
    delay(1000);
    digitalWrite(BUZZER_PIN, LOW);
  }
}

Importações

Como antes, começamos por incluir a biblioteca ArduinoJson, usada para analisar dados JSON recebidos do Watcher.

#include <ArduinoJson.h>

Documento JSON

Depois é criado um DynamicJsonDocument chamado doc com capacidade para 100 kilobytes. Este documento irá conter os dados JSON analisados recebidos do Watcher.

DynamicJsonDocument doc(1024 * 100);  // 100K

Constantes

A constante BUZZER_PIN define o pino GPIO ligado ao buzzer, aqui definido como D0 (que corresponde ao GPIO 1 no ESP32-C5). Outra constante, MAX_SIT_TIME_MS, define o tempo máximo permitido sentado em milissegundos, definido para 60 minutos (1000 ms × 60 s × 60 min).

const int BUZZER_PIN = D0; // GPIO 1
const unsigned long MAX_SIT_TIME_MS = 1000 * 60 * 60;

Variáveis

Usamos várias variáveis para controlar o tempo e o estado da deteção. tPerson guarda a última vez que uma pessoa foi detetada, tSitting regista quando o período sentado começou, e personDetected é uma flag booleana que indica se uma pessoa está atualmente detetada.

unsigned long tPerson = 0;
unsigned long tSitting = 0;
bool personDetected = false;

Função Setup

A função setup() inicializa a comunicação serial para debug (Serial) e comunicação com a câmara AI Vision (Serial1) a 115200 baud. O pino do buzzer é configurado como saída e inicialmente desligado. O código espera que a porta serial esteja pronta, depois inicializa as variáveis de tempo tPerson e tSitting com o tempo atual em milissegundos. Finalmente, imprime “running…” no monitor serial para indicar que o programa começou.

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200, SERIAL_8N1, D7, D6);  // RX, TX
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  while (!Serial)
    ;
  delay(100);
  tPerson = millis();
  tSitting = millis();
  Serial.println("running...");
}

Função Loop

A função loop() corre repetidamente e executa a lógica principal de monitorização. Primeiro lê o tempo atual em milissegundos para tCurrent.

Se houver dados disponíveis em Serial1 (da câmara AI Vision), tenta analisar o JSON recebido para doc. Se o JSON contiver a chave "inference", significa que uma pessoa foi detetada. O código imprime quantos segundos a pessoa está presente, atualiza tPerson para o tempo atual, e se esta for a primeira deteção após um período sem deteção, reinicia tSitting para começar a contar a duração sentado. A flag personDetected é definida como verdadeira.

Se passarem mais de 10 segundos desde a última deteção de pessoa (tCurrent - tPerson > 10000), o código assume que a pessoa saiu, define personDetected como falso e reinicia tSitting para o tempo atual.

Finalmente, se uma pessoa estiver detetada e o tempo sentado atingir ou ultrapassar o tempo máximo permitido (MAX_SIT_TIME_MS), o buzzer é ativado por 1 segundo (1000 ms) para lembrar o utilizador a fazer uma pausa. O temporizador de sentado tSitting é reiniciado após o buzzer tocar para começar um novo período de monitorização.

void loop() {
  unsigned long tCurrent = millis();

  if (Serial1.available()) {
    deserializeJson(doc, Serial1);
    if (doc.containsKey("inference")) {
      Serial.printf("person sitting %d sec\n", (tCurrent - tSitting)/1000);
      tPerson = tCurrent;
      if (!personDetected)
        tSitting = tCurrent;
      personDetected = true;
    }
  }

  if ((tCurrent - tPerson) > 1000 * 10) {
    personDetected = false;
    tSitting = tCurrent;
  }

  if (personDetected && ((tCurrent - tSitting) >= MAX_SIT_TIME_MS)) {
    tSitting = tCurrent;
    digitalWrite(BUZZER_PIN, HIGH);
    Serial.println("Take a break now!");
    delay(1000);
    digitalWrite(BUZZER_PIN, LOW);
  }
}

Podes testar o código reduzindo o MAX_SIT_TIME_MS para um minuto (1000 * 60). Se estiveres sentado na secretária por mais de 60 segundos, o buzzer deve tocar. Se saíres antes, o temporizador será reiniciado.

Note que o modelo de deteção de pessoas apenas deteta a presença, não se a pessoa está sentada ou não. No entanto, poderias usar um modelo esquelético para detetar poses específicas e contar apenas o tempo em que a pessoa está realmente sentada, por exemplo.

Conclusões

O SenseCAP Watcher W1-B combina uma plataforma ESP32-S3 com capacidades integradas de visão, áudio e IA. Permite construir sensores inteligentes na edge. A arquitetura baseada em tarefas e a conectividade flexível facilitam a integração com ferramentas estabelecidas como Node-RED e Home Assistant.

Para makers que trabalham com os ecossistemas Arduino ou ESP32, o Watcher pode atuar como um co-processador AI de alto nível que descarrega as tarefas intensivas de perceção AI. A lógica específica da aplicação e potencialmente complexa pode ser implementada num microcontrolador separado que comunica com o Watcher via interface serial. Note, porém, que o SenseCAP Watcher opera com lógica de 3.3 Volt e é necessário um conversor de nível para ligar a um Arduino UNO de 5V, por exemplo.

Como sensor de visão AI, o SenseCAP Watcher é semelhante aos dispositivos HUSKYLENS ou HUSKYLENS 2. No entanto, o Watcher é mais como um agente AI autónomo que pode interpretar cenas e agir autonomamente. Enquanto o HUSKLENS e HUSKLENS 2 são sensores de visão desenhados para descarregar a interpretação e reação a objetos detetados para um microcontrolador via interfaces UART/I2C.

Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.

Boas criações 😉

Peças Necessárias

SenseCAP Watcher

XIAO ESP32-C5

Cabo USB C

Buzzer Ativo 5V

Conjunto de Fios Dupont

Breadboard

O que é o SenseCAP Watcher W1-B?

Operação baseada em tarefas e interação do utilizador

Integração IoT

Cenários típicos de aplicação

Hardware do SenseCAP Watcher

Capacidades Visuais e Áudio

Ferramentas de Interação e Indicadores

Conectividade e Alimentação

Especificações Técnicas

Ligação do SenseCAP Watcher a um ESP32

Criar uma Tarefa com notificação UART

Exemplo de Código: Ler resultados de deteção

Importações

Objeto Documento JSON

Função Setup

Função Loop

Exemplo de Saída

Exemplo de Código: Extrair dados de deteção

Exemplo de Código: Monitor de Inatividade na Secretária

Importações

Documento JSON

Constantes

Variáveis

Função Setup

Função Loop

Conclusões

Links