Interface du SenseCAP Watcher W1-B avec ESP32

Le SenseCAP Watcher est un assistant alimenté par l’IA de Seeed Studio. Il utilise le microcontrôleur ESP32-S3 pour fournir un traitement local de la vision et de la voix.

Le Watcher est équipé d’un écran tactile circulaire de 1,2 pouce, d’une caméra intégrée, d’un microphone et d’un haut-parleur intégré. Il offre une connectivité Wi-Fi et Bluetooth et peut être étendu via un connecteur Grove, un header d’extension avec une connexion série et un emplacement pour carte microSD.

Dans ce tutoriel, vous apprendrez comment connecter le SenseCAP Watcher à un ESP32 pour recevoir les résultats de détection via l’interface série et y réagir. Nous allons créer un Moniteur d’Inactivité au Bureau qui vous encourage à faire de l’exercice si vous restez à votre bureau plus de 60 minutes.

Pièces requises

Vous aurez besoin d’un SenseCAP Watcher, disponible chez Seeed Studio. Il est livré avec un câble USB-C, un support et un adaptateur femelle 1/4″. Vous aurez également besoin d’un ESP32. J’ai choisi un XIAO ESP32-C5, mais tout autre ESP32 fonctionnera aussi. Enfin, pour le projet de Moniteur d’Inactivité au Bureau, un buzzer actif, des fils et une breadboard seront nécessaires pour les connexions.

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’est-ce que le SenseCAP Watcher W1-B ?

Le SenseCAP Watcher W1-B est un nœud de détection AI compact et autonome qui combine vision par ordinateur, interaction audio et automatisation des tâches en un seul appareil.

Au niveau matériel, l’appareil intègre un microcontrôleur ESP32-S3 avec un accélérateur AI dédié, une caméra grand angle, un microphone, un haut-parleur, un écran tactile et une connectivité sans fil via Wi-Fi et Bluetooth.

Cette combinaison permet au Watcher d’effectuer des inférences en temps réel directement sur l’appareil, comme la détection d’objets ou la reconnaissance d’événements, sans dépendre entièrement du cloud, ce qui améliore la latence et la confidentialité.

SenseCraft platform — Plateforme SenseCraft (source)

Un concept clé du Watcher est son architecture IA hybride. La vision et la logique de base peuvent s’exécuter localement sur l’appareil, tandis que les traitements plus avancés peuvent être délégués à des services externes ou à de grands modèles de langage via la plateforme SenseCraft.

Fonctionnement basé sur les tâches et interaction utilisateur

Au lieu d’une logique firmware traditionnelle, le Watcher fonctionne avec un modèle de flux de tâches. Les fonctions sont organisées en blocs modulaires qui produisent ou consomment des données, à la manière de Node-RED. Ces blocs sont connectés pour définir un comportement, par exemple : détecter une personne → analyser la condition → envoyer une notification → déclencher un système externe.

L’interaction avec l’appareil est multimodale. La caméra intégrée permet des déclencheurs basés sur la vision, tandis que le microphone et le haut-parleur supportent les commandes vocales via une interface push-to-talk. L’écran tactile et la molette rotative offrent un contrôle local et un retour d’information.

Intégration IoT

Le Watcher est conçu pour faire le lien entre la perception AI et l’infrastructure IoT existante. Il expose ses données et événements via plusieurs interfaces, dont HTTP, UART et des intégrations basées sur les messages, ce qui lui permet de se connecter à des frameworks comme Node-RED et Home Assistant.

Dans une configuration Node-RED, le Watcher fonctionne généralement comme une source d’événements intelligente. Les événements détectés, tels que « personne détectée » ou « objet manquant », peuvent être envoyés via HTTP ou MQTT dans un flux Node-RED pour un traitement ultérieur.

Intégré à Home Assistant, le Watcher devient un capteur de haut niveau qui complète les capteurs binaires traditionnels. Au lieu de simplement signaler un mouvement, il peut fournir des informations sémantiques comme l’identification d’objets ou de situations spécifiques. Cela permet des automatisations plus avancées, par exemple déclencher différentes actions selon la personne qui entre dans une pièce ou l’activité détectée.

