SMART DEVICES – Manips arduino

Partie I : Installation des Outils et librairies

I-1 Ajout de plateformes (SOCs, Cartes) non officielles à Arduino
I-2 : Installation des librairies
I-3 : Installation des Utilitaires (tools)
I-4 : Installation des Projets (Sketchs) Arduino
I-5 : Installation des Applications Android

Partie II : Applications à base des SOCs ESP8266 & ESP32

ESP8266 (Carte NodeMCU)

I- Configuration de l’IDE Arduino pour les cartes NodeMcu et ESP8266-01
II- Exemple1 : ESP8266_Button_Led_Serial
Exemple2 : ESP8266_Json_SPIffs_Wr
Exemple3 : ESP8266_AsyncAccP_Web_Server
Exemple 4 : ESP8266_CLOUDMQTT_Subscribe

ESP32 (Carte Wemos D1)

I- Configuration de l’IDE Arduino pour les cartes Wemos et DevKit

II- Pinout de la carte Wemos

III- Exemple1 : ESP32_Wemos_Button_LedRGB_Serial

IV- Exemple2 : ESP32_Wemos_AnlogInSerial

V- Exemple3 : ESP32_Wemos_MMA7760_I2C_ReadAccel

Exemple4 : ESP32_Wemos_MMA7760_I2C_Plot

Exemple5 : ESP32_Json_SPIffs_Wr

Exemple6 : ESP32_AsyncAccP_Web_Server

Exemple 7 : …
Partie III : Applications à base du SOC nRF52840 (Nina B306 - NANO 33 BLE Sense)
I- La carte NANO 33 BLE Sense
II- Configuration de l’IDE Arduino pour les cartes NANO 33
III- Exemple 1 : Lecture de Température à partir d’un capteur I2C (HTS221) :
Nano33Ble_HTS_I2C_ReadTemperature
Exemple 2 : Lecture de la Température et de l’humidité à partir du HTS221 par

utilisation de la librairie HTS221 Nano33Ble_HTS_Read

Exemple 3 : Acquisition des données du IMU LSM9DS1 Nano33Ble_IMU_Capture

Exemple 4 : Communication BlueTooth (BLE) avec la carte NANO 33

Exemple 5 : Tiny ML avec Arduino « Reconnaissance de gestes avec Tensorflow Lite »

 Partie I : Installation des Outils et Librairies (PC/Smartphone)

ARDUINO est un environnement de développement C++, donc orienté objet, pour des plateformes
embarquées avec des mémoires FLASH/SRAM de taille limitée. A l’origine, il supportait les plateformes
officielles fabriquées par Arduino même (https://www.arduino.cc/en/Main/Products?from=Main.Hardware), mais
il est possible d’ajouter des cartes d’autres fabricants (I-1).

1) Télécharger et installer Arduino IDE : https://www.arduino.cc/en/software

Remarque :
Il existe des versions pour Windows et d’autres pour Linux et MAC .
Les étapes suivantes ont été effectuées sous Windows. Mais, ça devrait être la même chose pour Linux.

I-1 Ajout de plateformes (SOCs, Cartes) non officielles à Arduino

Il est possible d’utiliser l’environnement avec des plateformes d’autres fabricants (ESP, ST, etc…). Pour
cela, il faut installer le Firmware ainsi que le «wrapping logic» jouant le rôle de couche de liaison entre le
Firmware et le code C++.

1) Ajouter les url des fichiers json qui contiennent les informations relatives aux firmware des
différentes plateformes (STM32, ESP8266 et ESP32)

 File >> Preferences

2) Appuyer sur le bouton au niveau de « Additional Boards Manger URLs… »

1
 3) ajouter les lignes suivantes:

http://arduino.esp8266.com/stable/package_esp8266com_index.json ,

https://dl.espressif.com/dl/package_esp32_index.json ,

https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json

4) Une fois les fichiers json téléchargés, il faut aller à tools / Board / Board Manager…

 On trouvera que la liste comporte, pour le moment, uniquement les cartes Arduino. Pour ajouter d’autres
plateformes (ESP8266, ESP32, STM32, Nano 33) qui ne font pas par défaut partie de Arduino :

5) Installer les Firmware des plateformes à base de ESP8266, ESP32 et STM32 (choisir les versions les
plus récentes)

2
 Si on demande d’installer des drivers pour la carte, accepter.

I-2 : Installation des librairies

Les librairies ainsi que les sketchs (projets Arduino) seront sauvegardés par défaut dans le répertoire
« C:\users\…..\Documents\Arduino ». Il est possible de changer cet emplacement en modifiant le paramètre
dans la partie Sketchbook location de la fenêtre préférences (File >> Preferences).

Redémarrer Arduino.

3
I-2-a : Installation automatique des Librairies

Les fichiers json, spécifiés dans l’étape précédente, contiennent également des indications (liens)
relatives aux librairies (middleware) des plateformes ajoutées à Arduino, telles que les protocoles TCP, UDP,
MQTT , les systèmes de gestion de fichier ou les parseurs json, etc….

Pour installer les librairies, aller à Tools >> Manage Libraries

Et installer les librairies suivantes :

ESP 8266
1- La librairie pour la gestion de l’interface wifi

2- La librairie PubSubClient pour la gestion de la communication en utilisant le protocole MQTT.

3- ArduinoJson: une librairie permettant de traiter les fichier json

4
NANO 33 BLE Sense

- La librairie pour l’acquisition des mesures issues du IMU.

- La librairie pour accède aux mesures de température et humidité (HTS221)

- La librairie pour implémenter des algorithmes IA sur la carte NANO

- Librairie pour la communication Bluetooth (BLE)

I-2-b : Installation Manuelle des Librairies

Pour les librairies qui ne sont pas disponibles à travers les liens, ou qui sont développées par
l’utilisateur même, il est possible de les ajouter manuellement en les copiant dans le répertoire Librairies ou
5
en les importer en utilisant le menu « sketch > Include Library > Add .ZIP Library » (si la librairie est compressé
sous format ;zip).

On installera les librairies permettant l’implémentation d’un serveur web sur des plateformes à base des
SOCs ESP8266, et la gestion de la navigation entre pages web d’une façon simple (semblable aux framework
pour applications PC)

Télécharger le fichier « SmartD_Libs_Tools.rar » à partir du lien

https://drive.google.com/file/d/1hBNVtogslcJRr2ZIMe2iWjW2EohwJclk/view?usp=sharing

 Décompresser le fichier, accéder au répertoire et Copier les dossiers « ESPAsyncWebServer » ,

« ESPAsyncTCP » et « AsyncTCP » vers le répertoire …./.. /Librairies/

I-3 : Installation des Utilitaires (tools)

Les utilitaires ou outils sont des fichiers de code implémentant des fonctionnalités qu’on peut ajouter

