Led multi-modes - Contrôle tactile - Historique des versions

François-Régis : /* Code */

2024-05-14T07:58:21Z

‎Code

François-Régis : /* Choix du Wemos */

2024-05-14T07:49:33Z

‎Choix du Wemos

François-Régis : /* Spécificités du code C++ */

2024-05-14T07:24:24Z

‎Spécificités du code C++

François-Régis le 13 mai 2024 à 14:32

2024-05-13T14:32:12Z

François-Régis : /* Choix du Wemos */

2024-05-13T12:47:15Z

‎Choix du Wemos

François-Régis le 13 mai 2024 à 12:46

2024-05-13T12:46:48Z

François-Régis : Page créée avec « ==Description== Contrôler une led RGB, un led ring ou ici un ruban led (led strip), grâce à un bouton tactile. A chaque contact détecté par le bouton tactile, le mode... »

2024-05-13T12:41:55Z

Page créée avec « ==Description== Contrôler une led RGB, un led ring ou ici un ruban led (led strip), grâce à un bouton tactile. A chaque contact détecté par le bouton tactile, le mode... »

Nouvelle page

==Description==
Contrôler une led RGB, un led ring ou ici un ruban led (led strip), grâce à un bouton tactile.
A chaque contact détecté par le bouton tactile, le mode de contrôle des led est changé.

==Liste du matériel==
===Électronique===
* 1 x Module Wifi D1 Mini Wemos ou 1 x Arduino UNO ou équivalent
* 1 x Ruban de LED 1 mètre/60 LED
* Câbles Dupont M-F et M-M
* 1 x Bouton tactile TTP223
* 1 x mini breadboard

===Coût===
Pour l'ensemble du matériel et en étant large, il faut compter moins de 30€.

==Réalisation du projet==
La réalisation de ce projet est relativement simple. Elle se résume en 3 étapes :
# Connecter les matériel comme indiqué ci-dessous dans la partie '''[[#Schéma|Schéma]]''' ;
# Télécharger le programme dans le D1 mini Wemos (cf. '''[[#Code|Code]]''') ;
# Et c'est fini.

===Schéma===
[[Fichier:Schéma_circuit_Led_Touch.jpeg|500px|center]]
===Code===
Certaines lignes sont surlignées <span style="background:#ffffcc;">en jaune</span>. Ces lignes identifient les paramètres qui peuvent être modifiés sans risque afin de s'adapter aux spécificités et choix faits pour votre projet.
<syntaxhighlight lang="C++" line highlight="7,9,11,31,33">
#include <Adafruit_NeoPixel.h>

// définition d'un type pour faciliter la déclaration des fonctions liées aux interruptions
typedef void (*LED_MODE_FUNC)();

// broche du wemos sur laquelle est connectée le ruban de led
#define PIN_RUBAN_LED D3
// broche du wemos sur laquelle est connecté le bouton tactile TP223
#define PIN_BOUTON_TACTILE D2
// nombre de led sur le ruban
#define NB_LED 60

// permet de suivre le mode dans lequel sont configurées les led (couleur unique, arc-en-ciel, etc.)
/************************************/
/* par défaut 6 modes : */
/* - 0 : éteint */
/* - 1 : couleur unique (rouge) */
/* - 2 : couleur unique (vert) */
/* - 3 : couleur unique (bleu) */
/* - 4 : arc-en-ciel */
/* - 5 : arc-en-ciel harmonisé */
/************************************/
volatile byte led_mode = 0;
// permet de switcher de mode d'affichage selon le mode actif
volatile LED_MODE_FUNC ledFonction = NULL;

// permet de forcer les fonctions contrôlant les led à sortir de leurs boucles,
// et à contrôler les temps de bascule entre deux changements de couleur dans les modes arc-en-ciel
volatile byte led_delai = 0;
// délai par défaut entre deux changements de couleur en mode arc-en-ciel
const byte LED_DELAI = 20;
// définit la durée d'attente entre 2 changements de mode en milliseconde
const unsigned long dureeAntiRebond = 1000;

// initialise le ruban led
// paramètre 1 = nombre de led dans le ruban
// paramètre 2 = numéro de la broche sur laquelle est connecté le ruban
// paramètre 3 = configuration des led du ruban
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel ruban = Adafruit_NeoPixel(NB_LED, PIN_RUBAN_LED, NEO_GRB + NEO_KHZ800);

