Archives par étiquette : lua

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 : 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 🙂

ESP8266 : sonde de température prolixe

Quoi de mieux pour de la domotique que de pouvoir mesurer la température où et quand nous le souhaitons ? Et si j’avais envie de déployer 50 sondes dans les 50 pièces de mon immmmmmmmense château familial ?!

Eh bien là encore, nous allons passer via l’ESP8266 et une sonde DS18B20 que vous trouverez sans mal sur ebay pour quelques euros :

Notre sonde (le tube métallique étanche en haut à gauche de l’image) se branche sur le port GPiO 3 :

Sur la platine d’expérimentation Nodemcu, DQ se relie à D3, VDD à 3v3 et GND à… GND.

Chargez ds18b20.lua sur ce lien et injectez le dans l’ESP8266.

Le script maintenant, tempe.lua :

require('ds18b20')
-- connexion au reseau wifi

wifi.sta.config("reseau_wifi","password")
wifi.sta.connect()
tmr.delay(1000000)
print(wifi.sta.status())
print(wifi.sta.getip())

-- Choix du GPiO pour la sonde DS18B20
gpio0 = 3
ds18b20.setup(gpio0)

-- Activation du serveur UDP port 5665 pour recevoir les trames
-- de commande

port=5665
srv=net.createServer(net.UDP)
srv:on("receive", function(srv, pl)
 print("Trame UDP")
 print(pl)
 -- si trame recue = SONDE, alors on lit temperature
 if pl=="SONDE\n" then
 t1=ds18b20.read()
 t1=ds18b20.read()
 print("Temp:"..t1.." C\n")
 tempe="TEMPE"..t1..""

-- et on repond sur l'IP 192.168.1.124 avec la
 -- valeur de la temperature

cu=net.createConnection(net.UDP)
 cu:on("receive",function(cu,c) print(c) end)
 cu:connect(5665,"192.168.1.124")
 cu:send(tempe)
 end
 end)
srv:listen(port)

Ici nous allons donc écouter le port UDP 5665 et guetter l’apparition d’une trame SONDE, trame qui va déclencher la lecture de la température, puis son envoi à notre Raspberry Pi chargé de recevoir et traiter les informations, sur 192.168.1.124 : vous adapterez en fonction de vos besoins et de votre installation, ce billet n’existe que pour vous présenter le principe.

ESP8266 : détecteur d’ouverture

Avec le développement de mon RaspiDomo, le branchement de détecteurs d’ouverture est rapidement arrivé à l’ordre du jour. Comme je n’ai pas envie de tirer des fils de partout, la solution totalement connectée semble la plus intéressante : tout passe via le réseau ethernet ou WiFi, un réseau sauvegardé et protégé, et donc impossible à interrompre par le cambrioleur de base.

C’est ici que va intervenir le petit ESP8266, associé à un bout de code Lua que nous allons injecter dans init.lua pour qu’il se lance dès la mise sous tension :

-- connexion au reseau wifi
wifi.sta.config("nom_du_reseau","password")
wifi.sta.connect()
tmr.delay(1000000)
print(wifi.sta.status())
print(wifi.sta.getip())

-- contact porte ferme par defaut
ouvert = 0

function contact(level)  -- on lit le contact du gpio3
  etat = gpio.read(3)
  if etat == 1 then
    ouvert = 1
    print('PORTE OUVERTE')
    cu=net.createConnection(net.UDP)
    cu:on("receive",function(cu,c) print(c) end)
    cu:connect(5665,"192.168.1.124") -- envoi port 5665 udp a l ip 192.168.1.124
    -- code ouvertA et retour ligne
    cu:send("ouvertA\n")

  else ouvert = 0
  end
  end

-- configuration port gpio 3 en entree

gpio.mode(3, gpio.INT, gpio.PULLUP)
gpio.trig(3, 'down', contact)  -- si changement etat on lance la fonction contact

Sur la platine d’expérimentation Nodemcu, voici le branchement du contact de fermeture :

En bas à gauche, la masse (GND), en haut à droite, 4ème broche en partant de la droite, GPiO3. Lorsque le port est lu, à l’intérieur de la fonction contact, la valeur 1 est retournée si le contact est ouvert, 0 s’il est fermé.

En cas d’ouverture, nous indiquons PORTE OUVERTE et émettons une trame ouvertA sur le port UDP 5665, à destination de l’IP de notre Raspberry Pi, 192.168.1.124 (à adapter selon VOTRE configuration donc).

Coté Raspberry Pi, il va nous falloir recevoir cette trame avec un bout de code python, à placer dans udp.py par exemple :

import socket
sock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
sock.bind( ('',5000) )

while True:
    data, addr = sock.recvfrom(1024)
    data = str(data, encoding='utf8')
    if "ouvertA" in data:
      print ("PORTE OUVERTE")

que vous allez lancer avec un sudo python udp.py.

A vous désormais de tester avec un ou plusieurs capteurs d’ouverture connectés au WiFi de votre box internet, et de programmer des actions sur le Raspberry Pi : alerter par email, alerter par SMS, etc.

ESP8266 : GPiO « HIGH » au démarrage, la solution

Nombre de messages sur les forums font état de niveaux hauts (HIGH) sur les ports GPiO des ESP8266, conduisant à des situations pas forcément enviables si vous y avez raccordé des relais. En clair, vous vous retrouvez avec du 3,3 Vcc sur chaque broche de GPIO un fois l’ESP8266 sous tension. Bien entendu, on peut venir rétablir la situation avec un init.lua qui commandera aux ports de se couper, mais vous aurez toujours une demi seconde d’activation, cela ne changera rien.

Sur ce billet, nous avons vu comment commander un relai, au moyen d’un transistor 2N2222 et quelques résistances :

Nous allons y ajouter un inverseur, toujours avec un 2N2222 :

Branchez le GPiO sur IN, puis la commande du relai (schéma au début du billet) sur OUT. Vous enchainez donc deux montages à base de 2N2222. Pour activer le relai, il faudra valider un port sur LOW et non HIGH : 0 V sur le GPiO => relai activé ! Simple non ?

On peut envisager un montage avec un circui intégré inverseur, plus compact, mais pour juste un ou deux relais, l’intérêt est peu évident. Les bricoleurs pourront réaliser une platine avec l’inverseur et le 2N2222, tout ça en CMS : compact, simple, mais nécessitant un peu de matériel pour produire le montage.

Blog WiFi / 3G / 4G / Hotspots

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