Interfaz SenseCAP Watcher W1-B con ESP32

El SenseCAP Watcher es un asistente potenciado por IA de Seeed Studio. Utiliza el microcontrolador ESP32-S3 para ofrecer procesamiento local de visión y voz.

El Watcher cuenta con una pantalla táctil circular de 1,2 pulgadas, una cámara integrada, un micrófono y un altavoz incorporado. Ofrece conectividad Wi-Fi y Bluetooth y es ampliable mediante un conector Grove, un header de expansión con conexión serial y una ranura para tarjeta microSD.

En este tutorial aprenderás cómo conectar el SenseCAP Watcher a un ESP32 para recibir resultados de detección vía interfaz serial y reaccionar a ellos. Construiremos un Monitor de Inactividad en el Escritorio que te animará a hacer ejercicio si estás en tu escritorio más de 60 minutos.

Partes necesarias

Necesitarás un SenseCAP Watcher, que puedes adquirir en Seeed Studio. Viene con un cable USB-C, un soporte y un adaptador hembra de 1/4″. También necesitarás un ESP32. Yo elegí un XIAO ESP32-C5, pero cualquier otro ESP32 funcionará. Finalmente, necesitarás un buzzer activo para el proyecto del Monitor de Inactividad en el Escritorio, además de algunos cables y una protoboard para conectar todo.

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.

¿Qué es SenseCAP Watcher W1-B?

El SenseCAP Watcher W1-B es un nodo compacto y autónomo de detección con IA que combina visión por computadora, interacción de audio y automatización de tareas en un solo dispositivo.

A nivel de hardware, el dispositivo integra un microcontrolador ESP32-S3 junto con un acelerador de IA dedicado, una cámara gran angular, micrófono, altavoz, pantalla táctil y conectividad inalámbrica vía Wi-Fi y Bluetooth.

Esta combinación permite que el Watcher realice inferencias en tiempo real y en el dispositivo, como detección de objetos o reconocimiento de eventos, sin depender completamente de la nube, lo que mejora la latencia y la privacidad.

SenseCraft platform — Plataforma SenseCraft (source)

Un concepto clave del Watcher es su arquitectura híbrida de IA. La visión y la lógica básica pueden ejecutarse localmente en el dispositivo, mientras que el procesamiento más avanzado puede delegarse a servicios externos o modelos de lenguaje grandes a través de la plataforma SenseCraft.

Operación basada en tareas e interacción con el usuario

En lugar de la lógica tradicional de firmware, el Watcher funciona usando un modelo de flujo de tareas. Internamente, las funciones se organizan en “bloques” modulares que pueden producir o consumir datos, similar a cómo funciona Node-RED. Estos bloques se conectan para definir comportamientos, por ejemplo: detectar persona → analizar condición → enviar notificación → activar sistema externo.

La interacción con el dispositivo es multimodal. La cámara integrada permite activadores basados en visión, mientras que el micrófono y altavoz soportan comandos de voz mediante una interfaz push-to-talk. La pantalla táctil y el control rotatorio ofrecen control y retroalimentación local.

Integración IoT

El Watcher está diseñado para actuar como puente entre la percepción IA y la infraestructura IoT existente. Expone sus datos y eventos a través de múltiples interfaces, incluyendo HTTP, UART e integraciones basadas en mensajes, lo que permite conectarlo con frameworks como Node-RED y Home Assistant.

En una configuración con Node-RED, el Watcher funciona típicamente como una fuente inteligente de eventos. Eventos detectados, como “persona detectada” u “objeto ausente”, pueden enviarse vía HTTP o MQTT a un flujo de Node-RED para su procesamiento posterior.

Al integrarse con Home Assistant, el Watcher se convierte en un sensor de alto nivel que complementa sensores binarios tradicionales. En lugar de solo reportar movimiento, puede proporcionar información semántica como identificar objetos o situaciones específicas. Esto permite automatizaciones más avanzadas, como activar diferentes acciones según quién entre a una habitación o qué actividad se detecte.

