microcontrôleur esp8266 – Installation et utilisation

Introduction

Contrôler l’environnement physique fait partie intégrante des arts numériques. En effet, l’interaction est un des éléments clés pour réussir une oeuvre immersive, qui fait appel au public, qui l’incite à interagir avec l’oeuvre présentée.

Pour cela, il faut utiliser des microcontrôleurs. C’est des circuits intégrés qui rassemble ce qu’on trouve habituellement dans un ordinateur : mémoire, processeur, interface d’E/S, Wifi…etc. Sauf qu’ils sont bien plus minuscules !

Il existe différents modèles de microcontrôleur, le plus populaire étant l’Arduino. Chaque circuit à ses avantages et ses faiblesses, mais notre choix va se tourner principalement pour l’ESP8266, et voici pourquoi :

Le prix : l’ESP8266 est à environ 3$ (Ali Express). quasiment au même prix que les Arduino (pas l’officiel mais plutôt le générique vendu par les fournisseurs en Chine), mais pour la puissance et son wifi, l’ESP8266 est bien plus avantageux.

La puissance : avec 4Mo de mémoire et 128kb RAM, l’ESP8266 est plus puissant comparé à un Arduino. Il est aussi équipé d’un wifi. Arduino Uno n’a que 32Ko en ROM et 2Kb en RAM. La différence est claire !

La taille : L’ESP8266 fait 3.5cm sur 2.5cm et est déjà équipé du wifi, alors que l’Arduino fait 6,8cm sur 5,3cm… il faut rajouter un shield wifi à ce dernier si on veux avoir cette fonctionnalité, ce qui va augmenter encore plus son épaisseur…

L’environnement de développement : L’ESP8266 peux se programmer en C++ via Arduino IDE, mais aussi avec Lua (nodeMCU), en javascript (Espruino), en MicroPython et même en C.

Les ressources : Une quantité importante de ressources concernant ce petit circuit et une communauté grandissante de jour en jour. Sa petite taille et sa puissance en fait un candidat idéal pour l’Internet des Objets, d’où son succès.

Il existe une multitude de variante de l’ESP8266, provenant de différents vendeurs. La différence réside dans le nombre de pins, la disponibilité d’une entrée micro usb…etc.

Installation

L’installation et l’utilisation de ce circuit se fait à travers le terminal. Si vous n’êtes pas familier avec cette environnement, je vous invite à voir ce cours : https://openclassrooms.com/fr/courses/2383231-domptez-votre-mac-avec-os-x-yosemite/2386639-le-terminal-dans-os-x

Ce tutoriel est destiné aux utilisateurs de Linux et Mac. Si vous êtes sur Windows, vous avez la possibilité d’installer le bash Ubuntu et d’utiliser ces logiciels, mais bizarrement Windows bloque la communication via les ports USB… il est toujours possible de flasher et de téléverser des fichiers dans l’ESP, mais pas de communiquer directement et avoir des retours via le terminal du nodeMCU uploader…

  • esptool = Ceci va nous permettre de flasher le wemos et de lui installer un micrologiciel.
  • nodeMCU uploader = Utile pour téléverser des fichiers et contrôler le circuit via un terminal.

Esptool s’installe via pip. Si vous n’avez pas ce dernier, installez-le en tapant cette commande :

sudo easy_install pip

ensuite installez esptool :

pip install esptool

Si une erreur survient, faites sudo pip install esptool ou encore python -m pip install esptool

Ensuite, installez NodeMCU uploader :

pip install nodemcu-uploader

Pour savoir si les deux logiciels ont bien été installés, tapez esptool.py ou nodemcu-uploader dans le terminal.

Build du firmware

Maintenant, on va personnalisé le firmware avec seulement les éléments dont on aura besoin. L’ESP doit être capable de lire l’analog to digital converter (ADC), doit pouvoir envoyer et interpréter les messages MQTT, doit pouvoir exécuter des fichiers, activer le WIFI…

Il existe un site https://nodemcu-build.com/ où on va pouvoir sélectionner les modules qu’on veut et en faire un build.

Pour ce tutoriel, on va se servir de ces modules : adc dht file gpio mqtt net node tmr uart wifi

N’oubliez pas d’entrer votre adresse courriel et cliquez sur Start your build. La réception du courriel peut prendre plusieurs minutes, soyez patients ! Vous recevrez un courriel contenant deux liens : en float et en integer. Télecharger le float.

Flash de l’ESP8266

Maintenant qu’on a tous les éléments, on peut commencer à flasher le petit circuit.
Branchez l’ESP8266 dans un port USB. Une petite lumière bleu va clignoter pendant un bref instant. Maintenant, ouvrez le terminal et faites ceci :

esptool.py --port /dev/tty.usbserial-1440 flash_id