à Arduino et qui vont apparaitre comme commandes au niveau du menu « Tools » de l’environnement. Il

faut les placer dans le répertoire …./…../Tools/

 Les utilitaires ESP8266FS et ESP32FS (File Systems)

Les plateformes à base des SOCs ESP8266 et ESP32 (tel que NodeMCU) disposent d’une mémoire

Flash de taille 4M. Il est ainsi possible de placer des fichiers de configuration, des pages web, etc..

L’utilitaire ESP8266FS ou bien ESP32FS (File System) permet à l’utilisateur de sélectionner une partie de la

mémoire Flash (indépendante de la partie dédiée au code) pour l’utiliser comme étant un système fichiers.

Ou bien créer un répertoire Tools dans le répertoire spécifié dans « Sketch location » et copier
dedans les dossiers « ESP8266FS » et « ESP32FS ». Les dossiers se trouvent dans le fichier téléchargé
(SmartD_LibsTools.rar )

6
 Une fois le répertoire copié, il faut redémarrer Arduino pour la prise en compte du nouvel
utilitaire. Dans ce cas, on verra apparaitre la commande « Upload Sketch Data » au niveau du menu
Tools.

I-4 Installation des applications Android

Pour le test des applications tournant sur les « smart devices », et qui utilisent le Bluetooth ou bien le
protocole MQTT pour communiquer avec d’autres appareils (Smartphone dans notre cas), on a besoin des
applications Android suivantes :

1- MQTT Client de « Webneurons » : Il s’agit d’un client qui est capable de publier des données
relétives à un topic (publish) ou bien recevoir des données envoyées par un autre client à un topic
auquel le client est souscrit (subscribe)

2- Light Blue de “Punch Through Design”: pour jouer le role d’un Client GATT (BLE)

3- BLE Peripheral Tool: pour jouer le rôle d’un Périphérique GATT (BLE)

4- nRF Connect de « Nordic Semiconductor »

7
 Partie II : Applications à base du SOC ESP8266 (Carte
Node MCU) et ESP32 (Wemos D1)

A- ESP8266
I- Configuration de l’IDE Arduino pour les cartes NodeMcu et ESP8266-01

II- Exemple1 : ESP8266_Button_Led_Serial

Exemple2 : ESP8266_Json_SPIffs_Wr

Exemple3 : ESP8266_AsyncAccP_Web_Server

Exemple 4 : ESP8266_CLOUDMQTT_Subscribe

B- ESP32

I- Configuration de l’IDE Arduino pour les cartes Wemos et DevKit

II- Pinout de la carte Wemos

III- Exemple1 : ESP32_Wemos_Button_LedRGB_Serial

IV- Exemple2 : ESP32_Wemos_AnlogInSerial

V- Exemple3 : ESP32_Wemos_MMA7760_I2C_ReadAccel

Exemple4 : ESP32_Wemos_MMA7760_I2C_Plot

Exemple5 : ESP32_Json_SPIffs_Wr

Exemple6 : ESP32_AsyncAccP_Web_Server

Exemple 7 : …
 Partie II : Applications à base du

SOC ESP8266

I- Configuration de l’IDE Arduino pour les cartes NodeMcu et ESP8266-01

Au niveau de l’IDE Arduino, il faut commencer tout d’abord par choisir le type de la carte à
programmer.

Esp8266-01

Esp8266 node
mcu

Remarque: Pour la carte ESP8266-01, elle n’a pas une interface USB. Il faut la placer sur un adaptateur dédié
(Figure ci-dessous).
Il faut relier les pins GPIO0 et CH avant de relier l’adaptateur
au port USB du PC

 Une fois connectée au port USB, un port série virtuel (COM PORT) sera attribué à la carte. Il est