Para proyectos maker, el Watcher puede usarse como un módulo de percepción de alto nivel conectado a microcontroladores como placas ESP32. Por ejemplo, puede detectar personas o gestos y enviar datos estructurados vía UART o HTTP para activar LEDs, buzzers, motores u otro hardware.

Escenarios típicos de aplicación

La flexibilidad de combinar IA en el dispositivo con orquestación externa permite una amplia gama de aplicaciones. En un entorno de hogar inteligente, el Watcher puede detectar presencia y contexto, por ejemplo, reconociendo cuando una persona entra a una habitación y ajustando automáticamente la iluminación o mostrando información relevante. También puede monitorear mascotas o detectar situaciones inusuales como una caída.

En escenarios de seguridad, el dispositivo puede actuar como un nodo de vigilancia inteligente que distingue entre actividad normal y anomalías, reduciendo falsas alarmas en comparación con sensores de movimiento tradicionales. Al procesar localmente, los datos sensibles de imagen no necesitan salir del dispositivo.

En este tutorial usaremos el Watcher para construir un Monitor de Inactividad en el Escritorio. El Watcher monitoreará la presencia de una persona sentada en un escritorio. La información de detección se enviará vía UART a un ESP32 conectado, que llevará el control del tiempo. Si la persona no se levanta del escritorio por más de 60 minutos, el ESP32 activará un buzzer como recordatorio para hacer ejercicio.

Hardware del SenseCAP Watcher

El SenseCAP Watcher está potenciado por un microcontrolador ESP32-S3 que corre a 240MHz. Este chip ofrece procesamiento de doble núcleo y soporte nativo para Wi-Fi y Bluetooth. Incluye 8MB de PSRAM dedicada para aplicaciones que requieren mucha memoria. El sistema también cuenta con 32MB de almacenamiento flash para firmware y datos de usuario.

Arquitectura del SenseCAP Watcher (source)

Un procesador AI Himax HX6538 separado maneja cálculos avanzados de visión y vectores. Este procesador secundario incluye 16MB adicionales de memoria flash para modelos de IA.

Capacidades visuales y de audio

La parte frontal del dispositivo alberga una pantalla táctil circular de 1,45 pulgadas con resolución de 412×412 píxeles. Un sensor de cámara OV5647 ofrece un campo de visión gran angular de 120 grados. La cámara está configurada con enfoque fijo a una distancia de tres metros.

La entrada de audio se captura mediante un micrófono integrado único en la placa. Un altavoz incorporado de 1W proporciona retroalimentación de audio y respuestas de voz. La imagen a continuación muestra el frente y la parte trasera del SenseCAP Watcher:

Front and Back of the SenseCAP Watcher — Frontal y trasera del SenseCAP Watcher (source)

Herramientas de interacción e indicadores

Los usuarios pueden navegar el software interno usando una rueda digital ubicada en el lateral. Esta rueda soporta desplazamiento y función de botón para selecciones. Un LED RGB único indica estados como energía o conectividad. Un botón de reset dedicado es accesible mediante un pequeño orificio en la parte inferior de la carcasa. El dispositivo también incluye una ranura para tarjeta microSD con almacenamiento ampliable hasta 32GB.

Conectividad y alimentación

La comunicación inalámbrica se maneja vía Wi-Fi 2.4GHz y Bluetooth 5.0. La unidad cuenta con dos puertos USB-C para diferentes escenarios de montaje y alimentación. El puerto inferior soporta alimentación de 5V y programación serial para desarrollo. El puerto trasero está reservado solo para alimentación de 5V. Una batería de litio de 400mAh sirve como fuente de energía de respaldo para uso a corto plazo.

Para hardware externo, el Watcher incluye un puerto Grove I2C y un header hembra 2×4 para expansión GPIO. La imagen a continuación muestra los diferentes conectores en la parte trasera del SenseCAP Watcher:

Interfaces del SenseCAP Watcher (source)

