Veilleuse_de_nuit_esp8266_arduino_led_rgb

Veilleuse sur pile à base de ESP8266, Arduino et LED RGB

Et oui lorsque l’on a un enfant, on cherche toujours un moyen de le rassurer la nuit et surtout pour qu’il nous laisse dormir tranquillement :). La solution la plus répandue reste de mettre en place une veilleuse. Il en existe de toutes les formes, sur pile, sur secteur, avec une ou plusieurs couleurs, détection de luminosité, projection sur les murs ou les plafonds… bref il en existe des tonnes. voyez par vous même sur Amazon…

Vu que j’aime bien faire les choses par moi-même et que j’avais déjà une base pour réaliser ce projet, je me suis lancé sur ce thème.

Ma note :

Votre note :

[Total : 2    Moyenne : 4/5]

 

Conception de la veilleuse

Pour élaborer ma veilleuse, j’utilise la base de mon capteur de température/humidité WiFi sur pile. En effet, il a presque tout ce dont j’ai besoin comme :

  • Un microcontrôleur  (l’ESP8266 sur lequel je vais désactiver le WiFi)
  • Un Timer (le TPL5110) qui me permettra de jouer les scénarios de lumières pendant X temps
  • Un PCB tout fait avec un support de pile rechargeable (CR123A 3.6v)
  • Des IOs accessibles

Face avant du capteur temperature humidité version 2ESPIOT capteur T/H WiFi

Il ne me manque qu’une partie pour ce projet, c’est la LED. J’ai donc choisi d’intégrer une LED RGB classique.

LED RGBLED RGB

Dans cet article, c’est cette partie que je vais vous expliquer.

Ce projet est en soi relativement simple (4-5 composants max) à rajouter mais il va nécessiter de faire une schématique, un design et des modifications mécaniques pour l’adapter à l’ESPIOT.

En effet, pour réaliser ce projet, je vais devoir monter une carte fille qui viendra se « plugger » sur la carte mère (ESPIOT)

Face avant du capteur T/H version 2

Je vais utiliser :

  • La masse GDM
  • La patte Red sur GPIO12(MISO)
  • La patte Green sur GPIO13(MOSI)
  • La patte Blue sur GPIO4 (SDA)

Pour le timer TPL5110, je devrai le configurer en mode « ONE SHOT » (dessouder un pont). Sur l’appuie du bouton, le timer va :

  • Déclencher l’alimentation de l’objet.
  • Le scénario de lumière va être joué en boucle jusqu’à atteindre le temps voulu.
  • Le timer coupera l’alimentation.

Pour la partie boitier, je vais utiliser le même boitier que le capteur ESPIOT (mes fameuses boules… ;))

bulle-blanche-oplain-ballkit2Boitier de la veilleuse

Achats

Pour les achats, c’est assez simple puisqu’il faut acheter presque la même chose que le capteur ESPIOT sans le capteur de température/humidité, mais avec une LED RGB.

  PrixPUAction
ESP12F1.92€1.92€
MOSFET Canal N1.15€ (les 10)0.12€
Timer TPL51110.858€0.858€
Support pile5.05€ (les 5)1.05€
LEDs RGB6.5€ (les 50)0.13€
Plaque de cuivre1.5€1.5€
Bulles blanches 5CM5.46€ (les 10)0.55€
Pile CR123A 3.7v recheargeable5.39€ (les 2)2.70€
TOTAL9€

Réalisation de la veilleuse

Pour utiliser une LED RGB, il y a quelques règles à respecter. En effet, il faut s’assurer de plusieurs points pour ne pas avoir de surprises:

La tension

Ça peut paraître étrange, mais sur ce type de LED, la tension appliquée à chaque couleur doit être différente. Pour des raisons physiques [voir explications], la production d’une longueur d’onde (la couleur) se fait par des composants différents. Du coup, l’alimentation est différente. Par exemple :

  • Le rouge nécessite souvent une alimentation de 1.8V
  • Le bleu nécessite une alimentation de 3.0 -3.3V
  • Le vert nécessite une alimentation de 2.4V

Pour le moment, ces tensions restent compatibles avec la tension délivrée par les GPIOs de l’ESP8266 qui délivre jusqu’à 3.3V.

Le courant

Le courant de fonctionnement pour ce type de diode est généralement autour de 10mA. (bien entendu, je généralise mais il faut quand même s’assurer de ce type d’informations en épluchant la datasheet du composant).

Cette fois-ci pas de distinction entre les couleurs, chaque patte accepte un courant max de 10mA.

Ce courant est aussi compatible avec les GPIOs de l’ESP8266 qui est capable de fournir jusqu’à 12mA.

Pour conclure, cette mini étude permet de valider le matériel et de choisir une schématique simplifiée et adaptée. (Pas besoin d’utiliser des transfos ou d’alimentation externe).

Il ne reste plus qu’à calculer les valeurs des résistances pour monter le système. Voici la règle de calcul à suivre :

(Tension GPIO - Tension diode) / Courant de fonctionnement = Valeur de résistance

Couleur rouge :

(3.3-1.8) / 10 = 150 ohm

Couleur verte :

(3.3-2.4)/10 = 90 ohm

Couleur bleu :

(3.3-3)/10 = 30 ohm

Réalisation du circuit

schematique_veilleuseSchématique carte fille veilleuse

Comme on peut le voir, le schéma est enfantin. Attention, la LED que j’ai choisi est à cathode commune. C’est à dire que le pôle négatif est commun aux 3 couleurs. Cependant, il existe le même type de LED avec anode commune. Je ne le répèterai jamais assez, il faut toujours bien vérifier ce type de données en consultant la datasheet.

