Premiers pas avec Python pour ESP8266 et ESP32 : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Informations

L'ESP8266 et son jeune grand frère ESP32 sont des micropuces Wi-Fi à faible coût avec une pile TCP/IP complète et une capacité de microcontrôleur. La puce ESP8266 a attiré l'attention de la communauté des fabricants pour la première fois en 2014. Depuis lors, son prix bas (<5 USD), sa capacité Wi-Fi, une mémoire flash intégrée de 1 ou 4 Mo et une variété de développements disponibles cartes, a fait de la puce ESP l'un des microcontrôleurs les plus populaires pour les projets de bricolage WiFi et IoT.

MicroPython est une implémentation allégée et efficace du langage de programmation Python de plus en plus populaire qui comprend un petit sous-ensemble de la bibliothèque standard Python et est optimisé pour s'exécuter sur des microcontrôleurs.

La combinaison de ces deux est une option très intéressante pour les projets de bricolage, à la fois pour les débutants et les utilisateurs plus avancés.

Le projet MiPy-ESP

En 2015, mes premiers projets avec ESP8266 ont commencé avec la puce ESP-01 utilisant Arudions pour exécuter les commandes AT de la puce via une connexion série. Après cela, au cours des années suivantes, j'ai appliqué le noyau Arduino pour ESP8266 pour programmer les puces avec le langage C++. Cela fonctionne bien, mais pour un passionné de Python, ma découverte de l'implémentation MicroPython de Python 3 était une excellente nouvelle.

Le projet MiPy-ESP est un cadre flexible appliquant MicroPython pour les projets Python IoT à pile complète sur les microcontrôleurs de la famille ESP.

Le framework est développé par l'équipe de développeurs de logiciels du comité technique de LeGarage (LG-TC-SWDT-01) dans le but de remplacer le code déjà établi basé sur C++ pour nos applications de microcontrôleurs.

Le projet fournit des fonctionnalités de base telles que

• Procédures de connexion réseau
• Serveur Web du point d'accès à puce (pour la connexion Wi-Fi et le service des pages Web de la puce pour les E/S de données)
• Fonctionnalités MQTT
• Journalisation/débogage
• Planification d'événements de microcontrôleur
• Routines d'E/S matérielles

Avec un script de code compact principal (main.py), le tout avec une configuration globale (config.py).

Ce code de microcontrôleur fonctionne avec une maintenance robuste des connexions de puces au réseau WiFi et aux courtiers MQTT. Les modules MicroPython existants pour divers matériels peuvent être facilement intégrés au système.

Le framework MiPy-ESP est devenu l'épine dorsale de tous nos projets IoT d'électronique de loisir impliquant des microcontrôleurs de la famille ESP. Il a été testé sur plusieurs cartes de la famille ESP, comme les cartes NodeMCU, Wemos et Lolin.

Le didacticiel suivant est un guide expliquant comment démarrer avec les microcontrôleurs de la famille ESP et MicroPython à l'aide du framework MiPy-ESP.

Étape 1: La carte Wemos D1 Mini ESP8266

Le framework MiPy-ESP fonctionne avec la plupart des microcontrôleurs basés sur ESP8266.

La mini carte de développement Wemos D1 est basée sur la puce ESP-8266EX. Sur une empreinte de 2,5 x 3,5 cm, il dispose d'une mémoire flash de 4 Mo, de 11 broches d'entrée/sortie numériques, toutes les broches prennent en charge les interruptions, PWM, I2C, SPI, série et 1 entrée analogique avec une entrée maximale de 3,3 V, peut fonctionner sur une alimentation de 5 V, a une connexion micro USB et est compatible avec les maquettes. Son petit prix et sa petite taille en ont fait ma planche ESP préférée.

De plus, la version D1 mini pro de la carte est livrée avec une option pour connecter une antenne externe, augmentant considérablement la portée de connexion (+100 m de portée). En plus de cela, la carte est également livrée avec une variété de cartes d'extension prêtes à l'emploi avec une taille compacte similaire.

Étape 2: Se préparer pour MicroPython sur la puce ESP

Dans cette première étape, vous

• Connectez la carte ESP via USB à votre ordinateur
• Installez le logiciel Esptool pour flasher la puce
• Effacer la mémoire de la puce
• Flasher la puce avec le firmware MicroPython
• Installez Rshell pour activer l'interaction en ligne de commande avec votre puce
• Installer mpy-cross (pour la compilation de fichiers.py en binaire)

La connexion de la carte à votre ordinateur via des cartes USB avec un port série USB intégré rend l'UART disponible sur votre PC et constitue l'option la plus simple pour commencer. Pour les cartes sans connexion USB, un module FTDI avec USB vers série peut être utilisé pour connecter les broches GPIO pour flasher connectées au monde extérieur, mais cela n'est pas couvert dans ce tutoriel.

Pour MicroPython utilisant le code MiPy-ESP, l'exigence minimale pour la taille flash de la puce est de 1 Mo. Il existe également une version spéciale pour les cartes de 512 Ko, mais elle ne prend pas en charge un système de fichiers dont dépend MiPy-ESP.