Ten en cuenta que el pin de 5V es una entrada, mientras que el pin de 3V3 es una salida. No conectes el pin de entrada 5V y al mismo tiempo alimentes el Watcher vía el puerto USB.

Especificaciones técnicas

La siguiente tabla resume las especificaciones técnicas del SenseCAP Watcher:

Hardware	Descripción
MCU	ESP32-S3 @240MHz 8MB PSRAM
Procesador AI integrado	Himax HX6538 (Cortex M55 + Ethos-U55)
Cámara	OV5647 120° FOV Enfoque fijo a 3 metros
Wi-Fi	Compatible con IEEE 802.11b/g/n Banda 2.4GHz Alcance inalámbrico: hasta 100 metros (prueba en espacio abierto)
Bluetooth LE	Bluetooth 5
Antena	Antena integrada Wi-Fi y BLE
Pantalla	Pantalla táctil de 1.45 pulgadas, resolución 412×412
Micrófono	Micrófono único
Altavoz	Salida de altavoz de 1W
Rueda	Soporta desplazamiento arriba y abajo y botón
LED	1 LED RGB para indicación
Ranura para tarjeta microSD	Soporta tarjetas microSD FAT32 hasta 32GB
Flash	32MB Flash para ESP32-S3 16MB Flash para Himax HX6538
Interfaz de expansión	1 interfaz Grove IIC Header hembra 2×4 (1xIIC, 2xGPIO, 2xGND, 1×3.3V_OUT, 1x5V_IN)
USB-C	1 USB-C en la parte trasera (solo alimentación) 1 USB-C en la parte inferior (alimentación y programación)
Botón de reset	1 botón RST en el orificio inferior
Fuente de alimentación	Alimentación DC 5V
Batería	Batería Li-ion 3.7V 400mAh como fuente de respaldo
Temperatura de operación	0 ~ 45°C

Conectando el SenseCAP Watcher a un ESP32

El SenseCAP Watcher ofrece varios métodos para transmitir información de detección a otros sistemas para su procesamiento, como Node-RED o Home Assistant. Sin embargo, esto requiere que tengas un servidor Node-RED o Home Assistant en funcionamiento.

Para un sistema de detección pequeño y local, una mejor opción es conectar el SenseCAP Watcher a otro microcontrolador que evalúe los resultados de detección y luego realice acciones, por ejemplo, activar una alarma. Esto se puede lograr usando la interfaz serial (UART) del Watcher.

En la parte trasera del Watcher encontrarás un conector de 8 pines con interfaces I2C (SCL, SDA), UART (RX, TX) y alimentación. El diagrama de conexiones a continuación muestra cómo conectar el SenseCAP Watcher a una placa XIAO ESP32-C5 vía UART:

Connecting SenseCAP Watcher to an ESP32 — Conectando SenseCAP Watcher a un XIAO ESP32-C5

Comienza conectando el TX del Watcher al pin D7 (RX) del XIAO ESP32-C5. Luego conecta el RX del Watcher al pin D6 (TX) del ESP32-C5. Alimentaremos el Watcher desde el ESP32-C5 conectando los pines 5V y GND. La siguiente tabla muestra las conexiones que debes hacer:

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

Asegúrate de usar el puerto USB-C del ESP32-C5 para alimentar el circuito. Esto proporcionará energía tanto para el ESP32-C5 como para el Watcher. No conectes el puerto USB-C del Watcher.

Creando una tarea con notificación UART

El envío de resultados de detección desde el Watcher vía UART a un ESP32 conectado debe habilitarse por tarea en la aplicación SenseCraft. En esta sección aprenderás cómo hacerlo, pero necesitas tener la aplicación SenseCraft instalada en tu teléfono y conectada a tu SenseCAP Watcher. Si no, lee primero la Quick Start Guide y sigue las instrucciones allí.

Crear una tarea de detección en la aplicación SenseCraft es sencillo. Por ejemplo, escribe «Notify via uart if person detected» para crear una tarea de detección de personas:

Create Task with UART notification — Crear tarea con notificación UART