PCB_LED_RGBRéalisation du PCB selon schématique

Dernière étape, paramétrer le Timer en mode « ONE SHOT » et pendant 20 min.

Timer_veilleuse_config

Comme je le disais précédemment, il va falloir changer la configuration du timer TPL5110:

  • Pour le passer en mode « ONE SHOT », il faudra supprimer le pont (rond rouge 0)
  • Pour changer la durée à 20 min, il faudra remplacer les résistances en parallèle par les valeurs suivante (rond jaune 0) :
    • 100K
    • 330K

Modification faite, la veilleuse jouera ses scénarios de couleurs pendant 20 minutes puis coupera l’alimentation. seul un appuie sur le bouton poussoir relancera la veilleuse.

Sketch Arduino

#include <ESP8266WiFi.h>
extern "C" {
#include <user_interface.h>
}
#define FPM_SLEEP_MAX_TIME 0xFFFFFFF

int redPin = 4;
int greenPin = 13;
int bluePin = 12;

//uncomment this line if using a Common Anode LED
//#define COMMON_ANODE

void setup()
{
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);  
}

void early_init()
{
  WiFi.persistent(false);
  WiFi.mode(WIFI_OFF);
  WiFi.forceSleepBegin();
  wifi_station_disconnect();
  wifi_set_opmode(NULL_MODE);
  wifi_set_sleep_type(MODEM_SLEEP_T);
  wifi_fpm_open();
  wifi_fpm_do_sleep(FPM_SLEEP_MAX_TIME);
}

void loop()
{
  int i=0;
  for (i=0;i<255;i++)
  {
    delay(10);
    setColor(i, 0, 0);  // red
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(i, 0, 0);  
  }
  delay(1000);
  for (i=0;i<255;i++)
  {
    delay(10);
    setColor(0, i, 0);  // green
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(0, i, 0);  
  }
  delay(1000);
  for (i=0;i<255;i++)
  {
    delay(10);
    setColor(0, 0, i);  // blue
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(0, 0, i);  
  }
  delay(1000);
   for (i=0;i<255;i++)
  {
    delay(10);
    setColor(i, i, 0);  
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(i, i, 0);  //yellow
  }
  delay(1000);  
   for (i=0;i<255;i++)
  {
    delay(10);
    setColor(i, 0, i);  
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(i, 0, i);  //purple
  }
  delay(1000);
  for (i=0;i<255;i++)
  {
    delay(10);
    setColor(0, i, i);  // blue
  }
  for (i=255;i==0;i--)
  {
    delay(10);
    setColor(0, i, i);  //aqua
  }
  delay(1000);
}

void setColor(int red, int green, int blue)
{
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);  
}

Comme on peut le voir dans le code, je désactive le WiFi et je le fais dès le boot de l’ESP8266 avec la fonction early_init(). En effet, J’ai suivi un tutoriel où on désactive le WiFi dès l’initialisation du microcontrôleur (ce qui permet de ne pas avoir d’appel de courant important à l’initialisation du module). L’inconvénient est qu’il faut toucher au SDK de l’ESP8266 pour rajouter l’appel de la fonction early_init().

Le reste du code est assez classique. On joue avec les couleurs en appliquant une tension sur chaque patte de la LED. L’ESP8266 ayant un convertisseur ADC de 10 bits, les valeurs appliquées à chaque patte peuvent varier de 0 a 1023.

La fonction analogWrite permet d’utiliser le PWM. C’est une méthode permettant de « pulser » en fonction de la valeur (entre 0 et 1023) où 0 correspond à zéro pulse et 1023 une tension constante et non pulsé.

pwm_graph

Graphe de fonctionnement du PWM

L’intérêt du PWM est en quelque sorte de limiter la consommation d’énergie d’une LED sans avoir d’incidence sur le rendu. En effet, notre persistance rétinienne fait que vous ne pourrez pas voir les pulsations ou voir la LED clignotée. Vous ne persevrez qu’une baisse de luminosité.

Bon comme c’est une veilleuse et pas un phare, j’ai configuré la luminosité max à 1/4 (255). Concernant les boucles que j’ai appliqué avec un délai, c’est pour faire ce qu’on appelle un effet « wanadoo », pour que les changements de couleurs soient plus « smoothy ».

Consommations

La consommation de cette veilleuse n’excède pas les 18mA. La pile est une CR123A rechargeable de 800mAh.

Si on utilise la veilleuse tous les soirs pendant 20 min :

(18mA x  1200 ) / 3600 sec = 6mAh

800mAh / 6mAh = 134 utilisations

Le boitier

Pour le boitier on prend les mêmes et on recommence. J’utilise les boules du capteurs de température/humidité sans usiner les petits trous.

boitier_veilleuseBoitier de la veilleuse

Conclusion

Voilà encore un petit projet réalisé. Il ne m’a pris que très peu de temps et coûte presque rien à réaliser. En effet, lorsque l’on rebondi de projet en projet, on s’aperçoit que ce qui a été déjà fait peut être détourné ou réutilisé pour d’autres choses.

C’est pour cette raison que j’essaie au maximum de penser à d’autres utilités possibles lorsque que j’étudie un projet. Vous verrez dans beaucoup de mes articles que je réutilise constamment ce que j’ai déjà fait. D’ailleurs, je pense que le projet ESPIOT va être au menu très souvent…

Bref, je me suis amusé, ça ne m’a pratiquement rien coûté (temps et argent) et ma fille est contente parce qu’elle a un nouveau jouet.

Lien Github

Leave a Reply

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *