Spectrino: Soluciones Touch-Free TinyML e IoT con Arduino Nano 33 BLE Sense y ESP8266

Componentes y materiales

Arduino Nano 33 BLE Sense	×1
Espressif ESP8266 ESP-01	×1
Arducam Mini 2MP Plus	×1
Pantalla MAX7219 (4 en 1, display 32×8)	×1
Zumbador	×1
Servomotor SG90 / MG995 / MG959	×2
Cargador Micro-Lipo Adafruit	×1
Batería Li-Po Adafruit	×1
Arduino MKR WiFi 1010	×1
LED RGB difuso cátodo común	×1
Sensor ultrasónico HC-SR04	×1

Herramientas necesarias

• Kit 10 cables jumper, 5 cm

Aplicaciones y servicios en línea

• Arduino Web Editor
• ThingSpeak API
• Edge Impulse Studio
• TensorFlow

Sobre este proyecto

Visión general

La pandemia ha introducido una restricción a la interacción social: la distancia. Considerando este factor de riesgo, países de todo el mundo han estado en diversos niveles de cuarentena, y muchos centros comerciales han tenido que cerrar debido a una caída significativa de consumidores. Esto ha provocado un nivel muy alto de despidos de personal de centros comerciales, así como desafíos económicos similares para propietarios de negocios.

Complicación

Considerando los datos, el equipo determinó un gran desafío: la incertidumbre del riesgo respecto a la densidad de población en diferentes tiendas de centros comerciales que siguen abiertos. Además, aunque el uso de mascarillas y evitar el contacto es obligatorio en muchos lugares, aún hay incumplimientos. Esto dificulta que el personal y propietarios, que no pueden trabajar remotamente, naveguen con seguridad este nuevo entorno laboral. La pregunta es: ¿cómo garantizar con cierta certeza que, en un momento dado, una tienda concreta es segura para entrar?

Todos luchamos contra la pandemia COVID-19 y debemos adaptarnos con más medidas de seguridad. Mientras la vida vuelve a la normalidad, añadir seguridad en lugares públicos y concurridos también prevalece en las ciudades. Pero hay situaciones donde debemos romper medidas de seguridad e interactuar con elementos inseguros para satisfacer necesidades. Este proyecto aborda la prevención de la propagación del COVID-19 a través de interacciones táctiles.

Se realizó un experimento para ver la propagación de virus por contacto. Los resultados mostraron la necesidad de automatizar los dispositivos más usados en viviendas y sociedades para garantizar comunicación manos libres.

Soluciones desarrolladas en este prototipo

1. Sistema Intercomunicador Inteligente con TinyML en Arduino 33 BLE Sense: Solución sin contacto usando visión artificial y modelo TinyML para detectar persona en la puerta y activar timbre sin tocarlo.
2. Monitor de Temperatura con IoT y Sistema de Alertas: Detecta personas al entrar, mide su temperatura y la muestra en dashboard IoT para análisis de tendencias. Al detectar temperatura anómala, genera alertas para segunda inspección.
3. Ascensor Touch-Free con Reconocimiento de Voz TinyML en Arduino BLE 33 Sense: Identifica comandos "subir" o "bajar" y acciona servos para pulsar botones.
4. Sistema de Detección de Mascarillas con TinyML y Monitor IoT: Detecta si una persona lleva mascarilla y envía datos a dashboard IoT para monitorizar e imponer restricciones.
5. Monitor Inteligente de Colas en Supermercados/Centros Comerciales con TinyML, IoT y Visión Artificial: Detecta personas en entrada, permite acceso a 50 personas cada 15 minutos. Datos proyectados en dashboard IoT tiempo real.
6. Monitor de Personas en Pasillos y Sistema de Sanitización por Contaminación: Detecta personas en área; si supera umbral, sanitiza automáticamente con luz UV. Períodos de sanitización en dashboard IoT.

Configuración y requisitos del proyecto

Hardware requerido

1) Arduino Nano 33 BLE Sense

Evolución del Arduino Nano tradicional con procesador nRF52840 (ARM Cortex-M4 a 64 MHz). 1MB memoria de programa (32× Uno), RAM 128× mayor. Incluye Bluetooth por NFC y modos ultra-bajo consumo.