Lorsque vous utilisez un câble USB, la carte est alimentée par votre ordinateur lorsqu'elle est connectée. Cela permet également la programmation et le débogage via la connexion série. Lorsque le code du projet est téléchargé et que votre projet est déployé, une alimentation externe est appliquée sur les broches d'alimentation de la carte.

Installation d'EsptoolLes informations sur le logiciel Esptool sont disponibles dans le référentiel Esptool GitHub. Si vous souhaitez utiliser Windows/Linux/OSX (MAC), le lien ci-dessus couvre également cela. Le package Python peut être installé par

pip installer esptool

Pour les utilisateurs de Linux, les packages pour Esptool sont maintenus pour Debian et Ubuntu, et peuvent également être installés avec

sudo apt installer esptool

Effacement de la mémoire flash ESPA l'aide d'Esptool, vous effacez ensuite la mémoire flash ESP avec la commande

esptool.py --port /dev/ttyUSB0 effacer_flash

Téléchargement du micrologiciel MicroPytonLe micrologiciel MicroPython réside dans un fichier.bin qui peut être téléchargé à partir du site Web MicroPython.

La branche actuelle du maître de projet du référentiel a été testée et est opérationnelle avec Micropython v.1.12. Afin d'assurer le succès avec le framework MiPY-ESP, téléchargez le fichier 'esp8266-2091220-v1.12.bin' à partir de ce lien et écrivez le firmware sur la puce par la commande:

esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 esp8266-2091220-v1.12.bin

Installation de RshellLe package Rshell permet une interaction en ligne de commande avec votre environnement MicroPython installé sur la puce. Il peut être trouvé dans ce lien. Rshell est un shell simple qui s'exécute sur l'hôte et utilise le raw-REPL de MicroPython pour envoyer des extraits de code python au pyboard afin d'obtenir des informations sur le système de fichiers et de copier des fichiers vers et depuis le système de fichiers de MicroPython. REPL signifie Read Evaluate Print Loop et est le nom donné à l'invite interactive MicroPython à laquelle vous pouvez accéder sur l'ESP8266. L'utilisation du REPL est de loin le moyen le plus simple de tester votre code et d'exécuter des commandes. Installez Rshell par la commande:

sudo pip installer rshell

Installation du compilateur mpy-cross MicroPython peut être appliqué avec des fichiers ascii.py téléchargés sur le système de fichiers de la puce. MicroPython définit également le concept de fichiers.mpy qui est un format de fichier conteneur binaire contenant du code précompilé et pouvant être importé comme un module.py normal. En compilant les fichiers.py en.mpy, plus de mémoire RAM sera disponible pour votre code en cours d'exécution - et cela est nécessaire pour avoir un module de base fonctionnel du framework MiPy-ESP.

Pour le déploiement de code MiPy-ESP, un compilateur croisé mpy-cross MicroPython compile les scripts.py en.mpy avant le téléchargement de la puce. Installez le package mpy-cross en suivant les instructions de ce lien. Alternativement, la commande mpy-cross peut être installée par la commande Python pip ou exécutée à partir du chemin du dossier mpy-cross si vous clonez le référentiel MicroPython à partir de GitHub ici.

Vous avez maintenant MicroPython et tous les outils nécessaires installés pour commencer à construire votre premier projet MiPy-ESP

Étape 3: Premiers pas avec MiPy-ESP

Dans cette étape, vous allez

Télécharger le framework MyPy-ESP

Téléchargement du framework MiPy-ESPLe projet MiPy-ESP est disponible sur GitHub dans ce référentiel de code. Depuis GitHub, vous pouvez télécharger la structure du fichier du référentiel ou la cloner sur votre ordinateur en

git clone

Avec le référentiel de code installé sur votre ordinateur, vous disposez désormais de tous les modules de code dont vous avez besoin pour créer un projet ESP IoT prêt à l'emploi. Plus de détails sur la boîte à outils à l'étape suivante.

Étape 4: L'architecture du cadre MiPy-ESP

Dans cette étape, vous allez

en savoir plus sur le workflow de code MiPy-ESP

Architecture de code MiPy-ESP

Tous les modules du framework Python se trouvent dans le dossier /src du référentiel de code MiPY-ESP. Le dossier src/core contient les modules de base qui entrent dans chaque projet. Le dossier src/drivers contient une sélection de modules pour divers matériels à connecter à votre puce. Le dossier src/utilities contient des modules utilitaires facultatifs à inclure dans votre projet.

Les fichiers main.py et config.py se trouvent dans le dossier src/. Voici les principaux fichiers à éditer pour construire votre projet:

config.py:

Ce fichier est le fichier de configuration global de votre projet. Il a divers paramètres, tous avec des commentaires descriptifs dans le fichier.

main.py:

C'est le script principal de la boucle de code du microcontrôleur. Il contient le code spécifique à l'application dans le framework. Au démarrage de la puce, main.py exécute et importe tous les modules dépendants du projet avec les entrées données du fichier config.py. L'organigramme ci-dessus montre la disposition du script main.py.

