Les bases pour utiliser l'ESP01: réalisation d'un contrôle d'état des volets.

Dans cet article nous allons étudier comment créer un objet connecté en WiFi, autonome et capable d'envoyer un signal à notre serveur domotique lors du changement d'état d'un microrupteur!




Bon d'accord, dit comme ça, cette phrase n'est pas très sexy et on se demande bien à quoi ça va servir ! Connaitre le changement d'état d'un microrupteur c'est bien gentil mais c'est pas ça qui va améliorer notre solution domotique ! Hé bien si vous pensez cela détrompez vous ! Créer un objet connecté capable d'informer notre serveur domotique du changement d'état d'un microrupteur ça va nous permettre de faire plein de choses. Nous allons pouvoir fabriquer un capteur d'ouverture et fermeture de portes, nous allons pouvoir créer un détecteur de fin de course pour des volets, nous allons pouvoir domotiser notre boite aux lettres pour savoir si le facteur est passé .... dingue! 

Mais avant toute chose, il faut que je vous parle de moi. Encore ? Ben oui ... désolé ! 


Parlons de moi ... 


Il y a quelques années, j'ai aménagé dans une maison moderne que j'ai faite construire. Si vous avez lu mes précédents articles vous savez certainement que j'ai fait installer une cuve de récupération d'eau de pluie et que j'utilise cette eau pour mes toilettes et mon jardin. J'ai d'ailleurs fabriqué une sonde de niveau qui me permet de savoir à tout instant combien de litres il me reste.
Cette installation est décrite dans l'article ICI.

Par contre ce qui se sait moins .... normal car je n'en ai pas encore parlé ... c'est que j'ai également fait installer des volets roulants électriques avec une télécommande centralisée.  Ces volets disposent d'un interrupteur individuel qui permet de commander chacun d'entre eux. Mais cet interrupteur est également un récepteur sans fil qui peut s’appairer avec une télécommande afin d'être commandé à distance. J'ai donc appairé tous mes volets à une même télécommande et je peux désormais, en appuyant sur un seul bouton, fermer ou ouvrir tous les volets de la maison. C'est vraiment magnifique la nuit venue, d'une seule petite pression sur un bouton, de voir l'ensemble des volets de sa maison se fermer automatiquement !

A cette époque, quand je partais en vacances, je confiais la télécommande au voisin afin que ce dernier ouvre les volets de chez lui le matin et les ferme le soir. Histoire de simuler une présence. Mais c'était quand même un peu gênant de demander au voisin ce service à chaque vacances. Alors quand je me suis lancé dans la domotique, mon premier projet a été de pouvoir piloter mes volets depuis mon téléphone et cela de n'importe où dans le monde ! 
A moi les joies de l'autonomie ! Le bonheur de l'indépendance ! Le plaisir de la libération !

Pour ce faire cela a été plutôt facile. Les récepteurs de mes volets étant à la norme RTS, un protocole développé par Somfy et communiquant sur la longueur d'onde 433Mhz, j'ai simplement ajouté à ma box domotique un boitier RFXTRX433E (que vous pouvez trouver ICI) , activé le protocole RTS et le tour était joué !
Boitier RFXTrx433e compatible RTS/Somfy


Et pourtant, sous cette image de bonheur idyllique subsistait une ombre : je n'étais pas totalement satisfait !
En effet, je n'ai actuellement aucun retours d'état sur mes volets. Par exemple, lorsque je demande la fermeture, je ne sais pas si l'ordre a bien été exécuté. Et si quelqu'un ouvre les volets avec la télécommande alors qu'ils ont été fermé depuis l'interface domotique, cette dernière ne prend pas en compte ce changement d'état. Pour déployer des services plus évolués, comme par exemple une simulation de présence ou l'ouverture/fermeture automatisée des volets en fonction de l'heure de la journée ou de la luminosité extérieure, les programmes que nous pourrons développer doivent connaitre l'état des volets et pouvoir contrôler le résultat d'une commande. J'avais bien essayé de placer des capteurs d'ouverte à différents endroits sur les volets, mais le signal n'était absolument pas fiable. L'armature aluminium des fenêtres perturbe fortement les émetteurs 433Mhz et les rend très difficilement exploitables.

C'est pour cette raison que je me suis dit "pourquoi ne pas fabriquer moi même un détecteur d'ouverture qui ne soit pas magnétique et qui fonctionne sur une autre longueur d'onde que le 433Mhz". C'était l'occasion d'apprendre à utiliser ces petits ESP-01 qui traînaient dans le fond de mon tiroir.  

Et c'est là que notre objet connecté capable de remonter un changement d'état d'un microrupteur à notre serveur domotique va entrer en jeu !

Après une page de pub on se met au travail ! 






Difficultés du projet 

L'objet de cet article sera d'apprendre à utiliser et programmer un Esp01, un microrupteur mais aussi nous commencerons à acquérir des connaissances sur la consommation électrique des montages électroniques dans le but de pouvoir nous construire des obets connectés disposant d'une autonome la plus longue possible.
Mais comme dans tous mes articles, j'aime que cet apprentissage puisse s'appuyer sur un projet concret et utile.  Le projet dans cet article, va consister à créer un objet connecté sur batterie, capable de détecter l'état d'ouverture des volets de la maison et d'en informer un serveur domotique.


volet aelex2504


Afin de le mener à bien, quelques prérequis seront nécessaires et ensuite nous devrons résoudre un certain nombre de difficultés identifiées ci-dessous.

Pré requis 

En fonction de mes expériences passées (et de mes connaissances actuelles), le plus facile pour moi pour créer un objet connecté capable d'échanger avec un serveur domotique, est d'utiliser une puce ESP8266. Pour ceux d'entre vous à qui la notion d'ESP/NodeMCU ne parle pas, j'invite à lire mon article sur le sujet ICI car pour suivre il faudra connaitre un minimum ces microcontrôleurs Wifi.

Quelques notions de base d'électronique seront utiles également.

Il vous faudra aussi avoir un serveur domotique capable de recevoir des informations via une requête HTML/Json et bien entendu capable de gérer un "device" virtuel qui représentera l'état ouvert ou fermé des volets.

Par contre il n'est pas nécessaire d'avoir des volets roulants électriques et commandables à distance. Il n'est pas nécessaire que vous ayez déjà domotisé vos volets car même avec des volets classiques il peut être intéressant d'en connaitre l'état.

Difficultés liées au microrupteur 

Un microrupteur est un composant électronique qui ressemble et fonctionne comme un petit interrupteur. Il y en a de plusieurs sortes. Les plus courants disposent de 3 bornes : COM / NC / NO.

J'ai trouvé une page à l'adresse ICI qui explique bien comment fonctionne un microrupteur. 

Voici le schéma de fonctionnement : 



Les microrupteur ont un petit "levier" qui, selon qu'il soit libre ou appuyé, permettent de d'ouvrir ou fermer le circuit entre la broche COM et les broches NO ou NF. 
Ce petit levier est très sensible. Ainsi on peut les utiliser également dans des robots pour détecter un contact ou alors pour détecter des fins de course.

La difficulté que nous devrons lever n'est pas dans l'utilisation de ce composant mais essentiellement comment l'utiliser avec un microcontrôleur : câblage, résistances de pull up / pull down, programmation ....

Difficultés liées à l'autonomie électrique et à l'encombrement


Etant donné que nous souhaitons disposer d'un objet qui va devoir se loger dans un petit espace à proximité des volets et que ce dernier doit pouvoir être alimenté sur piles sans devoir les changer toutes les semaines, nous allons devoir résoudre la double problématique de l'encombrement et de la consommation électrique. Ces deux aspects de notre réalisation devront pouvoir être minimisés au maximum (j'adore cette phrase ! un peu comme "plus on pédale doucement, moins on avance plus vite" ...  mais revenons à nos moutons).

Pour répondre à ces critères j'ai choisi d'utiliser un ESP-01 plutôt qu'un NodeMCU que je connais bien. L'ESP-01 est tout petit, à peu près la taille d'une pièce d'un euro. De plus il consomme moins que le NodeMCU car il n'embarque pas autant de composants électroniques.

Je résoudrais plus tard la problématique de la taille de la réalisation finale. Pour le moment j'imagine le tout assemblé ensemble autours de deux ou trois piles ou alors d'une batterie externe que j'aurais dédié à cet usage. J'espère pouvoir obtenir quelque chose qui soit au maximum de la taille d'un paquet de cigarettes.

Et enfin, pour minimiser la consommation électrique je vais utiliser la fonction de mise en sommeil profond (DeepSleep) du microcontrôleur.


Difficultés liées à l'ESP01 

Lorsque j'ai commandé mes NodeMCU, j'ai pris les NodeMCU ESP12E mais j'ai aussi pris quelques petits ESP01 avec un adaptateur USB FDTI. Jusqu'à présent je ne m'en était pas servi mais aujourd'hui je pense que j'ai été bien inspiré d'ajouter ces composants de quelques euros chacun à ma commande car leur caractéristiques de taille et de consommation électrique vont m'être utiles dans ce projet.
La difficulté à laquelle je suis confrontée c'est réussir à maîtriser un ESP01. Autant maintenant, je maîtrise le NodeMCU (j'ai écrit un article sur la manière de le programmer ICI), autant l'ESP01 m'est inconnu.