Inteligencia Artificial Embebida: Permite Edge Computing (AI) con TinyML. Crea modelos con TensorFlow Lite y súbelos vía Arduino IDE.

2) ESP8266 ESP-01

Módulo Wi-Fi que da a microcontroladores acceso a red Wi-Fi. SOC autónomo que no necesita microcontrolador externo. Hasta 9 GPIOs según versión. Versátil: da acceso a internet como shield Wi-Fi, o actúa como microcontrolador programable.

3) Arducam Mini 2MP Plus

Cámara SPI 2MP optimizada con sensor CMOS OV2640. Tamaño miniatura, interfaz hardware fácil y librería open source. Compatible con Arduino, Raspberry Pi, Maple, Chipkit, Beaglebone mientras tengan SPI/I2C.

4) Arduino MKR WiFi 1010

Punto de entrada fácil a IoT básico y pico-redes. Procesador SAMD21 Cortex-M0 32-bit. Conectividad WiFi/BLE con módulo u-blox NINA-W10 (2.4GHz). Comunicación segura con chip Microchip ECC508. Incluye cargador de batería y LED RGB direccionable.

Herramientas de software

1) Arduino Web Editor

Plataforma online integrada: IDE online, Arduino IoT Cloud, Project Hub, Device Manager. De idea a proyecto IoT terminado más rápido.

2) Edge Impulse Studio

Permite recopilar datos de sensores reales, entrenar modelos ML en la nube y desplegarlos en Arduino. Integración en sketches con una llamada a función. Ejemplos integrados para acelerómetro y micrófono.

3) ThingSpeak

Servicio analítico IoT para agregar, visualizar y analizar streams de datos en vivo en la nube. Ejecución de código MATLAB. Usado para prototipos y pruebas de concepto IoT. Envío de datos vía REST API o MQTT.

Implementaciones

1er Proyecto: Ascensor Touch-Free con Reconocimiento de Voz TinyML

Usamos ascensores varias veces al día. Los botones son tocados por todos. Creé solución touch-free con comandos de voz, sin IoT/WiFi, que acciona servos para pulsar botones.

Soluciones existentes con gestos o ultrasónicos requieren distancia cercana (riesgo de contacto) y son muy sensibles (falsos positivos). Propuse reconocimiento de voz en Arduino 33 BLE Sense para mayor precisión y distancia de activación.

Entrenamiento del modelo en Edge Impulse Studio:

1. Acumulación de datos raw: 1:30 min total, 2 seg por muestra "subir"/"bajar"
2. Crear impulso: Ventana 300ms, red neuronal Keras para micrófono/acelerómetro
3. Conversión a datos procesados: Coeficientes cepstrales (DSP)
4. Entrenamiento: Datos con voces graves/agudas para robustez
5. Arquitectura red neuronal: Input → Reshape → 1D ConvPool (30 neuronas, kernel 5) → 1D ConvPool (10 neuronas, kernel 5) → Flatten

Resultado: 91.2% precisión media, pérdida 0.29 (100 épocas). Matriz de confusión clara. Test con datos reales: 75% precisión (24 seg).

Modelo desplegado como librería Arduino en Arduino 33 BLE Sense. Usa micrófono integrado y ~24-28 KB de 256 KB flash.

Lógica de respuesta a comandos:

if (found_command[0] == 'up') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW);  // LED verde para "subir"
  servo_7.write(0);         // Pulsa botón subir
  delay(100);
  digitalWrite(LEDG, HIGH);
  servo_7.write(180);       // Retorna posición original
}

if (found_command[0] == 'down') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW);
  servo_7.write(0);         // Pulsa botón bajar
  delay(100);
  digitalWrite(LEDG, HIGH);
  servo_7.write(180);
}

Comparativa de sensores:

• Ultrasónicos: Muy sensibles al movimiento, activaciones falsas, poca precisión
• Gestos: Más precisos pero requieren distancia cercana (riesgo contacto)
• Voz: Más preciso, activación a mayor distancia

2º Proyecto: Intercomunicador Inteligente con Reconocimiento Facial y TinyML

CDC confirma transmisión por fómites (superficies contaminadas). El coronavirus dura hasta 3 días en plástico/metal, 24h en cartón. Los intercomunicadores tradicionales requieren pulsar botón. Necesitamos soluciones sin contacto.

Sistema usa detección de personas en Arduino 33 BLE Sense con TinyML/TensorFlow Lite. Al detectar persona, activa zumbador y muestra "Persona" en matriz LED MAX7219.

Implementación:

Software: TensorFlow Lite, Arduino Web Editor

Modelo pre-entrenado TensorFlow con 3 clases: "unused", "person", "notperson". Arducam Mini 2MP captura imágenes, las envía a Arduino Nano 33 BLE Sense para procesado/clasificación. Imágenes redimensionadas a 96×96 para 256KB RAM.

Framework deep learning: Depthwise Conv2D → Conv2D → Average Pool2D → Flatten

Función clave (Arduino_detection_responder.cpp):

uint8_t person_score = output->data.uint8[kPersonIndex];
uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
RespondToDetection(error_reporter, person_score, no_person_score);

Lógica de funcionamiento:

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);   // Activa zumbador
  digitalWrite(LEDR, HIGH);  // Matriz muestra "Persona"
  digitalWrite(5, LOW);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Person");
  delay(100);
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
}

Librerías principales (main.ino):

#include <TensorFlowLite.h>
#include "main_functions.h"
#include "detection_responder.h"
#include "image_provider.h"
#include "model_settings.h"
#include "person_detect_model_data.h"
#include "tensorflow/lite/micro/kernels/micro_ops.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

Loop principal:

void loop() {
  if (kTfLiteOk != GetImage(error_reporter, kNumCols, kNumRows, kNumChannels, input->data.uint8)) {
    TF_LITE_REPORT_ERROR(error_reporter, "Image capture failed.");
  }
  if (kTfLiteOk != interpreter->Invoke()) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed.");
  }
  TfLiteTensor* output = interpreter->output(0);
  uint8_t person_score = output->data.uint8[kPersonIndex];
  uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
  RespondToDetection(error_reporter, person_score, no_person_score);
}

Proveedor de imágenes (arduino_image_provider.cpp):

#include <SPI.h>
#include <Wire.h>
#include <memorysaver.h>
#include <ArduCAM.h>
#include <JPEGDecoder.h>

#define MAX_JPEG_BYTES 4096
#define CS 7

ArduCAM myCAM(OV2640, CS);
uint8_t jpeg_buffer[MAX_JPEG_BYTES] = {0};
uint32_t jpeg_length = 0;

TfLiteStatus InitCamera(tflite::ErrorReporter* error_reporter) {
  Wire.begin();
  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);
  SPI.begin();
  myCAM.write_reg(0x07, 0x80);
  delay(100);
  myCAM.write_reg(0x07, 0x00);
  delay(100);
  myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
  uint8_t test = myCAM.read_reg(ARDUCHIP_TEST1);
  if (test != 0x55) {
    TF_LITE_REPORT_ERROR(error_reporter, "Can't communicate with ArduCAM");
    return kTfLiteError;
  }
  // ... configuración completa de cámara
}

Componentes del firmware:

• Arduino 33 BLE Sense: Procesa, clasifica, envía comandos
• Zumbador: Alerta persona en puerta
• Arducam Mini 2MP Plus: Captura continua datos visuales
• Cargador Li-Ion Adafruit + Batería: Fuente alimentación
• MAX7219 4-en-1: Muestra "Persona"

Función adicional: Activar intercomunicador existente

Servo adicional para pulsar botón de video del intercomunicador actual:

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  digitalWrite(5, LOW);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Person");
  servo_8.write(0);   // Activa intercomunicador
  delay(500);
  servo_8.write(180); // Desactiva
  delay(100);
}

3er Proyecto: Detección Autónoma de Temperatura con IoT

Sensor temperatura fundamental para medir temperatura corporal. Fiebre es síntoma principal de COVID-19. El comercio minorista ha sido muy afectado. Tras reapertura, medición manual de temperatura aumenta mano de obra y riesgo de contacto.