/***************************************************************************************/
/* Pour réduire le risque d'endommager le ruban led : */
/* - ajouter un condensateur de 1000µF entre le vcc et la masse alimentant le ruban */
/* - ajouter un résistance de 300/500 ohms entre le wemos et le câble data du ruban */
/* - réduire au maximum la distance entre le wemos et le ruban led */
/* - si branchement à chaud, connecter en 1e la masse du ruban led */
/***************************************************************************************/

void setup() {
ruban.begin();
// force la luminosité du ruban à 0 (ruban éteint)
ruban.setBrightness(0);
ruban.show();
// initialise la fonction paramétrant les led du ruban à rubanOff
ledFonction = rubanOff;
// initialise la broche du bouton tactile en pull up afin d'éviter les faux signaux
pinMode(PIN_BOUTON_TACTILE, INPUT_PULLUP);
// lie le bouton tactile à une interruption qui déclenche la fonction configLedMode
attachInterrupt(digitalPinToInterrupt(PIN_BOUTON_TACTILE), configLedMode, FALLING);
}

void loop() {
// exécute la fonction liée au mode d'affichage sélectionné par l'utilisateur
ledFonction();
}

// fonction déclenchée par interruption via le bouton tactile
// ICACHE_RAM_ATTR : force le stockage de cette fonction dans la RAM,
// sinon elle est stockée dans la mémoire flash, et forcément ça plante
ICACHE_RAM_ATTR void configLedMode() {
// stocke la dernière fois que le mode a été effectivement modifié
// pour mémoire 1 changement de mode par seconde au maximum (cf. ligne 33 : dureeAntiRebond)
static unsigned long date_mode_precedent = 0;

// récupère l'instant actuel
unsigned long date = millis();
// si dernier changement de mode depuis plus d'une seconde alors on traite le signal
if ((date - date_mode_precedent) > dureeAntiRebond) {
// enregistre l'instant actuel
date_mode_precedent = date;
// incrémente le mode
led_mode++;

// modifie la fonction ledFonction selon le mode choisi
switch(led_mode)
{
default: // mode hors porté, alors repasse le mode à 0
led_mode = 0;
case 0: // ruban led éteint
ledFonction = rubanOff;
break;

case 1: // couleur unie rouge
ledFonction = rubanCouleurRouge;
ruban.setBrightness(50);
break;

case 2: // couleur unie verte
ledFonction = rubanCouleurVerte;
break;

case 3: // couleur unie bleue
ledFonction = rubanCouleurBleue;
break;

case 4: // arc-en-ciel en boucle
ledFonction = arcEnCiel;
break;

case 5: // arc-en-ciel en boucle avec harmonisation des couleurs
led_delai = 0; // force la sortie des boucles "for" du mode précédent
ledFonction = arcEnCielCycle;
break;
}
}
}

// éteint les led
void rubanOff() {
// permet de forcer la sortie des boucles arc-en-ciel
led_delai = 0;

// éteint les led en passant la luminosité à 0 et le couleur des led à 0
ruban.setBrightness(0);
rubanCouleurUnie(0);
ruban.show();

// passe en attente du prochain changement de mode
ledFonction = rubanAttente;
}

// ne fait rien
void rubanAttente() {
delay(1);
}

// Applique la même couleur à toutes les led du ruban
// Puis modifie la fonction ledFonction pour passer en attente
void rubanCouleurUnie(uint32_t couleur) {
for(uint16_t num_led = 0; num_led < ruban.numPixels(); num_led++) {
ruban.setPixelColor(num_led, couleur);
}
ruban.show();

// passe en attente du prochain changement de mode
ledFonction = rubanAttente;
}

void rubanCouleurRouge() {
rubanCouleurUnie(ruban.Color(255, 0, 0));
}

void rubanCouleurVerte() {
rubanCouleurUnie(ruban.Color(0, 255, 0));
}

void rubanCouleurBleue() {
rubanCouleurUnie(ruban.Color(0, 0, 255));
}

// fait varier la couleur des led en arc-en-ciel
void arcEnCiel() {
arcEnCiel(false);
}

// fait varier la couleur des led en arc-en-ciel tout en faisant en sorte que les couleurs soient équilibrées/adoucies entre-elles
void arcEnCielCycle() {
arcEnCiel(true);
}

