Archives par étiquette : nodemcu

ESP8266 : Wifi Kit 8 en test

Découverte récente sur Amazon du Wifi Kit 8 produit par Heltec :

Sur cette image, nous lui avons monté une sonde de température DS18B20, histoire de faire travailler la bestiole en charge. Cette sonde transmet ses données toutes les 2 minutes sur notre broker MQTT Mosquitto, via une connexion WiFi.

Ce petit ESP8266 dispose d’un écran LCD mais surtout d’une alimentation pour batterie, avec gestion de charge intégrée :

Un simple batterie LiPo de 1000 mAh et vous voici protégé d’une coupure de courant, c’est simple et pourtant radical. Venez ajouter un chargeur solaire sur la prise micro-USB et vous voici en totale autonomie avec un petit IoT très sympa.

Son brochage reste simple, avec de multiples E/S et une unique entrée analogique :

Le flashage sous ESPeasy est possible, il n’a fonctionné ici qu’avec Esptools depuis Ubuntu : jamais Winchose 10 n’a réussi à le flasher, jamais il n’a trouvé le bon port COM. Amis Linuxiens, la solution reste et restera toujours le libre pour bricoler en paix 😉

Retenez par contre qu’ESPeasy nécessitera d’ajouter cette rule pour valider l’afficheur au boot de l’IoT :

On System#Boot do
gpio,16,1
endon

En effet, sans valider le GPiO 16, point d’Oled, c’est ainsi, un petit bug connu sur ce modèle, facile à contourner comme vous pouvez le voir.

Un bon p’tit ESP8266 donc, pas le moins cher, mais sympa si vous avez besoin d’afficher 2 ou 3 lignes d’informations, capable d’être autonome en prime, pas de raison de se priver donc.

MQTT : découverte

MQTT, vous connaissez ? Non, alors allez faire un saut sur Wikipedia par exemple, il s’agit d’un protocole à destination de ces IoT, l’internet des objets, ou encore les objets connectés, ces petits modules qui vont rapidement envahir notre univers et consommer nos adresses IP pour venir communiquer, qui une température, qui une mesure de l’air, une vitesse du vent, une luminosité, un taux de remplissage d’un container, etc.

Curieux, je me suis intéressé à Mosquitto, un serveur que j’ai installé sur un gros serveur Ubuntu d’Ovh, mais qui fonctionnera tout aussi bien sur Raspberry Pi 3 (cherche Google, cherche…). Ce serveur, s’appelle Broker dans le langage des objets connectés.

MQTT va fonctionner avec des topics, c’est à dire des sujets donnés : par exemple /capteur/exterieur/temperature sera un sujet auquel il sera possible d’accéder si l’un de vos IoT diffuse dessus.

De même, /capteur/+/temperature viendra concerner à la fois /capteur/interieur/temperature que /capteur/exterieur/temperature, mais ne lire pas les trames de /capteur/exterieur/pression par exemple.

Pareil, avec /capteur/exterieur/#, vous lirez TOUS les capteurs extérieurs, mais pas l’intérieur.

Nous avons donc des IoT, un Broker, et des clients. L’IoT se connecte au Broker (mode publish), transmet des informations sur un topic donné, peu importe les informations, tout est possible. Le serveur les reçoit et les diffuse aux clients qui sont abonnés (mode subscribe) au bon topic. L’exemple ci-dessous tiré d’internet illustre le fonctionnement de base :

Vous suivez ? Ajoutons qu’on peut sécuriser les connexions par login/mot de passe, voir même basculer en SSL moyennant la génération de certificats.

Imaginons un exemple concret :

un raspberry Pi en broker MQTT
un raspberry Pi abonné à différents topics, chargé d’afficher ce qu’il reçoit
une sonde de température
une sonde de luminosité
un sonde de détection de CO2

Chaque sonde publiera un topic en particulier, via le Raspberry Pi installé en broker. Le Raspberry Pi client pourra alors récupérer via un script Python les différentes valeurs et les afficher sur une page html au fur et à mesure de leur arrivée : vous avez un tableau de bord simple, très économique, et pourrez en permanence mesurer ce que bon vous semble.

En sonde, j’ai utilisé avec succès un simple NodeMcu, basé sur un ESP8266, connecté en WiFi à une box quelconque, programmé avec un script Arduino trouvé au hasard sur internet. J’ai également pu m’exercer à diffuser (= publish) des informations via le terminal d’un portable Ubuntu.

