Spectrino : Solutions sans contact TinyML & IoT avec Arduino Nano 33 BLE Sense et ESP8266

Composants et fournitures

Arduino Nano 33 BLE Sense

Espressif ESP8266 ESP-01

Arducam Mini 2MP Plus

Affichage MAX7219

Suggéré : 4 en 1, 32×8

Buzzer

Servomoteur SG90 Micro

Générique – utilisation MG995 ou MG959

Chargeur Micro-Lipo Adafruit

Batterie Li-Po Adafruit

Arduino MKR WiFi 1010

LED RGB diffuse cathode commune

Capteur ultrasons HC-SR04

Outils nécessaires

Kit 10 fils de connexion, 5 cm

Applications et services en ligne

Arduino Web Editor

API ThingSpeak

Edge Impulse Studio

TensorFlow

À propos de ce projet

Vue d'ensemble

La pandémie a imposé une contrainte majeure : la distanciation physique. Les confinements ont entraîné la fermeture de nombreux centres commerciaux, provoquant une vague massive de licenciements dans la restauration, le commerce de détail et le divertissement (environ 4 millions d'emplois perdus aux USA en juillet 2020). Globalement, on estime plus de 103 000 suppressions de postes.

Complication

Pour les centres restés ouverts, l'incertitude sur la densité de population dans chaque boutique persiste. Malgré le port du masque obligatoire, des violations subsistent, mettant en danger le personnel qui ne peut pas télétravailler. Comment garantir qu'une boutique est sûre à entrer à tout moment ?

Une expérience a montré la propagation virale par contact. J'ai donc décidé d'automatiser les dispositifs les plus courants pour garantir une interaction sans contact.

Solutions développées

Interphone intelligent avec TinyML (Arduino Nano 33 BLE Sense) : Détection de personne par vision artificielle, sonnerie sans contact.
Surveillance de température IoT avec alertes : Détection d'entrée, mesure de température, tableau de bord ThingSpeak, alerte si fièvre.
Ascenseur sans contact par reconnaissance vocale (TinyML) : Commandes « haut » / « bas » actionnant les boutons via servomoteurs.
Détection de masque (TinyML + IoT) : Vision artificielle pour détecter le port du masque, données sur tableau de bord.
Gestion de file d'attente intelligente (TinyML + IoT + vision) : Comptage entrées/sorties, limitation à 50 personnes, temps d'attente affiché.
Surveillance d'allées et auto-désinfection UV : Détection de densité, seuils de contamination, désinfection UV autonome.

Matériel et logiciels requis

Matériel principal

Arduino Nano 33 BLE Sense : Processeur nRF52840 (Cortex-M4 64 MHz), 1 Mo flash, 256 Ko RAM, Bluetooth NFC, ultra-low power. Capteurs intégrés + microphone. Idéal pour TinyML (TensorFlow Lite).
ESP8266 ESP-01 : Module Wi-Fi, SoC autonome, jusqu'à 9 GPIO, donne l'accès Internet aux microcontrôleurs.
Arducam Mini 2MP Plus : Caméra SPI 2 MP (capteur OV2640), interface simple, compatible Arduino/Raspberry Pi.
Arduino MKR WiFi 1010 : SAMD21 Cortex-M0, Wi-Fi/Bluetooth (NINA-W10), puce crypto ECC508, chargeur batterie, LED RGB.

Outils logiciels

Arduino Web Editor : IDE en ligne, IoT Cloud, Device Manager, partage de projets.
Edge Impulse Studio : Collecte données capteurs, entraînement modèles ML dans le cloud, déploiement sur Arduino en un clic. Exemples pour accéléromètre et microphone.
ThingSpeak : Analytics IoT dans le cloud, visualisation temps réel, exécution code MATLAB, API REST/MQTT, intégrations LoRaWAN/4G.

Projet 1 – Ascenseur sans contact par reconnaissance vocale

Les boutons d'ascenseur sont des vecteurs de contamination. Les solutions à ultrasons ou gestuelles sont trop sensibles ou requièrent une proximité risquée. La commande vocale (« haut » / « bas ») est plus précise et utilisable à distance.

Entraînement du modèle sur Edge Impulse

Collecte de données : 1 min 30 par classe (« haut », « bas »), échantillons de 2 s.
Création d'impulsion : Fenêtre 300 ms, réseau de neurones Keras pour audio/accéléromètre.
Traitement DSP : Coefficients cépstraux.
Entraînement : Données à fréquences variées pour robustesse. Architecture : Input → Reshape → 1D ConvPool (30 neurones, noyau 5) → 1D ConvPool (10 neurones, noyau 5) → Flatten.
Résultats : Précision moyenne 91,2 %, perte 0,29 sur 100 époques. Matrice de confusion claire. Test sur 24 s : 75 % de précision.

Déploiement en bibliothèque Arduino pour Nano 33 BLE Sense. Le modèle utilise ~24–28 Ko sur 256 Ko flash.

Logique de réponse

// Si commande "up" détectée
if (found_command[0] == 'up') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW);      // LED verte allumée (active LOW)
  servo_7.write(0);             // Appuie bouton "haut"
  delay(100);
  digitalWrite(LEDG, HIGH);     // LED éteinte
  servo_7.write(180);           // Retour position initiale
}