Au branchement du circuit, l’ordinateur va assigner un fichier qui va servir de relais pour communiquer avec le circuit. Il faut identifier ce fichier là. Pour cela, il faut écrire esptool.py –port /dev/tty.usbserial- ensuite tapez une fois (ou parfois deux) la touche Tab, le terminal va compléter tout seul le chemin s’il y a un seul périphérique usb branché. Si tout se passe bien, vous allez voir apparaitre quelque chose comme ceci :

Serial port /dev/tty.usbserial-1440
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
MAC: 68:c6:3a:89:f6:4c
Uploading stub...
Running stub...
Stub running...
Manufacturer: ef
Device: 4016
Detected flash size: 4MB
Hard resetting via RTS pin...

On va effacer la mémoire du circuit :

esptool.py --port /dev/tty.usbserial-1440 erase_flash

Vous allez voir ceci :

Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
MAC: 68:c6:3a:89:f6:4c
Uploading stub...
Running stub...
Stub running...
Erasing flash (this may take a while)...
Chip erase completed successfully in 6.8s
Hard resetting via RTS pin...

et mettre le nouveau firmware :

esptool.py --port /dev/tty.usbserial-1440 write_flash -fm qio 0x0 nodemcu-master-10-modules-2019-06-10-21-08-55-float.bin

Tapez cette commande si vous êtes dans le répertoire où se trouve le firmware, sinon glisse déposer le firmware juste apres 0x0.

Vous aurez en retour ceci :

esptool.py v2.6
Serial port /dev/tty.usbserial-1440
Connecting
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
MAC: 68:c6:3a:89:f6:4c
Uploading stub...
Running stub...
Stub running...
Configuring flash size...
Auto-detected Flash size: 4MB
Flash params set to 0x0040
Compressed 446464 bytes to 290230...
Wrote 446464 bytes (290230 compressed) at 0x00000000 in 28.2 seconds (effective 126.7 kbit/s)...
Hash of data verified.
Leaving...
Hard resetting via RTS pin...

On va accéder au terminal du circuit via nodemcu-uploader.

nodemcu-uploader --port /dev/tty.usbserial-1440 terminal

Tapez deux fois sur entrée et vous allez voir apparaitre un >.
On y est ! le circuit est maintenant prêt à recevoir les commandes.

Test

On va procéder à un petit test et faire allumer la petite led bleue du microcontrôleur.
on va tout d’abord initialiser la pin 4 :

gpio.mode(4,1)

Ensuite, on va allumer la lumière :

gpio.write(4,0)

Pour fermer la lumière :

gpio.write(4,1)

Tout au long de ce tutoriel, on va utiliser le langage Lua qui est un langage script léger, puissant et facile à incorporer. Notre ESP8266 est donc équipé du firmware NodeMCU écrit en lua, qu’on installe une seule fois et qui nous permet d’interagir avec sans qu’on flash à chaque fois. On peut programmer facilement soit en tapant directement via le terminal ou en téléversant directement des scripts.

un hello world en Lua ressemblera donc à ceci :

print 'hello world !'

les espaces, l’indentation, les fins de lignes et le point virgule ne sont pas nécessaires avec ce langage. Pour les commentaires, ils se placent à droite de — et sont automatiquement ignorés.
Les nombres peuvent être des entiers ou flottants et on peut faire les opérations habituelles + – * / % == ~=​.

Je vous conseils cet excellent tutoriel sur le langage lua :

Pour redémarrer le circuit :

node.restart()

et pour connaitre l’utilisation de la mémoire :

=node.heap()

Pour faire une fonction :

function f() print 'hello world !' end
f() -- exécute la fonction

Pour appeler cette fonction une fois par seconde, on va programmer un timer dans la variable mytimer avec 1 seconde d’intervalle et en mode auto :

mytimer = tmr.create()
mytimer:alarm(1000,tmr.ALARM_AUTO,f)

pour arrêter le timer :

mytimer:stop()

même si l’écran continue de faire le print du hello world, vous pouvez toujours taper et exécuter la commande.

Pour pouvoir quitter le terminal, il suffit de faire un ctrl+}. Pour éviter toute erreur, il faut impérativement stopper les timers et quitter le terminal proprement.

Connexion WIFI

Pour pouvoir connecter le microcontrôleur au WIFI, il faut téléverser un fichier de configuration qu’on va modifier avec le nom (SSID) et le mot de passe du WIFI. Voici à quoi il ressemble :

print("WIFI !")

function listap(t)
    for ssid,v in pairs(t) do print(ssid,v) end
end


wifi.setmode(wifi.STATION)
wifi.sta.getap(listap)
print("connexion au WIFI...")
config={}
config.ssid="LE NOM DU WIFI" -- modifier ceci
config.pwd="LE MOT DE PASSE" -- et ceci aussi
wifi.sta.config(config)

myTimerWifi = tmr.create()