En conclusion de ce rapide billet, sachez que MQTT peut tout faire, et plus encore si vous le reliez à LoraWan : il disposerait ainsi d’une connexion sans fil équivalente à un réseau GSM de base, à moindre coût toutefois. Je pense que nous en reparlerons, ce nouveau monde connecté semble très sympa à explorer, surtout avec l’utilisation de petits sondes à coût très faible.

ESP8266 ESP12 : map des ports GPIO

Il n’est pas toujours aisé d’associer les ports GPIO physiques d’un ESP12 à la valeur à utiliser en programmation d’un script LuA. Voici le brochage d’un ESP12 :

et voici les correspondances que j’ai pu trouver, du moins pour les GPIO utilisables sur ce module :

PORT PHYSIQUE GPIO	PORT SCRIPT LUA
0	3
2	4
4	2
5	1
12	6
13	7
14	5
15	8
16	0

Par exemple, si vous branchez une LED sur le GPIO15 (broche +) et sur la masse (GND), via une résistance de 2k2, vous pouvez utiliser ce script LuA pour la faire clignoter :

gpio.mode(8, gpio.OUTPUT)
gpio.write(8, gpio.LOW)
for i = 1, 4 do
 gpio.write(8, gpio.HIGH)
 tmr.delay(100000)
 gpio.write(8, gpio.LOW)
 tmr.delay(100000)
end

Si vous utilisez la broche GPIO4, dans le script vous remplacerez 8 par 2 :

gpio.mode(2, gpio.OUTPUT)
gpio.write(2, gpio.LOW)
for i = 1, 4 do
 gpio.write(2, gpio.HIGH)
 tmr.delay(100000)
 gpio.write(2, gpio.LOW)
 tmr.delay(100000)
end

Simple non ?

Raspberry Pi 2 domotique : ESP8266 capteur d’ouverture suite (13)

Le capteur d’ouverture présenté dans le précédent billet prend forme. Le voici désormais totalement intégré dans une boite de dérivation :

La boite de dérivation ira s’encastrer dans une cloison en placo, l’installation étant prévu dans une maison en rénovation. Elle comporte l’alimentation 220 V / 3.3v, les bornes électriques, les dominos pour venir raccorder le capteur d’ouverture reed, et un petit ESP8266 version ESP12 programmé en Lua.

Le point d’accès de la photo va lui permettre de relier tous les capteurs ESP12 ensemble, indépendamment de la box internet utilisée : changez de box, les capteurs seront toujours opérationnels, pas besoin de reprogrammer leur réseau WiFi. Les IP sont affectées par le serveur dhcp de la box, mais on peut aussi envisager des IP fixes (gaffe au changement de box dans ce cas…).

Dans le projet de rénovation, plusieurs capteurs d’ouverture vont être implantés, avec le projet d’en ajouter également un sur la sonnette de la porte d’entrée, de façon à être prévenu en notre absence : email + capture d’écran de la caméra rue, par exemple.

Il va falloir désormais s’occuper de gérer le script en Python3 sur le Raspberry Pi utilisé comme serveur, et là, c’est le plus difficile, même si cela reste vraiment passionnant à développer 😉

Raspberry Pi 2 domotique : ESP8266 capteur d’ouverture (12)

Transformons un petit ESP8266 (version ESP12) en capteur d’ouverture de porte. Je passe sur le script init.lua destiné à initialiser la connexion Wifi par exemple, vous en trouverez un exemple sur ce billet.

ESP12

Voici le script que j’ai appelé contactESP2.lua, on se retrouve après pour détailler son fonctionnement :

-- on active le GPIO4 en entree
gpio.write(2, gpio.LOW)
gpio.mode(2, gpio.INT, gpio.PULLUP)

-- contact porte ferme par defaut
ouvert = 0
cu = nil
-- 
-- nom = nom du capteur
-- porttcp = port TCP d'émission de trame si détection d'ouverture
-- portudp = port UDP d'écoute des trames de status
-- ip = adresse IP du serveur TCP Raspi Domo en écoute
--
nom = "sonde1"
porttcp = 5665
portudp = 5665
ip = "192.168.1.60"