Tout savoir sur l'ESP-01


L'ESP01 est un composant électronique à base de microcontrôleur ESP8266 qui embarque une puce wifi. Il permet donc de manière native de monter une connexion en wifi sur la box de notre réseau local et par conséquent d'accéder à tous les équipements connectés sur le LAN : dont bien sur notre serveur domotique !

Le microcontrôleur étant de la série ESP8266, on va pouvoir le programmer en utilisant l'IDE Arduino comme pour un NodeMCU. Toutefois, ne disposant pas de port USB et ayant un brochage différent il va falloir utiliser un procédé différent pour injecter le programme.

Dans ce chapitre nous allons étudier en détails les caractéristiques d'un Esp01 et comment injecter un programme.

Présentation de l'ESP-01 

De petite taille, l'ESP01 dispose de 8 broches. Il diffère de l'ESP12e et du NodeMCU notamment sur les critères suivants :
  • Ne dispose pas de port USB pour raccorder directement un ordinateur et injecter un programme. 
  • Ne présente que 2 ports GPIO (4 si on utilise les broches Tx et Rx comme GPIO01 et GPIO03). 
  • Alimentation en 3.3v. 

Schéma de brochage : 


Role des broches :

  • Tx/Rx : Liaison série mais peuvent également servir de GPIO (GPIO01 et GPIO03 respectivement).
  • CH_PD : chip power-down doit être raccordé au 3,3V. Si cette broche est raccordée au GND, l'Esp entre dans un mode "basse consommation" dans lequel toutes les fonctions sont figées et le programme ne s’exécute plus. 
  • GPIO0 :  Utilisable comme broche I/O mais également permet d'entrer dans le mode « Flash mode » si elle est connectée à la masse lors de la mise sous tension (puis replacée sur VCC quelques secondes après). Dans ce mode l’ESP8266 ne démarrera pas son programme interne mais entrera dans un mode appelé « UART download mode » où il écrira tout ce qu’il reçoit sur la liaison série, dans sa mémoire. C'est de cette manière qu'il faut procéder pour injecter un programme. Cette broche dispose d'une résistance de rappel (pull up) qui fait que par défaut elle est en état haut.
  • GPIO2 : Utilisable comme broche I/O. Cette broche dispose d'une résistance de rappel (pull up) qui fait que par défaut elle est en état haut. De plus cette broche est raccordée sur la LED bleue (version esp01s). Malgré ce que l'on peut voir dans certaines documentations, pour un démarrage correct cette broche doit être sur 3.3v.
  • RST doit être raccordé au 3.3v. Une pulse à GND sur cette broche génère un reset du composant. Le reset permet à l'Esp de redémarrer en exécutant son setup et lui permet également de sortir d'une mise en sommeil.


Notes concernant l'Esp8266 en général : 

L'ESP8266EX, qui équipe les circuits Esp01, est un microcontrôleur développé par la société Espressif. La société Ai-Thinker a développé des modules utilisant le 8266EX.

Il est intéressant de savoir également que l'Esp8266 dispose d'une résistance de pull-down interne pour la broche GPIO15. Mais cette broche n'est pas disponible sur la carte ESP-01.