Pour les projets makers, le Watcher peut être utilisé comme un module de perception de haut niveau connecté à des microcontrôleurs comme les cartes ESP32. Par exemple, il peut détecter des personnes ou des gestes et envoyer des données structurées via UART ou HTTP pour déclencher des LED, buzzers, moteurs ou autres matériels.

Scénarios d’application typiques

La flexibilité de combiner l’IA embarquée avec une orchestration externe permet une large gamme d’applications. Dans une maison intelligente, le Watcher peut détecter la présence et le contexte, par exemple reconnaître quand une personne entre dans une pièce et ajuster automatiquement l’éclairage ou afficher des informations pertinentes. Il peut aussi surveiller les animaux domestiques ou détecter des situations inhabituelles comme une chute.

En sécurité, l’appareil peut agir comme un nœud de surveillance intelligent qui distingue l’activité normale des anomalies, réduisant les fausses alertes par rapport aux capteurs de mouvement traditionnels. Comme le traitement peut se faire localement, les données d’image sensibles ne quittent pas l’appareil.

Dans ce tutoriel, nous utiliserons le Watcher pour construire un Moniteur d’Inactivité au Bureau. Le Watcher surveillera la présence d’une personne assise à un bureau. Les informations de détection seront envoyées via UART à un ESP32 connecté, qui suivra le temps. Si la personne ne quitte pas le bureau pendant plus de 60 minutes, l’ESP32 déclenchera un buzzer pour rappeler de faire de l’exercice.

Matériel du SenseCAP Watcher

Le SenseCAP Watcher est alimenté par un microcontrôleur ESP32-S3 cadencé à 240 MHz. Cette puce offre un traitement double cœur et un support natif pour le Wi-Fi et le Bluetooth. Elle inclut 8 Mo de PSRAM dédiée pour les applications gourmandes en mémoire. Le système dispose aussi de 32 Mo de mémoire flash pour le firmware utilisateur et les données.

Architecture du SenseCAP Watcher (source)

Un processeur AI Himax HX6538 distinct gère les calculs avancés de vision et de vecteurs. Ce processeur secondaire comprend 16 Mo de mémoire flash supplémentaire pour les modèles AI.

Capacités visuelles et audio

L’avant de l’appareil intègre un écran tactile circulaire de 1,45 pouce avec une résolution de 412×412 pixels. Un capteur caméra OV5647 offre un champ de vision grand angle de 120 degrés. La caméra est réglée sur une mise au point fixe à trois mètres.

L’entrée audio est captée par un microphone intégré unique sur la carte. Un haut-parleur intégré de 1W fournit un retour audio et des réponses vocales. L’image ci-dessous montre l’avant et l’arrière du SenseCAP Watcher :

Front and Back of the SenseCAP Watcher — Avant et arrière du SenseCAP Watcher (source)

Outils d’interaction et d’indication

Les utilisateurs peuvent naviguer dans le logiciel interne grâce à une molette digitale située sur le côté. Cette molette supporte le défilement et une fonction bouton pour les sélections. Une LED RGB unique indique l’état, comme l’alimentation ou la connectivité. Un bouton reset dédié est accessible via un petit trou en bas du boîtier. L’appareil comprend aussi un emplacement microSD pour un stockage extensible jusqu’à 32 Go.

Connectivité et alimentation

La communication sans fil se fait via Wi-Fi 2,4 GHz et Bluetooth 5.0. L’unité dispose de deux ports USB-C pour différents scénarios de montage et d’alimentation. Le port inférieur supporte l’alimentation 5V et la programmation série pour le développement. Le port arrière est réservé à l’alimentation 5V uniquement. Une batterie lithium-ion de 400 mAh sert de source d’alimentation de secours à court terme.

Pour le matériel externe, le Watcher inclut un port Grove I2C et un header femelle 2×4 pour l’extension GPIO. L’image ci-dessous montre les différents connecteurs à l’arrière du SenseCAP Watcher :