print(nom .. "/n")
function contact(level) -- on lit le contact du gpio4
 etat = gpio.read(2)
 if etat == 1 then
 ouvert = 1
 print('PORTE OUVERTE')
 cu=net.createConnection(net.TCP)
 cu:on("receive",function(cu,c) print(c) end)
 cu:connect(porttcp,ip) -- connexion du port tcp sur l'ip choisie
 cu:send(nom .. "\n") -- envoi du code du capteur suivi d'un retour ligne
 
 tmr.delay(1000000)
 else ouvert = 0
 end
 end

-- configuration port gpio 4 en entree

gpio.trig(2, "both", contact) -- si changement etat on lance la fonction contact

-- si on emet une trame udp "sat"+nom du capteur sur le port udp sélectionné
-- la sonde repond par "ok" suivi du nom du capteur

s=net.createServer(net.UDP) 
s:on("receive",function(s,c)
 print(c)
 if c == "stat" .. nom then
 print('status sonde ok')
 cu=net.createConnection(net.TCP)
 cu:connect(porttcp,ip)
 cu:send("ok".. nom .. "\n")
 end 
 end) 
s:listen(portudp)

Et voilà, de retour, c’est long, oui je sais 😉

Branchez un contacteur de porte sur le port GPIO4 de votre ESP 12 (j’ai utilisé cette version pour éviter certains bugs logiciels au boot) d’un coté, sur GND (la masse) de l’autre.

ESP12 + capteur d’ouverture

Dans notre exemple, lorsque le contact s’ouvre (= port ouverte), une trame « sonde1 » est envoyée sur l’ip 192.168.1.60 port TCP 5665. Si j’envois une trame « statsonde1 » sur le port UDP 5665, la sonde va me répondre « oksonde1 » sur son port TCP 5665.

Bien entendu, tout se configure :

[checklist]

le port TCP
le port UDP
l’IP du serveur qui va recevoir les trames (j’ai programmé un Raspberry Pi en Python3 pour cela)

[/checklist]

On peut faire différent, et imaginer par exemple recevoir l’impulsion de détection d’un capteur de mouvement, lui aussi alimenté en 3.3v si je ne m’abuse, un peu ce genre de platine :

Capteur de mouvement

La fonction d’interrogation de la sonde est un gadget, mais cela peut être utile si vous souhaitez demander à votre domotique de surveiller régulièrement le fonctionnement des différents capteurs : c’est mieux qu’un ping, et on peut au besoin envoyer d’autres informations, comme avec cette sonde de température domotique que Blogwifi vous avait présentée par le passé.

L’ESP12 disposant de multiples GPIO, vous devriez pouvoir rajouter d’autres possibilités de détection en parallèle avec le GPIO4. A vous de jouer, n’hésitez pas à faire part de vos expériences dans les commentaires.

ESP8266 : flasher l’ESP201

L’ESP201 fait partie des multiples déclinaisons de l’ESP8266, jugez-en plutôt avec son brochage impressionnant :

Pour le flasher, il va vous falloir relier correctement quelques broches :

GND / VCC / RXD / TXD sur le convertisseur série/TTL
CHIP_EN au 3.3Vcc
GPIO00 à la masse (GND)
GPIO02 au 3.3Vcc
GPIO15 à la masse (GND)

Une fois sous tension, vous allez flasher avec esptool.py, en Python. Voici ce que donne le branchement en labo, avec à gauche l’ESP201, au centre le convertisseur série/usb et sur la droite une platine d’alimentation destinée à fournir le 3.3v du montage, ouf :

Une fois le flashage terminé, débranchez l’alimentation, et reliez les broches comme suit :

GND / VCC / RXD / TXD sur le convertisseur série/TTL
CHIP_EN au 3.3Vcc
GPIO00 et GPIO002 au 3.3Vcc ou juste non connectés
GPIO15 à la masse (GND)

Pour nos essais, nous allons donc volontairement exclure d’office les GPIO0, 2 et 15, pour n’utiliser que les GPIO4, 5, 12, 13, et 14. Cela évitera tout soucis ou tout ajout matériel pour éviter qu’en cas de coupure secteur votre ESP ne redémarre dans un mode particulier.

ESP-12 : présentation

Suite de la série des essais avec l’ESP8266, cette fois-ci avec l’ESP-12, toujours plus petit :

ESP-12

On peut difficilement faire plus petit, enfin si, mais pas avec autant de GPiO intégrés, 9 au total, donc 8 utilisables si j’ai bien suivi.

On peut soit envisager de se relier directement, soit utilisé le kit commandé en Asie, avec une platine sur laquelle vous allez souder l’ESP12 et venir ajouter des connecteurs « à taille humaine » pour vos branchements ultérieurs :

Kit ESP-12

Perception de la loupe, et en avant la soudure, avec patience et douceur. Quelques minutes plus tard, voici la bestiole raccordé dignement :

Vous noterez l’antenne WiFi stripline sur le haut du module, et une petite LED cms chargée de vous donner quelques indications de fonctionnement.

Reste désormais à tester, sans doute avec NodeMCU, mais ce sera l’objet d’un prochain billet.

ESP8266 : flashage bloqué avec ESPTOOLS, la solution

Si vous n’arrivez pas à flasher un ESP8266 avec l’utilitaire Python Esptools, venez éditer esptool.py et remplacez les lignes suivantes comme ceci :
ESP_RAM_BLOCK = 0x180
ESP_FLASH_BLOCK = 0x40

Il vous suffit donc d’ôter un zéro 😉 Sauvegardez et relancez le flashage :

esptool.py -p /dev/tty.usb0 write_flash 0x000000 nodemcu_latest.bin

Vous remplacerez /dev/tty.usb0 par le nom de votre port série usb, et le fichier .bin par celui que vous utilisez, bien entendu.

ESP8266 : quelle platine ?

Je joue depuis plusieurs jours avec des platines ESP8266 et j’en découvre toujours plus chaque jour. Le soucis maintenant est de choisir LA platine parfaitement adaptée à mon application : fonctionner comme détecteur d’ouverture, reliée au réseau WiFi d’une box, et transmettant des trames UPD pour signaler les évènements.

Je vais donc revenir sur plusieurs modèles qui me semblent intéressants :

ESP-01 :

La plus accessible des platines avec son gros connecteur et son antenne WiFi intégrée. Elle dispose de deux GPIO, 0 et 2, mais attention : ils ne doivent pas être à la masse lors du boot, sinon la platine se place soit en mode flash, soit en mode de secours, l’idiote !! La encore, forte impression d’avoir un ingénieur Fxxxmobile à l’autre bout tellement ça manque de réflexion côté firmware, c’est impressionnant. Bon, ajoutez une résistance de 1k2 ou 1k en série avec GPIO2, un interrupteur d’ouverture, et la masse, et le boot sera possible, ce n’est pas si compliqué à contourner pour une fois, ouf.

ESP-01

ESP-02 :

Bon là, clairement, il va vous falloir des doigts de fée pour venir souder proprement sur les demi-lunes de la platine. Mais on y arrive avec un bon fer et une bonne loupe, rassurez-vous. Le soucis des GPIO à ne pas relier à la masse au boot subsiste, mais là la résistance de 1k2 n’y fera rien, je cherche encore la bonne valeur, pour le moment en vain. L’ESP-02 est la plus petite des platines, très facile à venir intégrer mais prévoyez tout de même d’y ajouter une antenne avec connectique UFL, un élément qui va occuper un peu de place du coup.

ESP-02

ESP-03 :

Pour des développements puissants, l’ESP-03 est mon préféré, avec pas mal de GPIO utilisables (au moins 6), sans le soucis de la masse évoqué pour les version ESP-01 et ESP-02. Il a une antenne intégrée plutôt efficace, mais il reste de petite taille : loupe et fer à souder en bon état seront vos meilleurs amis là encore 🙂

ESP-03

Nodemcu :

La platine Nodemcu est celle qui vous demandera le moins d’efforts pour débuter, et surtout aucun câblage : pas besoin de penser à alimenter ci ou ça, à brancher le fil pour programmer la flash, etc. Tout est sur une platine unique, des connexions accessibles, deux boutons pour agir sur la programmation ou effectuer un reset, et une interface RS232 immédiatement opérationnelle. Et je ne parle pas des nombreux GPIO accessibles sans difficultés.

Elle a immédiatement ma préférence pour développer, mais coûte un peu plus cher, forcément.

Nodemcu

D’autres platines existent, mais ne les ayant pas encore testées, cela fera l’objet d’un prochain billet, laissons le temps au temps.