Segundo fallo: datos no se almacenan ni sincronizan para monitorización.

Solución IoT en Arduino MKR WiFi 1010 con módulo temperatura Adafruit AMG8833. Ultrasonidos HC-SR04 detectan persona a 20cm → Arduino activa AMG8833 → Lectura enviada a ThingSpeak tiempo real. Al detectar >38.1°C (104°F), cierra puerta (servo 180°) y activa alarma.

Lógica:

├── Detección Temperatura Persona
├── HC-SR04 Ultrasonido
│   ├── Detección Persona
│   │   └── Si (distancia = 20cm), enviar comando
├── Arduino MKR WiFi 1010
│   ├── Si ultrasónico envía comando:
│   │   ├── Abrir puerta - Servo(0)
│   │   ├── Activar AMG8833 lecturas
│   │   ├── Enviar lecturas a ThingSpeak
│   │   │   └── Si Temp > 38.1°C
│   │   │       ├── Cerrar puerta - Servo(180)
│   │   │       ├── Activar Zumbador
│   │   └── Repetir bucle

Código principal (fragmentos):

#include <Wire.h>
#include <Adafruit_AMG88xx.h>
#include <Servo.h>
#include <WiFi.h>
#include <WiFiMulti.h>

Servo servo1;
int trigPin = 9, echoPin = 8;
long distance, duration;

WiFiMulti WiFiMulti;
const char* ssid = "Tu_SSID";
const char* password = "Tu_Password";
const char* host = "api.thingspeak.com/1121969";
String api_key = "Tu_API_Key";

Adafruit_AMG88xx amg;

void setup() {
  Serial.begin(9600);
  servo1.attach(7);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Connect_to_Wifi();
  bool status = amg.begin();
  if (!status) {
    Serial.println("Sensor AMG88xx no encontrado, revisa conexiones!");
    while (1);
  }
  delay(100);
}

void loop() {
  ultra();
  servo1.write(0);  // Puerta abierta
  if(distance <= 20){
    Serial.print("Temperatura = ");
    Serial.print(amg.readThermistor());
    Serial.println(" *C");
    Send_Data();
    delay(50);
    if(amg.readThermistor() > 38.1) {
      servo1.write(180);  // Cerrar puerta
      digitalWrite(6, HIGH); // Alarma zumbador
    }
  }
}

void Send_Data() {
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("Conexión fallida");
    return;
  }
  String data_to_send = api_key + "&field1=" + String(amg.readThermistor()) + "\r\n";
  client.print("POST /update HTTP/1.1\n");
  client.print("Host: api.thingspeak.com\n");
  client.print("Connection: close\n");
  client.print("X-THINGSPEAKAPIKEY: " + api_key + "\n");
  client.print("Content-Type: application/x-www-form-urlencoded\n");
  client.print("Content-Length: " + String(data_to_send.length()) + "\n\n");
  client.print(data_to_send);
  delay(200);
  client.stop();
}

Dashboard ThingSpeak público: Temperature Dashboard. Gráfico integrable en dashboard único multi-centro comercial para que visitantes elijan el más seguro.

Go to Market - Viabilidad:

• Identificar datos temperatura anómala por día/hora
• Implementar estrategias seguridad basadas en datos
• Reducir mano de obra y automatizar monitorización
• Ofrecer dashboard a visitantes para elegir momento más seguro
• Aumentar ventas/visitas garantizando seguridad
• Empresas IoT pueden invertir para producción masiva
• Más supermercados = más datos para gobierno, más opciones seguras para clientes
• Más asequible que monitorización manual (menos coste laboral + menos riesgo infección)

4º Proyecto: Monitor de Colas TinyML + IoT en Arduino 33 BLE Sense

Gestión de colas en centros comerciales es problema tras reapertura. Restricción de aforo se hace manualmente (más mano de obra). Datos de aforo no disponibles a visitantes. Si lo estuvieran, aumentaría % de visitas.

Colas virtuales/digitales permiten servir clientes manteniéndolos seguros. Tipos: estructuradas (supermercados), no estructuradas (taxis), basadas en kioscos (bancos), móviles (smartphone monitoriza dashboard IoT).