// Si commande "down" détectée
if (found_command[0] == 'down') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW);
  servo_7.write(0);             // Appuie bouton "bas"
  delay(100);
  digitalWrite(LEDG, HIGH);
  servo_7.write(180);
}

Pipeline : Capture audio → Spectrogrammes → Interpréteur TFLite → Inférence → Action servomoteur.

Schéma de câblage

Le micro intégré capture l'audio. Un délai de 100 ms entre deux échantillons, signalé par clignotement de la LED bleue intégrée.

Comparaison capteurs

Ultrasons : Trop sensibles aux mouvements parasites, imprécis.
Gestes : Plus précis mais distance d'activation trop courte → risque contact.
Voix : Précis, distance d'activation supérieure.

Projet 2 – Interphone intelligent par reconnaissance faciale (TinyML)

Le CDC confirme la transmission par surfaces contaminées (fomites). Le virus persiste 3 jours sur plastique/métal. Les interphones à boutons sont à risque.

Solution : Détection de personne par TinyML (TensorFlow Lite) sur Arduino Nano 33 BLE Sense avec Arducam Mini 2MP. Si personne détectée → buzzer + affichage « Person » sur matrice MAX7219.

Modèle de détection de personne

Modèle pré-entraîné TensorFlow (3 classes : « unused », « person », « notperson »). Images redimensionnées à 96×96 pour tenir dans 256 Ko RAM. Architecture : Depthwise Conv2D → Conv2D → Average Pool2D → Flatten.

Fonction clé (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);

Logique

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);   // Buzzer ON
  digitalWrite(LEDR, HIGH);  // Matrice affiche "Person"
  digitalWrite(5, LOW);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Person");
  delay(100);
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
}

Bibliothèques principales (main.ino)


#include 
#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"

Boucle principale


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

Fournisseur d'images (Arducam)


#include 
#include 
#include 
#include 
#include 

#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) return kTfLiteError;
  // ... configuration suite
}

Extension : activation interphone existant

Un servomoteur peut appuyer sur le bouton vidéo de l'interphone existant quand une personne est détectée.

Projet 3 – Détection de température autonome IoT (Arduino MKR WiFi 1010)

La fièvre est un symptôme clé du COVID-19. Le contrôle manuel crée du contact et ne stocke pas les données.

Solution : Capteur thermique AMG8833 + ultrasons HC-SR04 + Arduino MKR WiFi 1010 → ThingSpeak. Si température > 38,1 °C → porte fermée (servo) + alarme buzzer.

Logique


Ultrason (20 cm) → Détection personne
  → Arduino MKR WiFi 1010
    → Ouvre porte (servo 0°)
    → Active AMG8833
    → Envoie température à ThingSpeak
    → Si T > 38,1°C : Ferme porte (servo 180°) + Buzzer ON

Schéma et code clé


#include 
#include 
#include 
#include 
#include 

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

WiFiMulti WiFiMulti;
const char* ssid = "Votre_SSID";
const char* password = "Votre_MDP";
const char* host = "api.thingspeak.com";
String api_key = "VOTRE_CLE_API";

Adafruit_AMG88xx amg;

void setup() {
  Serial.begin(9600);
  servo1.attach(7);
  pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT);
  Connect_to_Wifi();
  if (!amg.begin()) { while(1); }
  delay(100);
}