Les alimentations :

Toutes ces magnifiques platines ne fonctionnent que sous 3.3 V : adieu donc l’alimentation USB, ou alors via un petit circuit intégré convertisseur, comme on en trouve facilement sur ebay :

Régulateur 3.3vcc

Prenez votre alimentation USB, coupez le connecteur à l’extrémité, dénudez un peu, repérez les fils rouge et noir et testez : vous devez y trouver 5 Vcc. Coupez les autres fils, ils ne serviront pas, et venez souder le rouge (+) et le noir (-) sur le régulateur. Soudez alors la sortie 3.3V (+ et -) sur votre ESP8266.

On peut également la relier sur une alimentation 220V/3.3v, et l’intégrer dans une prise de courant, là encore, direction ebay :

Alimentation 220 V / 3.3Vcc

Ah, un détail qui a son importance : je me suis aperçu que mon convertisseur série/3.3v se mettait souvent à genoux coté alimentation : pensez à utiliser une platine externe pour vous fournir le 3.3v destiné à l’ESP8266, et laissez simplement l’ordinateur alimenter le convertisseur, pas plus. Ce genre de platine ressemble à ça :

Alimentation USB / 3.3Vcc

Elle pourra venir s’enficher sur une platine d’expérimentation (breadboard) : prévoyez d’office tous les petits câbles mâle ou femelle venant s’insérer sur les pinoches ou les trous de connexion, cela vous facilitera grandement la vie, croyez moi. Là encore, sur ebay ce n’est pas cher mais tellement utile.

Le développement :

Tout ce petit monde n’a d’intérêt que si vous pouvez développer avec. Pour le moment, ma préférence va au langage LUA, mais vous avez également la possibilité d’utiliser l’environnement des Arduino si le langage C++ vous motive.

Sous OS/X et Ubuntu, j’ai utilisé avec succès ESPlorer, une application Java d’origine Russe qui permet pas mal de facéties avec Nodemcu. Bon ok, il faut un peu galérer pour installer Java, mais une fois fait, ce n’est que du bonheur.

ESPLORER

Sous Winchose, il y a LuaLoader, très bien conçu mais avec hélas l’environnement Winchose que, personnellement, je déteste. A vous de voir donc, mais mon choix se portera indéniablement sur OS/X ou Ubuntu, plus simples, plus ergonomiques, et sans plantages.

LuaLoader sous Winchose 7

ESP8266 : ESP-02, brochage et GPiO

Le plus petit des ESP8266 est enfin arrivé d’Asie. Le moins que l’on puisse dire, c’est que la documentation d’exploitation manque cruellement, par exemple pour flasher le firmware Nodemcu qui permettra de le programmer en Lua. Nous reviendrons sur cette programmation, obligatoirement via un convertisseur série/TTL 3.3v (pas 5 V) : plus de 3 heures à ramer sur os/x, Winchose 7, et finalement un succès sous Ubuntu, ouf.

Voici le brochage de la p’tite puce :

Vous penserez avant toute chose à venir brancher une antenne sur le connecteur UFL situé en bas à droite. Il y a tout ce qu’il faut chez Monwifi.fr, passez donc un coup de fil si vous êtes coincés.

Une fois le module flashé avec Nodemcu, vous allez vite vous apercevoir que les GPIO0 et GPIO2 ne répondent pas du tout à leurs numéros lorsque vous tentez d’activer ou non la sortie…

ESP1 et son interface série/TTL 3.3v + antenne WiFi

Pour le GPIO2, il vous faudra utiliser :

gpio.write(4, gpio.HIGH) ou gpio.write(4, gpio.LOW)

pour commander une LED branchée dessus (le – sur GND, le + de la LED via une résistance de 2k2 sur le GPIO).

Pour le GPIO0, il vous faudra utiliser :

gpio.write(3, gpio.HIGH) ou gpio.write(3, gpio.LOW)

Oui je sais, on a un peu l’impression que ce sont des ingénieurs de Freemobile qui ont conçu tout ça tellement ça parait être brouillon et pas du tout abouti, mais pourtant cela fonctionne, si on prend un peu de temps pour découvrir 🙂

Blog WiFi / 3G / 4G / Hotspots

!! Le spécialiste du wifi et du sans fil sur un blog !!