Notez que la broche 5V est une entrée, tandis que la broche 3V3 est une sortie. Ne connectez pas la broche d’entrée 5V tout en alimentant le Watcher via le port USB.

Spécifications techniques

Le tableau suivant résume les spécifications techniques du SenseCAP Watcher :

Matériel	Description
MCU	ESP32-S3 @240MHz 8MB PSRAM
Processeur AI intégré	Himax HX6538 (Cortex M55 + Ethos-U55)
Caméra	OV5647 120° FOV Focale fixe 3 mètres
Wi-Fi	Compatible IEEE 802.11b/g/n Bande 2,4 GHz Portée sans fil : jusqu’à 100 mètres (test en espace ouvert)
Bluetooth LE	Bluetooth 5
Antenne	Antenne Wi-Fi et BLE intégrée
Écran	Écran tactile 1,45 pouce, résolution 412×412
Microphone	Microphone unique
Haut-parleur	Sortie haut-parleur 1W
Molette	Supporte défilement haut/bas et bouton
LED	1 LED RGB pour indication
Emplacement carte microSD	Supporte carte microSD FAT32 jusqu’à 32 Go
Flash	32 Mo Flash pour ESP32-S3 16 Mo Flash pour Himax HX6538
Interface d’extension	1 interface Grove IIC Header femelle 2×4 (1xIIC, 2xGPIO, 2xGND, 1×3.3V_OUT, 1x5V_IN)
USB-C	1 USB-C à l’arrière (alimentation uniquement) 1 USB-C en bas (alimentation et programmation)
Bouton Reset	1 bouton RST dans le trou en bas
Alimentation	Alimentation DC 5V
Batterie	Batterie Li-ion 3,7V 400mAh en secours
Température de fonctionnement	0 ~ 45°C

Connexion du SenseCAP Watcher à un ESP32

Le SenseCAP Watcher propose plusieurs méthodes pour transmettre les informations de détection à d’autres systèmes pour traitement, comme Node-RED ou Home Assistant. Cependant, cela nécessite d’avoir un serveur Node-RED ou Home Assistant en fonctionnement.

Pour un système de détection local et simple, une meilleure option est de connecter le SenseCAP Watcher à un autre microcontrôleur qui évalue les résultats de détection puis effectue des actions, par exemple déclencher une alarme. Cela peut se faire via l’interface série (UART) du Watcher.

À l’arrière du Watcher, vous trouverez un connecteur 8 broches avec interfaces I2C (SCL, SDA), UART (RX, TX) et alimentation. Le schéma de câblage ci-dessous montre comment connecter le SenseCAP Watcher à une carte XIAO ESP32-C5 via UART :

Connecting SenseCAP Watcher to an ESP32 — Connexion du SenseCAP Watcher à un XIAO ESP32-C5

Commencez par connecter le TX du Watcher à la broche D7 (RX) du XIAO ESP32-C5. Ensuite, connectez le RX du Watcher à la broche D6 (TX) de l’ESP32-C5. Nous alimenterons le Watcher depuis l’ESP32-C5 en reliant les broches 5V et GND. Le tableau suivant récapitule les connexions à réaliser :

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

Assurez-vous d’utiliser le port USB-C de l’ESP32-C5 pour alimenter le circuit. Cela alimentera à la fois l’ESP32-C5 et le Watcher. Ne connectez pas le port USB-C du Watcher.

Création d’une tâche avec notification UART

L’envoi des résultats de détection du Watcher via UART à un ESP32 connecté doit être activé pour chaque tâche dans l’application SenseCraft. Dans cette section, vous apprendrez comment faire, mais vous devez avoir l’application SenseCraft installée sur votre téléphone et connectée à votre SenseCAP Watcher. Sinon, lisez d’abord le Quick Start Guide et suivez les instructions.

Créer une tâche de détection dans l’application SenseCraft est simple. Par exemple, tapez « Notify via uart if person detected » pour créer une tâche de détection de personne :

Create Task with UART notification — Créer une tâche avec notification UART