Également, la broche GPIO16 du microcontrôleur Esp8266 propose une fonction spéciale : c'est cette dernière qui va pouvoir émettre une courte impulsion au niveau GND lorsque le "timer du watchdog*" va arriver à bout de son décompte. C'est donc en raccordant cette broche sur la broche RST que l'on peut faire sortir l'Esp du mode sommeil au bout d'un temps défini dans le programme.
Malheureusement le GPIO16 du microcontrôleur n'est pas raccordé aux broches de la carte Esp01. Donc à moins d'aller faire un point de soudure dans une zone minuscule (il y en a qui l'on fait !) mieux vaut oublier GPIO16.

*Le watchdog timer est un système de protection qui permet de générer un reset du processeur dans différents cas. Par exemple lorsque ce dernier entre dans une boucle infinie ou se met à dysfonctionner suite à des perturbations électriques. Par exemple, lors du boot de l'Esp, il n'est pas rare de voir des messages du genre "wdt rst". WDT étant les initiales de "Watch Dog Timer". On peut le programmer car il dispose d'un système de minuterie qui au bout du décompte d'un nombre de microsecondes données génère une impulsion à GND sur la broche 16 du microcontrôleur. C'est de cette manière que l'esp sort du sommeil. Durant le sommeil, ce timer est la seule fonction qui reste active dans la puce et qui justifie la faible consommation électrique de ce mode.


Etat des broches au démarrage


Lorsque l'Esp démarre suite à une mise sous tension, l'état dans lequel se trouvent les broches GPIO0 et GPIO2 vont déterminer le mode de fonctionnement du microcontrôleur.

 
GPIO01 GPIO02 Mode de
démarrage
Signification
HIGH HIGH Normal Le microcontrôleur boot de manière normale sur son programme.
LOW* HIGH UART Le microcontrôleur boot dans un mode qui permet d'injecter en mémoire le programme qu'il reçoit sur sa liaison série (broches Tx/Rx).

* Une fois le microcontrôleur démarré (après une ou deux secondes) il faut remettre la broche GPIO01 dans un état HIGH ou libre.

Les broches RST et CH_PD doivent également être dans un état fixé :

  • RST : doit être sur HIGH.
  • CH_PD : doit être sur HIGH.


Versions :


Il existe (à ma connaissance et à la date actuelle d'avril 2018) deux versions du composant.
La version originale ESP-01 et la version ESP-01S.
Pour ma part, ce sont des ESP-01S dont je dispose. Cet article sera donc rédigé à partir de cette version.

Les différences entre les deux versions (ESP-01 vs ESP-01S) sont les suivantes :
  • PCB bleu vs PCB noir 
  • flash de 512kB vs flash de 1MB 
  • LED d'alimentation rouge vs  pas de LED d'alimentation.
  • LED bleue sur TX vs LED bleue sur GPIO2 (bas = activé)
  • Meilleur signal WiFi sur le 01S
  • Vitesse de la liaison série : 9600 bauds sur le 01 et 115200 sur le 01S.

Programmation 


Pour injecter un programme dans la mémoire de l'ESP01 depuis notre ordinateur en utilisant l'environnement de développement Arduino (ou un autre environnement de développement capable de compiler du code pour ESP8266) il y a deux conditions à remplir :

  1. Pouvoir connecter l'ESP01 à l'ordinateur : la seule possibilité est de le faire via un port USB. Hors l'ESP01 ne dispose pas de port USB. Il va donc falloir trouver un équipement qui sera capable de se connecter d'un coté en USB à l'ordinateur, et de l'autre à l'ESP. Pour ma part je vais utiliser un adaptateur USB pour module ESP8266
  2. Activer le mode "flash" : Ce mode est nécessaire pour injecter un programme dans la mémoire de l'ESP. Le mode flash s'active quand l'ESP démarre avec sa broche GPIO00 raccordée au pole négatif (GND). 


Raccorder l'ESP à l'ordinateur : 

On trouve plusieurs méthodes sur Internet.
Le but étant d'envoyer un programme sur la liaison série de l'ESP. La liaison série est constituée par les broches Tx/Rx (Tx pour la transmission, Rx pour la réception des données).
Il faut donc utiliser un protocole qui envois sur le port USB, un signal qui pourra être repris par un équipement intermédiaire (qui sera présenté ci-dessous) connecté sur le port USB et qui fera le relais avec les broches Tx/Rx de l'Esp.
Le protocole de communication qui permet à un programme sur ordinateur d'envoyer des données série sur un port USB porte le joli petit nom de 340G. Il vous faudra donc vérifier que votre ordinateur dispose bien des drivers 340G.
Pour savoir si c'est le cas, quand vous brancherez l'équipement en question sur le port USB vous devriez le voir dans la liste des équipements connectés en USB :


Si ce n'est pas le cas il vous faudra installer ce driver 340G. Vous le trouverez ICI pour windows 7. Pour les autres OS je laisse google vous aider.

L'équipement qui permet de recevoir les données sur le port USB et de les envoyer sur les broches Tx/Rx de l'Esp est soit un Arduino, soit un adaptateur USB spécialisé. Dans mon cas, c'est cette seconde solution que j'ai utilisé car j'avais les équipements et c'est plus facile. L'adaptateur ressemble à une clé USB avec un socle (jaune) sur lequel on peut enficher l'Esp01. Au passage notez qu'il ne faut pas se tromper de sens quand on place l'Esp sur le socle !



Vous le trouverez ICI sur Amazon, pour les impatients avec une livraison express!
Sinon, si vous pouvez attendre quelques semaines le temps que l'engin vienne de Chine vous le trouverez beaucoup moins cher ICI sur eBay.
Dans tous les cas je vous conseille d'en prendre au moins deux car nous allons un peu le malmener! Vous comprendrez en lisant la suite de cet article.

Tester que l'ESP fonctionne 

J'aime bien tester à chaque étape le bon fonctionnement de ce que je met en place.
Au niveau de cette étape, lorsque l'esp a été raccordé à l'ordinateur, il est possible de le tester en utilisant le jeu de commandes AT.

Par défaut, l'ESP est programmé pour interpréter les commandes AT. Il s'agit d'un jeu de commandes permettant de contrôler le composant. Ces commandes sont disponibles uniquement si votre Esp n'a jamais été flashé ! Lorsque vous aurez injecté votre propre programme, ce dernier effacera le programme initial et les commandes AT ne seront plus reconnues.

Pour avoir la liste de ces commandes vous pouvez consulter le site en français ICI. En ce qui me concerne, le but étant uniquement de tester le bon fonctionnement de la carte et de la communication série, je vais me contenter de quelques commandes :
  1. AT : Commande de test qui renvoie "OK"
  2. AT+GMR : Renvoie des informations sur le Firmware de l'ESP8266 (Version, Date de compilation)
  3. AT+CWMODE_CUR=X : Définit le mode de fonctionnement du module en client WiFi. Avec X ayant pour valeurs:
    • 1=Client WiFi, 
    • 2=Point d'accès
    • 3=Les deux
  4. AT+CWLAP : Retourne la liste des réseaux Wi-Fi (SSID) à portée.
Notez que ces commandes doivent être utilisées en respectant les majuscule. 
Pour envoyer ces commandes à l'Esp depuis votre ordinateur il faudra utiliser un moniteur série en ayant par avance identifié le port COM sur lequel l'ESP est connecté.

Pour identifier ce port (sous windows 7) :
  • Clique droit sur l'icone "Ordinateur" du bureau puis "Propriétés". 
  • Ouvrez "Gestionnaire de périphériques". 
  • Cliquez sur "Ports(COM et LPT).
Vous verrez ensuite dans la liste qui s'affiche le port COM associé à la liaison série USB de l'ESP.


En ce qui concerne le moniteur série vous avez le choix. Vous pouvez utiliser le moniteur série de l'IDE Arduino comme ci-dessous, ou (plus sportif) vous pourrez utiliser Putty:


Respectez les réglages que j'ai entouré en rouge : CR et NL pour chaque commande et vitesse de connexion 115200 bauds (cette valeur peut changer en fonction de la version de votre ESP. Pour la version de base il faut mettre 9600). Cela marche parfaitement bien mais il y a un peu plus compliqué :

Si vous aimez le sport, vous pouvez essayer d'utiliser Putty : 

Il faut savoir qu’apparemment Putty ne gère pas les caractères LF comme attendus sur la liaison série. Il faudra donc après chaque commande envoyée, après avoir appuyé sur "Entrée", appuyer sur CTRL+J (contrôle J). Il y a un moyen de forcer putty à envoyer les bons caractères en entrant dans le moniteur la séquence Esc [20h (touche Esc, crochet, 2, 0 et h en minuscule).

Voici les réglages à faire dans Putty. Ils correspondent chez moi aux paramètres par défaut :





Et cela fonctionne !



Configurer l'EDI Arduino 

Une fois tout connecté, avant d'injecter notre premier programme, il va falloir configurer correctement l'environnement de programmation.

Si vous avez déjà utilisé l'IDE pour générer du code pour ESP8266 alors seule la dernière étape est nécessaire car les premières consistent à inclure les bonnes libraires dans l'IDE. 

Les étapes sont les suivantes :
  • Ouvrez l'EDI Arduino et cliquez sur Fichier / Préférences
  • Entrez "http://arduino.esp8266.com/stable/package_esp8266com_index.json" dans URL de gestionnaire de cartes supplémentaires.
  • Cliquez ensuite sur Outils / type de carte / Gestionnaire de cartes. Dans le champ recherche, taper "ESP". Sélectionnez "esp8266 by ESP8266 Community" et cliquer sur "Installer".
  • Cliquez sur Outils / Type de carte / Generic ESP8266 Module

Activation du mode "Flash"


La dernière étape pour prendre en main notre ESP va consister à activer le mode flash qui nous permettra de lui injecter un programme.

Si vous utilisez un Arduino comme intermédiaire entre l'ESP et l'ordinateur, je vous laisse chercher le schéma de câblage sur internet.

Si vous avez la chance d'avoir un adaptateur Série-USB pour ESP01 qui dispose d'un bouton poussoir de passage en mode programmation, alors vous n'avez rien à faire : il faudra juste passer en mode prog, connecter les composants à l'ordinateur en USB et téléverser le programme depuis l'interface de programmation Arduino. Je n'ai pas testé ce composant mais vous pouvez le trouver ICI.


Sinon, si comme moi vous utilisez un adaptateur Série-USB et que vous n'avez pas la chance d'avoir le modèle avec un petit bouton, il va falloir faire un peu de soudure ! En effet, pour passer l'Esp en mode Flash, nous avons vu que la broche GPIO0 doit être raccordée à GND lorsque l'ESP démarre.
On trouve sur internet des montages plus ou moins élaborés avec des boutons. Pour ma part je vais faire hyper simple: je vais souder deux câbles Dupont sur les bornes GPIO0 et GND de l'adaptateur. Quand je voudrais mettre l'Esp en mode Flash, ces câbles seront reliés entre eux au moment ou je connecte le tout à l'USB. Une fois l'Esp démarré je déconnecterais les deux cables.
Il ne faut pas oublier qu'au moment de téléverser le programme le GPIO0 ne doit plus être raccordé au GND ! C'est juste au moment du démarrage que ce doit être le cas.
Voici en quelques photos ce que cela donne. Repérez bien la position des deux broches concernées!

On va souder les deux câbles dupond reliés entre eux sur les broches correspondantes au GND et GPIO0 de l'adaptateur.



Une fois soudés, les deux câbles Dupont pourront être ouverts afin que l'Esp fonctionne normalement ou être fermés lorsque l'on connecte l'adaptateur à l'USB pour démarrer l'Esp en mode programmation.



Et pour tester que cela fonctionne j'ai adapté le programme classique "Blink", qui permet de faire clignoter le LED du composant.
Attention toutefois, il faudra modifier le programme car sur Esp01s la LED interne est sur GPIO2.


/*
  Blink apté à ESP-01
  Ce programe fait clignoter la LED interne du composant.
  La constante LED_BUILDIN ne fonctionne pas sur ESP01.
  La LED est connectée ou GPIO 2.
*/

#define LED 2

// the setup function runs once when you press reset or power the board
void setup() {

  /////////////////////////////////////////////////////////Initialisation port série : a adapter en fonction de la version.
  Serial.begin(115200);
  delay( 100 );
  Serial.println( "\nInitialisation liaison serie : OK" );

  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED, HIGH);   // turn the LED on (HIGH is the voltage level)
  Serial.println( "Allume" );
  delay(1000);                       // wait for a second
  digitalWrite(LED, LOW);    // turn the LED off by making the voltage LOW
  Serial.println( "Etteind" );
  delay(1000);                       // wait for a second
}


La configuration de l'IDE pour injecter le programme est la suivante : 



Une fois téléversé l'Esp commence à clignoter et les messages (allumé/éteint) sont bien envoyés sur le port série.

Nous avons réussi à programmer notre Esp01 ! Les choses sérieuses vont pouvoir commencer. 

Optimisation de la consommation électrique 

Pour qu'un objet connecté puisse être autonome, c'est à dire alimenté électriquement sur batterie, il faut que sa consommation soit la plus faible possible.
Personne n'imagine devoir changer les piles toutes les semaines d'un objet connecté. Un changement tous les 6 mois est déjà à la limite de l'acceptable. Idéalement, en ce qui me concerne, j'imagine une durée de vie des batteries d'un an au minimum.
Nous allons donc essayer d'étudier comment alimenter notre montage sur batterie, quels accu choisir et surtout à quelle autonomie pourrons nous prétendre.

Le choix des batteries / accu 

Pour réaliser le montage final j'ai décidé d'utiliser des accu de type 18650. Pourquoi ceux ci plutôt que des piles ou des accu classiques AA ou AAA ? Parce que les 18650 fournissent une tension de 3.7V et je me dis que c'est bien pratique pour tous les montages à base d'Esp8266 qui nécessitent d'être alimentés en 3.3V. Je pense que ces derniers vont pouvoir supporter du 3.7V d'autant plus qu'au fil de la décharge la tension doit baisser un peu.

De plus, bien qu'on ne les trouve pas dans la grande distribution, ce type d'accu est très répandu et standardisé. On trouve donc facilement sur les boutiques en ligne tout les accessoires nécessaires : boîtiers, adaptateurs, chargeurs ...

J'ai fait quelques recherches sur mes sites préférés et après avoir lu les commentaires et les notes des différentes produits, voici ceux que je me suis procuré. J'ai choisi un lot de 4 que vous pouvez trouver ICI.

Accu 18650 3,7V 

Et concernant le chargeur, je n'en avais pas qui pouvait charger ce type de batterie. Et là je me suis fait plaisir à mon coté geek ! Je choisi un chargeur capable de recharger 4 batteries de manière indépendantes avec un affichage de la charge, la tension, le temps de charge indépendant pour chacun des accus ! Ce chargeur est compatible avec une foultitude de formats : AA/ AAA/ AAAA/ C batterie 26650 / 18650 / 18500, 18350, 17670, 17500, 16340, 14500, 10440 ...  Le top du top!
Il n'est pas donné mais parfois il faut savoir se faire plaisir. Vous le trouverez ICI.

Chargeur intelligent Universel


Et il y a deux cerises sur le gâteau :

  1. On peut le brancher avec une prise jack classique mais aussi en USB depuis un ordinateur ou un chargeur USB.
  2. Il dispose d'une sortie USB qui permet de l'utiliser comme batterie externe ou Power Bank pour vos appareils en USB. 
En plus il fait batterie externe !

Boite support batterie 18650





Pour finir, j'ai également commandé ICI, des boîtiers qui me permettront de placer ces accus de manière unitaire. Etant donné le petit prix, j'en ai pris une dizaine afin de pouvoir en associer plusieurs ensemble en fonction de mes besoins.





Calculs de l'autonomie

Maintenant que nous savons quels accus nous allons utiliser, nous allons nous livrer à des calculs d’apothicaire pour essayer d'estimer l'autonomie possible pour notre montage.

Calcul de la capacité disponible 

Commençons par étudier quelle capacité électrique nous allons avoir à disposition.

Les accus 18650 que j'ai acheté, présentent une capacité affichée de 2400mAh. Par expérience je sais qu'entre un affichage marketing et la réalité, il y a souvent une différence. Pour prendre un peu de marge je vais considérer que cette différence est de 20%. Donc je peux compter sur 1920mAh par accu.
Si nous mettons en parallèle 2 ou 4 accus nous allons avoir respectivement 3,84Ah et 7,68Ah d'électricité disponible.

Calcul des consommations électriques 

Le montage que nous allons réaliser va associer différents composants qui vont consommer de l’électricité.
Déjà il va y avoir le microcontrôleur. D'après ce que j'ai pu trouver lors de mes recherches l'Esp01 consomme en moyenne :
  • 170mAh en fonctionnement normal.
  • 20µAh en mode DeepSleep. 
Ensuite nous allons avoir besoin d'une résistance de pulldown. Pour cela, j'ai utilisé une résistance de 100㏀. Pour simplifier les calculs je vais considérer que la perte d'énergie due à cette résistance est constante. La consommation est calculée avec la fameuse formule U=RI. 

Pour finir, je vais prendre une marge et appliquer un coefficient de correction à toutes mes consommations. Je vais considérer que j'ai encore une consommation supplémentaire de 20%. 

Tableaux de résultats 


Le tableau ci-dessous calcul la consommation électrique quotidienne pour les éléments que nous venons de voir : 

Eléments de consommation
Consommation
(en A)
Durée
(en s par jour)
Courant consommé
(par jour et en Ah)
Proportion de la conso totale
Fonctionnement nominal de l'Esp avec connexion wifi (2 fois par jour pendant 12s).
0,17
24
0,001133333
38%
Mode Deep Sleep
0,00002
86376
0,000479867
16%
Résistance de pull down
0,000037
86400
0,000888
30%
Coefficient de correction 80%

86400
0,00050024
17%
Totaux
0,170057

0,00300144
100%

Le tableau ci-dessous donne la durée d'autonomie espérée en heures, jours, mois et années et en fonction du nombre d'accus que nous pourrons utiliser (1,2 ou 4) : 

Capacité pile
(en Ah)
1,92 3,84 7,68
Durée pile (en heures) 639,69 1279,39 2558,77
Durée pile (en jours) 26,65 53,31 106,62
Durée pile (en mois) 0,89 1,78 3,55
Durée pile (en années 0,07 0,15 0,30

En conclusion, nous voyons que nous sommes assez loin des 6 mois d'autonomie espérée. 
Avec un accu, nous pouvons espérer environ 1 mois et jusqu'à 4 avec 4 accus. Ceci est insuffisant pour faire un objet connecté viable et utilisable sur le long terme. Toutefois, le premier tableau nous montre que le fonctionnement nominal de l'ESP consomme moins de 40% de la consommation totale. Nous voyons donc d'emblée des pistes d'optimisation si nous trouvons des moyen de supprimer la résistance de pull down et aussi de réduire la consommation du mode sommeil. 
Parmi les autres pistes d'optimisation il y a également la durée nécessaire à l'ESP pour se connecter au wifi et envoyer l'information demandée. Par exemple en associant une adresse IP fixe au module on réduit les échanges DHCP. 
Et pour finir, il y a également des possibilités d'augmenter la capacité électrique dont nous allons disposer. Soit en utilisant des accus de plus grande capacité, soit en en utilisant plus, soit en associant des mécanismes qui nous permettront de regagner en charge, tels que des panneaux solaires. 

Au final, je vais continuer mon expérimentation avec un seul accu. J'étudierais toutes les optimisations possibles et le gain réel que nous pourrons escompter dans un prochain article. Mais en faisant un rapide calcul sur la base de : 

  • Optimisation consommation du fonctionnement de l'ESP 
  • Réduction de l'utilisation du pulldown et du deep sleep.
  • Augmentation de la capacité des accus (jusqu'à 15000mAh). 
⇰ je pense pouvoir dépasser largement la durée d'autonomie de 12 mois ! 


Mais pour le moment nous n'en sommes pas encore là et il nous reste du plain sur la planche avant de penser aux optimisations à venir. 

Utilisation du microrupteur avec l'ESP 01 

Après toutes ces grandes théories (et après une petite page de pub) nous allons nous lancer dans la pratique.







Généralités sur la cible à atteindre ! 

Vision globale : 

L'idée est de construire un objet connecté qui pourra se fixer sur les volets et qui va ressembler à quelque chose comme ça :



Le fonctionnement sera très simple : 

  1. Quand le volet est ouvert, le microrupteur du haut sera appuyé, alors que celui du bas sera relâché. 
  2. Quand le volet sera dans un état intermédiaire, les deux microrupteurs seront relâchés. 
  3. Quand le volet sera fermé, ce sera le microrupteur du bas qui va être appuyé alors que celui du haut sera relâché. 

Voici sur un schéma ce que cela donne : 

L'objet connecté que nous allons réaliser sera fixé à l'intérieur du volet de sorte à ce qu'il soit le plus discret possible. 

Pour arriver à ce résultat, nous allons voir comment câbler l'Esp, écrire le programme et pour commencer nous constituer un petit environnement de test qui va nous permettre de nous doter d'outils afin de contrôler nos montages avant de les fixer de manière plus stable et de débuger les programmes.

Principe de fonctionnement : 

Je suis persuadé qu'il existe des milliers de manière de réaliser cet objet connecté avec un Esp.
J'en ai essayé plusieurs. J'ai aussi connu quelques échecs, dont certains ont été traumatisants ! Comme celui ou une fois arrivé au but je me suis rendu compte d'un comportement spécifique du mode DeepSleep de l'Esp qui remettait en cause tout ce que j'avais fait jusqu'ici. Des heures de montage, d'essais, de calculs à reprendre depuis le début. 😢

Le principe de fonctionnement que je propose répond aux critères suivants : 

- Pour économiser de l'énergie, le microcontrôleur doit être en mode économie d'énergie  le plus possible. Ce mode n'est possible que si le microcontrôleur est éteint ou en sommeil profond.
- Lorsque le volet s'ouvre totalement, le microcontrôleur doit se réveiller, détecter que le volet est ouvert (et pas fermé), envoyer l'information au serveur domotique et se remettre en mode économie d'énergie.
- Lorsque le volet est en position intermédiaire, qu'il se ferme ou s'ouvre, le microcontrôleur n'a rien à faire. Il peut donc être en mode économie d'énergie.
- Lorsque le volet est fermé le microcontrôleur doit se réveiller, détecter que le volet est fermé (et pas ouvert), envoyer l'information au serveur domotique et se remettre en mode économie d'énergie.

De plus, pour une première expérimentation, j'ai du prendre en compte les contraintes suivantes :
- Je n'ai pas de compétences évoluées en électronique. Donc je n'étais pas capable de créer un circuit complexe.
- Je n'ai pas beaucoup de composants électroniques à disposition. J'ai juste acheté un kit de base (comme celui ICI) qui me permet de disposer du strict minimum (résistances, LED, condensateurs ...). Mais rien de suffisant pour faire des circuit complexes embarquant des portes logiques par exemple.

Pour finir, l'objectif de cet article est de poser les bases de l'utilisation d'un Esp01 et d'étudier comment créer un objet connecté qui puisse être en autonomie sur batterie. Pas de réaliser un projet parfait mais au contraire nous permettre d'acquérir des connaissances pour ensuite aller plus loin dans la découverte d'autres composants qui permettront d'optimiser le fonctionnement et surtout la consommation électrique. Et j'ai déjà quelques idées pour l'avenir ...

Le mode de fonctionnement que je vais proposer, répond à ces critères. Le montage sera le plus simple possible. La sortie du microcontrôleur du mode sommeil sera basée sur une remise sous tension après coupure. La coupure aura lieu quand le volet devra changer de position pour passer de fermé à ouvert ou d'ouvert à fermé.
Bien sur pour un montage qui doit se réveiller 10 fois par seconde, ce fonctionnement ne serait pas réaliste. Par contre, pour des volets qui vont s'ouvrir et se fermer deux ou trois fois maximum par jour, il n'y a pas de risque d'endommager les composants en fonctionnant ainsi.


L'algorithme de fonctionnement que je propose est le suivant :

Quand le volet est ouvert et fermé, l'Esp a besoin d'être alimenté car il doit envoyer un message au serveur domotique. Lorsque le message indiquant l'état du volet aura été envoyé au serveur, alors le microrupteur se mettra en mode sommeil profond réduire au maximum sa consommation électrique.

L'Esp sera alimenté sur sa broche Vcc par les deux micro-rupteurs qui auront chacun :

  • Leur broche COM reliée au 3.3V de l'alimentation.
  • Leur broche NO reliée à la broche Vcc du microrupteur. 

Ainsi, quand au moins un des deux microrupteur sera enclenché, l'Esp sera alimenté. Ce sera le cas quand le volet sera en bas ou en haut. Entre ces deux positions, le microrupteur ne sera pas alimenté.

Donc, lorsque le volet arrive en fin de course, que ce soit en position haute ou basse, le microcontrôleur va passer d'un état "hors tension" à "alimenté".
Le fait d'avoir coupé l'alimentation quelques secondes (3 secondes environ) et puis ensuite de la remettre, fait sortir le microrupteur du mode sommeil.

Lorsqu'il démarre, le microrupteur se connecte au wifi. Ensuite il doit regarder si le volet est en état haut ou bas.
Pour cela, nous dédions la broche NC du microrupteur haut qui sera raccordé à la broche Rx du microcontrôleur. La broche Rx sera configurée comme GPIO03.
Une résistance de pull down devra être installée sur cette broche afin que, lorsque le microrupteur est ouvert par rapport sur la broche NC, le microcontrôleur puisse lire un état LOW (volet en haut) . Et il lira l'état HIGH lorsque le microrupteur sera relâche (volet en bas). 
Nous ne pouvons pas utiliser les broches GPIO00 et GPIO02 car ces dernière doivent être fixée en état HIGH lorsque le microcontrôleur démarre. Hors, lorsque le volet sera ouvert, la broche NC du microrupteur du haut sera à l'état "ouvert". Donc avec la résistance de pull down que nous allons devoir mettre en place, nous aurons un état LOW sur la broche qui y est raccordée.


Une fois que le microcontrôleur aura déterminé si le volet est ouvert ou fermé, il envoi l'information au serveur domotique et il se remet en mode économie d'énergie.


Pour réveiller le microcontrôleur, on s'appuie sur le passage du volet en état intermédiaire. Cet état va couper l'alimentation qui sera remise quand le volet sera à nouveau totalement fermé ou ouvert.

Bon si tout cela ne vous semble pas très clair, pas d'inquiétude, je vais mettre quelques schémas.

Vision schématique du circuit :

Les 3 schémas ci-dessous montrent comment sera câblé notre montage dans sa version de test et comment le circuit réagit dans les différents états possibles qui sont :

  1. Volet haut ou ouvert.
  2. Volet en position intermédiaire
  3. Volet en position basse ou fermé.

Dans la version finale, nous n'aurons plus besoin du traducteur série. Les connexion traducteur-GND et TXD pourront être simplement retirées.



Le volet est en position ouverte : l'esp est alimenté et la broche de détection DT est à LOW par la résistance de pull down.




Le volet est en position intermédiaire. L'alimentation est coupée. 



Le volet est en position basse. L'alimentation est activée et la broche DT est à HIGH.

Maquette et environnement de tests

Avant de nous lancer dans la construction de l'objet finalisé, il va falloir le concevoir. Et pour cela nous allons passer par une phase de maquettage sur breadboard et de débugage intensif à coup de message de debug sur la liaison série.
En ce qui concerne le matériel que j'ai utilisé vous en trouverez la liste dans l'annexe à cet article intitulé de manière très pertinente "Liste des courses" ICI

Socle d'accueil de l'Esp 

L'Esp-01 ne peux pas se connecter directement sur une breadboard. Pour pouvoir le raccorder facilement à une breadboard et exploiter ses broches de manière unitaires, il va falloir se créer un petit socle dans lequel l'enficher.
Ceci n'est pas obligatoire du tout et vous pouvez relier les différents éléments par des câbles Dupont.
Pour ma part j'ai eu envie de réaliser ce socle pour mettre en ligne les différentes broches de l'Esp et aussi pouvoir changer la puce sans avoir à tout recâbler à chaque fois.




Il y a quelque temps j'avais acheté un lot de barrettes de connexion compatibles avec les broches standard d'écartement 2,53mm. Je vais les utiliser et les souder sur une plaque PCB afin d'avoir d'un coté un socle de 2*8 broches afin d'enficher l'Esp et de l'autre coté une ligne de 1*8 pour récupérer chaque broche.
Je souderais en dessous les liaisons 1 pour 1 de chaque broche.


C'est pas simple à écrire alors voici en image ce que donne le résultat : 


J'ai collé une étiquette sur la ligne pour identifier à quelle broche de l'Esp correspond la position.
Ce petit montage va nous permettre de relier l'Esp soit au traducteur FTDI (comme on le voit sur la 4ième photo en bas à droite) ou alors de relier l'Esp à une breadboard. Une fois le montage réaliser on pourra changer l'Esp facilement sans avoir à toucher au câblage.

Le programme de test 


Le but est de monter l'installation sur breadboard et de valider en suivant un maximum de log sur la liaison série que tout fonctionne correctement.

/*
  Volets :
  ========
  Programme pour ESP01s :
    - Se connecte au wifi
    - Lecture de l'état de la broche définie par DT
    - Envois de la valeur On ou Off au serveur domotique via l'appel d'une URL.

  Notes :
    - La constante LED_BUILDIN ne fonctionne pas sur ESP01s qui est associée à GPIO2


  Versions :
    -v3 : DT est configurée en INPUT. La résistance de PULL_UP est gérée en externe.
*/
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

/*===================================================================
 * Constantes
 ====================================================================*/
// Quand on compilera la version finale on désactivera le mode debug.
#define DEBUG true

#define GPIO0 0 //Doit être sur + au démarrage si sur - démarre en mode programmation
#define SGL_RST 1 // Tx ou GPIO01 doit etre connecte sur RST pour que la fonction reboot fonctionne
#define DT 3 // GPIO3 ou Rx : Pin GPIO pour savoir si microrupteur sur - ou ouvert (doit avoir une resistance de pullup).
#define LED 2 // Pin GPIO associée à la LED (c'est GPIO02 sur un esp01s)


// temps maxi d'attente pour se connecter au wifi
#define MAX_TIME_WAIT_WIFI 60

// Idx du switch domoticz a mettre à jour
#define DOMOTICZ_SWITCH 1516

/*=====================================================================
 * Variables
 =====================================================================*/

/* Variables pour le wifi */
IPAddress oipIpEsp(192, 168, 1, 61);
IPAddress oipGateway(192, 168, 1, 1);
IPAddress oipSubnet(255, 255, 255, 0);
IPAddress oipDns(192, 168, 1, 1);

const char* sSsid = "Livebox";
const char* sPassword = "mot de passe top secret";
const char* sHostname ="esp01-1";

/* Variables pour le serveur domotique */
char *sDomoticzIp = "192.168.1.150";
int iDomoticzPort = 8080;

/* Variables globales */
bool bValeur = true;

/*=====================================================================
 * Setup
 * =====================================================================*/
void setup() {
 // -----------------------------------------------------------------------------------------------------
 // Variables locales
 // -----------------------------------------------------------------------------------------------------
  byte tbMac[ 6 ] = {0,0,0,0,0,0};

 // -----------------------------------------------------------------------------------------------------
 // Initialisation port série
 // -----------------------------------------------------------------------------------------------------
#if DEBUG
  Serial.begin(115200);
  delay( 100 );
  Serial.println( "\nInitialisation liaison serie : OK" );
#endif

 // -----------------------------------------------------------------------------------------------------
 // Initialisation Wifi
 // -----------------------------------------------------------------------------------------------------
  WiFi.config(oipIpEsp, oipGateway, oipSubnet, oipDns );
  delay(100);
  WiFi.disconnect(1); // utile en cas de connexion/deconnexions successives.
  WiFi.begin( sSsid, sPassword );
  delay( 1000 );

  // On va attendre que la connexion s'établisse
  int iCompteur = 0;

#if DEBUG
  Serial.printf("Connection status: %d\n", WiFi.status());
  Serial.print( "Connecting WiFi ." );
#endif

  while (WiFi.status() != WL_CONNECTED ){
    delay( 1000 ); //on attend une seconde

#if DEBUG
     Serial.print( "." );
#endif

     if ( iCompteur++ > MAX_TIME_WAIT_WIFI ) {
       // On a dépassé le temps maxi autorisé pour se connecter. On reboot l'ESP.
        vFonctionReboot();
        // Si ces lignes sont executee c'est que le wifi ne s'est pas connecte
        // ET que le reboot n'a pas fonctionné (pb de broches ?)
        // On met donc l'esp en mode sommeil pour economiser la batterie
        ESP.deepSleep( 0, WAKE_RF_DISABLED );
     }
  }

#if DEBUG
  String stRes = "\nConnected to : " + String( sSsid );
  stRes += "\nAdresse IP : ";
  stRes += WiFi.localIP().toString() ; //Type IPAddress = tableau de 4 entiers.

  WiFi.macAddress( tbMac ); //récupère l'adresse MAC
  stRes += "\nAdresse MAC : ";
  for (int i = 0; i<=5; i++ ) {
    if ( i == 0 ) stRes += String( tbMac[ i ], HEX );
    else stRes += "." + String( tbMac[ i ], HEX );
  }
  Serial.println( stRes );
#endif

  // -----------------------------------------------------------------------------------------------------
  // Initialisation des broches
  // -----------------------------------------------------------------------------------------------------

  // initialise la broche Detection
  pinMode( DT , INPUT );
  }


/*=====================================================================
 * Loop
 * =====================================================================*/
void loop() {
// Variable pour la valeur à envoyer au serveur domotique en fonction de l'état du volet.
  String osValue = "";

#if DEBUG
if ( bValeur == true )  Serial.println( "bValeur0 == true" );
 else Serial.println( "bValeur0 == false" );
#endif

 // On calcul l'état du volet sur la base de la broche NC du microrupteur du haut.
 // Si NC est HIGH : le volet est baissé => on renvoi Off
 // Si NC est LOW : le volet est ouvert => on renvoi On.
 int iDt = digitalRead( DT );
 if ( iDt == HIGH ) {
    bValeur = false;
    osValue = "Off";
 } else {
  bValeur = true;
  osValue = "On";
 }
#if DEBUG
 Serial.println( "Etat du volet : " + osValue );
 delay( 2000 );
#endif

  // On envoi la valeur à domoticz
  int iResCallDomo = iEnvoiDomoticz(  osValue );
#if DEBUG
  switch ( iResCallDomo ){
    case 0 :
      // L'appel de la fonction c'est bien passé
      Serial.println( "iEnvoiDomoticz OK" );
      break;
     default :
      // On a un code <> 0 donc il y a une erreur.
      // Les codes erreurs sont 1,2.
      Serial.println( "iEnvoiDomoticz NOK" );
      break;
  }
#endif


#if DEBUG
  Serial.println( "On passe en mode sommeil" );
#endif

  ESP.deepSleep( 0, WAKE_RF_DISABLED );
}


/*=====================================================================
 * Fonction lance le reboot de l'ESP en placant D0 à LOW
 * La broche SGL_RST doit etre connectée sur RST pour que la fonction reboot fonctionne
 * =====================================================================*/
 void vFonctionReboot(){
#if DEBUG
     Serial.println( "Dans vFonctionReboot" );
#endif

    pinMode( SGL_RST, OUTPUT );
    digitalWrite( SGL_RST, LOW ); //Broche "SGN_RST"  connectée sur RST obligatoire sinon ne fonctionne pas
 }


/*=====================================================================
 * Fonction pour mettre a jour le capteur dans domoticz
 * =====================================================================*/
int iEnvoiDomoticz( String osValue ){
  String osUrl = "";
  HTTPClient oDomoticzClient;
  int iRes = 0;

#if DEBUG
  Serial.println( "Start fonction iEnvoiDomoticz" );
#endif


  // Construction de l'URL
  // Cette URL sera a adapter en fonction de votre installation domotique. La mienne est valable pour domoticz. 
  osUrl = "/json.htm?type=command&param=switchlight&idx=";
  osUrl += String( DOMOTICZ_SWITCH );
  osUrl += "&switchcmd=";
  osUrl += String( osValue );

#if DEBUG 
  Serial.print( "Url d'appel domoticz = " );
  Serial.println( osUrl );
#endif

  oDomoticzClient.begin( sDomoticzIp, iDomoticzPort, osUrl );
  int iHttpCode = oDomoticzClient.GET();
   if ( iHttpCode ){
    if ( iHttpCode == 200 ){
#if DEBUG
      String osPayload = oDomoticzClient.getString();
      Serial.println( "Domoticz response" );
      Serial.println( osPayload );
#endif
      iRes = 0;
    } else {
#if DEBUG
      String osPayload = oDomoticzClient.getString();
      Serial.println( "Domoticz response error " );
      Serial.println( osPayload );
      Serial.print( "Adresse IP ESP : " );
      Serial.println( WiFi.localIP().toString() );
      Serial.print( "iHttpCode : " );
      Serial.println( iHttpCode );
#endif
      iRes = 1;
    }
  } else {
#if DEBUG
    Serial.println( "Domoticz not response" );
#endif
    iRes = 2;
   }
  oDomoticzClient.end();

  return iRes;
 }



Mon montage de test 


Maintenant que nous avons le programme, nous allons réaliser la maquette de notre montage pour en tester le bon fonctionnement. 

La première chose à faire est de placer l'Esp sur la platine que nous avons réalisée précédemment. Si vous ne l'avez pas, ce n'est pas très important et il vous suffira de raccorder directement les câbles dupont depuis l'Esp sur la breadboard au lieu de câbler comme ci-dessous depuis la platine.
L'avantage de passer par cette platine est qu'une fois le câblage réalisé, nous pourrons changer de microcontrôleur très facilement.
Si vous raccorder directement l'Esp à la breadboard il vous faudra des câbles Dupont M-F (Male - Femelle).

L'Esp sur sa base prêt à être raccordé.

Dans un second temps, nous allons câbler notre breadboard.
Les numéros de 0 à 13 décrivent les étapes pour arriver au montage ci-dessous.



L'étape 0 consiste à placer une alimentation sur la breadboard. Je l'ai placé de cette manière afin de garder toute les lignes + et - à disposition pour l'Esp et surtout afin de contrôler ces dernières avec les microrupteurs. Si vous n'avez pas de breadboard vous pourrez la trouver ICI. Et si vous ne savez pas ce qu'est une breadboard (on dit aussi plaque d'essai en français) vous pouvez regarder la vidéo de Tronik Aventur qui traite du sujet ICI.
Concernant l'alimentation vous pourrez en trouver un lot de 6 ICI. C'est toujours pratique d'en avoir plusieurs et par 6 elles coutent moins de 2 euros chacune. Avec un cavalier vous pouvez régler la tension de sortie que vous souhaitez, au choix entre 3.3V et 5V.
Mais attention, ne faites pas la même erreur que moi en laissant sur 5V alors que pour l'Esp01 il faut du 3.3V.
Voici la description des autres connexions que j'ai réalisé : 

  1. J'ai placé une LED avec une résistance (220Ω) alimentée par la ligne que je destine à l'alimentation de l'Esp. Cette LED me sert juste à contrôler si l'alimentation est active. Dans le montage final, bien entendu, il n'y en aura pas pour économiser l'énergie.
  2. Ces deux cables sont raccordé au Vcc et au GND de l'Esp. 
  3. CH_PD est raccordé au 3.3v.
  4. RST est raccordé au 3.3v.
  5. GPIO02 est raccordé au 3.3v.
  6. GPIO00 est raccordé au 3.3v. Quand nous voudrons démarrer l'Esp en mode programmation il faudra déplacer ce câble sur GND, mettre l'alimentation et après une seconde le replacer sur 3.3V. 
  7. Résistance de pulldown. Cette dernière est entre la broche Rx (GPIO01 dans notre cas) et la broche NC du microrupteur correspondant au volet position haute. J'ai fait le test avec deux types de résistances : 10kΩ et 100kΩ. Les deux fonctionnent. Donc je vais garder la 100kΩ pour minimiser encore plus la déperdition électrique. Edit : Après plusieurs essais j'ai remarqué une instabilité dans la liaison série qui a pu être corrigée en utilisant la résistance de 10kΩ. Par contre dans le montage final, lorsque la liaison série ne sera plus utile, je remettrais la résistance 100kΩ pour minimiser la perte d'énergie.
  8. Cette ligne de la breadboard permet de connecter la broche Rx (en vert) au NC (le fil orange) du microrupteur. 
  9. Correspond au VCC de l'alimentation. Ce fils va être connecté aux deux broches COM des deux microrupteurs. Pour cela j'utiliserais des cordons à pince crocodile comme ceux que vous pouvez trouver ICI.
  10. Le GND de l'alimentation vers la ligne GND qui va alimenter l'Esp. 
  11. On utilise une des broches du dessus de l'alimentation pour raccorder les poles moins (GND) de l'alimentation au moins du traducteur FDTI. 
  12. Malgrès sa couleur noire, ce cordon est dans la ligne VCC de la breadboard et il correspond au retour (broche NO) du microrupteur associé au volet du haut. 
  13. Idem que le précédent mais correspond au microrupteur du volet bas. 

Raccordement des microrupteurs

Les schéma ci-dessous, avec la légende associé, montre comment j'ai raccordé les microrupteurs.



  1. Les deux microrupteurs vont recevoir sur leurs broches COM le Vcc de l'alimentation (fils verts sur la photo).
  2. Les broches NO des deux microrupteurs viennent raccorder la ligne VCC qui va alimenter le microcrontroleur. Ainsi, lorsqu'un des deux microrupteurs va être actionné, l'alimentation va être activée. 
  3. La broche NC du microrupteur haut sera raccordée à la broche Rx de l'Esp. Broche Rx qui s'utilise comme GPIO01. Sur la même ligne de jonction des ces fils, on retrouve également le départ de la résistance de pulldown (qui de l'autre coté sera raccordée au GND). 

Téléversement du programme 

Si ce n'est pas déjà fait, pour finaliser notre maquette, nous allons devoir téléverser le programme.
Pour ma part j'utilise l'IDE Arduino.
Etant donné que le module Esp est installé sur son socle, nous allons devoir le raccorder au module FTDI avec des fils dupont.  Le schéma ci-dessous et la légende associée montrent comment raccorder l'Esp01s au module FTDI qui sera ensuite placé sur un port USB du PC.



  1. Raccorder le GND du module FTDI au GND de l'alimentation. Nous avons vu l'arrivée de ce cable sur l'alimentation de la breadboard dans les schémas ci-dessus.
  2. Ce cordon bleu foncé correspond à la broche Tx de l'Esp. 
  3. Le cordon bleu clair correspond à la broche Rx de l'Esp. Dans les schémas précédent nous avons vu que ce fil est raccordé sur la breadboard sur la même ligne que la broche NC d'un microrupteur et avec la résistance de pulldown. Pour injecter le programme il faudra donc reprendre ce fil et le placer sur le module FTDI. Il pourra être remis à sa place une fois le téléversement terminé. 
  4. Les deux fils que l'on apperçoit sur la photo sont ceux que nous avions soudé sur le module pour le passage en mode programmation de l'Esp. Etant donné que l'Esp n'est pas sur la base du module FTDI, il n'est pas utile que ces deux fils soient raccordés entre eux. Par contre il faudra agir sur le cablage du fil GPIO00 de la manière suivante : 
    • Eteindre l'alimentation.
    • S'assurer que tous les raccordements présentés ci-dessus ont été réalisés. 
    • Placer le fil du GPIO00 dans la ligne d'alimentation GND de la breadboard. Si on se réfère à la photo précédente qui montrait comment cabler la breadboard, il s'agit ici de faire passer le fil de l'étape (6) sur le GND au lieu du VCC. 
    • Alumer l'alimentation.
    • Remettre le fil GPIO00  à sa place initiale : sur VCC. 
Une fois ces étapes réalisées l'Esp va démarer en mode programmation. Nous pouvons maintenant demander le téléversement du programme dans l'IDE Arduino. 

S'il y a un problème, éteignez l'alimentation et rédémarer l'Esp en suivant l'étape (4) : pour passer en mode programmation l'esp doit démarrer avec un pulse sur GND sur GPIO00.

Finalisation des tests

Maintenant que nous avons tout cablé et que nous avons notre environnement de test prêt, il ne reste qu'a ajouter un capeur virtuel dans notre serveur domotique.
Pour ma part j'ai juste ajouté un switch virtuel (dont l'idx est 1516) à domoticz.

Lorsque l'on appuie sur le microrupteur du haut, on doit voir la LED qui s'alume et après quelques secondes le switch passer à "On" (alumé ou ouvert).



Lorsque l'on appuie sur le microrupteur du bas, on doit voir la LED qui s'alume et après quelques secondes le switch passer à "Off" (alumé ou ouvert).


Test réussi ! Si vous n'arrivez pas à ce résultat du premier coup et que vous galérez un peu c'est normal. Ne vous inquiétez pas. Les principales sources de problèmes sont la cablages. Vérifiez qu'ils sont aux bons endroits et aussi qu'ils sont stables. 

Coté PC vous devriez pouvoir suivre les traces du programme depuis le moniteur série.

Le programme et le montage final


L'objectif de cet article était de montrer comment utiliser l'ESP01 et de l'associer avec un microrupteur. Le projet final, tel que je l'ai adapté à mon contexte n'est pas l'essentiel. De plus, à ce jour (02/05/2018) mon installation est encore en cours de finalisation. Ce paragraphe sera donc complété au fur et à mesure de mes avancées.

Les principales différences entre la maquette et le montage final sont : 
  • L'agencement du montage : je vais cabler le tout sur un PCB et les jonctions des fils seront soudées afin d'avoir des connexions sures sans perturbations électriques.  De plus il devra y avoir sur le PCB un composant qui transformera la tension reçue de 5V en 3.3V et la LED de test de mise sous tension sera supprimée.
  • L'emplacement des microrupteurs : En fonction de l'espace que je vais trouver pour placer le montage, il se peut que je sois obligé de placer les microrupteurs à un autre endroit que prévu, à distance de l'esp et reliés à ce dernier par des fils plus longs. Ces fils seront soudés. 
  • Le remplacement de l'alimentation de breadboard par une alimentation sur batterie. J'ai d'ailleurs acheté une batterie USB externe (comme celle ICI mais en moins bien car le mienne n'est que de 2600mAh et surtout ne peut pas être chargée en même temps qu'utilisée).
  • L'ajout d'un condensateur aux bornes de l'alimentation pour stabiliser la tension.
Les principales différences entre le programme de test et le programme final sont : 

  • Compilation et téléversement sans l'option DEBUG.

Annexes

Quelques problèmes rencontrés et leurs solutions


L'ESP est bien alimenté, on constate une bref impulsion de la LED bleue mais il ne fonctionne pas. Vérifier que :
  • CH_PD : chip power-down doit être raccordé au 3,3V.
  • RST : doit être raccordé au 3.3V également.
Impossible de recevoir les messages depuis la liaison série. Vérifier que :

  • La vitesse de transmission correspond bien à la vitesse de l'ESP : 9600 bauds pour les anciens, 115200 pour les ESP01S.
  • Le mode fin de ligne avec caractères NL et CR est bien activé. 
  • TX/RX ne sont pas inversé. 
La liaison série envoie des caractères spéciaux ou bizares de manière discontinue :

  • Reliez le GND du traducteur FTDI au GND de l'alimentation de l'ESP. 
  • La liaison série n'arrête pas de se réinitialiser suite à un problème de perturbation électrique sur un câble ou une mauvaise connexion. En réalité l'ESP rejoue sa séquence de boot. Vérifiez vos connexions physiques.
Comportements étranges  :

  • Ne mélangez pas deux sources d'alimentation. Par exemple en utilisant une alimentation externe sur pile ou breadboard avec l'alimentation de l'adaptateur FTDI.
  • Les principaux problèmes que j'ai rencontré avec des comportements étranges et imprévisibles de l'Esp à tout moment mais principalement au boot, étaient dus à des problèmes de connexions électriques. Soit un port USB instable, soit un câble dupond mal enfiché, soit une pince crocodile qui faisait mal la connexion. Réalisez ces branchements avec soins et utilisez une source d'alimentation stable et délivrant suffisamment de puissance. 
  • J'ai aussi grillé un ESP01 en le connectant à une source en 5V. Ce dernier a continué à fonctionné mais son comportement est devenu imprévisible. J'ai mis du temps à identifier qu'il s'agissait de l'Esp et pas de mon programme ou des câblages. Prévoyez un ou deux Esp de secours pour tester et comparer les comportements. 
Impossible de téléverser le programme :

  • Votre logiciel de programmation retourne un message d'erreur qui ressemble à celui-ci : 

esp_com open failed
error: Failed to open COM33
error: espcomm_open failed
error: espcomm_upload_mem failed


Le microcontrôleur n'est surement pas passé en mode UART : assurez vous d'avoir bien démarré avec GPIO0 sur RST et ensuite replacé GPIO0 sur HIGH (ou laissé libre).

  • Sur la liaison série vous voyez apparaître des messages du type : ets Jan  8 2013,rst cause:4, boot mode:(3,7)

Les significations de "rst cause" sont :
    • 0: 
    • 1: normal boot
    • 2: reset pin
    • 3: software reset
    • 4: watchdog reset

Améliorations à venir 

Ce premier article sur l'ESP01 nous a montré comment prendre en main cette puce qui est selon moi une petite merveille malgrès tous les défauts qu'elle présente. Ne serait-ce que par sa petite taille elle permet d'imaginer des centaines d'applications possibles.
Dans de prochains articles j'ai pour projet d'étudier un peu plus en profondeur comment réaliser des circuits électroniques avec des condensateurs, des transistors et des relais. Sans aller très loin afin de rester accessible, je pense que la connaissance et la maîtrise de ces composants de base, vont nous permettre, associé a un Esp01, de réaliser de grandes choses.
Parmi ces évolutions que je souhaite étudier, il y a notamment la possibilité pour notre circuit d'être alimenté par une simple pression sur un microrutpeur, et une fois le traitement réalisé, de couper lui même sa propre alimentation. Ainsi nous pourrons espérer économiser encore plus d'électricité et d'avoir des objets connectés réellement autonomes sur la durée. 

Sites à consulter pour aller plus loin  

Pour écrire cet article j'ai passé beaucoup de temps à faire des tests, à lire des documents et aussi des sites sur internet. Parmis ces derniers je voudrais citer :


Liste des courses

Vous trouverez ci-dessous des liens pour vous procurer tout le matériel que j'ai utilisé dans cet article.



ESP01: Module ESP8266 ESP-01S
Adaptateur USB pour module ESP8266 :

  • Comme le miens ICI 
  • Avec le bouton qui permet de passer en mode programmation sans avoir de fils à souder : ICI.

Pour pouvoir alimenter l'Esp avec plusieurs piles, avec une somme des tensions pouvant aller jusqu'à 12V : 3.3V Output AMS1117-3.3 V DC/DC Power Supply Module Voltage Regulator 

Pour alimenter l'Esp avec une source allant jusqu'à 12V mais en soudant vous même le composant : Régulateur De Tension Linéaire De 5Pcs LD1117V33 3.3V 800Ma TO-220


Un lot de barrettes de connexion compatibles avec les broches standard d'écartement 2,53mm :
20 Pièces 2,54 mm Breakaway PCB Board 40pin mâle et femelle

Des cables dupond ! Lachez vous, c'est pas cher et ça sert toujours. Prenez en de chaque catégories : M-M, F-F et M-F et si vous le pouvez des 10cm et des 20cm. ICI

Des cordons à pince crocodile : Très pratique pour des tests, des mesures, des montages temporaires. ICI.

Des plaques PCB pour réaliser vos montages : 
36 Pièce Plaque PCB Circuit Imprimé Prototype Double Face PCB Board Imprimé Universelle

Des breadboard. Il y a plusieurs modèles disponibles et je vous conseil d'en prendre des 3 : des 830 points, des 400 points et des 170 points. Chacun à son utilité : Platine Électronique d’essai MB-102 Breadboard Prototypage Sans Soudure

Un super chargeur pour geek compatible avec une foultitude de formats : AA/ AAA/ AAAA/ C batterie 26650 / 18650 / 18500, 18350, 17670, 17500, 16340, 14500, 10440 ...  : ICI.

Un lot de 4 accus 18650 recommandés pour leur qualité que vous pouvez trouver  ICI.




Soutenez la blogoculture ...


Le plus simplement du monde, si vous avez un achat à faire sur Amazon, accédez au site à partir de ce lien (que vous pouvez ajouter dans vos favoris)https://amzn.to/2nbe4sm




Soutenez la blogoculture ...


Le plus simplement du monde, si vous avez un achat à faire sur Amazon, accédez au site à partir de ce lien (que vous pouvez ajouter dans vos favoris)https://amzn.to/2nbe4sm


... mais aussi ...


Vous appréciez les articles frais et vitaminés de ce blog et vous voulez faire un geste pour encourager ce partage, saluer le travail, ou parce que vous y avez trouvé des choses utiles ( et que vous êtes sympa ) ?

... c'est possible et vous avez le choix !
Si vous avez un compte Paypal et quelques euros à offrir sans vous mettre sur la paille, subventionnez la culture domotique à l'ancienne !
Vous ne dépenserez pas un radis de plus en faisant un achat sur eBay à partir de ce lien.
Economisez du blé avec Amazon Prime ! Offre d'essais 1 mois gratuit (et renouvelable).
Soyez chou et aidez les petits producteurs de blog à se faire connaitre auprès de vos amis facebook !

Merci

Commentaires