La figure ci-dessus décrit le workflow de main.py:

1. Au démarrage, le code tente de connecter la puce au réseau Wi-FiLes réseaux précédemment appliqués et leurs mots de passe (cryptés sur puce) sont stockés dans la mémoire flash. Les SSID du réseau et leurs mots de passe peuvent être provisionnés dans le fichier wifi.json au format {" SSID1":"Mot de passe", "SSID":"Mot de passe2"}. Les réseaux donnés dans ce fichier sont stockés, les mots de passe sont cryptés et le fichier est supprimé au démarrage.
2. Si aucun réseau connu n'est trouvé, le code configure un serveur Web de point d'accès (AP). Le SSID et le mot de passe du serveur AP de la puce sont définis dans le fichier config.py. En vous connectant au SSID de la puce, une page Web pour la connexion de la puce au Wi-Fi est servie à 192.168.4.1. Les réseaux détectés sont affichés dans un menu, ou le SSID peut être entré manuellement (réseaux cachés) avec le mot de passe Wi-Fi. Une fois la connexion réussie de la puce au Wi-Fi, le serveur AP s'arrête et le code main.py passe aux étapes suivantes.

3. Dans la section Configuration de main.py,

   • des fonctions pour les travaux et les rappels (rappels MQTT, etc.) et les événements réguliers sont définis.
   • Différentes tâches temporisées pour l'exécution des fonctions sont définies.
   • Le client du courtier MQTT est établi

4. Le code passe ensuite dans la boucle principale du microcontrôleur,

   • vérifier en permanence les connexions réseau et courtier MQTT,
   • Abonnements MQTT,
   • E/S matérielles
   • et les travaux programmés.
   • En cas de perte de connexion au réseau ou au courtier MQTT, le code tente de se rétablir.

Étape 5: Préparation de votre code de projet

Dans cette étape, vous allez

• en savoir plus sur la structure de fichiers du référentiel MiPy-ESP
• préparez votre code de projet pour le téléchargement de la puce

Structure des dossiers du référentiel La figure ci-dessus décrit la structure des dossiers du référentiel et répertorie les modules actuels du framework. Votre projet est en étapes dans le dossier src/. Les modules de base du framework MiPy-ESP résident dans src/core, les modules utilitaires en option dans src/utilities et les modules matériels dans src/drivers.

La plupart des bibliothèques matérielles MicroPython disponibles peuvent aller dans le dossier drivers/ sans aucune modification. Tous les pilotes présents sont testés avec le framework MiPy-ESP. Concernant les modules dans le dossier utilitaires/, d'autres seront ajoutés au fur et à mesure qu'ils prendront vie.

Mise en scène du code du projet Votre code spécifique à votre projet doit être placé dans le dossier src/. Déjà là, se trouvent les fichiers main.py et config.py que vous pouvez modifier. Copiez également les utilitaires de projet souhaités de src/utilities et src/drivers vers src/.

Au cas où vous voudriez fournir des réseaux Wi-Fi connus et des mots de passe à la puce, ajoutez le fichier wifi.json à src/.

Compilation et préparation pour le téléchargementUn Makefile fourni peut être appliqué pour préparer les fichiers à transférer sur la puce en compilant les fichiers.py dans /src, en compilant les modules de base et en transférant les fichiers compilés dans un nouveau dossier nommé build/ par la commande

faire construire

Les fichiers en construction sont prêts à être téléchargés sur le système de fichiers de la puce. Par défaut, main.py et config.py ne sont pas compilés en binaire, afin d'y accéder facilement pour l'inspection des puces déployées. La commande:

rendre propre

Supprime le dossier build/ et son contenu.

Étape 6: Compilation et téléchargement du code sur le microcontrôleur

Dans cette section, vous

• télécharger les fichiers préparés dans build/ à partir de la dernière section
• démarrer et surveiller le code en cours d'exécution

Télécharger des fichiers de construction/avec Rshell

Téléchargez tous les fichiers du répertoire /build sur la puce ESP à l'aide de Rshell. Avec le microcontrôleur connecté à l'USB, à partir du dossier build/start Rshell avec la commande

rshell -p /dev/ttyUSB0

Ensuite, inspectez les fichiers de puce (le cas échéant) en

ls / pyboard

Tous les fichiers sur puce peuvent être supprimés par

rm /pyboard/*.*

Copiez tous les fichiers de projet dans build/ sur la puce:

cp *.* /pyboard

Démarrez ensuite le terminal Python interactif par la commande

remplacer

Vous pouvez maintenant appeler des commandes Python ou importer des modules et surveiller la sortie série de la puce à partir du module d'enregistrement MiPy-ESP.

Redémarrez la puce en appuyant sur le bouton de réinitialisation, ou à partir de la ligne de commande en

importation principale

ou

machine d'importation

puis

machine.reset()

En fonction de vos paramètres de journalisation/débogage dans le fichier de configuration du projet, le repl affichera désormais les messages de débogage de la puce ESP via la connexion série.

Cela devrait, espérons-le, vous aider à démarrer.