// faire varier les couleurs des led
void arcEnCiel(bool harmonise) {
uint16_t num_led, id_couleur;

// paramètre le taux de rafraichissement des changements de couleurs
led_delai = LED_DELAI;

// si vrai, permet d'harmoniser les couleurs des led entre-elles
harmonise = (harmonise) ? 256 / ruban.numPixels() : 1;

// varaiation de la couleur des led
while(led_delai) {
for(id_couleur = 0; id_couleur < 256 && led_delai; id_couleur++) {
// applique à chaque led une nuance de couleur différente selon la couleur souhaitée
for(num_led = 0; num_led < ruban.numPixels() && led_delai; num_led++) {
ruban.setPixelColor(num_led, cycleRoue(((num_led * harmonise) + id_couleur) & 255));
}
ruban.show();
delay(led_delai);
}
}
}

// permet de boucler sur les transitions des couleurs : rouge/vert/bleu/rouge/vert/...
uint32_t cycleRoue(byte position_cycle) {
position_cycle = 255 - position_cycle;

// selon la valeur demandée, applique une nuance de couleur
if(position_cycle < 85) {
return ruban.Color(255 - position_cycle * 3, 0, position_cycle * 3);
}
if(position_cycle < 170) {
position_cycle -= 85;
return ruban.Color(0, position_cycle * 3, 255 - position_cycle * 3);
}
position_cycle -= 170;
return ruban.Color(position_cycle * 3, 255 - position_cycle * 3, 0);
}
</syntaxhighlight>
===Explications===
====Chargement du programme====
Voici les étapes à suivre afin de pourvoir charger le '''[[#Code|programme]]''' sur le D1 mini Wemos :
# '''Lancez le programme ''Arduino IDE'''''
# '''Ajoutez la carte Wemos aux cartes pouvant être gérées par ''l'IDE Arduino'''''
## Ajoutez une carte supplémentaire à partir de menu Fichier > Préférences ;
## Dans l'onglet "Paramètres" cliquez sur le bouton situé en face de "URL de gestionnaire de cartes supplémentaires" : [[File:Config ide arduino esp8266.jpg|500px|center]]
## Ajoutez le lien suivant dans la fenêtre qui s'est ouverte et validez : <nowiki>https://arduino.esp8266.com/stable/package_esp8266com_index.json</nowiki>
## Ajoutez les librairies permettant de gérer les cartes à base d<nowiki>'</nowiki>''ESP8266'' (menu Outils > Carte > Gestionnaire de carte) ;
## Dans l'onglet qui s'ouvre, tapez "ESP8266" dans la barre de recherche ;
## Sélectionnez la carte "'''ESP8266''' par ESP8266 Community" et installez-la ;
# '''Ajoutez la bibliothèque Neopixel permettant de contrôler le ruban LED'''
## Allez dans le menu Outils > Gérer les bibliothèques ;
## Dans la barre de recherche, saisissez : ''neopixel'' ;
## Sélectionnez la bibliothèque ''Adafruit Neopixel par Adafruit'' ;
# '''Copiez et téléversez le programme'''
## Copiez le '''[[#Code|code]]''' dans l'interface ''Arduino IDE'' ;
## Dans le menu "Outils > Carte", sélectionnez "esp8266 > LOLIN (WEMOS) D1 R2 & Mini", ainsi que le port série (menu Outils > Port) ;
## Compilez et téléversez vers le D1 Mini Wemos.
====Fonctionnement général====
Par défaut, 6 modes de fonctionnement sont programmés pour contrôler l'éclairage des led :
# Eteint
# Couleur unie rouge
# Couleur unie verte
# Couleur unie bleue
# Arc-en-ciel
# Arc-en-ciel v2

Pour basculer d'un mode à l'autre, il suffit d'appuyer sur le bouton tactile. Si l'on appuie que le dernier mode est en cours d'exécution, le programme boucle sur le 1e mode (ici ''Eteint'').
====Choix du Wemos====
Au prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie ''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
====Spécificités du code C++====
'''Interruption'''

Dans ce programme, on utilise le système d'interruptions pour basculer d'un mode d'éclairage à un autre.

Dans notre cas, on utilise le système des interruptions afin que lorsque l'on appuie sur le bouton tactile le basculement du mode d'éclairage au suivant soit instantané. Effectivement, si l'on n'utilisait pas les interruptions, cela signifierait que les appuis sur le bouton tactile ne seraient pas toujours pris en compte. La lecture de l'état du bouton tactile interviendrait uniquement au moment où l'instruction correspondante est exécutée. Dans cette hypothèse, si l'utilisateur appuie au moment où le programme rentre dans une boucle un peu longue, alors l'appui ne sera pas détecté. Ainsi, afin de pallier cet écueil, les changements d'état du bouton tactile sont associés au déclenchement d'une interruption. Dans ce cas, dès qu'un changement d'état est opéré au niveau du bouton tactile, cela déclenche une interruption qui met ''en pause'' le fonctionnement normal du programme pour aller exécuter prioritairement la partie du code associée à ladite interruption avant de reprendre l'exécution normale du programme.