possible de le trouver dans gestionnaire de périphériques (parties Ports (COM et LPT). Pour les
cartes ESP, le driver est généralement CH340 (ou bien le CP210x). – Voir Figure ci-dessous
 Pour le paramètre Upload speed (vitesse de chargement du code sur la carte), choisi de
préférence 512000 bits/sec, même si un débit supérieur est possible.

1
2
II- Exemple1 : ESP8266_Button_Led_Serial

Description

Cet exemple est basique, c’est l’équivalent de « Hello world » pour la programmation sur PC.
Il montre l’utilisation des entrées et sorties numériques d’un smart device, ainsi que la
communication série.

Dans cet exemple, l’entrée sera reliée à un bouton poussoir et la sortie à une Led.
L’application teste continuellement (toutes les secondes) l’état du bouton poussoir, s’il est appuyé la
Led va être allumée, sinon éteinte. Parallèlement, un message sera envoyé sur le port série pour
indiquer l’état du bouton et de la Led.

Pour les pins utilisés au niveau de la carte node MCU pour le bouton poussoir et la Led (tous
les deux intégrés déjà dans la carte) sont les suivants (voir Figure)
Bouton Poussoir : D3  GPIO 0
LED : D4  GPIO 2

Pour la programmation des pins dans l’environnement Arduino, on a besoin de connaitre soit
le Numéro du GPIO (0, 1, 2, etc..) ou bien l’identifiant du connecteur Arduino (D0, D1, etc..). Ainsi
pour configurer le bouton poussoir (D3, GPIO0) en entrée, on utilise :
pinMode (D3, INPUT); ou bien pinMode (0, INPUT)
Pour la LED (D4, GPIO2) configurée en sortie :
pinMode (D4, OUTPUT); ou bien pinMode (2, OUTPUT)

3
 voici le code complet :

Test
Compiler et charger le code sur la carte Node MCU, et ouvrir le moniteur série.

A chaque appui sur le bouton poussoir la LED sera allumée, sinon éteinte et un message apparait sur
le moniteur série.

4
II- Exemple2 : ESP8266_Json_SPIffs_Wr

Description

Cet exemple montre comment lire (parser) des fichiers JSON et les éditer en utilisant la
librairie Arduinojson. Comme pour tous les projets Arduino qui manipulent des fichiers, en plus du
fichier code .ino, le projet doit contenir un dossier data qui à son tour contient les fichiers qui vont
être chargés dans la zone consacrée aux fichiers données (File System) de la plateforme cible (à base
de ESP8266)

Dans ce cas, on a un fichier vide (weather2.json) et un fichier contenant des données

(weather1.json) :

{
"city":"Tunis",
"weather":"Sunny",
"humidity": [80.5,27.75],
"temp": {
"max":49,
"min":28
}
}

On commence par afficher le contenu des 2 fichiers weather1.json et weather2.json, ensuite

on édite le contenu du deuxième fichier weather2.json, et on l’affiche de nouveau. Pour la
« sérialization » (passage d’une structure de données à un fichier json) et la « déserialization » on
utilise les fonctions de la librairie ArduinoJson

Rq : Peut être déployée aussi bien sur un ESP8266-01 que sur un ESP8266 Node MCU.

5
 Test
1- Il s’agit d’une application où le sketch (projet Arduino) contient des fichiers ( données) à charger sur la carte,
(dans le répertoire Data) alors il faut s’assurer que le microcontrôleur est configuré pour réserver une partie
de la mémoire SPI pour le système de fichiers SPIFFS .

Pour la carte ESP8266-01, utiliser une taille

parmi les tailles disponibles 64K -> 512K

Pour la carte ESP8266 Node MCU, utiliser l’une

des 3 tailles possibles pour le FS : 1M, 2M et 3M

2- Une fois, la configuration appliquée, charger le fichier contenant les données (JSON dans cet exemple)
en utilisant la commande suivante (voir ci-dessous).

3- Compiler et charger le programme.

6
4- Normalement, le programme est lancé automatiquement après le chargement. Il est par contre possible de
le relancer (Remise à zéro) en appuyant sur le bouton RST de la carte.
Pour voir les messages envoyés par la carte sur le port série avec l’instruction print il faut appuyer
sur le bouton Serial monitor ou bien utiliser le menu Tools>>Serial Monitor

Au démarrage de l’application, un message vous demande d’entrer un caractère. Taper un caractère

et appuyer sur « send ».
 Les contenus des 2 fichiers seront visualisés. On voit bien que le 2 ème fichier est vide.

 Envoyer de nouveau un caractère. Le 2 ème fichier sera rempli de données JSON et son contenu
affiché.

Remarque : A la fin du programme, le code effacera le contenu du 2ème fichier. Et le même comportement décrit est
exécuté d’une façon continue. (fonction loop)

7
II- Exemple3 : ESP8266_AsyncAccP_Web_Server
Description
Le projet, contient en plus du sketch, deux fichiers (html et css) dans le dossier data, et qui
seront chargés dans la zone SPIFFS de la mémoire du Node MCU.

La page web (index.html) représente une interface graphique avec deux boutons (ON et
OFF) qui permettront de commander la LED du Node MCU.

On voit bien le texte %STATE% au niveau du code html : il s’agit de placeholder, une
zone texte dont le contenu n’est pas prédéfini, mais défini en temps réel au niveau du traitement des
requêtes (spécification des routes).
Pour les actions : quand on appuye sur le bouton ON, on est aiguillé vers /on.
quand on appuye sur le bouton OFF, on est aiguillé vers /off.

Cet exemple utilise, en plus de la librairie SPIFFS (File System) pour le stockage des données, 2
autres librairies :

- La librairie ESP8266Wifi : pour la configuration du ESP8266 en Point d’accès et/ou Client wifi et la
gestion de la communication wifi (envoi, réception).

8
 Dans ce cas, Node MCU est configuré en
point d’accès uniquement. Accessible sans
mot de passe.
Changer le nom du point d’accès pour ne pas
avoir plusieurs points d’accès avec le même
nom.

- La librairie ESPAsyncWebServer : pour ajouter des fonctionnalités de Serveur Web au Node MCU,
ainsi que la gestion de l’aiguillage des requêtes web en spécifiant des routes. Une route permet de
spécifier, en plus de la page web à afficher, un ensemble de traitements à appliquer à la page web
même ou bien des traitements matériels (Leds, etc..)

9
 Pour chaque route, on spécifie la page web à afficher, la fonction à exécuter pour déterminer
la valeur du placeholder (ici la valeur de %STATE% qui peut prendre l’une des 2 valeurs ON ou
OFF), ainsi qu’une action matérielle à lancer (soit on allume ou on éteint la led).

Exécution & Test

Charger les fichiers du dossier Data sur la zone « File system » Node MCU. Compiler le sketch et le
charger.

Une fois l’application lancée, l’adresse IP du nodeMCU (configuré comme étant point d’accès), est
affichée sur le moniteur série.

Au niveau d’un PC ou un smartphone, se connecter au point d’accès (node MCU), saisir l’adresse IP
du serveur web, les paramètres de connexion http et appuyer sur connexion.

Au niveau de l’interface qui apparait dans le navigateur, appuyer sur l’un des boutons (ON / OFF). A
chaque appui, on voit l’état de la Led changer ainsi que la valeur de placeholder %STATE%

10
 Il est possible de configurer le nodeMCU comme étant un client wifi si un point d’accès est déjà
disponible. Dans ce cas, spécifier les paramètres du point d’accès (ssid et mot de passe).

Et décommenter l’appel à la fonction nodemcu_WifiClient()

Dans ce cas, on peut accéder au serveur web à partir d’un PC ou un smartphone connecté au même
point d’accès. L’adresse Ip du serveur (device) est affichée dans le moniteur série.

Rq : On peut garder la fonction nodemcu_AP, puisque le device est capable de fonctionner comme étant point d’accès et
client wifi en même temps.

11
 II- Exemple 4 : ESP8266_CLOUDMQTT_Subscribe

Description & Code

Dans cet exemple, le protocole MQTT va être utilisé pour envoyer des données d’un
smartphone ou un PC (publish) à un smart device « Node MCU » (subscribe). Evidemment, les deux
actions (publish et subscribe) devraient utiliser le même topic (iotdevice/led, dans ce cas) puisque les
données reçues par le node MCU vont être utilisés pour allumer/éteindre la led.

Evidemment, le node MCU pourrait également envoyer des données (publish) qui seront
reçues par un autre client mqtt (subscribe).

Aussi bien le Node MCU que le smartphone devrait avoir un accès Internet et sur chacune
des deux plateformes, une application MQTT Client doit s’exécuter. La synchronisation entre les 2
parties communicantes (node MCU et smartphone ou PC) sera assurée par un serveur MQTT
(cloudmqtt.com dans ce cas, un compte devrait être crée). Ainsi la solution complète :

MQTT Client MQTT Server

Publish
MQTT Client
iotdevice/led
Cloud MQTT
User: Subscribe
Subscribe Pwd: iotdevice/led
Port:
Publish

La première partie du code permet de spécifier les

paramètres du point d’accès à internet ainsi que
ceux du serveur MQTT. On déclare également un
client MQTT qui peut faire des opérations de
Publish et subscribe.

12
 Le code permettant de se connecter au serveur
MQTT, de se souscrire au topic « iotdevice/led » et
de déclarer une callback function qui sera exécuté
chaque fois que des données sont récupérées.

La fonction callback est déjà prédéfinie

(juste les paramètres sans code) et reçoit le
message récupéré au niveau du paramètre payload.
Le code à ajouter permet de récupérer le
premier caractère du payload et de le comparer à 0.
Si c’est un 0, la Led (ou bien relai en mode OFF)
va être éteinte sinon allumée.

Exécution & Test

Au niveau du Smartphone

Installer l’application MQTT Client (de webneurons). Appuyer sur + pour ajouter un Broker.

13
 Saisir les paramètres indiqués sur la figure et sauvegarder.

pour le Nickname, il est possible d’utiliser n’importe

quel nom, nodemcuLed par exemple

Host : m24.cloudmqtt.com
Port : 19507
Username : bspgpsfa
Password :

Revenir à l’interface d’accueil et appuyer sur le broker crée, ensuite sur publish.

Une fois, la fenêtre publish messages affichée, saisir le topic (iotdevice/led) et le message à envoyer
(0 ou 1 ) et appuyer sur publish. Le message sera envoyé vers le serveur MQTT et sera récupéré par tous les
clients souscrits ai Topic.

14
Au niveau Arduino/ESP8266
Compiler et charger le programme sur la carte node MCU et ouvrir le Serial Monitor. Ensuite au
niveau du smartphone envoyer (publish) des données vers le topic « iotdevice/led ». Essayer avec 0 ou bien
autre chose et suivre l’état de la LED ainsi que les messages au niveau du serial monitor.

15
 Partie II - suite: Applications à base du

SOC ESP32

I- Configuration de l’IDE Arduino pour les cartes à base du SoC ESP32

Les deux cartes à base du SoC ESP32 à utiliser sont :

La carte Wemos D1 R32 qui a l’avantage de La carte ESP32 DevKit v1. Elle dispose de connecteurs
(Non Arduino), d’un bouton poussoir (Boot + user)
dispsoser de connecteurs Arduino permettant ainsi que d’une LED (Pin2)
d’étendre ses fonctionnailtés en ajoutant des shields
contenant des capteurs, des afficheurs, etc…

Au niveau de l’IDE Arduino, il faut choisir la référence

Au niveau de l’IDE Arduino, il faut choisir la
ESP32 dev Module.
référence WEMOS D1 MINI ESP32

 Une fois connectée au port USB, un port série virtuel (COM PORT) sera attribué à la carte. Il est
possible de le trouver dans gestionnaire de périphériques (parties Ports (COM et LPT). Pour les
cartes ESP, le driver est généralement CH340 (ou bien le CP210x). – Voir Figure ci-dessous
 Pour le paramètre Upload speed (vitesse de chargement du code sur la carte), choisi de
préférence 921600 bits/sec.

1
I-A Pinout de la carte Wemos

Pour programmer un SoC, il est primordial de connaitre son Pinout, c’est-à-dire une liste qui
donne les pins, le GPIO auquel est relié chaque pin ainsi que son numéro, la ou les fonctionnalités que
peut ce pin assurer, ainsi que sa position exacte au niveau du connecteur Arduino.

La figure suivante donne le pinout complet de la carte WEMOS D1.

Il est à rappeler que généralement (pour l’ESP32 au moins), l’identifiant GPIO d’un pin est en même
temps son identifiant au niveau de l’IDE Arduino. C’est-à-dire le numéro qu’on peut utiliser pour
configurer ce pin ou lui imposer une valeur ou bien lire son état.

2
II- MBED shield avec la Carte Wemos

Pour une partie des manips à effectuer (Bouton poussoir, Leds RGB, acquisition Analogique
communication I2C), on utilisera une carte d’extension « Shield » : MBED Application Shield (Figure
ci-dessous).

II-A Correspondance MBED Shield/Wemos

Comme déjà cite, il faut connaitre le numéro Arduino des pins à programmer. Donc, pour pouvoir
utiliser les composants se trouvant sur la carte shield, il faut également savoir à quel partie du connecteur
chaque composant est relié.

La figure suivant donne le schéma du shield ainsi que le pinout de la carte Wemos.

On voit bien la correspondance entre les pins de la carte et les signaux utilisés au niveau di shield.

Signal/composant « Shield » Numéro Arduino = Numéro GPIO

Potentiomètre 2
Bouton 17
Led Rouge 16
Led Bleue 12
Led Verte 13
I2C_SDA 21
I2C_SCL 22

3
III- Exemple1 : ESP32_Wemos_Button_RGBLed_Serial

Description

Cet exemple est basique, c’est l’équivalent de « Hello world » pour la programmation sur PC.
Il montre l’utilisation des entrées et sorties numériques d’un smart device, ainsi que la
communication série.

Dans cet exemple, l’entrée sera reliée à un bouton poussoir et la sortie à une Led RGB
(l’équivalent de 3 LEDS : une rouge, une bleue et une verte).

L’application teste continuellement (toutes les secondes) l’état du bouton poussoir, s’il est
appuyé les Leds vont être allumées une à la suite de l’autre, ensuite toutes vont être allumées
ensemble (lumière blanche).Parallèlement, un message sera envoyé sur le port série pour indiquer
l’état du bouton et de la Led.

Pour les numéros des pins, on utilisera les suivants (voir II-A)

Signal/composant « Shield » Numéro Arduino = Numéro GPIO

Bouton 17
Led Rouge 16
Led Bleue 12
Led Verte 13

Voici les parties déclaration et setup du sketch Arduino (Toutes les leds vont être éteintes : HIGH
puisqu’elles sont actives au niveau logique bas) :

4
 La partie loop teste continuellement le bouton poussoir et fait appel à la fonction Setleds_oneByOne
s’il est appuyé.

Test
Compiler et charger le code sur la carte Wemos, et ouvrir le moniteur série.

A chaque appui sur le bouton poussoir les 3 LEDs vont être allumées à tour de rôle et enfin
ensemble. Un message sera également affiché au niveau du Serial Monitor.

5
IV- Exemple2 : ESP32_Wemos_AnalogInSerial

Description

Cet exemple montre comment faire l’acquisition d’un signal analogique (dans ce cas généré par un
potentiomètre 10Kohm) et calculer la résistance du potentiomètre.

Etant que l’ADC du ESP32 a une résolution de 12 bits, les valeurs générées après la conversion
seront comprises entre 0  0 Ohm et 4095 (2^12 -1)  Rmax = 10 Kohm.

La relation entre la résistance du potentiomètre et la valeur de la conversion :

Résistance = (Résultat de la conversion * 10000 ohm) /4095

Le code suivant (Déclaration et setup) permet de spécifier le numéro du pin à utiliser pour l’entrée
analogique (sortie potentiomètre – voir II-2) et d’initialiser la communication série.

6
 La partie loop, lance une conversion A/N toutes les 2 secondes, lit le résultat de la conversion et
l’affiche sur le Serial monitor.

Test
Compiler et charger le code sur la carte Wemos, et ouvrir le moniteur série.

Toutes les 2 secondes, la résistance du potentiomètre est calculée puis affichée niveau du Serial
Monitor.

7
V- Exemple3 : ESP32_Wemos_MMA7760_I2C_ReadAccel
Description

La carte Mbed Shield est équipée d’un certain nombre de capteurs reliés au SOC à travers le port
I2C. Parmi ces capteurs, on trouve le MMA7760 qui est un MEMS avec un Full scale de +/- 1.5 g et capable
de convertir les accélérations (sur les 3 axes X, Y et Z) sur 6 bits et de mettre le résultat dans des registres
spécifiques (en complément à 2).
Au cours de cette manip, on va commencer par configurer le MMA760 pour l’activer et lancer les
mesures des accélérations selon les 3 axes.
Évidemment, comme la majorité des circuits I2C, le MMA760 contient un certain nombre de
registres (t8 bits) de contrôle, d’état et de données (voir figure ci-dessous).

Registres de données (Accel)

Registres de contrôle

Ainsi, la programmation du MMA7760 va consister en une suite d’opérations d’écriture/lecture de

ces registres. On commencera par écrire dans les registres de contrôle pour activer le circuit et lancer les
conversions A/N. Ensuite, une lecture des registres des résultats pour la récupération des contenus des 3
registres de données (1 * 8 bit pour chaque axe), et enfin une conversion de ce contenu en une donnée de
type int (qui peut être positive ou négative).

Exécution & Test

Compiler le programme et le charger sur la carte. Ouvrir le Serial Monitor, les résultats de conversion
stockés dans les registres du MMA7760 vont être affichés, ensuite utilisés pour calculer les accélérations
selon les axes X, Y et Z.

8
Explication du Code
La première partie du code va être la définition de constantes contenant les adresses des registres
qu’on va utiliser.

Ensuite, on va définir l’adresse de l’esclave, les pins utilisés par le bus I2C et déclarer un objet de la
classe TwoWire permettant la communication I2C (l’adresse I2C est donné dans le document technique de la
carte Mbed Shield) :

La configuration de l’interface I2C (pins et Vitesse) et son initialisation vont être effectuées au niveau du
setup.

9
 On définira 2 fonctions writeI2creg et readI2cReg qui permettent respectivement l’écriture et la
lecture d’une donnée 8 bits dans (resp à partir d’un) un registre à travers le bus I2C :

La fonction d’écriture prend en entrée 2

paramètres : l’adresse du registre et la donnée à
écrire.
On commence par spécifier l’adresse de
l’esclave, envoie ensuite l’adresse du registre
suivie par la donnée.
On finit par indiquer la fin du transfert en passant
à la fonction endTransmission la valeur True.

La fonction de lecture prend en entrée un seul

paramètre qui est l’adresse du registre à lire.
On commence par spécifier l’adresse de
l’esclave I2C et envoie l’adresse du registre.
On indique ensuite que le transfert n’est pas
terminé en passant à la fonction endtransmission
la valeur false (puisqu’on attend de recevoir des
données).
Finalement, on envoie une requête à l’esclave
pour récupérer la valeur du registre (dont
l’adresse a été envoyée) qui sera la donnée de
retour de la fonction.

Le code de la fonction setup qui est exécuté au démarrage permet de :

Spécification des pins SCL,SDA et Initialisation du

périph I2C du microcontrôleur (SOC) de la carte Wemos
avec une vitesse de 400 kbps.

Ecrire 0x01 dans le registre de Mode (bit 0 = 1 ) pour

activer le circuit MMA7760.

10
Au niveau de la fonction loop qui va être exécutée continuellement :

On lit le registre contenant le résultat de la conversion

et on le convertit en entier signé int. (voir figure ci-
dessous)

On calcule l’accélération en tenant compte :

La résolution est de 6 bits.
Le Full Scale est de +/- 1.5g

11
V-A Exemple4 : ESP32_Wemos_MMA7760_I2C_Plot

Il s’agit de la même manip que dans V-, juste avec la différence que l’envoi vers le port série a été mis en forme
pour une meilleure visualisation sur le serial Plotter :

12
VI- Exemple5 : ESP32_Json_SPIffs_Wr

Même que ESP8266_Json_SPIFFS_Wr

VII- Exemple6 : ESP8266_AsyncAccP_Web_Server

Même que ESP8266_AsyncAccP_Web_Server

VIII- Exemples7,8 : BlueTooth Applications

Même que les applications dans la partieNano33Ble_BlueTooth

13
 Partie III : Applications à base du SOC
nRF52840 (Nina B306 - NANO 33 BLE Sense)

I- La carte NANO 33 BLE Sense

II- Configuration de l’IDE Arduino pour les cartes NANO 33

III- Exemple 1 : Lecture de Température à partir d’un capteur I2C (HTS221) :

Nano33Ble_HTS_I2C_ReadTemperature

Exemple 2 : Lecture de la Température et de l’humidité à partir du HTS221

par utilisation de la librairie HTS221 Nano33Ble_HTS_Read

Exemple 3: Acquisition des données du IMU LSM9DS1

Nano33Ble_IMU_Capture

Exemple 4 : Communication BlueTooth (BLE) avec la carte NANO 33

Exemple 5 : Tiny ML avec Arduino « Reconnaissance de gestes avec

Tensorflow Lite »
 Partie III: Applications à base du SOC nRF52840 (carte NANO 33)

I- La carte NANO 33 BLE Sense

Il s’agit d’une carte équipé d’un circuit NINA B306, contenant un microcontrôleur nRF 52480 à base
d’un processeur ARM CortexM4, une partie RF (2.4Ghz) ainsi que d’une pile protocolaire BLE.

Elle contient un ensemble de capteurs permettant l’acquisition d’un grand nombre de paramètres
(température, humidité, luminosité, accélération, vitesse rotative, etc….)

La grande partie de ces capteurs communiquent avec le module NINA à travers le port I2C1 et ne
nécessitent par conséquence que 2 pins. La figure ci-dessous donne les pins utilisés ainsi que la
correspondance avec les définitions dans arduino.h.

1
 II- Configuration de l’IDE Arduino pour les cartes NANO 33

Au niveau de l’IDE Arduino, il faut choisir « arduino Mbed OS nano Boards », ensuite la carte
NANO33 BLE. Une fois la carte connectée, le COM relatif à la carte NANO va être affiché.

Comme Programmer (permettant de charger le code sur la carte), choisir ARM CMSIS-DAP.

2
 III- Exemple 1 : Lecture de Température à partir d’un capteur I2C (HTS221) :
Nano33Ble_HTS_I2C_ReadTemperature

Description

La carte Nano 33 BLE Sense est équipée d’un certain nombre de capteurs reliés au SOC à travers le
port I2C 1. Parmi ces capteurs, on trouve le HTS221 qui est capable de faire l’acquisition de la température
et de l’humidité relative.
Au cours de cette manip, on va configurer le HTS221 pour lancer des mesures de la température et
les lire. Évidemment, comme la majorité des circuits I2C, le HTS221 contient un certain nombre de registres
(t8 bits) de contrôle, d’état et de données (voir figure ci-dessous).

Registres de contrôle

Registre d’état

Registres de données (température)

Ainsi, la programmation du HTS va consister en une suite d’opérations d’écriture/lecture de ces

registres. On commencera par écrire dans les registres de contrôle pour activer le circuit et lancer les
conversions A/N. Ensuite, une lecture du registre d’état pour tester si la conversion A/N est finie.
Après la fin de la conversion, on procédera à la lecture des 2 registres de données (8 bits) et les
combiner pour trouver le résultat de la conversion (16 bits) = TEMP_OUT_L | (TEMP_OUT_H <<8).
Finalement, on calcule la valeur de la température en utilisant les paramètres de la courbe (linéaire)
de conversion.

Exécution & Test

Compiler le programme et le charger sur la carte Nano33 BLE. Ouvrir le Serial Monitor, les résultats
de conversion stockés dans les registres du HTS221 vont être affichés, ensuite utilisés pour calculer la
température

3
 Explication du Code
La première partie du code va être la définition de constantes contenant les adresses des registres
qu’on va utiliser.

Ensuite, on va définir l’adresse de l’esclave, les pins utilisés par le bus I2C et déclarer un objet
Nano33_I2C de la classe TwoWire permettant la communication I2C :

4
 On définira 2 fonctions writeI2creg et readI2cReg qui permettent respectivement l’écriture et la
lecture d’une donnée 8 bits dans (resp à partir d’un) un registre à travers le bus I2C :

La fonction d’écriture prend en entrée 2

paramètres : l’adresse du registre et la donnée
à écrire.
On commence par spécifier l’adresse de
l’esclave, envoie ensuite l’adresse du registre
suivie par la donnée.
On finit par indiquer la fin du transfert en
passant à la fonction endTransmission la
valeur True.

La fonction de lecture prend en entrée un seul

paramètre qui est l’adresse du registre à lire.
On commence par spécifier l’adresse de
l’esclave I2C et envoie l’adresse du registre.
On indique ensuite que le transfert n’est pas
terminé en passant à la fonction
endtransmission la valeur false (puisqu’on
attend de recevoir des données).
Finalement, on envoie une requête à l’esclave
pour récupérer la valeur du registre (dont
l’adresse a été envoyée) qui sera la donnée de
retour de la fonction.

Le code de la fonction setup qui est exécuté une seule fois au démarrage permet de :

Initialisation du périph I2C du microcontrôleur (SOC) de la

carte Nano 33 Ble

Lecture du registre WHO_AM_I qui devrait contenir la

valeur 0xBC. En effet dans chaque circuit esclave I2C, on
trouve un registre WHO_AM_I contenant une valeur
spécifique qui permet de l’identifier. Ceci permet de
s’assurer qu’il s’agit du circuit correct avant d’écrire des
valeurs qui peuvent endommager son fonctionnement.

Ecrire 0x80 dans le registre de contrôle 1 (bit 7 = 1 ) pour

activer le circuit HTS221.

5
Au niveau de la fonction loop qui va être exécutée continuellement :

On lance la conversion en mettant le bit 0 du

registre de contrôle 2 à 1.

Lecture du registre d’état et test du bit 0

continuellement jusqu’à ce que ce bit passe à 1
pour indiquer que le résultat de la conversion de la
température est disponible.

Lecture des registres contenant les 8 bits poids Fort

(OUT_H) et les 8 bits poids faible (OUT_L) du
résultat de la conversion A/N (intégré au HTS221).

Calcul de la valeur totale (16 bits) de conversion.

Calcul et affichage de la température en fonction de

la pente (Temp_Slope) et de la valeur de référence
(Temp_Zero) (paramètres du convertisseur A/N).

6
 III- Exemple 2 : Lecture de la Température et de l’humidité à partir du HTS221 par utilisation
de la librairie HTS221 Nano33Ble_HTS_Read

Description

Dans cette manip on va lire à partir du capteur HTS221, en plus de la température, l’humidité
relative, et les afficher sur le serial Monitor. Mais, contrairement à la manip précédente, en utilisant les
méthodes et classes de la librairie HTS221. Ceci permet de configurer et lire les résultats du HTS221 d’une
façon transparente et sans se soucier des détails des fonctions I2C ou bien des adresses des registres.
Exécution et test
Compiler et charger le programme sur la carte Nano 33 BLE. Ouvrir le Serial Monitor.

Code

La méthode begin de l’objet HTS permet de vérifier

l’identité du circuit esclave (WHO_AM_I) et de
l’activer.

Les méthodes readTemperature resp. readHumidity

permettent de lancer les conversions de la température
resp. humidité, d’attendre la fin de la conversion, la
lecture des résultats de conversion et le calcul des
valeurs de la température resp ; humidité. (en se basant
sur les valeurs de pente et de référence récupérés à
partir du circuit HTS221 même).

7
 III- Exemple 3 : Acquisition des données du IMU LSM9DS1

Description

La carte Nano 33 BLE Sense est équipé d’un iNEMO inertial module LSM9DS1: qui
contient un accéléromètre 3 degrés de liberté pour mesurer les accélérations selon les 3 axes x,y et z,
un gyroscope 3D pour mesurer les rotations (vitesse angulaire) selon les 3 axes ( pitch, roll and yaw )
et un magnetomètre 3D.

Commencer par tester les 3 applications fournies avec la librairie LSM9DS1 qui permettent de tester
les fonctionnalités du module iNemo.

Pour chacune des 3 applications, faire tourne la carte nano 33 dans les différents sens et visualiser les
données à travers le Serial monitor, ainsi que le serial plotter qui permet d’afficher les valeurs sous forme de
courbes.

8
 III- Exemple 4 : Communication BlueTooth (BLE) avec la carte NANO 33

Il s’agit d’établir une communication Bluetooth (BLE) entre 2 cartes NANO 33 BLE.
 L’une jouant le rôle d’un périphérique (Peripheral) publiant un service LED avec 2
« characteristics » Led et Button accessibles en écriture et en lecture.
 L’autre étant une centrale (Central) : découvrant le(s) service(s) publié(s) par le(s) périphériques er
permettant la lecture et le contrôle des valeurs des « characterstics » du service.

Partie -1 : Périphérique BLE sur NANO 33 BLE

On commencera, comme première étape de faire tourner le programme relatif à la fonctionnalité

« Peripheral » sur une carte NANO 33 BLE, et utiliser une application Android (LightBlue) tournant
sur un smartphone, comme « Central ».

Ainsi, on pourra tester le projet (peripheral) indépendamment du projet « Central ».

9
 Cet exemple est fourni avec le package d’installation de la carte NANO 33 BLE.

Description & code

Il permet de faire fonctionner la carte comme étant un périphérique BLE (GATT server) avec la
création d’un service ledService contenant 2 « characteristics » : ledCharacteristic pour le contrôle d’une
LED et ButtonCharacteristic permettant de suivre l’état du bouton poussoir de la carte.

- Déclaration du service et des « chacarcterisics »

// create service
BLEService ledService("19B10010-E8F2-537E-4F6C-D104768A1214");

// ledCharacteristic (type Byte) pouvant être accédé en lecture et écriture

BLEByteCharacteristic ledCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214",
BLERead | BLEWrite);
// ledCharacteristic (type Byte) pouvant être accédé en lecture et écriture
BLEByteCharacteristic ButtonCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214",
BLERead | BLEWrite);