Une fois la tâche créée, cliquez sur le bouton « Detail Configs » pour ouvrir la configuration manuelle. Vous y trouverez plusieurs cases à cocher. Assurez-vous que « Serial Port / UART Output » est activé :

Configurer la tâche avec notification UART

La plupart des autres cases sont cochées par défaut, mais pour la communication série, elles ne sont pas nécessaires. Pour plus de détails, consultez la UART Output section de la documentation Seeed Studio pour le SenseCAP Watcher.

Enfin, appuyez sur le bouton « Run Task » en bas de la fenêtre pour lancer la tâche.

Exemple de code : lecture des résultats de détection

Une fois la tâche en cours et le Watcher connecté via UART à l’ESP32-C5, nous pouvons tester la transmission des résultats de détection. Téléversez le code suivant sur votre ESP32-C5, qui doit être connecté à votre PC via le câble USB-C. Ne connectez pas le 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>());
    }
  }
}

Le code ci-dessus reçoit les données de détection au format JSON envoyées par le Watcher via la connexion série et affiche les informations dans le moniteur série.

Imports

Le code commence par inclure la bibliothèque ArduinoJson, essentielle pour analyser les données JSON reçues du Watcher. Cette bibliothèque facilite la gestion des données structurées au format JSON.

#include <ArduinoJson.h>

Objet Document JSON

Ensuite, un DynamicJsonDocument nommé doc est déclaré avec une capacité de 100 kilo-octets (1024 * 100 octets). Cet objet contiendra les données JSON analysées reçues de la caméra. La taille est choisie pour accueillir la taille maximale des messages JSON envoyés par le Watcher.

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

Fonction setup

Dans la fonction setup(), deux interfaces série sont initialisées. La première, Serial, est lancée à 115200 bauds pour la communication avec le moniteur série de l’IDE Arduino. La seconde, Serial1, est aussi lancée à 115200 bauds mais configurée avec les broches spécifiques D7 (RX) et D6 (TX) pour communiquer avec la caméra SenseCAP Watcher.

Le code attend que la connexion série USB soit établie avant de continuer, garantissant que les messages de débogage sont visibles immédiatement. Après un court délai de 100 millisecondes, il affiche « Ready. » pour indiquer que l’ESP32 est prêt à recevoir des données.

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

Fonction loop

La fonction loop() vérifie en continu s’il y a des données disponibles sur Serial1, connecté au Watcher. Lorsqu’une donnée est détectée, elle tente de désérialiser le flux JSON entrant dans l’objet doc.

Si le JSON analysé contient la clé "inference", la valeur correspondante est extraite en chaîne de caractères et affichée dans le moniteur série.

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

Exemple de sortie

En exécutant ce code sur l’ESP32-C5, vous devriez voir des résultats de détection similaires apparaître dans le moniteur série :

Sinon, vérifiez le câblage et assurez-vous que « Serial port / UART output » est activé pour la tâche de détection.

Les données envoyées dépendent du modèle de détection. Pour la tâche de détection de personne, vous recevez toujours les boîtes englobantes des personnes détectées, la valeur de confiance, l’ID de classe et la liste des noms de classes, ici uniquement [« person »].

Si vous utilisez le modèle de détection de gestes qui détecte Pierre, Papier ou Ciseaux, les données envoyées par le Watcher ressemblent par exemple à ceci :

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

Exemple de code : extraction des données de détection

Dans l’exemple précédent, nous avons interprété et affiché les données de détection transmises par le Watcher sous forme de chaîne. Cependant, dans de nombreux cas, vous souhaitez extraire des informations spécifiques sous forme numérique, par exemple la largeur et la hauteur de la boîte englobante.

Le code suivant montre comment faire cela. Il extrait les données du document JSON et les affiche sous forme de valeurs numériques :

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

Le code est identique à l’exemple précédent, sauf pour l’affichage des données de détection. Au lieu d’afficher en chaîne (doc["inference"].as()), il extrait la première boîte englobante du tableau "boxes" dans les données d’inférence.

Cette boîte englobante est un tableau JSON contenant six entiers représentant les coordonnées et métadonnées de l’objet détecté : x, y, width, height, score (confiance), et cls_id (ID de classe). Ces valeurs sont affichées dans une chaîne formatée. Voici un exemple de sortie.

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