function tryIp()
    print(".")
    ip = wifi.sta.getip()
    if ( ( ip ~= nil ) and  ( ip ~= "0.0.0.0" ) )then
        print("Succès ! Notre ip : ",ip)
        myTimerWifi:stop()
    end
end

myTimerWifi:alarm(1000, tmr.ALARM_AUTO, tryIp)

Vous pouvez aussi télécharger le fichier directement et le modifier avec le bon SSID et mot de passe :

Maintenant, il faut téléverser le fichier dans l’ESP8266 à l’aide de nodemcu-uploader. Il faut quitter le terminal du microcontrôleur et accéder via le terminal à l’endroit où il y a le fichier wifi.lua ensuite exécuter cette commande :

nodemcu-uploader --port /dev/tty.usbserial-1440 upload wifi.lua 

il ne faut pas glisser déposer le fichier dans le terminal mais plutôt y accéder via le terminal en cd comme mentionné en haut.

Maintenant, il faut revenir vers le terminal du microcontrôleur et exécuter le fichier :

nodemcu-uploader --port /dev/tty.usbserial-1440 terminal
dofile('wifi.lua')

Le fichier va s’exécuter et se connecter au WIFI que vous avez spécifié. Un message de confirmation avec une adresse IP qui vous a été assigné sera affiché.

Installer un senseur de température

Dans cette exemple, on va utiliser le senseur de température MCP9700.
Ce senseur possède trois pins :

Le côté aplatie en face, il faut brancher la pin de gauche au 3.3V, la pin du milieu dans A0 (analog) et la pin à droite dans le ground (GND). Le tout en ayant le microcontrôleur hors tension.

Voici un exemple du montage :

Maintenant, via le terminal de nodemcu-uploader, faites ceci :

=adc.read(0)

Vous aurez probablement une valeur haute au alentours de 250. La pin A0 renvoies une lecture en voltage de 0 à 1023. Il faut convertir cette valeur pour pouvoir afficher la température en Celsius.

v=adc.read(0)*3/1023*100-50
v=math.floor(v*10+0.5)/10
=v

en faisant =v, vous aurez la température en Celsius.

On peut créer une fonction avec un timer pour afficher la température chaque seconde :

function temperature()
    v=adc.read(0)*3/1023*100-50
    v=math.floor(v*10+0.5)/10
end

myTemp = tmr.create()
myTemp:alarm(1000,tmr.ALARM_AUTO, temperature)

Pour arrêter le timer :

myTemp:stop()

Publication via un serveur MQTT :

Résumons ce qu’on a fait jusqu’à maintenant : on a fait un script qui va se connecter au WIFI et on a installé un senseur de température dans le microcontrôleur. Maintenant, on peut envoyer ces valeurs vers un serveur MQTT.

Si vous avez déjà un serveur MQTT en local ou vous connaissez un serveur publique, vous pouvez l’utiliser pour la suite des étapes. Si vous voulez configurer un serveur MQTT avec un Raspberry Pi, suivez ces étapes !

Sinon, voici une liste de quelques broker MQTT :

BrokerAdressePorts
HiveMQ broker.hivemq.com1883 / non-SSL
Mosquittotest.mosquitto.org1883 / non-SSL
8883 / SSL
Eclipseiot.eclipse.org1883 / non-SSL

Dans cette exemple, on va utiliser le broker Mosquitto avec le port 1883.