Colas largas disuaden clientes, limitan productividad, causan estrés. Tiempo percibido ≠ tiempo real (sobreestimación ~36%). Tiempo ocupado se siente más corto.

Razón principal miedo a visitar supermercados: datos insuficientes. Visitantes no conocen densidad interior. Mayor gente = mayor riesgo. Cálculo manual entrada/salida en tiempo real imposible. Visitante no sabe mejor día/hora ni tiempo espera en otros supermercados cercanos. Resultado: menos conversión y visitas. Solución: Arduino TinyML + IoT para datos disponibles a visitantes, aumentar conversión con seguridad.

Basado en visión artificial y detección personas (TensorFlow). Implementado en entradas: Arducam captura imágenes → Arduino 33 BLE Sense procesa/clasifica. Si persona detectada: incrementa contador, abre entrada (servo), envía dato a ThingSpeak vía ESP8266-01. Al alcanzar 50 personas (umbral configurable): cierra puerta, espera 15 min, muestra tiempo espera en matriz LED. Visitantes ven aforo en dashboard.

Cálculo tiempo espera: X = entraron, Y = salieron, X-Y = dentro. Z = umbral (50). Z-(X-Y) = count. Si count negativo: tiempo espera = count × (-tiempo medio estancia). Si positivo: espera = 0.

Implementación sistema físico de colas:

Software: TensorFlow Lite, ThingSpeak, Arduino Web Editor

Mismo modelo pre-entrenado 3 clases. Arducam Mini 2MP → Arduino 33 BLE Sense (96×96, modelo 125KB).

Lógica respondedor detección (Arduino_detection_responder.cpp):

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  servo_8.write(0);  // Abre puerta entrada sin contacto
  count++;
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
  servo_8.write(180); // Cierra puerta
}

if (count % 50 == 0) {  // Múltiplos de 50
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Espera 15min");
  delay(60000);
}

Componentes:

• Arduino 33 BLE Sense: Procesa, clasifica, comanda
• Servo MG959/MG995: Abre/cierra puertas (alimentación externa)
• Arducam Mini 2MP Plus: Captura continua imágenes
• Cargador Li-Ion + Batería: Alimentación
• ESP8266-01: Envía datos a ThingSpeak vía WiFi
• MAX7219 4-en-1: Muestra tiempo espera

Dashboard ThingSpeak:

Dos campos: entrada y salida. Coordenadas del local en mapa. Datos tiempo real para staff: análisis día/hora, imponer restricciones si aforo supera esperado.

Dashboard visible: IoT Dashboard

¿Por qué no ultrasónicos/infrarrojos? Inexactos para conteo real, hardware adicional. Detección personas puede usar cámaras CCTV existentes → Arduino BLE Sense para clasificación central, reduciendo coste hardware.

Go to Market:

• Conteo entrada/salida tiempo real
• Estrategias seguridad con algoritmos gestión colas eficientes
• Reducir mano de obra, automatizar gestión colas
• Dashboard visitantes: densidad y momento más seguro
• Garantizar seguridad → aumentar ventas/visitas
• Empresas AI/IoT invertir producción masiva
• Más supermercados = más datos gobierno, más opciones seguras + comparación tiempos espera
• Más asequible que sistemas manuales
• Usar CCTV real para gestión colas autónoma (tendencias temporales + análisis espacial densidad)
• Decisiones data-driven para seguridad y colas eficientes

Código GitHub: Arduino Autonomous TinyML and IoT based queuing system

Adición: Sistema Detección Mascarillas (Extensión detección personas)

Mascarillas protegen contra enfermedades transmitidas por gotículas (gripe, tos ferina, neumonía). Control de fuente reduce transmisión infecciones respiratorias. Portadores asintomáticos pueden transmitir virus. Aumenté necesidad de mascarillas + sistemas touch-free para seguridad en centros comerciales.

Modelo personalizado detección mascarillas: detecta mascarilla/no mascarilla, muestra datos en ThingSpeak para concienciar a staff y visitantes sobre tendencias temporales sin mascarilla. Aumenta conciencia y permite restricciones basadas en datos.

