Contrôlez les lumières d'Halloween avec un ESP32 sur batterie

Dans ce tutoriel, vous apprendrez comment faire fonctionner un ESP32 lite sur batteries avec le mode deep-sleep pour contrôler des lumières d’Halloween. Et pour rendre cela vraiment cool, nous allons l’utiliser pour donner à un crâne d’Halloween une paire d’yeux rouges brillants et effrayants 😉

Dans le cadre de ce projet, vous découvrirez la carte de développement Lolin32 lite, le mode deep-sleep pour préserver la batterie, et comment créer des effets d’éclairage simples avec des LEDs.

Amusons-nous un peu.

Overview

Pièces requises

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Vous trouverez ci-dessous les composants nécessaires pour réaliser le projet. Pour ce projet, j’utilise une ancienne carte ESP32, qui est obsolète mais que vous pouvez encore obtenir à très bas prix. C’est celle listée ci-dessous. Il existe un modèle successeur avec des spécifications améliorées, que vous pouvez trouver here. Je ne l’ai pas essayé moi-même mais il devrait fonctionner de la même manière.

De plus, le crâne que j’ai utilisé est différent de celui que j’ai listé ci-dessous. Je pense que celui-ci est en fait plus esthétique mais un peu plus petit. Cependant, j’ai essayé et la carte ainsi que la batterie s’intègrent très bien.

Enfin, toutes les batteries LiPo 903052 que j’ai pu trouver ont le mauvais connecteur. Donc celles suggérées ci-dessous ! Vous devrez couper le connecteur et le remplacer par un connecteur JST PH 2 broches de 2,0 mm. Mais j’aime le format de ces batteries car elles ont presque les mêmes dimensions que la carte ESP32.

Connexion des composants

Nous voulons construire un crâne d’Halloween avec une paire d’yeux rouges lumineux. Pour les yeux, nous utilisons deux LEDs rouges. De plus, nous voulons que ces yeux clignotent ou affichent un autre effet. Cela signifie que nous aurons besoin d’un microcontrôleur.

L’image ci-dessous montre comment connecter ces composants.

Breadboard wiring of the ESP32 and the LEDs — Connexion des LEDs à l’ESP32

Comme vous pouvez le voir, c’est très simple. Nous connectons la broche GND de la carte ESP32 avec un fil bleu aux cathodes des deux LEDs (ce sont les broches les plus courtes). Les anodes (les broches les plus longues) des LEDs sont connectées aux broches 16 et 17 via un résistance de 68Ω (fil violet et vert).

Peu importe quelle LED vous connectez à quelle broche sur la carte. Assurez-vous simplement de savoir quelle LED sera l’œil droit et laquelle sera l’œil gauche.

Pour l’instant, nous utilisons le port USB pour la programmation et l’alimentation. Donc aucune batterie n’a besoin d’être connectée.

Écriture du logiciel

Dans cette section, je vais vous montrer comment implémenter le logiciel de contrôle des LEDs. Nous visons l’effet suivant :

une phase de 5 secondes où les yeux/LEDs s’assombrissent lentement avec un scintillement aléatoire vers la fin
suivie d’une autre phase de 5 secondes où les LEDs sont complètement éteintes.

Nous voulons donner l’impression que le crâne se réveille soudainement, vous fixe avec ses yeux rouges brillants, puis s’endort lentement jusqu’à un sommeil prolongé.

Si vous êtes complètement novice dans le monde Arduino, jetez peut-être un œil à notre tutoriel How To Blink An LED Using Arduino d’abord. Sinon, jetez un coup d’œil rapide au code ci-dessous. J’expliquerai les détails dans les sections suivantes.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;  

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

void loop() {
  dozingoff();
  sleeping();
}

Constantes

Nous commençons par définir quelques constantes. ledPin1 et ledPin2 sont évidemment les broches où les LEDs sont connectées.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;

Ensuite, nous avons des constantes de temps. Nous les utilisons pour réguler la durée des phases d’endormissement et de sommeil. Ces temps sont en millisecondes (ms), donc 5000 ms correspondent à 5 secondes.

