Le Monde des Objets Connectés
Le Monde des Objets Connectés
Robots et Objets Inter-Connectés
Le Monde des Objets Connectés
Techcryptage : De quoi s’agit-il ?
Étude du NodeMCU Developpement Kit
Installation et Configuration -
Chargement “Flashage” du dernier micro-code “Firmware” NodeMCU
Nos premiers pas avec LUA
1) Débutons par le classique “Bonjour à Tous”
2) Plus sérieux : Le Bonjour des geek, la LED qui clignote ‘le blink’
3) Création d’un fichier programme dans notre NodeMCU
4) Séquence d’initialisation sous LUA
5) Utilisation du script de transfert luatool
Un IDE pour l’ESP8266 & NodeMCU
(Fin provisoire de l’article)
A.1) Outils pour flacher le firmware :
Récupération firmware en mode Windows
ESP8226 avec l’IDE Arduino
Exemples de codes & montages
Mise en place d’un container docker ESP
Techcryptage : De quoi s’agit-il ?
De créer une infrastructure d’Objets en Connectés sans fil, qui interagiront de façon autonome comme un assistant global. Une espèce de Robot éthérisé à notre service.
Un exemple, un peut futuriste (mais si peut) de ce concept dans notre vie quotidienne :
Votre réveil connecté à votre smartphone s’est programmé tout seul grâce à votre agenda électronique, ce même réveil a programmé le grille-pain pour que votre tartine saute en même temps que le café est servi. Votre voiture a programmé l’ouverture des portes de votre garage etc ..
Ainsi Internet et les objets connectés ne forme plus qu’un ensemble à la fois physique et virtuel.
Techniquement, l’internet des objets est un réseau de réseaux qui permet par des systèmes d’identifications complexes de transmettre des données entre objets physiques et virtuels. Ainsi Internet n’est plus qu’un réseau invisible mais il prend forme dans ces objets.
On peut imaginer, ce réseau d’objets connectés, un peut comme un robot autonome à notre service.
Dans une vision optimiste, avec l’assistance de l’intelligence artificielle, cette nouvelle urbanisation d’objets connectés sera doté de comportement d’assistant, proche de celle que nous pouvons nous même apporté à notre entourage.
Le développement de cette nouvelle sphère d’objets inter-agissant dans notre quotidien, constituera en soi un écosystème de “cyber-objets”, qui sera bien plus efficace, qu’une simple agrégation d’objets, mais un ensemble d’agents économiquement utile à la Société.
Globalement, C’est une bataille technologique aux enjeux considérables. Opérateurs et industriels sont en train de créer de nouveaux réseaux de communication pour les milliards d’objets connectés qui nous attendent dans l’avenir.
Votre curiosité à été titillé, vous voulez en savoir d’avantage tout en restant généraliste :
Objet connecté : histoire et définition
Les différents usages des objets connectés
Remarque globale de lecture :
L’article se situ à deux niveaux,
l’un généraliste dans l’esprit Techcryptage, rend compte du sujet, sans plonger dans les rouages des techniques nécessaires au fonctionnement de la technologie évoquée.
Un second pour comprendre comment mettre en œuvre cette technologie, avec détails et exemples de réalisations. Cette partie s’adresse bien sur aux membres du groupe µSystem, et ceux qui à cette occasion oseront plonger dans ce grand bain du nouvel internet, celui des Objets.
Pour chaque chapitre, je proposerais une intro de type TechCryptage.
Pour une connaissance fonctionnelle des objets connectés vous pouvez picorer, en sautant de ‘Techcryptage’ en ‘Techcrypage’ le long de l’article.
L’objectif de l’article est d’apporter une description détaillé avec le support d’exemples de réalisation, permettant à ceux qui le souhaitent de construire ou d’adapter un réseau d’objets connectés, en utilisant les briques techniques de bas niveau. Par l’étude des composants matériels et logiciels constituant ce cette vaste technologie des Objets Connectés.
L’on va débuter cette étude avec l’un des composants clé de ce bouillonnement (buzz), des objets connectes, le Module ESP8266.
L’ESP8266 est un module de communication Wifi-Série (je reviendrais sur cette définition) apparu ces derniers temps (fin 2013 - début 2014 pour les premières versions fiabilisées).
L’ESP8266 est un design Open-Hardware d’ESPressif Systems une entreprise chinoise.
Proposé à un tarif très agressif (à partir de 2€ sur les sites chinois) avec un positionnement en Open-Hardware, cela à contribuer d’emblée à une explosion de l’offre.
Une gamme1 en forte croissances de modules sont disponible chez de nombreux fournisseurs 2.
La version initiale l’ESP-01 d’une taille réduite (env une piéce de 2€) contient :
Le µContrôleur EPS8266 à 80Mhz ,
une puce WI-FI avec son antenne,
un port série et deux Entrées/Sorties (GPIO).
D’autres versions, contiennent d’avantages de GPIO, ou d’autres particularités, forcement positionné sur une grille de tarif adapté.
Certains modules comme le NodeMCU3 incorpore un modèle EPS-12 ou EPS-12E sur une mini carte mère comprenant un connecteur micro USB et un brochage normalisé pour les platines d’expérimentations (breadboard), simplifiant l’élaboration du prototypage. Le ModeMCU est conçus comme un kit d’initiation au module ESP8266.
le NodeMCU dû à ses caractéristiques d’outils d’expérimentation, sera le premier module évalué dans cette étude.
Un Forum (ESP8266 Community Forum) ainsi qu’un Wiki fédère une communauté assez active.
Le module ESP8266 est avant tout un équipement de communication série :
soit en mode direct câblé,
soit en mode sans fil Wifi, qui reste une encapsulation dans le protocole Wifi, d’une communication série standard. C’est en effet une Communication de type UART, comme celle que l’on retrouve dans les modules de communication série sans fil traditionnel 433MHz .
L’ESP8266, comme pour les modules de comm serie 433MHz, sont à la fois bon marché mais également de basse consommation électrique. Et comme pour les modules 433MHz, les modules ESP8266 peuvent s’interconnecter entre eux pour faire de L’UART à travers un pont Wifi.
Mais alors pourquoi l’ESP8266 ?
les modules standard de communication sans fil à 433Mhz ne sont-il pas suffisant ?
Les différences ne sont pas nombreuses mais elles sont majeurs :
L’ESP8266 possède une unité de traitement, le µContrôleur cadencé à 80Mhz, assez remarquable pour le prix du composant. Cela confère une autonomie de fonctionnement, il peut donc se passer d’un arduino ou autre µSystem pour effectuer des taches de traitements localisés,
Le protocole WIFI est supporté, d’une façon un peut particulière certes ( on verra cela lors de l’implémentation des exemples). Grâce à quoi il peut tout de même interférer avec nos réseaux locaux voir communiquer avec des sites distants,
il bénéficie de la sécurité de chiffrement WPA/WPA2, inhérent au Wifi,
Une porté de communication très convenable, qui permet d’être en interconnexion partout dans un champs wifi conventionnel, donc partout dans la maison,
Grand plus, en fonction des modèles, il dispose de point de raccordement plus ou moins nombreux avec son environnement, les fameuse Entrées/Sorties GPIO, conférant par la même d’une capacité d’interaction direct avec l’environnement. Ouvrit une porte de garage, enclenché la cafetière ….,
Dernier point et non des moindres, la capacité à reflacher le firmware. Le fait que le module soit openHarware et OpenSource, ouvre des perspectives intéressantes. De nombreux Microcodes (Firmware) sont disponible permettant permettant d’attaquer le module avec différents environnement et différents langages.
Pour une connaissance détaillé sur le module le datasheet est la référence.
Voyons comment se servir de ce module EPS8266, avec le NodeMCU
Étude du NodeMCU Developpement Kit
NodeMCU Developpement Kit que je vais simplement nommer NodeMCU dans la suite de cet article
Pour cette première étude approfondie j’utilise une version 1.0 (Black, la version précédente 0.9 était nommé blue), embarquant le module ESP8266 - ESP-12E -. Pour les reconnaître rien de plus facile la 1.0 est noir la précédente était bleu.
Le NodeMCU , n’est rien d’autre qu’un module ESP-12E .
Monté sur une platine avec :
une connexion micro USB, avec un chip UART CP2102,
Un régulateur de tension,
Un bouton de Reset ‘RST’, raccordé sur la broche REST de l’ESP-12E
Un bouton de ‘FASH’, raccordé en entrée sur le GPIO_00
Une LED Bleu de contrôle, raccordé en sortie sur le GPIO_01
Un ensemble de 30 broches(2x15) au pas standard pour plaque d’expérimentation (breadboard).
- Le Brochage du module embarqué ESP-12E
- Le brochage de la carte NodeMCU
Installation et Configuration -
Remarque :
Bien que je vais utiliser le NodeMCU, pour la suite de ce chapitre. Le cœur de notre platine est composé d’un ESP8266, la version ESP-12E pour être précis.
Tout autres équipements possédant une puce ESP8266, par exemple ceux d’autres constructeurs comme Olimex, sont tout aussi indiqués pour réaliser les mêmes manipulations.
Les différences entre les modules vont se situer sur la forme, la facilité de réaliser les montages sur une plaque d’expérimentation, le raccordement direct en mode USB, mais également sur le nombres d’entrée/sorties GPIO disponibles.
Le jeu de commande ou langage sera lié au firmware utilisé. Ces firmwares pourront être installé sur tous les modules incorporant la puce ESP8266.
Chargement “Flashage” du dernier micro-code “Firmware” NodeMCU
Une mise à niveau du firmware est toujours une bonne option lorsque l’on démarre sur une nouvelle plate forme. Ne serait-ce que pour récupérer les dernières évolutions et patchs correctifs, d’autant plus que le produit est très jeune et donc soumis à correctifs et mise à jour régulières.
Organisation de mes répertoires pour cet exemple :
Répertoire firmware : $HOME/Developpement/µSystem/EPS/NodeMCU
Répertoire esptool : $HOME/Developpement/µSystem/EPS/esptool
Commençons par récupérer le dernier firmware sur le site nodemcu-firmware
Ou directement ici :
Pour procéder à l’installation nous auront besoin d’un outil de transfert.
Sous Linux une mini application en ligne de commande, écrite en python, par un contributeur, fera amplement l’affaire.
esptool : disponible sur Github.
Entrez dans votre répertoire de travail. Pour ma part et pour la suite du document se sera $HOME/Developpement/µSystem/EPS :
Si vous n’avez par encore installé le programme Git, faite le maintenant :
- avec Ubuntu
- Avec OpenSuse
Pour d’autres distrib voir votre gestionnaire de paquet.
On passe à l’installation esptool
$ git clone https://github.com/themadinventor/esptool.git
Dernier point avant de lancer le flashage du firmware. Sur le brochage du NodeMCU vous avez peut être remarqué une broche noté “FLASH“, cette broche doit être raccordé au GND pour effectué cette opération.
Le bouton “FLASH” devrait effectuer cette action, cela n’a pas eu d’effet lors de mes tests, j’ai donc opté pour le pont filaire direct.
Le pont étant en place on lance la commande depuis le répertoire esptool :
sudo python esptool.py --port /dev/ttyUSB0 \ write_flash -fm=dio -fs=32m \ 0x00000 ../NodeMCU/nodemcu_float_0.9.6-dev_20150704.bin
Pour flasher uniquement les données et les fichiers utilisateurs + init (nous auront besoin de cette séquence un peut plus loin)
sudo python esptool.py --port /dev/ttyUSB0 \ write_flash \ 0x7C000 nodemcu-firmware/bin/esp_init_data_default.bin \ 0x7E000 nodemcu-firmware/bin/blank.bin
Après le temps de transfert on obtient :
Parfait, nous allons pouvoir jouer avec le module NodeMCU.
Un peut de patience, je vous propose avant cela de faire un peut connaissance avec le langage LUA
C’est un parti pris des concepteurs du NodeMCU que de proposer une interface de programmation en mode script, dans un esprit très similaire au Python.
Cela permet une interaction plus immédiate avec l’utilisateur, les commandes tapées dans la console sont directement exécutées ligne à ligne par l’interpréteur LUA. Pas de compilation, mais une interprétation du code, un retour immédiat pour l’utilisateur, qui peut ainsi directement visualiser le résultat des commandes.
LUA est un langage de script souple et puissant, destiné à être utilise sur des équipements lèges comme les systèmes embarqués.
La force de LUA, une taille très compacte et une portabilité aisé, pouvant par ce fait être intégré dans des plate-formes très réduite comme l’ESP8266. LUA est un langage que l’on trouve de plus en plus souvent en Robotique.
Autre atout, être abordable par des débutants en programmation.
Les curieux pourront aller voir sur le net, de très nombreuses pages traitant de ce langage, comme :
Nous allons donc nous faire quelques armes avec LUA sur NodeMCU.
Nos premiers pas avec LUA
Physiquement on raccorde le module NodeMCU via le port micro USB à notre ordinateur. Par défaut on sera raccordé sur le périphérique interne ttyUSB0. L’identification du périphérique (device) est indispensable pour paramétrer la console série.
Sous Linux, j’utilise la console minicom avec les paramètres suivant :
Périphérique de connexion : ttyUSB0 ‘a adapté selon votre config’
Vitesse du protocole : 9600 bauds
Autres paramètres : 8 bits de données, sans parité, 1 stop bit; qui est résumé par : 8N1
La première commande LUA que je vais utiliser, permet d’étendre le système de fichier sur la totalité de la mémoire disponible. Opération nécessaire après le flashage du firmware :
Pas d’inquiétude l’opération dure plusieurs minutes sans affichage particulier.
Nous voila avec un module NodeMCU parfaitement vivant et sain.
1) Débutons par le classique “Bonjour à Tous”
> print("Bonjour à Tous")
Facile ! C’est comme du python, on tape sa commande, et Hop! La ligne est interprété.
2) Plus sérieux : Le Bonjour des geek, la LED qui clignote ‘le blink’
Le petit montage idoine :
La séquence des commande pour le clignotement :
> gpio.mode(3, gpio.OUTPUT) > gpio.write(3, gpio.LOW) > gpio.write(3, gpio.HIGH)
J’allume, j’éteins, OK! . Ce serait mieux si j’automatisais un peut la chose
> while 1 do >> gpio.write(3, gpio.LOW) >> tmr.delay(1000000) -- délais 1.000.000 µs = 1 seconde >> gpio.write(3, gpio.HIGH) >> tmr.delay(1000000) -- délais 1.000.000 µs = 1 seconde > end
! Génial ! Dès ma dernière commande validée, le programme est en action et ma LED clignote.
C’est pas mal, mais se serait plus pratique de pouvoir créer un fichier, plutôt que de saisir ligne à ligne chacune des commandes de notre petit programme.
3) Création d’un fichier programme dans notre NodeMCU
Avant de nous lancer dans la réalisation de ce programme, un petit retour sur le site officiel NodeMCU . On y trouve la liste des commandes et instructions LUA, disponible pour notre module.
On va particulièrement intéresser au groupe de commande file module, pour la construction du fichier programme.
Commandes utilisées pour la création de notre fichier de programme.
Description : Création et Ouverture du fichier nommé.
Syntaxe : file.open(NomFichier, Mode)
Parametres :
NomFichier: type ‘string’, le nom du fichier à ouvrir, directories are not supported
”r”: fichier en Lecture (Le mode par défaut) “read”
“w”: Fichier en écriture “write”
“r+”: Mode de mise à jour, écriture en début de fichier avec préservation des données,
“w+”: Mode de mise à jour avec effacement des données,
“a+”: Mode de mise à jour, écriture en fin de fichier avec préservation des données,
Description : Écrit une chaîne de caractères dans le fichier et ajoute une mise à la ligne \n
Syntaxe : file.writeline(string)
Parametres :
string: Contient la chaîne de caractère à écrire
je n’en precise pas d’avantage, tout est dans le nom.
L’écriture du programme sous la forme d’un fichier pour l’ESP8266 devient :
> file.open("blink.lua","w+") > file.writeline([[while 1 do]]) > file.writeline([[gpio.write(3, gpio.LOW)]]) > file.writeline([[tmr.delay(1000000)]]) > file.writeline([[gpio.write(3, gpio.HIGH)]]) > file.writeline([[tmr.delay(1000000)]]) > file.writeline([[end]]) > file.close()
Et pour lancer ce petit bout de programme,
Vu la difficulté à saisir ce petit bout de code, est-il au moins persistant suite à une coupure de courant ?
Faisons le test ! Je débranche .
-> le terminal m’informe de la perte de la connexion
et rebranche après une petite attente de 30s.
-> Je retrouve automatiquement le prompt de LUA, après une action sur ma touche ‘Enter’
Faisons un petit contrôle sur l’état des fichiers en mémoire dans le module.
Saisir le petit code suivant dans la console :
l = file.list(); for f,t in pairs(l) do print("Fichier:"..f..", Taille:"..t) end
(mettre image du résultat)
2 fichiers sont bien présent, dont : Fichier:blink.lua, Taille:102
Je relance l’exécution du fichier “blink”
Et à nouveau ma LED Clignote !
Qu’avons nous appris ?
Le firmware NodeMCU est doté d’un gestionnaire de fichier. On peut ainsi invoqué l’exécution d’un fichier via la console ou par programmation.
Il serait pertinent de pouvoir faire exécuter notre programme immédiatement au démarrage du module. Est-ce possible ?
Bien sur NodeMCU, possède d’un fichier auto-exécutable au démarrage, un fichier d’initialisation.
4) Séquence d’initialisation sous LUA
Le fichier d’initialisation, est simplement défini par son nom, et comme on peut s’en douter il se nomme : “init.lua”
Si ce fichier existe, son contenu est exécuté au démarrage d’un module ESP8266.
Reste à faire la vérification sur le NodeMCU , c’est parti :
> file.open("init.lua","w+") > file.writeline([[print("Demarrage du programme Blink")]]) > file.writeline([[dofile("blink.lua")]]) > file.close()
On voit ce qui ce passe après une action sur le bouton de reset ‘RST‘.
Super ! Ça démarre avec le petit jingle d’accueil ’ Demarrage du programme Blink ’ puis on enclenche sur le programme ‘blink.lua‘.
Satisfait ?
Ça fonctionne comme je le souhaitais.
Mais ATTENTION .. ce code soufre d’un Gros BUG…
Le programme une fois lancé ne laisse plus la main, plus de console et donc plus aucun moyen de passer la moindre commande. Impossible de supprimer éventuellement le programme d’init ou le Blink.
Le programme Blink tourne dans une boucle sans fin. La seule issue, consiste à re-fasher le ModeMCU pour effacer les data et repartir dans une configuration propre (on est tout de même pas obliger de re-flacher le ‘firmware’).
je vous avais bien dit que nous allons avoir à nouveau besoin de cette séquence réinitialisation
On re-Flash la zone data et les zones utilisateurs
sudo python esptool.py --port /dev/ttyUSB0 \ write_flash \ 0x7C000 nodemcu-firmware/bin/esp_init_data_default.bin \ 0x7E000 nodemcu-firmware/bin/blank.bin
Correction de notre code
Le module ‘timer’ du langage LUA, propose une fonction interruptive qui sera traité à intervalle paramétré.
A chaque appel, le timer alarme ‘tmr.alarm()’ transfert le pointeur d’exécution, à la fonction passé en paramètre au timer.
Si cette fonction est nommé ‘function()’ elle sera directement codé dans le module ‘tmr.alarm‘, à la suite de la déclaration.
C’est ce mode compact, que j’utilise dans la ré-écriture du code ‘blink‘.
Une utilisation plus conventionnel du module ‘tmr.alarm’ sera traité ultérieurement.
Saisir ou recopier le script suivant dans votre éditeur, nommé ce fichier blink.lua
allume=0 pin=3 gpio.mode(pin,gpio.OUTPUT) -- la broche 3 est fixé en sortie tmr.alarm(1,2000,1,function() -- tmr.alarm traité toute les 2 secondes - function() est codé ci-suivant if allume==0 then -- si le suis éteint allume=1 -- j'alume gpio.write(pin,gpio.HIGH) else -- sinon allume=0 -- j’éteins gpio.write(pin,gpio.LOW) end end)
Précédemment nous avions écrit notre code directement dans le module NodeMCU via les instructions file.writeline([[..]])
Le moins que l’on puisse dire, c’est que le mode d’écriture, consistant à saisir ligne à ligne, chacune des commandes en utilisant la commande file.writeline([[..]]) est assez contraignant.
Ce même constat à été fait par d’autres expérimentateurs, et des réponses ont été apportées pour soulager la création de programme sous LUA.
La solution la plus simple : la création, l’utilisation d’un script de transfert.
Le script python ‘luatool’ établie une connexion série avec le module ESP8266, puis automatise la phase de création du fichier cible, complète chaque ligne avec la séquence : (élément en gras)
file.writeline([[ la ligne de code ]])
et termine le fichier avec l’instruction de clôture du fichier.
5) Utilisation du script de transfert luatool
Sur la racine du répertoire de travail, je charge le gitub du script luatool.
$ git clone https://github.com/4refr0nt/luatool.git
Je vous laisse découvrir la doc, sur le gitub du projet.
Transfert du script ‘blink.lua’ sur l’ESP8266
python luatool.py --port /dev/ttyUSB0 --src blink.lua --dest init.lua --verbose
Puis un reset sur le module pour lancer la phase d’init, la LED est a nouveau en clignotement.
Contrairement au programme précédent qui bouclait sans fin, on peut se connecter avec la console série, pour stopper/ supprimer le programme d’init.
Au restart, plus de programme init().
Cela clos, cette première initiation à ESP8266, de LUA et du module ModeMCU.
Dans le chapitre suivant je vous propose de traiter un projet complet. Pour ce faire, nous allons au préalable étudier un environnement de développement (IDE), plus adapté à la réalisation d’un projet plus conséquent.
Un IDE pour l’ESP8266 & NodeMCU
Cette première prise en main de L’ESP8266 sous un mode console série, nous a fait découvrir les bases de fonctionnements en mode console série.
Cette approche console série, si elle peut être intéressante dans cette phase de découverte, elle reste peut adapté à la création de projet plus ambitieux. Nous somme habitué à des environnements plus complet intégrant la communication avec les plates-formes cibles, un éditeur pleine page, des correcteurs de syntaxe voir des débogueurs pour la correction de nos programme.
Si un outil aussi complet n’est pas encore disponible, il existe une bonne approche en Open Source pour l’ESP8266 :
l’IDE ESPlorer, est un projet Java, multiplate-forme, disponible sous Windows, Mac et aussi Linux.
La pré-existence de Java est donc nécessaire à l’installation d’ESPlorer.
Si vous n’avez pas encore installé Java sur votre machine, voir le lien, pour l’installation de la version la plus récente adapté à votre configuration.
Java est en place, nous pouvons à présent télécharger ESPlorer.
Enregistrer le fichier compressé dans votre répertoire de téléchargement. Décompresser et installer ESPlorer dans votre répertoire d’applications. Pour ma part j’ai opté pour :
Dans votre lanceur d’applications ajouter une nouvelle entrée sous votre Menu ‘Développement’, comme pour l’image suivante :
Pour la commande de lancement :
java -jar /opt/ESPlorer/ESPlorer.jar
Un clic sur cette nouvelle entrée du menu ‘ESPlorer’ pour obtenir :
Une interface bien plus riche que ce que nous avions précédemment avec la console série, très épure.
Pas de crainte nous allons explorer l’utilisation de cette interface, dans la cadre de notre premier projet.
Connexion du NodeMCU
Quitter ESPlorer, connecté NodeMCU, puis relancer ESPlorer. (il existe un BP de ré-synchronisation, nous verrons plus tard)
On remarque qu’ESPlorer reconnaît automatiquement le périphérique connecté. Dans mon cas : ‘/dev/ttyUSB0’
Chargement, Sauvegarde du programme ‘blink’
Pour débuté nous allons faire un copier/coller du programme ‘blink’ dans la fenêtre gauche d’ESPlorer (fenêtre de l’onglet ‘NEW’)
On sauvegarde “icone save” au-dessus de la fenêtre d’édition, sous le nom et répertoire de votre choix.
Pour ma part : $HOME/Developpement/µSystem/ESP/My-Prog/blink.lua
Versement et Exécution de ‘blink’ dans l’ESP8266
Avant de pouvoir verser un programme dans le module ESP8266, il est nécessaire d’ouvrir la connexion.
Par défaut la vitesse de connexion est paramétré à 9600 bauds.
Il suffit de cliquer sur le gros bouton ‘Open’ au-dessus de la fenêtre de droite, qui passe instantanément à Close avec le résultat de la connexion dans la fenêtre de contrôle.
Sous la fenêtre d’édition cliqué sur ‘Save&Run’
(Fin provisoire de l’article)
Notes et liens utilisé pour mes essais
On peut mais c’est pas très pratique. Je vous conseil d’utiliser ESPlorer un environnement dédié développement LUA et MicroPython qui cible les plate-forme EPS8266.
A.1) Outils pour flacher le firmware :
esptool : Dialogue en comm serie, flashage, … (Linux)
modmcu-flasher : (Windows)
ESP Flasher Tool : (Windows)
Building and Running MicroPython on the ESP8266 (Adafruit)
<– ### Commande de connexion au réseau Wifi –>
<- Sur le réseau freebox
<
< wifi.sta.config(“freebox_photon”,”AF007BC123”)
<
<- Sur le réseau interne Fonera
<
Récupération firmware en mode Windows
https://github.com/nodemcu/nodemcu-flasher
ESP8226 avec l’IDE Arduino
Exemples de codes & montages
ESP8266 and Arduino IDE - blink :
Voir simplement dans la liste des exemples dans IDE
Mini Client with the Arduino TRINKET and the ESP8266 :
Installing and Building an Arduino Sketch for the $5 ESP8266 Microcontroller :
Mise en place d’un container docker ESP
https://github.com/speakinghedge/docker-esp-open-sdk
utilise :
https://github.com/pfalcon/esp-open-sdk
esptool : Dialogue en comm serie, flashage, … (Linux)
Loading new firmware onto an ESP8266 :
Construire son propre firmware :
Flashing the NodeMCU firmware on the ESP8266 (Linux) - Guide
What is NodeMCU How to Code LUA Script with a Simple Lines of Code :
explication de connexion +++ :
Wifi with ESP8266 - Part 2
Wifi with ESP8266 - Part 3
App Inventor 2 - ESP8266 GPIO Control with Nodemcu LUA
NodeMCU ESP8266 simple httpd (web server) example
How to push code to an ESP8266 module : esp
Tool for loading Lua-based scripts from file to ESP8266 with nodemcu firmware : luatool
ESP8266 NodeMCU/LUA: Saving, Executing, and Compiling Script Files : ESPlorer
0x7c000 .bin/esp_init_data_default.bin 0x7e000 ./bin/blank.bin
Wifi detector using ESP8266 and NodeMCU
ESP8266 + ds18b20 + thingspeak+ nodemcu
ESP8266 / NodeMCU: Methods of Interrupting init.lua During Boot
internet-of-things-photon
Code for the Internet of Things with the Photon book
User customizable Bluetooth / Internet / WiFi remote control for Arduino, PIC, etc.
Adafruit - Using NodeMCU Lua
4 raisons pour lesquelles j’ai abandonnés NodeMCU/Lua pour ESP8266 :
Une liste non exhaustive (à compléter)
- ESPressif
- Olimex
- Adafruit
- Spark
- Wireless-tag
- Qilianer
- … ↩
Site officiel NodeMCU : ↩
