Il SenseCAP Watcher è un assistente basato su AI di Seeed Studio. Utilizza il microcontrollore ESP32-S3 per fornire elaborazione locale di visione e voce.
Il Watcher dispone di uno schermo touch circolare da 1,2 pollici, una fotocamera integrata, un microfono e un altoparlante incorporato. Offre connettività Wi-Fi e Bluetooth ed è espandibile tramite un connettore Grove, un header di espansione con connessione seriale e uno slot per schede microSD.
In questo tutorial imparerai come collegare il SenseCAP Watcher a un ESP32 per ricevere i risultati di rilevamento tramite l’interfaccia seriale e reagire di conseguenza. Costruiremo un Monitor di Inattività sulla Scrivania che ti incoraggia a fare esercizio se rimani seduto per più di 60 minuti.
Parti Necessarie
Ti serviranno un SenseCAP Watcher, acquistabile da Seeed Studio. Include un cavo USB-C, un supporto e un adattatore femmina da 1/4″. Ti servirà anche un ESP32; io ho scelto un XIAO ESP32-C5, ma qualsiasi altro ESP32 andrà bene. Infine, per il progetto del Monitor di Inattività sulla Scrivania, ti servirà un buzzer attivo, alcuni fili e una breadboard per collegare tutto.
SenseCAP Watcher
XIAO ESP32-C5
Cavo USB C
Buzzer Attivo 5V
Set di Fili Dupont
Breadboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Cos’è il SenseCAP Watcher W1-B?
Il SenseCAP Watcher W1-B è un nodo di rilevamento AI compatto e autonomo che combina visione computerizzata, interazione audio e automazione in un unico dispositivo.
A livello hardware, il dispositivo integra un microcontrollore ESP32-S3 insieme a un acceleratore AI dedicato, una fotocamera grandangolare, microfono, altoparlante, touchscreen e connettività wireless tramite Wi-Fi e Bluetooth.
Questa combinazione permette al Watcher di eseguire inferenze in tempo reale direttamente sul dispositivo, come il rilevamento di oggetti o il riconoscimento di eventi, senza dipendere completamente dal cloud, migliorando latenza e privacy.
Un concetto chiave del Watcher è la sua architettura AI ibrida. La visione e la logica di base possono essere eseguite localmente sul dispositivo, mentre elaborazioni più avanzate possono essere delegate a servizi esterni o modelli di linguaggio tramite la piattaforma SenseCraft.
Operazione basata su task e interazione utente
Invece della logica firmware tradizionale, il Watcher funziona con un modello a flusso di task. Internamente, le funzioni sono organizzate in “blocchi” modulari che possono produrre o consumare dati, simili a Node-RED. Questi blocchi si collegano per definire il comportamento, ad esempio: rileva una persona → analizza la condizione → invia notifica → attiva sistema esterno.
L’interazione con il dispositivo è multimodale. La fotocamera integrata abilita trigger basati sulla visione, mentre microfono e altoparlante supportano comandi vocali tramite un’interfaccia push-to-talk. Il touchscreen e la rotella forniscono controllo e feedback locali.
Integrazione IoT
Il Watcher è progettato per fungere da ponte tra percezione AI e infrastruttura IoT esistente. Espone dati ed eventi tramite molteplici interfacce, inclusi HTTP, UART e integrazioni basate su messaggi, permettendo la connessione a framework come Node-RED e Home Assistant.
In un setup Node-RED, il Watcher funziona tipicamente come fonte intelligente di eventi. Eventi rilevati, come “persona rilevata” o “oggetto mancante”, possono essere inviati via HTTP o MQTT in un flusso Node-RED per ulteriori elaborazioni.
Integrato con Home Assistant, il Watcher diventa un sensore di alto livello che arricchisce i sensori binari tradizionali. Invece di segnalare solo il movimento, può fornire informazioni semantiche come l’identificazione di oggetti o situazioni specifiche, permettendo automazioni più avanzate, ad esempio azioni diverse a seconda di chi entra in una stanza o dell’attività rilevata.
Per progetti maker, il Watcher può essere usato come modulo di percezione di alto livello collegato a microcontrollori come le schede ESP32. Può rilevare persone o gesti e inviare dati strutturati via UART o HTTP per attivare LED, buzzer, motori o altro hardware.
Scenari applicativi tipici
La flessibilità di combinare AI on-device con orchestrazione esterna consente molte applicazioni. In una smart home, il Watcher può rilevare presenza e contesto, ad esempio riconoscendo quando una persona entra in una stanza e regolando automaticamente l’illuminazione o mostrando informazioni rilevanti. Può anche monitorare animali domestici o rilevare situazioni insolite come una caduta.
In scenari di sicurezza, il dispositivo può agire come nodo di sorveglianza intelligente che distingue tra attività normali e anomalie, riducendo falsi allarmi rispetto ai sensori di movimento tradizionali. Poiché l’elaborazione avviene localmente, i dati sensibili delle immagini non devono uscire dal dispositivo.
In questo tutorial useremo il Watcher per costruire un Monitor di Inattività sulla Scrivania. Il Watcher monitorerà la presenza di una persona seduta alla scrivania. Le informazioni di rilevamento persona saranno inviate via UART a un ESP32 connesso, che terrà traccia del tempo. Se la persona resta seduta per più di 60 minuti, l’ESP32 attiverà un buzzer come promemoria per fare esercizio.
Hardware del SenseCAP Watcher
Il SenseCAP Watcher è alimentato da un microcontrollore ESP32-S3 che opera a 240MHz. Questo chip offre elaborazione dual-core e supporto nativo per Wi-Fi e Bluetooth. Include 8MB di PSRAM dedicata per applicazioni che richiedono molta memoria. Il sistema dispone inoltre di 32MB di memoria flash per firmware e dati utente.
Un processore AI Himax HX6538 separato gestisce calcoli avanzati di visione e vettoriali. Questo processore secondario include 16MB di memoria flash aggiuntiva per modelli AI.
Capacità Visive e Audio
La parte frontale del dispositivo ospita un touchscreen circolare da 1,45 pollici con risoluzione 412×412 pixel. Un sensore fotocamera OV5647 offre un campo visivo grandangolare di 120 gradi. La fotocamera è impostata con messa a fuoco fissa a tre metri.
L’audio in ingresso è catturato da un singolo microfono integrato sulla scheda. Un altoparlante incorporato da 1W fornisce feedback audio e risposte vocali. L’immagine sotto mostra il fronte e il retro del SenseCAP Watcher:
Strumenti di Interazione e Indicatori
Gli utenti possono navigare nel software interno usando una rotella digitale posta sul lato. Questa rotella supporta lo scorrimento e la pressione per selezionare. Un singolo LED RGB indica stati come alimentazione o connettività. Un pulsante di reset dedicato è accessibile tramite un piccolo foro nella parte inferiore della custodia. Il dispositivo include anche uno slot per schede microSD espandibile fino a 32GB.
Connettività e Alimentazione
La comunicazione wireless avviene tramite Wi-Fi a 2,4GHz e Bluetooth 5.0. L’unità dispone di due porte USB-C per diversi scenari di montaggio e alimentazione. La porta inferiore supporta alimentazione 5V e programmazione seriale per sviluppo. La porta posteriore è riservata solo all’alimentazione 5V. Una batteria al litio da 400mAh funge da fonte di alimentazione di backup per usi a breve termine.
Per hardware esterno, il Watcher include una porta Grove I2C e un header femmina 2×4 per espansione GPIO. L’immagine sotto mostra i diversi connettori sul retro del SenseCAP Watcher:
Nota che il pin 5V è un pin di ingresso, mentre il pin 3V3 è un pin di uscita. Non collegare il pin di ingresso 5V e contemporaneamente alimentare il Watcher tramite la porta USB.
Specifiche Tecniche
La tabella seguente riassume le specifiche tecniche del SenseCAP Watcher:
| Hardware | Descrizione |
|---|---|
| MCU | ESP32-S3 @240MHz 8MB PSRAM |
| Processore AI Integrato | Himax HX6538 (Cortex M55 + Ethos-U55) |
| Fotocamera | OV5647 120° FOV Messa a fuoco fissa 3 metri |
| Wi-Fi | Compatibile IEEE 802.11b/g/n Banda 2.4GHz Portata wireless: fino a 100 metri (test in spazio aperto) |
| Bluetooth LE | Bluetooth 5 |
| Antenna | Antenna Wi-Fi e BLE integrata |
| Display | Touchscreen da 1,45 pollici, risoluzione 412×412 |
| Microfono | Microfono singolo |
| Altoparlante | Uscita altoparlante 1W |
| Rotella | Supporta scorrimento su/giù e pressione pulsante |
| LED | 1 LED RGB per indicazioni |
| Slot Scheda microSD | Supporta schede microSD FAT32 fino a 32GB |
| Flash | 32MB Flash per ESP32-S3 16MB Flash per Himax HX6538 |
| Interfaccia di Espansione | 1 interfaccia Grove IIC Header femmina 2×4 (1xIIC, 2xGPIO, 2xGND, 1×3.3V_OUT, 1x5V_IN) |
| USB-C | 1 USB-C sul retro (solo alimentazione) 1 USB-C sul fondo (alimentazione e programmazione) |
| Pulsante Reset | 1 pulsante RST nel foro inferiore |
| Alimentazione | Alimentazione DC 5V |
| Batteria | Batteria Li-ion 3.7V 400mAh come backup |
| Temperatura di Funzionamento | 0 ~ 45°C |
Collegare il SenseCAP Watcher a un ESP32
Il SenseCAP Watcher offre vari metodi per trasmettere informazioni di rilevamento ad altri sistemi per l’elaborazione, come Node-RED o Home Assistant. Tuttavia, questo richiede di avere un server Node-RED o Home Assistant in esecuzione.
Per un sistema di rilevamento piccolo e locale, un’opzione migliore è collegare il SenseCAP Watcher a un altro microcontrollore che valuta i risultati di rilevamento e poi esegue azioni, ad esempio attivare un allarme. Questo si può fare usando l’interfaccia seriale (UART) del Watcher.
Sul retro del Watcher trovi un connettore a 8 pin con interfacce I2C (SCL, SDA), UART (RX, TX) e alimentazione. Lo schema di collegamento sotto mostra come connettere il SenseCAP Watcher a una scheda XIAO ESP32-C5 via UART:
Inizia collegando il TX del Watcher al pin D7 (RX) del XIAO ESP32-C5. Poi collega il RX del Watcher al pin D6 (TX) dell’ESP32-C5. Alimenteremo il Watcher dall’ESP32-C5 collegando i pin 5V e GND. La tabella seguente mostra i collegamenti necessari:
| Watcher | ESP32-C5 |
|---|---|
| RX | D6/TX |
| TX | D7/RX |
| 5V | 5V |
| GND | GND |
Assicurati di usare la porta USB-C sull’ESP32-C5 per alimentare il circuito. Questo fornirà alimentazione sia all’ESP32-C5 che al Watcher insieme. Non collegare la porta USB-C del Watcher.
Creare un Task con notifica UART
L’invio dei risultati di rilevamento dal Watcher via UART a un ESP32 connesso deve essere abilitato per ogni task nell’app SenseCraft. In questa sezione imparerai come fare, ma devi avere l’app SenseCraft installata sul telefono e connessa al tuo SenseCAP Watcher. In caso contrario, leggi prima il Quick Start Guide e segui le istruzioni lì.
Creare un task di rilevamento nell’app SenseCraft è semplice. Ad esempio, digita “Notify via uart if person detected” per creare un task di rilevamento persona:
Una volta creato il task, clicca sul pulsante “Detail Configs” per aprire la finestra di configurazione manuale. Troverai diverse caselle di controllo. Assicurati che “Serial Port / UART Output” sia selezionato:
La maggior parte delle altre caselle sarà selezionata di default, ma per usare la comunicazione seriale non ci serviranno. Per informazioni più dettagliate consulta la UART Output della documentazione Seeed Studio per il SenseCAP Watcher.
Infine, premi il pulsante “Run Task” in fondo alla finestra per avviare il task.
Esempio di Codice: Leggere i risultati di rilevamento
Quando il task è in esecuzione e il Watcher è connesso via UART all’ESP32-C5, possiamo testare la trasmissione dei risultati. Carica il seguente codice sul tuo ESP32-C5, che deve essere collegato al PC tramite cavo USB-C. Non collegare il 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>());
}
}
}
Il codice sopra riceve i dati di rilevamento in formato JSON inviati dal Watcher tramite la connessione seriale e stampa le informazioni sul Monitor Seriale.
Importazioni
Il codice inizia includendo la ArduinoJson libreria, essenziale per il parsing dei dati JSON ricevuti dal Watcher. Questa libreria semplifica la gestione di dati strutturati in formato JSON.
#include <ArduinoJson.h>
Oggetto Documento JSON
Successivamente viene dichiarato un DynamicJsonDocument chiamato doc con una capacità di 100 kilobyte (1024 * 100 byte). Questo oggetto conterrà i dati JSON analizzati ricevuti dalla fotocamera. La dimensione è scelta per accogliere la massima dimensione dei messaggi JSON inviati dal Watcher.
DynamicJsonDocument doc(1024 * 100); // 100K
Funzione Setup
Nella funzione setup(), vengono inizializzate due interfacce seriali. La prima, Serial, è avviata a 115200 baud per comunicare con il Monitor Seriale dell’IDE Arduino. La seconda, Serial1, è anch’essa avviata a 115200 baud ma configurata con i pin specifici D7 (RX) e D6 (TX) per comunicare con la fotocamera SenseCAP Watcher.
Il codice attende che la connessione seriale USB sia stabilita prima di procedere, assicurando che i messaggi di debug siano visibili subito. Dopo un breve ritardo di 100 millisecondi, stampa “Ready.” per indicare che l’ESP32 è pronto a ricevere dati.
void setup() {
Serial.begin(115200);
Serial1.begin(115200, SERIAL_8N1, D7, D6); // RX, TX
while (!Serial)
;
delay(100);
Serial.println("Ready.");
}
Funzione Loop
La funzione loop() controlla continuamente se ci sono dati disponibili su Serial1, collegata al Watcher. Quando rileva dati, tenta di deserializzare il flusso JSON in arrivo nell’oggetto doc.
Se il JSON analizzato contiene la chiave "inference", il valore corrispondente viene estratto come stringa e stampato sul Monitor Seriale.
void loop() {
if (Serial1.available()) {
deserializeJson(doc, Serial1);
if (doc.containsKey("inference")) {
Serial.println(doc["inference"].as<String>());
}
}
}
Esempio di Output
Eseguendo questo codice sull’ESP32-C5 dovresti vedere risultati di rilevamento simili a quelli seguenti apparire sul Monitor Seriale:
In caso contrario, verifica i collegamenti e assicurati che “Serial port / UART output” sia abilitato per il task di rilevamento.
I dati inviati dipendono dal modello di rilevamento. Per il task di rilevamento persona riceverai sempre le bounding box delle persone rilevate, il valore di confidenza, l’id della classe e la lista dei nomi delle classi, in questo caso solo [“person”].
Se esegui il modello di rilevamento gesti che riconosce Rock, Paper o Scissors, i dati inviati dal Watcher saranno ad esempio:
{"boxes":[[176,208,144,218,83,0]],"classes_name":["Paper","Rock","Scissors"]}
Esempio di Codice: Estrazione dati di rilevamento
Nel precedente esempio abbiamo interpretato e stampato i dati di rilevamento trasmessi dal Watcher come stringa. Tuttavia, spesso si vuole estrarre informazioni specifiche come dati numerici, ad esempio larghezza e altezza della bounding box.
Il seguente esempio di codice mostra come fare. Estrae i dati dal documento JSON e li stampa come valori numerici:
#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>());
}
}
}
Il codice è identico all’esempio precedente tranne per la stampa dei dati di rilevamento. Invece di stampare come stringa (doc["inference"].as()) estrae la prima bounding box dall’array "boxes" all’interno dei dati di inferenza.
Questa bounding box è un array JSON contenente sei interi che rappresentano le coordinate e i metadati dell’oggetto rilevato: x, y, width, height, score (confidenza), e cls_id (ID classe). Questi valori sono stampati in una stringa formattata. Ecco un esempio di output.
x:131 y:290 w:240 h:208 | score:71 cls_id:0
Una volta ottenuti i risultati di rilevamento come dati numerici puoi eseguire calcoli. Ad esempio, potresti approssimare la distanza di una persona dal Watcher calcolando
distance = c * b[2].as<int>() * b[3].as<int>();
dove b[2] e b[3] contengono larghezza e altezza della bounding box, e c è una costante per convertire la misura in un’unità di distanza.
Esempio di Codice: Monitor di Inattività sulla Scrivania
Nell’ultimo esempio di codice costruiremo un Monitor di Inattività sulla Scrivania. Il SenseCAP Watcher sarà posizionato su una scrivania e eseguirà continuamente il task di rilevamento persona. I dati di rilevamento saranno inviati periodicamente all’ESP32-C5 connesso, che gestisce un timer. Se la persona resta seduta per più di 60 minuti senza interruzioni, l’ESP32-C5 attiverà un buzzer per incoraggiare una pausa.
Poiché l’ESP32-C5 non ha un buzzer integrato, dobbiamo collegarne uno esterno. È semplice: collega il polo negativo del buzzer a GND e il polo positivo al pin D0 come mostrato sotto.
Gli altri collegamenti restano invariati. La tabella sotto elenca tutti i collegamenti necessari.
| Watcher | ESP32-C5 | Buzzer |
|---|---|---|
| RX | D6/TX | |
| TX | D7/RX | |
| 5V | 5V | |
| GND | GND | GND |
| D0 | + |
Se ti serve aiuto con il buzzer, dai un’occhiata al nostro Active and Passive Piezo Buzzers with Arduino tutorial.
Assicurati di collegare il buzzer con la polarità corretta e che sia un buzzer attivo, altrimenti il codice per il Monitor di Inattività sulla Scrivania non funzionerà.
#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);
}
}
Importazioni
Come prima, iniziamo includendo la ArduinoJson libreria, usata per il parsing dei dati JSON ricevuti dal Watcher.
#include <ArduinoJson.h>
Documento JSON
Poi viene creato un DynamicJsonDocument chiamato doc con capacità di 100 kilobyte. Questo documento conterrà i dati JSON analizzati ricevuti dal Watcher.
DynamicJsonDocument doc(1024 * 100); // 100K
Costanti
La costante BUZZER_PIN definisce il pin GPIO collegato al buzzer, qui impostato a D0 (corrispondente al GPIO 1 sull’ESP32-C5). Un’altra costante, MAX_SIT_TIME_MS, definisce il tempo massimo consentito di seduta in millisecondi, impostato a 60 minuti (1000 ms × 60 s × 60 min).
const int BUZZER_PIN = D0; // GPIO 1 const unsigned long MAX_SIT_TIME_MS = 1000 * 60 * 60;
Variabili
Usiamo diverse variabili per tenere traccia del tempo e dello stato di rilevamento. tPerson memorizza l’ultimo momento in cui è stata rilevata una persona, tSitting registra quando è iniziato il periodo di seduta, e personDetected è un flag booleano che indica se una persona è attualmente rilevata.
unsigned long tPerson = 0; unsigned long tSitting = 0; bool personDetected = false;
Funzione Setup
La funzione setup() inizializza la comunicazione seriale per il debug (Serial) e la comunicazione con la fotocamera AI Vision (Serial1) a 115200 baud. Il pin del buzzer è configurato come uscita e inizialmente spento. Il codice attende che la porta seriale sia pronta, quindi inizializza le variabili temporali tPerson e tSitting con il tempo corrente in millisecondi. Infine, stampa “running…” sul monitor seriale per indicare l’avvio del programma.
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...");
}
Funzione Loop
La funzione loop() viene eseguita ripetutamente e implementa la logica principale di monitoraggio. Prima legge il tempo corrente in millisecondi in tCurrent.
Se sono disponibili dati su Serial1 (dalla fotocamera AI Vision), tenta di analizzare il JSON in arrivo in doc. Se il JSON contiene la chiave "inference", significa che è stata rilevata una persona. Il codice stampa da quanti secondi la persona è presente, aggiorna tPerson al tempo corrente e, se è la prima rilevazione dopo un periodo di assenza, resetta tSitting per iniziare a misurare la durata della seduta. Il flag personDetected viene impostato a true.
Se sono passati più di 10 secondi dall’ultima rilevazione di persona (tCurrent - tPerson > 10000), il codice assume che la persona sia andata via, imposta personDetected a false e resetta tSitting al tempo corrente.
Infine, se una persona è rilevata e il tempo di seduta ha raggiunto o superato il massimo consentito (MAX_SIT_TIME_MS), il buzzer viene attivato per 1 secondo (1000 ms) per ricordare all’utente di fare una pausa. Il timer di seduta tSitting viene resettato dopo il suono del buzzer per iniziare un nuovo periodo di monitoraggio.
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);
}
}
Puoi testare il codice riducendo MAX_SIT_TIME_MS a un minuto (1000 * 60). Se resti seduto più di 60 secondi il buzzer suonerà. Se ti alzi prima, il timer si resetterà.
Nota che il modello di rilevamento persona individua solo la presenza, non se la persona è seduta o meno. Tuttavia, potresti usare un modello scheletrico per rilevare pose specifiche e contare solo il tempo in cui la persona è effettivamente seduta.
Conclusioni
Il SenseCAP Watcher W1-B combina una piattaforma ESP32-S3 con capacità integrate di visione, audio e AI. Ti permette di costruire sensori intelligenti al bordo della rete. L’architettura basata su task e la connettività flessibile facilitano l’integrazione con strumenti consolidati come Node-RED e Home Assistant.
Per i maker che lavorano con Arduino o ecosistemi ESP32, il Watcher può agire come co-processore AI di alto livello che scarica i compiti di sensing AI intensivi. La logica di valutazione specifica e potenzialmente complessa può essere implementata su un microcontrollore separato che comunica con il Watcher tramite interfaccia seriale. Nota però che il SenseCAP Watcher opera con logica a 3.3 Volt e serve un level shifter per collegarlo ad Arduino UNO a 5V, per esempio.
Come sensore di visione AI, il SenseCAP Watcher è simile ai dispositivi HUSKYLENS o HUSKYLENS 2. Tuttavia, il Watcher è più simile a un agente AI autonomo che interpreta scene e agisce in modo indipendente, mentre HUSKLENS e HUSKLENS 2 sono sensori di visione progettati per delegare interpretazione e reazione a un microcontrollore via UART/I2C.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering 😉
Link
Ecco una lista di link che ho trovato utili mentre scrivevo questo tutorial:
- SenseCAP Watcher Wiki: La fonte principale per panoramiche hardware e linee guida operative.
- SenseCraft AI Workspace: Il portale web per il deployment di modelli no-code e aggiornamenti firmware.
- Seeed Studio Forum: Lo spazio comunitario ufficiale per troubleshooting e condivisione di progetti Watcher.
- Watcher GitHub Repository: Accesso a schemi hardware open-source e file firmware core.
- Home Assistant Integration Guide: Istruzioni passo-passo per collegare il Watcher al tuo server di automazione locale.
- Node-RED Integration: Impara come inviare dati di eventi AI a dashboard personalizzate e API esterne.