'''Pointeur de fonctions'''

Afin de faciliter et simplifier l'écriture de ce code, il a été choisi d'utiliser un pointeur de fonction. Sans entrer dans les détails, en C++ un pointeur de fonction se comporte comme une variable à laquelle il est possible d'assigner des valeurs. Ici, les valeurs assignées seront des fonctions. Ces fonctions correspondent individuellement à un mode d'éclairage. Ainsi, dans la boucle principale du programme une seule instruction est exécutée qui correspond à l'appel de la fonction ''ledFonction()''. Cette fonction un peu particulière est en fait le pointeur de fonction qui pointera ''in fine'' vers le code à exécuter associé au mode de fonctionnement sélectionné.
==Améliorations/Evolutions==
'''Améliorations'''

En termes d'amélioration, quelques recommandations doivent être appliquées (non mises en œuvre dans ce projet). Celles-ci concernent la réalisation du câblage et plus particulièrement la protection du ruban led contre les risques d'endommagement :
* ajouter un condensateur de 1000µF entre le vcc et la masse alimentant le ruban ;
* ajouter un résistance de 300/500 ohms entre le wemos et le câble data du ruban ;
* réduire au maximum la distance entre le wemos et le ruban led ;
* si branchement à chaud, connecter en 1e la masse du ruban led.

'''Evolutions'''

Afin de travailler sur la miniaturisation de l'électronique, il serait intéressant d'étudier son portage sur un microcontrôleur type ATTiny85

A vous de jouer ...
[[Catégorie:Arduino]]
[[Catégorie:Led]]
[[Catégorie:Fiche à Valider]]

@@ Ligne 267 : / Ligne 267 : @@
 Pour basculer d'un mode à l'autre, il suffit d'appuyer sur le bouton tactile. Si l'on appuie lorsque le dernier mode est en cours d'exécution, alors le programme boucle sur le 1e mode (ici ''Eteint'').
 ====Choix du Wemos====