- Lancement du BLE / Publication des services/Characteristics

C’est au niveau de la partie setup, qui est exécuté une seule fois après une remise à 0 de la carte qu’il
faut mettre ce code :

10
 On attribue un Nom au service
« ButtonLED » qui sera utilisé lors de
la publication et sera vu par les autres
périphs BLE.

- Réception des données BLE

Cette partie du code va être placée au niveau de la fonction loop, puisqu’elle va être exécutée d’une
façon continue. Le périph BLE va d’une façon continue scruter (poll) si des messages (type Byte) ont été
reçues, et de mettre à jour l’état de la LED en fonction de la valeur du message (0 OFF, sinon ON).

Exécution et Test

Pour pouvoir envoyer des ordres au Serveur (Carte NANO 33), on a besoin d’une autre entité qui
serait capable de jouer le rôle d’un Client BLE (GATT). On va utiliser à cette fin, l’application android Light
Blue à télécharger sur Google Store .

11
 Lancer l’application sur la carte NANO 33 BLE, ouvrir le Serial Monitor et attendre le message
indiquant le démarrage de la pile BLE.

Au niveau du périph Android (ou autre), activer la connexion BlueTooth, lancer l’application
LightBlue et lancer un Scan. Le service publié « ButtonLED » publié par le serveur (carte NANO 33) devrait
apparaitre dans la liste des services découverts. Se connecter au service.