Une fois que vous avez les résultats de détection sous forme numérique, vous pouvez effectuer des calculs. Par exemple, vous pourriez approximer la distance d’une personne au Watcher en calculant

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

où b[2] et b[3] contiennent la largeur et la hauteur de la boîte englobante, et c est une constante pour convertir la mesure en une unité de distance.

Exemple de code : Moniteur d’Inactivité au Bureau

Dans le dernier exemple de code, nous allons construire un Moniteur d’Inactivité au Bureau. Le SenseCAP Watcher sera placé sur un bureau et exécutera en continu la tâche de détection de personne. Les données de détection seront envoyées périodiquement à l’ESP32-C5 connecté, qui gère un minuteur. Si la personne reste à son bureau plus de 60 minutes sans interruption, l’ESP32-C5 déclenche un buzzer pour l’encourager à faire une pause.

Comme l’ESP32-C5 ne possède pas de buzzer intégré, nous devons en connecter un externe. C’est simple : connectez la borne négative du buzzer au GND et la borne positive à la broche D0 comme indiqué ci-dessous.

Connecting SenseCAP Watcher to an XIAO ESP32-C5 with a buzzer — Connexion du SenseCAP Watcher à un XIAO ESP32-C5 avec buzzer

Les autres connexions restent inchangées. Le tableau ci-dessous liste toutes les connexions nécessaires.

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

Si vous avez besoin d’aide avec le buzzer, consultez notre Active and Passive Piezo Buzzers with Arduino tutoriel.

Assurez-vous de connecter le buzzer avec la bonne polarité et qu’il s’agit d’un buzzer actif – sinon le code suivant pour le Moniteur d’Inactivité au Bureau ne fonctionnera pas.

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

Imports

Comme précédemment, nous commençons par inclure la bibliothèque ArduinoJson utilisée pour analyser les données JSON reçues du Watcher.

#include <ArduinoJson.h>

Document JSON

Ensuite, un DynamicJsonDocument nommé doc est créé avec une capacité de 100 kilo-octets. Ce document contiendra les données JSON analysées reçues du Watcher.

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

Constantes

La constante BUZZER_PIN définit la broche GPIO connectée au buzzer, ici fixée à D0 (correspondant à GPIO 1 sur l’ESP32-C5). Une autre constante, MAX_SIT_TIME_MS, définit le temps maximal d’assise autorisé en millisecondes, fixé à 60 minutes (1000 ms × 60 s × 60 min).

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

Variables

Plusieurs variables sont utilisées pour suivre le temps et l’état de détection. tPerson stocke le dernier moment où une personne a été détectée, tSitting enregistre le début de la période d’assise, et personDetected est un indicateur booléen indiquant si une personne est actuellement détectée.

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

Fonction setup

La fonction setup() initialise la communication série pour le débogage (Serial) et la communication avec la caméra AI Vision (Serial1) à 115200 bauds. La broche du buzzer est configurée en sortie et éteinte au départ. Le code attend que le port série soit prêt, puis initialise les variables de temps tPerson et tSitting avec l’heure actuelle en millisecondes. Enfin, il affiche « running… » dans le moniteur série pour indiquer que le programme a démarré.

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

Fonction loop

La fonction loop() s’exécute en boucle et réalise la logique principale de surveillance. Elle lit d’abord l’heure actuelle en millisecondes dans tCurrent.

Si des données sont disponibles sur Serial1 (provenant de la caméra AI Vision), elle tente d’analyser le JSON entrant dans doc. Si le JSON contient la clé "inference", cela signifie qu’une personne a été détectée. Le code affiche alors depuis combien de secondes la personne est présente, met à jour tPerson à l’heure actuelle, et si c’est la première détection après une période sans détection, il réinitialise tSitting pour commencer à chronométrer la durée d’assise. Le drapeau personDetected est mis à vrai.