Vous pouvez modifier ces constantes comme vous le souhaitez pour rendre les deux phases plus courtes ou plus longues. Faites dozingoff_ms plus grand si vous voulez un endormissement plus lent. Et faites sleeping_ms plus grand si vous voulez une phase de sommeil plus longue.

Nous parlerons plus tard du pas de temps ts_ms.

Fonctions utilitaires

Ensuite, nous implémentons quelques fonctions utilitaires pour garder le code bien structuré et lisible. Nous utilisons la fonction set_brightness() pour régler la luminosité des deux LEDs. Où analogWrite() fait le travail réel.

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

Notez que nous aurons besoin d’une broche supportant la modulation de largeur d’impulsion (PWM) pour que analogWrite() fonctionne. Pour la carte ESP32 que nous utilisons ici, ce n’est pas un problème. Les broches 16 et 17 sont des broches PWM, tout comme presque toutes les broches de cette carte. Consultez le schéma de brochage sous Pinout de la carte ESP32.

Le paramètre brightness sera une valeur entre 0 et 255, où 255 signifie luminosité maximale.

Pour créer l’effet d’endormissement, nous implémentons une fonction nommée effect(). Surprise, surprise. Elle prend un pas de temps t en paramètre et diminue la luminosité des LEDs de 255 à 0 au fil du temps. Pour rendre cela plus intéressant, nous ajoutons un scintillement aléatoire à mi-chemin de l’endormissement. Cela donnera l’impression que le crâne lutte contre le sommeil avec des paupières qui papillonnent. Je sais, les crânes n’ont pas de paupières, néanmoins…

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

J’espère que le diagramme suivant clarifiera le fonctionnement en détail.

Diagram of the dozing-off and sleeping phases that regulate the LED brightness

Fonction d’endormissement

Nous allons utiliser la fonction effect() dans la fonction dozingoff() montrée ci-dessous. Cette fonction itère simplement sur les pas de temps de longueur ts_ms, calcule la luminosité via la fonction effect() et règle ensuite la luminosité de la LED en conséquence.

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

Vous pouvez modifier la longueur des pas de temps, ce qui donnera un effet plus fluide ou plus grossier. J’ai choisi 10 ms, ce qui fonctionne bien. Vous pouvez économiser de la batterie en augmentant cette durée, mais l’animation sera moins fluide.

Fonction de sommeil

Pour faire dormir la tête, nous pourrions simplement régler la luminosité des LEDs à zéro puis attendre la durée de la phase de sommeil. Le code ci-dessous fait exactement cela.

void sleeping() {
  set_brightness(0);
  delay(sleeping_ms);
}

Cependant, cela gaspillerait de l’énergie précieuse, car le microprocesseur tourne toujours sans rien faire pendant la phase de sommeil. À la place, nous mettons le microprocesseur en mode deep-sleep mode deep-sleep, où il consomme beaucoup moins d’énergie. Le code ci-dessous montre comment faire.

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

D’abord, nous spécifions comment nous voulons nous réveiller. Il y a différentes façons de faire cela, mais ici nous réglons un minuteur via esp_sleep_enable_timer_wakeup (). Cette fonction prend le temps de sommeil en microsecondes. C’est pourquoi nous devons multiplier sleeping_ms par 1000.

Et dans la deuxième ligne, nous lançons simplement le mode deep sleep en appelant esp_deep_sleep_start(). Notez que cela signifie que les fonctions setup et loop s’exécutent, puis la carte s’endort, se réveille et répète le cycle en commençant par la fonction setup.

Fonction setup

Notre setup est très simple. Nous mettons simplement les broches qui contrôlent les LEDs en mode sortie. C’est tout.

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

Fonction loop

Et grâce à nos fonctions utilitaires, la fonction loop est aussi très simple. Nous faisons l’endormissement, puis le sommeil, et c’est tout.

void loop() {
  dozingoff();
  sleeping();
}