Maintenant qu’on est connecté au service, on peut avoir une idée sur les « characteristics » qu’il
contient, ainsi que la possibilité de les accéder en écriture et lecture.

12
 Appuyer sur « ButtonLED » :
 Une fenêtre apparait avec des informations sur
le periph (Addresse MAC), sur le Service
(UUID) ainsi que sur les « characteristics ». On
voit bien qui si la première partie du UUID du
service est 19b10010, alors la première
characteristic « LED » (ordre de publication)
aura l’UUID 19b10011, la deuxième
19b10012.
On voit bien que les 2 sont accessibles en
lecture et écriture (Readable, writable)

Appuyer sur la première « characteristic » (19b10011) pour pouvoir envoyer et recevoir des
messages vers la carte NANO 33.

Dans la fenêtre dédiée à la communication avec le service ButtonLED (ledcharacteristic), choisir de

préférence le format HEX (Hexadecimal) et il est possible de lire les données (état de la LED) en appuyant
sur READ AGAIN et d’envoyer des messages (commandes) pour changer l’état de la LED, en écrivant des
valeurs (0 ou autre) et appuyant sur WRITE.

13
 En envoyant les données, la Led au niveau de la carte NANO 33 BLE changera d’état et un message
indiquant l’état sera affiché sur le Serial monitor.