Dataset y entrenamiento en Edge Impulse:

• Dataset original: 3500 imágenes → filtradas a 813 entrenamiento + 487 test
• Clases: "mask" y "no_mask"
• Tamaño imagen: 96×96 (óptimo Arduino 33 BLE Sense)
• Bloque procesamiento: "images", Transfer Learning (Images) - MobileNetV2 0.35 (16 neuronas, 0.1 dropout)
• Profundidad color: RGB (color importante para clasificación)

Resultado entrenamiento (30 épocas, learning rate 0.0005): Accuracy 92.6%, Loss 0.19. Test data: 98.15% precisión.

Modelo desplegado como librería Arduino. Clasificación en vivo confirmada.

Código principal (main.ino - loop):

void loop() {
  if (kTfLiteOk != GetImage(error_reporter, kNumCols, kNumRows, kNumChannels, input->data.uint8)) {
    TF_LITE_REPORT_ERROR(error_reporter, "Image capture failed.");
  }
  if (kTfLiteOk != interpreter->Invoke()) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed.");
  }
  TfLiteTensor* output = interpreter->output(0);
  uint8_t mask_score = output->data.uint8[kmaskIndex];
  uint8_t no_mask_score = output->data.uint8[kno-maskIndex];
  RespondToDetection(error_reporter, mask_score, no_mask_score);
}

Respondedor (Arduino_detection_responder.cpp):

if (mask_score > no_mask_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  servo_8.write(0);  // Abre puerta
  count++;
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
  servo_8.write(180); // Cierra puerta
  count2++;
}

Contadores count (mascarilla) y count2 (sin mascarilla) → ThingSpeak IoT Dashboard.

GitHub: Arduino Mask Detection | Dashboard: IoT Dashboard

5º Proyecto: Detección Personas en Pasillos y Auto-Sanitización

Riesgo contaminación viral en supermercados/tiendas (ropa, comida, electrónica). Coronavirus sobrevive días en superficies: plástico/acero inoxidable hasta 3 días, cartón 24h. Luz UV usada en hospitales contra superbacterias; efectiva contra SARS (15 min UVC inactiva). MTA Nueva York usa UV en metro. Academia Ciencias: probable efectividad contra COVID-19.

Sanitización UV manual consume tiempo, sin datos tiempo real. No se sabe qué área tiene más contacto/riesgo. Solución robusta: TinyML visión artificial + IoT en Arduino 33 BLE Sense.

Marco estructurado:

Modelos desplegados individualmente en pasillos/áreas. Arducam Mini 2MP captura video continuo → Arduino Nano 33 BLE Sense procesa/clasifica. Si persona detectada: incrementa contador. Umbral según tasa contaminación por tipo objeto (alimentación, ropa, deporte, electrónica).

Umbral promedio: 1-25 seguro (LED verde), 26-50 alerta (LED azul), 51-100 contaminado (LED rojo), >150 sanitización UV automática. Alertas LED por colores instaladas en cada área.

Implementación sistema auto-sanitización:

Software: TensorFlow Lite, ThingSpeak, Arduino Web Editor

Mismo modelo pre-entrenado 3 clases. Arducam Mini 2MP → Arduino 33 BLE Sense (96×96, 125KB).

Lógica respondedor (detection_responder.cpp):

void RespondToDetection(...) {
  static bool is_initialized = false;
  if (!is_initialized) {
    pinMode(LEDR, OUTPUT); pinMode(LEDG, OUTPUT); pinMode(LEDB, OUTPUT);
    is_initialized = true;
  }
  digitalWrite(LEDG, HIGH); digitalWrite(LEDR, HIGH);
  digitalWrite(LEDB, LOW); delay(100); digitalWrite(LEDB, HIGH);

  if (person_score > no_person_score) {
    digitalWrite(LEDG, LOW); digitalWrite(LEDR, HIGH);
    count++;
  } else {
    digitalWrite(LEDG, HIGH); digitalWrite(LEDR, LOW);
  }
  TF_LITE_REPORT_ERROR(error_reporter, "Person score: %d No person score: %d", person_score, no_person_score);
}