Cependant, notez que la fonction loop ne s’exécutera qu’une seule fois, car nous entrons en mode deep-sleep pendant le sommeil, puis la carte redémarre au réveil.

Économies d’énergie

Nous voulons faire fonctionner notre crâne effrayant sur batteries. La question évidente est : combien de temps cela va-t-il durer et combien le mode deep-sleep aide-t-il ?

J’utilise une batterie LiPo de 1200mAh . J’ai mesuré le courant pendant la phase d’endormissement (LEDs allumées) à 50mA. En deep-sleep, la carte ne consomme que 0,054mA et si j’utilise delay() à la place, la consommation monte à 39mA . Maintenant, faisons les calculs.

D’abord, nous convertissons la capacité de la batterie en Coulombs :

1200mA x 3600s = 4 320 000 mC

Pour la phase d’endormissement, quand la carte est active pendant 5 secondes, nous consommons

50mA x 5s = 250 mC

Pendant les 5 secondes en mode deep sleep, cependant, nous ne consommons que

0,054mA x 5s = 0,27 mC

Au total, nous consommons 250 mC + 0,27 mC = 250,27 mC toutes les 10 secondes.

Par conséquent, nous obtenons un temps de fonctionnement continu d’environ

10s * 4 320 000 mC / 250,27 mC ≈ 17 263 s ≈ 48 heures = 2 jours

Si nous n’utilisons pas le mode deep-sleep, ce temps est divisé par deux. Si vous voulez augmenter le temps de fonctionnement, allongez la phase de sommeil (ou raccourcissez la phase d’endormissement). Ou utilisez une batterie plus grande, bien sûr.

Brochage de la carte ESP32

Dans cette section, je souhaite mettre en avant certains aspects spécifiques de la carte Lolin32 lite que nous utilisons pour ce projet. Vous trouverez le brochage ci-dessous.

Pinout of the Lolin32 lite development board — Lolin32 lite

Cette carte est particulièrement adaptée aux projets alimentés par batterie, car elle dispose d’un connecteur batterie et d’un circuit de charge avec un courant de charge maximal de 500mA. Cela signifie que vous pouvez connecter une batterie LiPo à la carte, l’alimenter sur batterie et la recharger via le port USB. Très pratique !

De plus, les courants en mode deep sleep sont assez faibles. La spécification indique 125mA avec le WiFi activé et 45mA avec le WiFi désactivé, ce que j’ai également mesuré approximativement.

Sans batterie connectée, et la carte alimentée par USB, vous verrez un clignotement continu de la LED de charge. C’est normal ! Si vous connectez une batterie, le clignotement s’arrêtera. Si la batterie est en charge, la LED sera bleue fixe et s’éteindra une fois la charge terminée.

Notez que la carte fonctionne avec un niveau logique de 3,3 V. Donc, tous les modules que vous obtenez pour Arduino ne fonctionneront pas forcément avec cette carte, car Arduino fonctionne en 5 V.

Enfin, un mot d’avertissement. Le connecteur batterie est un connecteur JST PH 2 broches de 2,0 mm. Mais la plupart des batteries avec ce connecteur ont une polarité inversée ! Regardez attentivement les marquages sur la carte. Sur la photo ci-dessus, la broche plus est à gauche. Assurez-vous que le fil rouge de la batterie est connecté à la broche plus. J’ai dû couper et inverser le connecteur sur ma batterie.

Câblage du crâne d’Halloween

Bien que la breadboard soit idéale pour tester le circuit, elle ne rentrera pas dans le crâne. Une fois que vous avez confirmé que tout fonctionne, vous devrez souder les fils à la carte et aux LEDs. Voici à quoi ressemble mon câblage

Inside of the Halloween skull and its LED eyes

Le crâne que j’ai acheté n’avait pas de dessus amovible. J’ai donc dû découper le bas et percer deux trous pour les yeux. Je l’ai aussi repeint et vieilli un peu. Mais je suis très satisfait du résultat final.

Surtout après que tout soit bien rangé :

Another Halloween skull with red glowing eyes

Conclusion