Partie -2 : Centrale BLE sur NANO 33 BLE

Comme on l’a fait pour la partie « peripheral », on fera tourner le code relatif à la fonction de la
centrale sur une carte NANO 33 et la fonction « Peripheral » sera assurée par une application Android
exécutée sur un smartphone (BLE Peripheral Tool).

Cet exemple (Arduino BLE>>CENTRAL>>Ledcontrol) est fourni avec le package d’installation de

la carte NANO 33 BLE.

14
 Description & code

Il permet de faire fonctionner la carte comme étant un «BLE CENTRAL » (GATT Client) : Il
commence par faire un scan à la recherche d’un service bien défini (service led dans ce cas : la recherche
peut être effectuée par UUID ou bien Nom). Une fois le service trouvé, l’application affiche l’adresse MAC
du « Peripheral », le nom du service ainsi que son UUID.
Ensuite, l’application explore le service Led à la recherche des « characteristics » Led et Button. Une
fois trouvés, elle scrute d’une façon continue l’état du bouton, et contrôle l’état de la Led.

La partie Initialisation (fonction setup)

lance le service BLE et démarre l’opération du scan
à la recherche d’un service ayant un UUID bien
déterminé (celui utilisé pour le service LED dans la
partie 1).

Dans la fonction loop (code exécuté d’une

façon continue), une fois le service trouvé, on
affiche sur le Serial monitor l’adresse MAC du
Peripheral, le nom du service et son UUID et on
fait appel à la fonction controlLED.