Una vez creada la tarea, haz clic en el botón «Detail Configs» para abrir el diálogo de configuración manual. Allí encontrarás varias casillas de verificación. Asegúrate de que «Serial Port / UART Output» esté marcada:

La mayoría de las otras casillas estarán marcadas por defecto, pero para usar la comunicación serial no las necesitaremos. Para más información detallada, consulta la UART Output sección de la documentación de Seeed Studio para el SenseCAP Watcher.

Finalmente, presiona el botón «Run Task» en la parte inferior del diálogo para iniciar la tarea.

Ejemplo de código: Leer resultados de detección

Una vez que la tarea está en ejecución y el Watcher está conectado vía UART al ESP32-C5, podemos probar la transmisión de resultados de detección. Sube el siguiente código a tu ESP32-C5, que debe estar conectado a tu PC mediante el cable USB-C. ¡No conectes el Watcher vía 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>());
    }
  }
}

El código anterior recibe los datos de detección en formato JSON enviados por el Watcher a través de la conexión serial y muestra la información en el Monitor Serial.

Importaciones

El código comienza incluyendo la ArduinoJson biblioteca, esencial para analizar datos JSON recibidos del Watcher. Esta biblioteca facilita el manejo de datos estructurados en formato JSON.

#include <ArduinoJson.h>

Objeto Documento JSON

A continuación, se declara un DynamicJsonDocument llamado doc con una capacidad de 100 kilobytes (1024 * 100 bytes). Este objeto contendrá los datos JSON analizados recibidos de la cámara. El tamaño se eligió para acomodar el tamaño máximo de mensajes JSON enviados desde el Watcher.

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

Función setup

En la función setup(), se inicializan dos interfaces seriales. La primera, Serial, se inicia a 115200 baudios para comunicación con el Monitor Serial del IDE de Arduino. La segunda, Serial1, también se inicia a 115200 baudios pero configurada con los pines específicos D7 (RX) y D6 (TX) para comunicarse con la cámara SenseCAP Watcher.

El código espera hasta que la conexión serial USB esté establecida antes de continuar, asegurando que los mensajes de depuración se puedan ver inmediatamente. Tras un breve retraso de 100 milisegundos, imprime «Ready.» para indicar que el ESP32 está listo para recibir datos.

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

Función loop

La función loop() verifica continuamente si hay datos disponibles en Serial1, que está conectado al Watcher. Cuando se detectan datos, intenta deserializar el flujo JSON entrante en el objeto doc.

Si el JSON analizado contiene la clave "inference", se extrae el valor correspondiente como cadena y se imprime en el Monitor Serial.

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

Ejemplo de salida

Al ejecutar este código en el ESP32-C5 deberías ver resultados de detección similares a los siguientes en el Monitor Serial:

Si no es así, revisa el cableado y asegúrate de que «Serial port / UART output» esté habilitado para la tarea de detección.

Los datos enviados dependen del modelo de detección. Para la tarea de detección de personas siempre recibes las cajas delimitadoras de las personas detectadas, el valor de confianza, el ID de clase y la lista de nombres de clase, en este caso solo [«person»].

Si ejecutaras el modelo de detección de gestos que detecta gestos de Piedra, Papel o Tijeras, los datos enviados por el Watcher se verían así, por ejemplo:

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

Ejemplo de código: Extrayendo datos de detección

En el ejemplo de código anterior interpretamos e imprimimos los datos de detección transmitidos por el Watcher como una cadena. Sin embargo, en muchos casos querrás extraer información específica como datos numéricos, por ejemplo, el ancho y alto de la caja delimitadora.

El siguiente ejemplo de código muestra cómo hacerlo. Extrae los datos del documento JSON y los imprime 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>());
    }
  }
}

El código es idéntico al ejemplo anterior salvo por la impresión de los datos de detección. En lugar de imprimir como cadena (doc["inference"].as()) extrae la primera caja delimitadora del arreglo "boxes" dentro de los datos de inferencia.