Dans cet article, nous avons exploré comment contrôler des lumières d’Halloween en utilisant un Lolin32 lite alimenté par batterie. Nous avons commencé par lister les pièces nécessaires, y compris la carte LoLin32 Lite, qui est un excellent choix pour un projet sur batterie. Nous avons ensuite discuté du processus de connexion des composants et du câblage des LEDs pour le crâne d’Halloween.

Ensuite, nous avons écrit le logiciel pour l’ESP32, qui consiste à programmer le contrôle des lumières et à entrer en mode deep sleep pour économiser la batterie. Cela permet aux lumières de fonctionner pendant une longue période sans alimentation constante.

Dans l’ensemble, ce projet offre une manière amusante et créative d’ajouter une touche effrayante à vos décorations d’Halloween. En utilisant l’ESP32 et quelques composants simples, vous pouvez facilement contrôler vos lumières d’Halloween et créer une expérience mémorable pour les enfants qui font du porte-à-porte.

Bien sûr, on pourrait faire beaucoup plus. Ajouter un capteur PIR ou un capteur radar pour allumer les lumières uniquement lorsqu’une personne est détectée. Ou ajouter un module sonore et plus d’effets lumineux, ou contrôler la tête via Wi-Fi. Les possibilités sont infinies.

Si vous avez des questions ou rencontrez des problèmes lors de ce projet, veuillez consulter la section FAQ ci-dessous pour plus d’aide.

Foire aux questions

Voici quelques questions fréquemment posées sur le contrôle des LEDs avec ESP32 sur batterie :

Q : Puis-je utiliser n’importe quelle carte ESP32 pour ce projet ?

R : Oui, vous pouvez utiliser n’importe quelle carte ESP32 pour ce projet. Cependant, dans cet article, nous utilisons spécifiquement la carte LoLin32 Lite, car elle est facile à alimenter sur batterie.

Q : Combien de temps la batterie va-t-elle durer ?

R : La durée de vie de la batterie dépend de plusieurs facteurs, comme la capacité de la batterie, la consommation des lumières et la durée du sommeil de l’ESP32. Il est recommandé d’utiliser une batterie à haute capacité et d’optimiser le code pour minimiser la consommation afin d’allonger la durée de vie. Voir les calculs ci-dessus.

Pour des méthodes plus avancées d’économie d’énergie, consultez cet excellent article : ESP32: Tips to increase battery life.

Q : Puis-je utiliser d’autres lumières au lieu du crâne d’Halloween ?

R : Absolument ! Vous pouvez utiliser n’importe quel type de lumière que vous préférez. Le câblage et le code peuvent varier selon les lumières choisies, mais le concept général reste le même. Une bonne idée serait d’utiliser des LEDs RGB pour avoir des effets de couleur.

Q : Est-il possible de contrôler plusieurs ensembles de lumières avec un seul ESP32 ?

R : Oui, il est possible de contrôler plus de lumières avec un seul ESP32. Vous pouvez connecter plusieurs lumières en parallèle ou utiliser un multiplexeur pour les contrôler individuellement. Cependant, gardez à l’esprit que la consommation d’énergie augmentera en conséquence, ce qui affectera la durée de vie de la batterie.

Q : Puis-je modifier le code pour ajouter plus de fonctionnalités ?

R : Certainement ! Le code fourni dans cet article est un exemple de base pour vous lancer. Vous pouvez le modifier et l’étendre pour ajouter plus de fonctionnalités, comme différents motifs lumineux, le contrôle à distance ou l’intégration avec d’autres appareils domotiques.

Q : Puis-je alimenter l’ESP32 avec un câble USB au lieu d’une batterie ?

R : Oui, vous pouvez alimenter l’ESP32 avec un câble USB au lieu d’une batterie. Cependant, le but de ce projet est de le rendre portable et sans fil en utilisant une batterie. Si vous préférez une installation filaire, vous pouvez connecter l’ESP32 à une source d’alimentation via USB.

Liens

Voici quelques liens utiles avec des informations supplémentaires.

Stefan Maetschke