15
La fonction LedControl :
- Commence par lancer une requête de
découverte des attributs du service.
- Ensuite, récupère la « charcteristic » led
(par UUID).
- Si elle n’est pas disponible, la connexion
est interrompue.
- Sinon, le bouton (relié au pin 2 du
NANO) va être testé et un message de
contrôle va être envoyé à la Led du
Peripheral: ON si le bouton est appuyé
sinon OFF.

Exécution & Test

Commencer par installer l’application « BLE Peripheral Tool » sur le Smartphone et l’exécuter.

16
 Choisir HEX comme type de données.
Pour BLE Name (service), saisir LED.
Et appuyer sur Start pour lancer le « Peripheral » qui va publier
(advertise) le service LED.

Comme on le remarque, pour le service, on ne peut spécifier que le

nom mais pas un UUID. Donc, il faut modifier le code du sketch pour
faire une recherche selon le nom et nm pas l’UUID.

Au niveau de la carte NANO33 BLE, Ouvrir le sketch Arduino

BLE>>CENTRAL>>Ledcontrol et changer la ligne permettant le scan du service selon l’UUID par une
recherche selon le nom : BLE.scanForName (‘LED’).

Compiler le sketch , le charger sur la carte et ouvrir le serial Monitor ( l’application Android déjà lancée).

On voit, au niveau du Serial Monitor, l’adresse du Peripheral ainsi que le nom et UUID du service
affichés. La découverte des attributs est également effectuée, mais sans trouver évidemment la « characteristic »
Led puisqu’au niveau de l’application Android, on n’a pas la possibilité d’ajouter des « characteristics ». mais,
c’est déjà un test d’une bonne partie des fonctionnalités du « CENTRAL ».

Partie -3 : Communication Central/ Peripheral BLE avec 2 cartes NANO 33 BLE

17
 Il s’agit tout simplement d’exécuter le sketch de la partie 1 sur une carte NANO 33 BLE (Peripheral)
et le sketch de la partie 2 (Central) sur une deuxième carte NANO33 BLE.

Ouvrir les Serial monitor relatifs aux deux cartes et observer les messages affichés.