-De prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de ce projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie '''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
+De prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de ce projet était d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. De plus, dans ce projet le breadbord n'a pas été utilisé, de même pour les broches, et les soudures entre les différents éléments électroniques ont été minimalisées au maximum. Toujours dans cet esprit de minimalisation, une piste alternative, autre qu'Arduino, est proposée dans la partie '''[[#Améliorations/Evolutions|Améliorations/Evolutions]]'''.
 ====Spécificités du code C++====

@@ Ligne 269 : / Ligne 269 : @@
 Pour basculer d'un mode à l'autre, il suffit d'appuyer sur le bouton tactile. Si l'on appuie lorsque le dernier mode est en cours d'exécution, alors le programme boucle sur le 1e mode (ici ''Eteint'').
 ====Choix du Wemos====
-De prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de ce projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie ''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
+De prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de ce projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie '''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
 ====Spécificités du code C++====
 '''Interruption'''

@@ Ligne 99 : / Ligne 99 : @@
 // ICACHE_RAM_ATTR : force le stockage de cette fonction dans la RAM,
 // sinon elle est stockée dans la mémoire flash, et forcément ça plante
 ICACHE_RAM_ATTR void configLedMode() {
    // stocke la dernière fois que le mode a été effectivement modifié
@@ Ligne 237 : / Ligne 238 : @@
+}
 </syntaxhighlight>
 ===Explications===
 ====Chargement du programme====

@@ Ligne 272 : / Ligne 272 : @@
 '''Interruption'''
-Dans ce programme, on utilise le système d'interruptions pour basculer d'un mode d'éclairage à un autre.
+Dans ce programme, on utilise le mécanisme des interruptions pour basculer d'un mode d'éclairage à un autre.
-Dans notre cas, on utilise le système des interruptions afin que lorsque l'on appuie sur le bouton tactile le basculement du mode d'éclairage au suivant soit instantané. Effectivement, si l'on n'utilisait pas les interruptions, cela signifierait que les appuis sur le bouton tactile ne seraient pas toujours pris en compte. La lecture de l'état du bouton tactile interviendrait uniquement au moment où l'instruction correspondante est exécutée. Dans cette hypothèse, si l'utilisateur appuie au moment où le programme rentre dans une boucle un peu longue, alors l'appui ne sera pas détecté. Ainsi, afin de pallier cet écueil, les changements d'état du bouton tactile sont associés au déclenchement d'une interruption. Dans ce cas, dès qu'un changement d'état est opéré au niveau du bouton tactile, cela déclenche une interruption qui met ''en pause'' le fonctionnement normal du programme pour aller exécuter prioritairement la partie du code associée à ladite interruption avant de reprendre l'exécution normale du programme.
+Dans notre cas, on utilise le mécanismes des interruptions afin que lorsque l'on appuie sur le bouton tactile le basculement du mode d'éclairage au suivant soit instantané. Effectivement, si l'on n'utilisait pas les interruptions, cela signifierait que les appuis sur le bouton tactile ne seraient pas toujours pris en compte. La lecture de l'état du bouton tactile interviendrait uniquement au moment où l'instruction correspondante est exécutée. Dans cette hypothèse, si l'utilisateur appuie au moment où le programme rentre dans une boucle un peu longue, alors l'appui ne sera pas détecté. Ainsi, afin de pallier cet écueil, les changements d'état du bouton tactile sont associés au déclenchement d'une interruption. Dans ce cas, dès qu'un changement d'état est opéré au niveau du bouton tactile, cela déclenche une interruption qui met ''en pause'' le fonctionnement normal du programme pour aller exécuter prioritairement la partie du code associée à ladite interruption avant de reprendre l'exécution normale du programme.
 '''Pointeur de fonctions'''
 Afin de faciliter et simplifier l'écriture de ce code, il a été choisi d'utiliser un pointeur de fonction. Sans entrer dans les détails, en C++ un pointeur de fonction se comporte comme une variable à laquelle il est possible d'assigner des valeurs. Ici, les valeurs assignées seront des fonctions. Ces fonctions correspondent individuellement à un mode d'éclairage. Ainsi, dans la boucle principale du programme une seule instruction est exécutée qui correspond à l'appel de la fonction ''ledFonction()''. Cette fonction un peu particulière est en fait le pointeur de fonction qui pointera ''in fine'' vers le code à exécuter associé au mode de fonctionnement sélectionné.
 ==Améliorations/Evolutions==
 '''Améliorations'''

@@ Ligne 120 : / Ligne 120 : @@
        case 0: // ruban led éteint
          ledFonction = rubanOff;
        break;
@@ Ligne 149 : / Ligne 150 : @@
 // éteint les led
 void rubanOff() {
    // éteint les led en passant la luminosité à 0 et le couleur des led à 0
    ruban.setBrightness(0);

@@ Ligne 267 : / Ligne 267 : @@
 # Arc-en-ciel v2
-Pour basculer d'un mode à l'autre, il suffit d'appuyer sur le bouton tactile. Si l'on appuie que le dernier mode est en cours d'exécution, le programme boucle sur le 1e mode (ici ''Eteint'').
+Pour basculer d'un mode à l'autre, il suffit d'appuyer sur le bouton tactile. Si l'on appuie lorsque le dernier mode est en cours d'exécution, alors le programme boucle sur le 1e mode (ici ''Eteint'').
 ====Choix du Wemos====
-Au prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie ''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
+De prime abord, le choix d'un contrôleur type Wemos n'est pas celui qui viendrait naturellement à l'esprit. Cependant, ce choix a été fait d'une part pour son prix et d'autre part pour sa petite taille. L'origine de ce projet est d'intégrer ce système de contrôle de ruban led dans un boîtier imprimé en 3D créant un jeu d'ombres chinoises. Aussi, fallait-il que le contrôleur soit le plus petit possible, et le Wemos (sans ses broches) était ce qu'il y avait de plus petit dans les tiroirs. Dans la partie ''[[#Améliorations/Evolutions|Améliorations/Evolutions]]''', une piste alternative, autre qu'Arduino, est proposée.
 ====Spécificités du code C++====
 '''Interruption'''
@@ Ligne 291 : / Ligne 291 : @@
 '''Evolutions'''
-Afin de travailler sur la miniaturisation de l'électronique, il serait intéressant d'étudier son portage sur un microcontrôleur type ATTiny85
+Afin de travailler sur la miniaturisation de l'électronique, il serait intéressant d'étudier son portage sur un microcontrôleur type ATTiny85.
 A vous de jouer ...