void loop() {
  ultra();
  servo1.write(0); // Porte ouverte
  if (distance <= 20) {
    float temp = amg.readThermistor();
    Send_Data(temp);
    if (temp > 38.1) {
      servo1.write(180); // Ferme porte
      digitalWrite(6, HIGH); // Buzzer
    }
  }
}

void Send_Data(float temp) {
  WiFiClient client;
  if (!client.connect(host, 80)) return;
  String data = api_key + "&field1=" + String(temp) + "\r\n";
  client.print("POST /update HTTP/1.1\n");
  client.print("Host: api.thingspeak.com\n");
  client.print("X-THINGSPEAKAPIKEY: " + api_key + "\n");
  client.print("Content-Type: application/x-www-form-urlencoded\n");
  client.print("Content-Length: " + String(data.length()) + "\n\n");
  client.print(data);
  delay(200);
  client.stop();
}

Tableau de bord ThingSpeak

Graphique température vs temps, intégrable en iframe. Permet aux visiteurs de vérifier la sécurité avant de venir.

Projet 4 – Gestion de file d'attente TinyML & IoT (Arduino Nano 33 BLE Sense)

Limitation manuelle de l'affluence = main-d'œuvre + pas de données temps réel pour les visiteurs. Solution : Comptage entrées/sorties par vision artificielle (Arducam + Nano 33 BLE Sense), seuil 50 personnes, attente 15 min, affichage temps d'attente sur MAX7219, données sur ThingSpeak via ESP8266.

Algorithme temps d'attente


X = personnes entrées, Y = personnes sorties
Inside = X - Y
Z = seuil (ex: 50)
count = Z - Inside
if (count < 0) wait_time = count * (-avg_time_per_person)
else wait_time = 0

Logique détection (similaire Projet 2)

Même modèle personne (125 Ko). Si personne détectée : compteur++, servo ouvre porte, envoi ThingSpeak. Si compteur multiple de 50 : porte fermée 15 min, affichage « Waiting 15min » sur matrice.

Projet 5 – Détection de masque (TinyML + IoT)

Le masque protège contre de nombreuses infections respiratoires. Modèle personnalisé entraîné sur Edge Impulse (dataset 813 images entraînement, 487 test, classes « mask » / « no_mask »). Transfert d'apprentissage MobileNetV2 0.35, 30 époques, précision 92,6 % (test 98,15 %). Déploiement sur Nano 33 BLE Sense.

Logique réponse


if (mask_score > no_mask_score) {
  digitalWrite(LEDG, LOW); digitalWrite(LEDR, HIGH);
  servo_8.write(0); count++; // Ouvre porte
} else {
  digitalWrite(LEDG, HIGH); digitalWrite(LEDR, LOW);
  servo_8.write(180); count2++; // Ferme porte
}
// Comptages mask / no_mask envoyés à ThingSpeak (2 champs)

Projet 6 – Surveillance d'allées et auto-désinfection UV

Le virus survit jours sur plastique/acier. Désinfection UV manuelle = lente, pas de données densité. Solution : Détection personne par allée (Arducam + Nano 33 BLE Sense), seuils adaptés par type d'allée, alertes LED (vert/bleu/rouge), désinfection UV auto au-delà du seuil, reset compteur, données ThingSpeak (4 champs : alimentation, sport, vêtements, électronique).

Seuils exemples

Alimentation (risque élevé) : Vert 1–25, Bleu 26–50, Rouge 51–75, UV 76–90, Reset >91
Vêtements : Vert 1–50, Bleu 51–75, Rouge 76–100, UV 101–110, Reset >111
Électronique (risque moindre) : Vert 1–75, Bleu 76–180, Rouge 181–225, UV 225–240, Reset >111

Code réponse (extrait)


if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW); digitalWrite(LEDR, HIGH); count++;
} else {
  digitalWrite(LEDG, HIGH); digitalWrite(LEDR, LOW);
}
if (count >= 1 && count <= 50) digitalWrite(LEDGREEN, LOW);
if (count >= 51 && count <= 75) digitalWrite(LEDBLUE, LOW);
if (count >= 76 && count <= 100) digitalWrite(LEDRED, LOW);
if (count >= 101 && count <= 110) digitalWrite(UV, LOW);
if (count > 111) count = 0;

Envoi ThingSpeak (ESP8266)


void Send_Data() {
  WiFiClient client;
  if (!client.connect(host, 80)) return;
  String data = 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.length()) + "\n\n");
  client.print(data); delay(10); client.stop();
}