Esta caja delimitadora es un arreglo JSON que contiene seis enteros que representan las coordenadas y metadatos del objeto detectado: x, y, width, height, score (confianza), y cls_id (ID de clase). Estos valores se imprimen en una cadena formateada. Aquí tienes un ejemplo de salida.

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

Una vez que tienes los resultados de detección como datos numéricos, puedes realizar cálculos. Por ejemplo, podrías aproximar la distancia de una persona al Watcher calculando

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

donde b[2] y b[3] contienen el ancho y alto de la caja delimitadora, y c es una constante para convertir la medida a alguna unidad de distancia.

Ejemplo de código: Monitor de Inactividad en el Escritorio

En el ejemplo final construiremos un Monitor de Inactividad en el Escritorio. El SenseCAP Watcher se colocará sobre un escritorio y ejecutará continuamente la tarea de detección de personas. Los datos de detección se enviarán periódicamente al ESP32-C5 conectado, que ejecutará un temporizador. Si la persona está en su escritorio más de 60 minutos sin interrupción, el ESP32-C5 activará un buzzer para animar a la persona a tomar un descanso.

Como el ESP32-C5 no tiene buzzer incorporado, necesitamos conectar uno externo. Es sencillo. Solo conecta el polo negativo del buzzer a GND y el polo positivo al pin D0 como se muestra a continuación.

Connecting SenseCAP Watcher to an XIAO ESP32-C5 with a buzzer — Conectando SenseCAP Watcher a un XIAO ESP32-C5 con buzzer

Las demás conexiones permanecen igual. La tabla a continuación lista todas las conexiones que debes hacer.

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

Si necesitas más ayuda con el buzzer, echa un vistazo a nuestro Active and Passive Piezo Buzzers with Arduino tutorial.

Asegúrate de conectar el buzzer con la polaridad correcta y que sea un buzzer activo; de lo contrario, el siguiente código para el Monitor de Inactividad no 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);
  }
}

Importaciones

Como antes, comenzamos incluyendo la ArduinoJson biblioteca, que se usa para analizar datos JSON recibidos del Watcher.

#include <ArduinoJson.h>

Documento JSON

Luego se crea un DynamicJsonDocument llamado doc con una capacidad de 100 kilobytes. Este documento contendrá los datos JSON analizados recibidos del Watcher.

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

Constantes

La constante BUZZER_PIN define el pin GPIO conectado al buzzer, aquí configurado en D0 (que corresponde al GPIO 1 en el ESP32-C5). Otra constante, MAX_SIT_TIME_MS, define el tiempo máximo permitido sentado en milisegundos, establecido en 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;

Variables

Usamos varias variables para llevar el control del tiempo y el estado de detección. tPerson almacena la última vez que se detectó una persona, tSitting registra cuándo comenzó el período sentado, y personDetected es una bandera booleana que indica si actualmente se detecta una persona.

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

Función setup

La función setup() inicializa la comunicación serial para depuración (Serial) y comunicación con la cámara AI Vision (Serial1) a 115200 baudios. El pin del buzzer se configura como salida y se apaga inicialmente. El código espera a que el puerto serial esté listo, luego inicializa las variables de tiempo tPerson y tSitting con el tiempo actual en milisegundos. Finalmente, imprime «running…» en el monitor serial para indicar que el programa ha comenzado.

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...");
}

Función loop

La función loop() se ejecuta repetidamente y realiza la lógica principal de monitoreo. Primero lee el tiempo actual en milisegundos en tCurrent.

Si hay datos disponibles en Serial1 (de la cámara AI Vision), intenta analizar el JSON entrante en doc. Si el JSON contiene la clave "inference", significa que se detectó una persona. El código imprime cuántos segundos ha estado la persona, actualiza tPerson al tiempo actual, y si es la primera detección tras un período sin detección, reinicia tSitting para comenzar a medir la duración sentado. La bandera personDetected se establece en verdadero.