La première chose à faire est de connecter le microcontrôleur au serveur MQTT et de lui donner un nom. Ensuite, la même fonction qu’on a créer pour lire la température, on va l’envoyer (m:publish) avec le nom du circuit (mqttInit(« circuit1 »)) et le nom du topic où on va publier (/temp). On souscrit aussi à tout (m:subscribe avec /#) si jamais on veut recevoir des messages.

function mqttInit(mqttnom)
    nom=mqttnom or "sansnom"
    m=mqtt.Client("id"..node.chipid(),120)
    m:connect("test.mosquitto.org",1883,0, -- le serveur MQTT et le port
    function(client)
        print("connexion ok")
        m:subscribe(nom.."/#",0, function(client) -- subscribe à tout #
        print("subscribe success") end)
    end,
    function(client, reason) print("failed reason: "..reason) end
    )
end

function mqttUninit()
    m:close()
    m=nil
end

function temperature()
    v=adc.read(0)*3/1023*100-50
    v=math.floor(v*10+0.5)/10
    m:publish(nom.."/temp",tostring(v),0,0) -- topic /temp
end

myTemp = tmr.create()
myTemp:alarm(1000,tmr.ALARM_AUTO, temperature)

mqttInit("circuit1") -- nom du circuit

On peut souscrire à un topic grâce à mosquitto_sub. Pour l’installer, il faut faire :

-- pour Mac avec brew installé
brew install mosquitto

-- pour Linux
sudo apt-get install mosquitto-clients

Ensuite :

mosquitto_sub -h test.mosquitto.org -t 'circuit1/#' -v

On va recevoir tout les messages qui proviennent du circuit1, si on veut seulement la température, souscrire au topic ‘circuit1/temp’

Contrôler la LED à distance :

Comme on le sait, le circuit comporte une petite lumière qu’on peut contrôler à distance via MQTT. Pour cela, il faut créer une fonction qui va changer l’état de la lumière et écouter les messages.

Je vais utiliser le même fichier mqtt.lua pour des raisons pratiques :

bleu=4
gpio.mode(bleu,gpio.OUTPUT)
gpio.write(bleu,1)

function lumiere(client, topic, data)
    print("got: "..topic.." : "..data)
    if topic==nom.."/bleu" and tonumber(data) then
        gpio.write(bleu,1-tonumber(data))
    end
end

function mqttInit(mqttnom)
    nom=mqttnom or "sansnom"
    m=mqtt.Client("id"..node.chipid(),120)
    m:connect("test.mosquitto.org",1883,0, -- le serveur MQTT et le port
    function(client)
        print("connexion ok")
        m:subscribe(nom.."/#",0, function(client) -- subscribe à tout #
        m:on("message", lumiere) -- callback 
        print("subscribe success") end)
    end,
    function(client, reason) print("failed reason: "..reason) end
    )
end

function mqttUninit()
    m:close()
    m=nil
end

function temperature()
    v=adc.read(0)*3/1023*100-50
    v=math.floor(v*10+0.5)/10
    m:publish(nom.."/temp",tostring(v),0,0) -- topic /temp
end

myTemp = tmr.create()
myTemp:alarm(1000,tmr.ALARM_AUTO, temperature)

mqttInit("circuit1") -- nom du circuit

Pour pouvoir contrôler la lumière, j’utilise un téléphone Android avec l’app MQTT Dash (gratuit)

On ajoute le serveur dans la liste
On choisit un type. Dans ce cas, Switch / button
On nomme le bouton et on souscrit au topic circuit1/bleu
On teste le tout !

Création du fichier init.lua :

On va faire en sorte que le microcontrôleur se connecte au wifi et au serveur MQTT tout seul sans faire de dofile et dès qu’il est alimenté. Pour cela, on va faire un fichier init.lua qui va s’exécuter automatiquement au démarrage.

La création de ce fichier comporte un risque important. En effet, si jamais il y a une erreur dans le code, l’ESP8266 va faire un reboot continuellement… il est difficile d’écraser le fichier par un autre. Bref, soyez certain de votre code sinon vous devriez flasher encore une fois ou sinon, avec un peu de chance, vous pouvez supprimer le fichier init.

On suppose qu’on a déjà exécuté une fois le fichier wifi.lua. Les paramètres du wifi vont être les mêmes, l’ESP8266 se reconnecte donc automatiquement sans faire de dofile du wifi.lua. La meilleur manière d’éviter tout problème c’est de créer comme un compte à rebours à 10 secondes :

print('--- Bonjour ! ---')
print('--- t:stop() pour arrêter ---')

t = tmr.create()

t:alarm(10000, tmr.ALARM_AUTO, function ()
	ip = wifi.sta.getip()
	if ( ( ip ~= nil ) and  ( ip ~= "0.0.0.0" ) ) then
		 print ('ip : ', ip)
		 t:stop()
		 print('démarre MQTT')
                 dofile('mqtt.lua')
	else
		print('ZzzZZZzz')
		t:interval(1000)
	end
end
)

On a créé un timer avec 10 secondes de délai. Donc vous avez 10 secondes pour arrêter l’exécution des fichiers si jamais il y a une erreur. Après 10 secondes, il se connecte au wifi déjà connue et nous assigne une adresse IP. Si cette étapes est un succès, il exécute enfin le fichier mqtt.lua, sinon, il va changer l’intervalle du timer à 1 seconde et réessayer.

nodemcu-uploader --port /dev/tty.usbserial-1440 upload init.lua 
nodemcu-uploader --port /dev/tty.usbserial-1440 node restart

Et voilà ! Faites un subscribe avec mosquitto_sub pour voir si vous êtes en train d’envoyer des messages.

Si jamais vous voulez effacer le fichier init.lua, vous pouvez exécuter cette commande dans le terminal :

nodemcu-uploader --port /dev/tty.usbserial-1440 file remove init.lua

Dans un prochain tutoriel, on verra comment interagir avec Processing.

N’hésitez pas à laisser un commentaire si vous avez des questions !

Liens utiles :

Documentation : https://nodemcu.readthedocs.io
Build du firmware : https://nodemcu-build.com/

restez à l’affût pour la suite et n’hésitez pas à réagir dans les commentaires !

Soyez le premier à commenter

Laisser un commentaire

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

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.