Pour la carte jouant le rôle du « CENTRAL », le bouton poussoir (#const int buttonPin = 2;) n’existe
pas, donc il faut ajouter un bouton poussoir externe relié au pin 2 (D2, voir Figure ci-dessous)

18
 IV- Exemple 5 : Tiny ML avec Arduino « Reconnaissance de gestes avec Tensorflow Lite »

Description

L’objectif de cette application est de reconnaitre le geste fait par une personne tenant en main la carte
Nano 33. On essaiera de déterminer un parmi 2 gestes : Punch (coup de poing vers l’avant) ou bien Flex
(Flexion du bras)

Punch Flex

1- Choix des données avec Nano33Ble_IMU_Capture_Accel.ino & IMU_Capture_Gyro.ino

La première étape d’une application IA est le choix des données qui vont être utilisés pour déterminer
le modèle et ses paramètres. Généralement, pour détecter des gestes ou des mouvements, le choix le plus
simple est l’image. Mais, pour des smart devices, avec des processeurs à performances limitées et des
mémoires de qq méga au plus (1 méga pour le Nano 33 BLE), des algorithmes IA traitant des images ne
seront pas adaptés.

Ce sont plutôt les données de l’accéléromètre et du gyroscope qui seront utilisées. Pour être certain
que ces données peuvent guider l’algorithme d’apprentissage vers un modèle avec des résultats précis, on
commence par visualiser ces mesures avec Serial plotter (Nano33Ble_IMU_Capture_Accel.ino,
Nano33Ble_IMU_Capture_Gyro.ino).

A- Accélérations pour PUNCH B- Accélération pour FLEX

19
 C – Vitesses angulaires pour PUNCH D- Vitesses angulaires pour FLEX

En observant les mesures, on remarque bien que chaque mouvement possède une signature
spécifique (évolution chronologique des mesures), et que si on dispose d’une courbe avec les 6 mesures on
pourrait normalement décider de quel type de mouvement il s’agit (punch ou Flex). Généralement, si on est
capable de le faire facilement par simple observation (intelligence humaine ordinaire), c’est qu’il est possible
de trouver des résultats avec un algorithme du domaine de l’Intelligence Artificielle.

Remarque : Les applications de capture lancent les mesures à partir d’une accélération de 2.5G. Donc, pour tester ces sketchs, il faut
faire le mouvement (coup de poing) rapidement vers l’avant et ensuite retirer la main lentement vers l’arrière, sinon des mesures de la
main bouger vers l’arrière vont être enregistrées et fausser la prédiction ensuite.
De même, pour le mouvement Flex, il faut que l’extension soit très lente.

2- Collecte des données avec Nano33Ble_IMU_Capture.ino

Maintenant, que le choix des données à utiliser pour l’apprentissage est fait, il faut les collecter et les
mettre sous forme de données étiquetées (labeled data). Le sketch IMU_Capture.ino permet d’assurer cet
étiquetage en envoyant les étiquettes, ensuite les données vers le « Serial Monitor » :

Charger le sketch sur la carte Nano 33 BLE, ouvrir le « Serial Monitor » et faites le geste de
« Punch » 10 fois au moins. Copier les données affichées sur le « serial Monitor » et les sauvegarder dans un
fichier punch.csv. Relancer l’application et refaire la même chose pour le mouvement Flex (fichier flex.csv)

20
 3- Construction du Modèle IA à base de Réseaux de neurones

En fait, l’objectif final de cette étape est de générer un fichier header model.h, contenant les
paramètres du modèle, qui va être intégré au sketch IMU_Classifier. Ce fichier model.h est déjà disponible
avec le sketch et il est possible de passer à l’étape suivante.

Cette partie (construction du modèle ML) n’étant pas l’un des objectifs du cours, on donnera juste
une idée générale sur le principe et les étapes de la construction du modèle.

Le modèle qui sera utilisé est un réseau de neurones, qui va être entrainé avec les données récupérées
dans punch.csv et flex.csv. Le choix de la taille du modèle « nombre de couches, de neurones par couche »,
est effectué au début en fonction de la complexité du système à modéliser. Si les résultats obtenus ne sont pas
suffisamment précis, on peut modifier (augmenter) ces paramètres, jusqu’à trouver des résultats satisfaisants.

En fait, étant donné que chaque neurone représente principalement une opération de somme pondérée
des entrées (Figure ci-dessous), l’entrainement du modèle a pour objectif de trouver les paramètres du
modèle qui ne sont, dans ce cas, que les valeurs des pondérations des entrées des Neurones (wj1, wj2, etc…)

L’étape d’entrainement ne sera pas évidement exécutée sur le smart device, puisqu’elle nécessite une
grande puissance de calcul. En fait, il s’agit d’un code, basé sur le framework tensorFlow, qui va récupérer
les données des accélérations, ainsi que le résultat (type de geste) et va pour chaque donnée, mettre à jour les
pondérations. Pour cet exemple, le code est déjà disponible sous forme d’un script Python sur le web et est
accessible via la plateforme « Google Colab » :
21
 https://colab.research.google.com/github/arduino/ArduinoTensorFlowLiteTutorials/blob/master/Gest
ureToEmoji/arduino_tinyml_workshop.ipynb

Il est possible ainsi, de voir les différentes étapes pour le calcul des paramètres du modèle. Pour
chaque étape, le code équivalent est affiché et n peut l’exécuter (sur le cloud de google) en appuyant sur la
flèche à gauche du code. La seule chose à faire, est de charger les fichiers punch.csv et flex.csv sur google
Colaboratory.

Généralement, les modèles générés par tensorflow contiennent des pondérations de type float, qui
occupent un espace mémoire de 32 bits et dont la multiplication est très pénalisante au niveau de l’utilisation
des ressources du processeur (nombre d cycles par opération).

C’est pourquoi, il est nécessaire de tronquer ces pondérations (les codes sur 8 bits au lieu des 32 bits),
tout en gardant une précision acceptable du modèle. Cette étape est gérée également par le script et permet de
générer un fichier de type tflite (Tensorflwo lite).

22
 La dernière étape, consiste à générer un fichier Header qui contient les paramètres du modèle (sur 8
bits) et qui peut être intégrée dans un sketch Arduino. Ce fichier « model.h » devrait être téléchargé et
sauvegardé dans le même dossier que le sketch « Nano33Ble_IMU_Classifier.ino »

4- Exécution et test

Finalement, avec le modèle disponible, il est possible de compiler le code et de le charger sur la
plateforme NANO 33 BLE. Ouvrir le Serial monitor, et une fois le message indiquant l’initialisation de
l’accéléromètre et du gyroscope (sample rate = 119.00 hz), prendre la carte NANO 33 dans la main et faire
les gestes Punch ou Flex et observer les résultats sur le Serial monitor

23
24