Si han pasado más de 10 segundos desde la última detección de persona (tCurrent - tPerson > 10000), el código asume que la persona se ha ido, establece personDetected en falso y reinicia tSitting al tiempo actual.

Finalmente, si se detecta una persona y el tiempo sentado ha alcanzado o superado el máximo permitido (MAX_SIT_TIME_MS), el buzzer se activa durante 1 segundo (1000 ms) para recordar al usuario que tome un descanso. El temporizador de sentado tSitting se reinicia después de sonar el buzzer para comenzar un nuevo período de monitoreo.

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);
  }
}

Puedes probar el código reduciendo MAX_SIT_TIME_MS a un minuto (1000 * 60). Si te sientas en tu escritorio más de 60 segundos, el buzzer debería sonar. Si te levantas antes, el temporizador se reiniciará.

Ten en cuenta que el modelo de detección de personas solo detecta la presencia, no si la persona está sentada o no. Sin embargo, podrías usar un modelo esquelético para detectar posturas específicas y contar solo el tiempo que la persona está realmente sentada, por ejemplo.

Conclusiones

El SenseCAP Watcher W1-B combina una plataforma ESP32-S3 con capacidades integradas de visión, audio e IA. Te permite construir sensores inteligentes en el borde. La arquitectura basada en tareas y la conectividad flexible facilitan su integración con herramientas establecidas como Node-RED y Home Assistant.

Para makers que trabajan con ecosistemas Arduino o ESP32, el Watcher puede actuar como un coprocesador IA de alto nivel que descarga las tareas intensivas de detección IA. La lógica específica y potencialmente compleja puede implementarse en un microcontrolador separado que se comunique con el Watcher vía interfaz serial. Ten en cuenta que el SenseCAP Watcher opera con lógica de 3.3 Voltios y se requiere un conversor de nivel para conectarlo a un Arduino UNO de 5V, por ejemplo.

Como sensor de visión IA, el SenseCAP Watcher es similar a los dispositivos HUSKYLENS o HUSKYLENS 2. Sin embargo, el Watcher es más como un agente IA autónomo que puede interpretar escenas y actuar por sí mismo. Mientras que HUSKLENS y HUSKLENS 2 son sensores de visión diseñados para descargar la interpretación y reacción a objetos detectados a un microcontrolador vía interfaces UART/I2C.

Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.

¡Feliz bricolaje! 😉

Enlaces

Aquí tienes una lista de enlaces que encontré útiles al escribir este tutorial:

SenseCAP Watcher Wiki: La fuente principal para vistas generales de hardware y guías de operación.
SenseCraft AI Workspace: El portal web para despliegue de modelos sin código y actualizaciones de firmware.
Seeed Studio Forum: El espacio comunitario oficial para resolver problemas y compartir proyectos con Watcher.
Watcher GitHub Repository: Acceso a esquemas de hardware open-source y archivos de firmware base.
Home Assistant Integration Guide: Instrucciones paso a paso para conectar el Watcher a tu servidor local de automatización.
Node-RED Integration: Aprende a enviar datos de eventos IA a paneles personalizados y APIs externas.

Stefan Maetschke

Partes necesarias

SenseCAP Watcher

XIAO ESP32-C5

Cable USB C

Buzzer Activo 5V

Set de cables Dupont

Protoboard

¿Qué es SenseCAP Watcher W1-B?

Operación basada en tareas e interacción con el usuario

Integración IoT

Escenarios típicos de aplicación

Hardware del SenseCAP Watcher

Capacidades visuales y de audio

Herramientas de interacción e indicadores

Conectividad y alimentación

Especificaciones técnicas

Conectando el SenseCAP Watcher a un ESP32

Creando una tarea con notificación UART

Ejemplo de código: Leer resultados de detección

Importaciones

Objeto Documento JSON

Función setup

Función loop

Ejemplo de salida

Ejemplo de código: Extrayendo datos de detección

Ejemplo de código: Monitor de Inactividad en el Escritorio

Importaciones

Documento JSON

Constantes

Variables

Función setup

Función loop

Conclusiones

Enlaces