if (constrain(count, 1, 50))   digitalWrite(LEDGREEN, LOW);  // Verde: seguro
if (constrain(count, 51, 75))  digitalWrite(LEDBLUE, LOW);   // Azul: alerta
if (constrain(count, 76, 100)) digitalWrite(LEDRED, LOW);    // Rojo: contaminado
if (constrain(count, 101, 110)) digitalWrite(UV, LOW);       // UV: sanitizar
if (count > 111) count = 0;  // Reset tras sanitización

Envío datos ThingSpeak (ESP8266-01):

void Send_Data() {
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) { Serial.println("connection failed"); return; }
  String data_to_send = api_key + "&field1=" + String(count) + "\r\n";
  client.print("POST /update HTTP/1.1\nHost: api.thingspeak.com\nConnection: close\n");
  client.print("X-THINGSPEAKAPIKEY: " + api_key + "\n");
  client.print("Content-Type: application/x-www-form-urlencoded\n");
  client.print("Content-Length: " + String(data_to_send.length()) + "\n\n");
  client.print(data_to_send);
  delay(10);
  client.stop();
}

Umbrales por tipo de pasillo:

Pasillo Ropa: 1-50 verde, 51-75 azul, 76-100 rojo, 101-110 UV, >111 reset

Pasillo Electrónica: 1-75 verde, 76-180 azul, 181-225 rojo, 225-240 UV, >111 reset (virus dura menos)

Pasillo Alimentación: 1-25 verde, 25-50 azul, 51-75 rojo, 76-90 UV, >91 reset (mayor riesgo)

Dashboard ThingSpeak IoT:

4 campos: Food-aisle, Sports-aisle, Clothes-aisle, Electronics-aisle. Coordenadas local en mapa. Visualizable en dashboard único multi-supermercado.

Dashboard: IoT Dashboard. Posible integración Tableau para plotear datos en plano planta supermercado. Visitantes interpretan decisiones data-driven (tienda menor densidad).

Ventaja diferencial:

Sistemas UV actuales: manuales o robots autónomos que mapean y sanitizan solo partes bajas, caros, no monitorizan densidad por pasillo ni sanitizan según contaminación real. Esta solución: por pasillo, según flujo real personas, datos continuos, escalable, asequible.

Go to Market y Viabilidad:

• Conteo y densidad por área + auto-sanitización
• Estrategias seguridad con algoritmos monitorización densidad
• Reducir mano de obra, automatizar sanitización
• Dashboard visitantes: densidad por área + tendencias temporales sanitización (caídas bruscas en gráfico = sanitización hecha)
• Garantizar seguridad → aumentar ventas/visitas
• Empresas AI/IoT invertir producción masiva
• Más supermercados = más datos gobierno, más opciones seguras comparando tiempo cola y seguridad
• Más asequible que robots UV, altamente escalable con dashboard IoT
• Usar CCTV real para sanitización autónoma (tendencias temporales + análisis espacial)
• Decisiones data-driven para seguridad y colas eficientes

GitHub: https://github.com/dhruvsheth-ai/self-sanitisation-person-detection

Vídeo del proyecto

¡Gracias por ver mi proyecto!

Código

• Automatización Ascensor con comandos "up"/"down": Librería Arduino (.zip) - Descarga
• Auto-Sanitización Pasillos con Detección Personas: https://github.com/dhruvsheth-ai/self-sanitisation-person-detection
• Monitor Temperatura IoT: https://github.com/dhruvsheth-ai/temperature-arduino-iot
• Algoritmo Detección Mascarillas: https://github.com/dhruvsheth-ai/ble-mask-detection-optimised
• Intercomunicador Autónomo TinyML: https://github.com/dhruvsheth-ai/person-autonomous-intercom
• Automatización Ascensor TinyML: https://github.com/dhruvsheth-ai/elevator-Automation-ARDUINO
• Detección Personas y Colas Entrada Centro Comercial: https://github.com/dhruvsheth-ai/Person-queuing-system-arduino33

Esquemáticos

Esquemático para sistema detección personas y auto-sanitización pasillos con datos a ThingSpeak IoT Dashboard

Detecta persona en puerta, activa timbre y muestra "Persona" en matriz LED