Si plus de 10 secondes se sont écoulées depuis la dernière détection (tCurrent - tPerson > 10000), le code considère que la personne est partie, met personDetected à faux, et réinitialise tSitting à l’heure actuelle.

Enfin, si une personne est détectée et que le temps d’assise atteint ou dépasse la limite maximale (MAX_SIT_TIME_MS), le buzzer est activé pendant 1 seconde (1000 ms) pour rappeler à l’utilisateur de faire une pause. Le minuteur d’assise tSitting est réinitialisé après le déclenchement du buzzer pour commencer une nouvelle période de surveillance.

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

Vous pouvez tester le code en réduisant MAX_SIT_TIME_MS à une minute (1000 * 60). Si vous restez assis plus de 60 secondes, le buzzer doit sonner. Si vous quittez votre bureau avant, le minuteur se réinitialise.

Notez que le modèle de détection de personne détecte uniquement la présence, pas si la personne est assise ou non. Cependant, vous pourriez utiliser un modèle squelettique pour détecter des postures spécifiques et ne compter que le temps où la personne est effectivement assise.

Conclusions

Le SenseCAP Watcher W1-B combine une plateforme ESP32-S3 avec des capacités intégrées de vision, audio et IA. Il vous permet de créer des capteurs intelligents en périphérie. L’architecture basée sur les tâches et la connectivité flexible facilitent l’intégration avec des outils établis comme Node-RED et Home Assistant.

Pour les makers travaillant avec Arduino ou l’écosystème ESP32, le Watcher peut agir comme un coprocesseur IA de haut niveau qui décharge les tâches intensives de détection AI. La logique d’évaluation spécifique et potentiellement complexe peut être implémentée sur un microcontrôleur séparé communiquant avec le Watcher via l’interface série. Notez cependant que le SenseCAP Watcher fonctionne en logique 3,3 V et qu’un convertisseur de niveau est nécessaire pour le connecter à un Arduino UNO 5V, par exemple.

En tant que capteur de vision AI, le SenseCAP Watcher est similaire aux appareils HUSKYLENS ou HUSKYLENS 2. Cependant, le Watcher est plus un agent AI autonome capable d’interpréter des scènes et d’agir de manière autonome. Tandis que HUSKLENS et HUSKLENS 2 sont des capteurs de vision conçus pour déléguer l’interprétation et la réaction aux objets détectés à un microcontrôleur via UART/I2C.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage 😉

Liens

Voici une liste de liens que j’ai trouvés utiles lors de la rédaction de ce tutoriel :

SenseCAP Watcher Wiki: La source principale pour les aperçus matériels et les guides d’utilisation.
SenseCraft AI Workspace: Le portail web pour le déploiement de modèles sans code et les mises à jour du firmware.
Seeed Studio Forum: L’espace communautaire officiel pour le dépannage et le partage de projets Watcher.
Watcher GitHub Repository: Accès aux schémas matériels open-source et aux fichiers firmware principaux.
Home Assistant Integration Guide: Instructions pas à pas pour connecter le Watcher à votre serveur d’automatisation local.
Node-RED Integration: Apprenez à pousser les données d’événements AI vers des tableaux de bord personnalisés et des API externes.

Stefan Maetschke

Pièces requises

SenseCAP Watcher

XIAO ESP32-C5

Câble USB-C

Buzzer actif 5V

Jeu de fils Dupont

Breadboard

Qu’est-ce que le SenseCAP Watcher W1-B ?

Fonctionnement basé sur les tâches et interaction utilisateur

Intégration IoT

Scénarios d’application typiques

Matériel du SenseCAP Watcher

Capacités visuelles et audio

Outils d’interaction et d’indication

Connectivité et alimentation

Spécifications techniques

Connexion du SenseCAP Watcher à un ESP32

Création d’une tâche avec notification UART

Exemple de code : lecture des résultats de détection

Imports

Objet Document JSON

Fonction setup

Fonction loop

Exemple de sortie

Exemple de code : extraction des données de détection

Exemple de code : Moniteur d’Inactivité au Bureau

Imports

Document JSON

Constantes

Variables

Fonction setup

Fonction loop

Conclusions

Liens