Programmer un microcontrôleur 32 bits en langage Python dans l'EDI Zerynth Studio

Concevoir des applications pour l'Internet des Objets

| UbiMaker | Maria Carlina Hernandez |

Traducteur

f-leb

Dans ce tutoriel, vous apprendrez à développer des applications pour l'Internet des Objets (IdO) en langage Python sur une grande variété de microcontrôleurs 32 bits grâce à la suite Zerynth. Les données des capteurs seront publiées en ligne sur la plateforme Cloud Ubidots (API REST) à des fins d'analyse ou de visualisation. Enfin, vous verrez comment contrôler votre dispositif connecté depuis un widget sur le tableau de bord de votre session Ubidots.

Commentez

- Titre : Programmer un microcontrôleur 32 bits en langage Python dans l'EDI Zerynth Studio

- Auteurs : UbiMaker, Maria Carlina Hernandez

- Traducteur : f-leb

- Parution : 19 novembre 2018

- Licence : Le contenu de cet article est rédigé par Maria Carlina Hernandez et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- I. Introduction

- II. Ressources nécessaires

- III. Installation et configuration de Zerynth

- IV. Poster des données sur Ubidots

- V. Contrôler son dispositif connecté depuis Ubidots

- VI. Conclusion

- VII. Notes de la rédaction Developpez.com

I - Introduction

Vous préférez coder en Python ? Si c'est bien le cas, Zerynth est justement une suite professionnelle comportant des outils de développement en Python ou en une version hybride C/Python pour microcontrôleurs 32 bits et la plupart des cartes de prototypage du marché : Arduino DUE, ST Nucleo, Particle Photon et Electron, Flip&Click, ESP32, ESP8266, et bien d'autres encore. Dans ce tutoriel, on explorera le développement en Python dans l'environnement Zerynth Studio et comment simplement visualiser les données de capteurs sur la plateforme IdO d'Ubidots.

Zerynth n'est pas seulement une bibliothèque de plus pour Arduino associé à un kit de capteurs. C'est un ensemble d'outils professionnels de développement créé de toutes pièces pour vous permettre d'accéder au monde de l'embarqué en quelques clics. Zerynth ne s'adresse pas uniquement aux développeurs professionnels du domaine de l'embarqué. Il offre également aux programmeurs Web, aux concepteurs de produits et aux intégrateurs de systèmes IdO un ensemble complet d'outils de développement de haute qualité pour programmer des microcontrôleurs et développer des solutions pour l'Internet des Objets (IdO).

Zerynth est compatible avec de nombreuses cartes de développement et permet une rapide intégration avec des capteurs, des actionneurs et des services Cloud, réduisant le temps et les efforts de développement des produits.

Dans ce tutoriel, on vous présentera la suite Zerynth pour programmer un ESP32-DevKitC connecté aux services Cloud d'Ubidots. À la fin de ce tutoriel, vous serez en mesure de visualiser les données de votre capteur sur Ubidots et de contrôler une LED à l'aide d'exemples de code fournis.

II - Ressources nécessaires

ESP32-DevKitC

L'ESP32-DevKitC sur le site officiel du constructeur Espressif : https://www.espressif.com/en/products/hardware/esp32-devkitc/overview.

Pour les besoins du tutoriel, vous connecterez :

- un capteur analogique sur l'entrée A0 (capteur de température ou autre) ;

- une LED en série avec une résistance de limitation de courant sur D3.

La carte du kit sera reliée à un PC via un câble USB.

Zerynth Studio

L'EDI de développement Python cross-platform de Zerynth : https://www.zerynth.com/zerynth-studio/.

Compte Ubidots

Vous pouvez souscrire un compte Educational ou Professional.

III - Installation et configuration de Zerynth

Téléchargez et installez Zerynth Studio. Aidez-vous du guide d'installation au besoin.

Poursuivez avec le guide Getting Started en prêtant attention à la section « Connect, Register and Vitualize your Device ». Une fois votre carte de développement correctement enregistrée et virtualisée dans l'EDI Zerynth, vous êtes prêt à poursuivre ce tutoriel.

Pour les utilisateurs sous Windows et Mac, si vous avez des erreurs en créant la Machine Virtuelle, vérifiez que les dernières versions des drivers ont bien été installées. Pour les utilisateurs sous Linux, il faut autoriser les accès aux ports série en ajoutant l'utilisateur au groupe et en donnant les droits en lecture/écriture :

- distribution Ubuntu → groupe dialout ;

- distribution Arch Linux → groupe uucp.

IV - Poster des données sur Ubidots

Créez un nouveau projet Zerynth. Pour cela, allez dans Browser Project > New Project puis renseignez le titre du projet et son dossier. Pour finir, cliquez sur « Create » :

Par la suite, votre nouveau projet Zerynth va automatiquement créer un fichier main.py. Ce fichier main.py est l'endroit où le code principal de l'application sera écrit en Python ou en langage hybride C/Python :

Une fois le projet correctement créé, copiez et collez le code ci-dessous dans la fenêtre d'édition du fichier main.py. Après avoir collé le code, renseignez le jeton (TOKEN) Ubidots et les informations d'identification Wi-Fi (SSID et mot de passe) aux endroits indiqués dans le code :

################################################################################
# Ubidots POST ESP32DevKitC
#
# Created at 2017-10-09 22:15:06.348664
# Authors: M. Hernandez
################################################################################
import streams  # import streams
import json     # import json
import adc      # import the adc module
import requests # import the http module
from wireless import wifi # import the wifi interface
from espressif.esp32net import esp32wifi as wifi_driver # networking driver for the wifi module
# assign Ubidots parameters
device_label = "esp32" # Ubidots device label
variable_label = "temperature" # Ubidots variable label
token = "Ubidots_TOKEN_here" # ubidots TOKEN
# create a serial port stream with default parameters
streams.serial()
# define the analog pin (A0) for reading the value
inputAnalog = A0
# set the pin as input with INPUT_ANALOG,
pinMode(inputAnalog,INPUT_ANALOG)
# init the wifi driver
wifi_driver.auto_init()
print("Establishing connection...")
try:
# change network name "ssid-name", security and password "ssid-pass" as needed
wifi.link("ssid-name",wifi.WIFI_WPA2,"ssid-pass")
print("Connected!")
except Exception as e:
print("Something wrong while connection. Verify your WiFi credentials", e)
while True:
sleep(1000)
# build the JSON directory to be sent
def build_json(variable, value):
try:
data = {variable: {"value": value}}
return data
except:
return None
# send the POST HTTP request to Ubidots
# reference to the Ubidots REST API reference for more information (https://ubidots.com/docs/api/)
def post_var(device_label, variable_label, value, token):
# Ubidots API access
url = "http://things.ubidots.com/api/v1.6/devices/" + device_label + "/?token=" + token
# data to be sent
data = build_json(variable_label, value)
# sends the request
response = requests.post(url, json=data)
# prints the status and the content of the request
print("Http Status:",response.status)
print("Http Content:",response.content)
print("---------------------------------")
return response

while True:
try:
# read the input on analog pin 0
sensorValue = adc.read(inputAnalog)
# send the POST HTTP request to Ubidots
print("Posting variables to Ubidots")
post_var(device_label, variable_label, sensorValue, token)

except Exception as e:
print(e)
sleep(2000)

Si vous ne savez pas comment retrouver votre jeton Ubidots (TOKEN), référez-vous à l'aide Ubidots.

Au préalable, sur votre session Ubidots, vous aurez créé un device nommé « esp32 » et une nouvelle variable nommée « temperature ».

Dans l'exemple du code ci-dessus, le label du dispositif (device label) est « esp32 » et le label de la variable (variable label) est « temperature ». Cela signifie que votre requête HTTP sera envoyée avec ces paramètres à Ubidots. Vous pouvez modifier cette partie du code au besoin.

Ce script envoie une requête POST HTTP à Ubidots. Une unique variable contenant la valeur lue sur le port analogique (A0) de l'ESP32-DevKitC est postée. Pour envoyer davantage de valeurs et apprendre comment construire vos propres requêtes HTTP : Ubidots API.

Avec le code précédent mis à jour avec vos informations d'identification, vous devez maintenant vérifier votre code en le compilant. Pour cela, cliquez sur l'icône avec la coche comme indiqué ci-dessous :

Une fois le code vérifié, il est temps de le téléverser (Uplink) dans l'ESP32-DevKitC. Pour cela, cliquez sur l'icône avec une flèche dirigée vers le haut comme indiqué ci-dessous :

Attendez quelques secondes, le temps que le code se téléverse dans la carte. Une fois le téléversement terminé, vous verrez le message « Uplink done » dans le terminal de Zerynth Studio.

Ouvrez la console afin de visualiser le statut des requêtes envoyées. Cliquez sur l'icône « open Console » comme indiqué ci-dessous :

Dans un premier temps, vous verrez s'afficher le statut de la connexion Wi-Fi dans la console. Puis vous commencerez à recevoir le statut des différentes requêtes HTTP retournées par Ubidots.

Si aucun message n'apparaît dans la console, pressez le bouton reset de la carte ESP32-DevKitC.

Sur votre compte Ubidots, allez à la section Device pour vérifier la bonne réception du message :

V - Contrôler son dispositif connecté depuis Ubidots

Le projet du chapitre précédent a permis de voir comment poster des données vers Ubidots (requête HTTP POST) afin d'analyser et visualiser en ligne les données du capteur. On propose de concevoir un nouveau projet où cette fois l'ESP32-DevKitC interroge à intervalle régulier l'état d'un bouton virtuel On/Off du tableau de bord de votre session Ubidots (requête HTTP GET) pour allumer ou éteindre une vraie LED.

Allez à la section Device de votre session Ubidots et ouvrez votre dispositif connecté nommé « esp32 » créé lors du chapitre précédent.

Créez une nouvelle variable (Default variable) nommée « control » en cliquant sur « Add Variable » :

Suivez les instructions en pointant-cliquant sur l'écran du générateur d'applications pour créer vos nouvelles variables. Une fois que la variable est créée, le tableau de bord de votre dispositif devrait ressembler à l'écran ci-dessous :

Allez à votre tableau de bord principal Ubidots (Dashboard) et créez un nouveau widget de contrôle. Cliquez sur l'icône « + » en jaune, et suivez les options proposées pour déployer de nouveaux widgets sur le tableau de bord. Sélectionnez Control > Switch > esp32 > control (la variable qui vient juste d'être créée) > Finish.

Après avoir défini votre nouveau widget, le tableau de bord va être rafraîchi et fera apparaître celui-ci :

Interrogé par l'ESP32-DevKitC, Ubidots renverra l'état On/Off du widget « Switch », et l'ESP allumera ou éteindra la LED selon l'état retourné.

Suivez les mêmes étapes que dans le chapitre précédent, configurez un nouveau projet dans Zerynth et donnez-lui un titre. Copiez-collez le code ci-dessous dans la fenêtre d'édition du script main.py, en complétant le jeton Ubidots (TOKEN) et les informations d'identification Wi-Fi aux endroits indiqués.

################################################################################
# Ubidots GET ESP32DevKitC
#
# Created at 2017-10-09 22:15:06.348664
# Authors: M. Hernandez
################################################################################
import streams  # import streams
import json     # import json
import adc      # import the adc module
import requests # import the http module
from wireless import wifi # import the wifi interface
# ESP32 WiFi driver (Sparkfun Esp32 Thing, Olimex Esp32, ...)
from espressif.esp32net import esp32wifi as wifi_driver # networking driver for the wifi module
# assign ubidots parameters
device_label = "esp32" # ubidots device label
variable_label = "control" # ubidots variable label
token = "your_ubidots_TOKEN_here" # ubidots TOKEN
# create a serial port stream with default parameters
streams.serial()
# init the wifi driver
wifi_driver.auto_init()
# set the pin as OUTPUT
pinMode(D3,OUTPUT)
print("Establishing Connection...")
try:
# change network name "ssid-name", security and password "ssid-pass" as needed
wifi.link("ssid-name",wifi.WIFI_WPA2,"ssid-pass")
print("Connected")
except Exception as e:
print("Something wrong while connection. Verify your WiFi credentials", e)
while True:
sleep(1000)
# send the GET HTTP request to Ubidots
def get_value(device_label, variable_label, token):
# Ubidots API access
url = "http://things.ubidots.com/api/v1.6/devices/" + device_label + "/" + variable_label + "/lv?token=" + token
# sends the request
response = requests.get(url)
# verify the status of the request
if response.status != 200:
return None
print("---------------------------------")
print("Http Status:",response.status)
# return the last value obtained
return response.content
while True:
# getting last value from Ubidots
last_value = get_value(device_label, variable_label, token)
# verify if the last value received is not 'None'
if last_value is not None:
last_value  = float(last_value) * 1.0
# led control
if last_value >= 1.0:
print("LED ON")
digitalWrite(D3, HIGH)  # turn the LED ON by setting the voltage HIGH
else:
print("LED OFF")
digitalWrite(D3, LOW)   # turn the LED OFF by setting the voltage LOW
sleep(1500) # minimum time sleep allowed

Ce code contrôle une LED connectée à la broche D3 de l'ESP32-DevKitC.

Une fois les paramètres modifiés, vérifiez et téléversez le code dans l'ESP32-DevKitC.

Le code étant téléversé, ouvrez la console. À l'ouverture de la celle-ci, vous verrez le statut de la connexion Wi-Fi, puis suivront le statut des requêtes HTTP à Ubidots et l'état de la LED.

Si vous ne voyez aucun message à l'ouverture de la console, pressez le bouton reset de l'ESP32-DevKitC.

Modifiez l'état du widget « Switch » depuis le tableau de bord d'Ubidots. Cela aura pour conséquence de changer le statut de la LED dans la console, ainsi que dans la vraie vie où l'état de la LED devrait basculer allumé/éteint.

VI - Conclusion

En quelques minutes, vous avez pu soumettre des requêtes HTTP vers le Cloud d'Ubidots avec du code Python écrit dans l'EDI Zerynth, et téléversé dans un ESP32-DevKitC. Vous pouvez simplement adapter le code à n'importe quel microcontrôleur supporté par Zerynth en choisissant le driver Wi-Fi approprié, et faire du prototypage et du déploiement très rapidement. Pour davantage d'informations sur la plateforme Zerynth, voir la documentation Zerynth.

Il est maintenant temps de retravailler les codes proposés afin de déployer vos propres applications. Apprenez à contrôler et gérer vos environnements avec Zerynth, les microcontrôleurs 32 bits et Ubidots. Pour en apprendre davantage sur la création de widgets et d'événements Ubidots : User guides.

VII - Notes de la rédaction Developpez.com

Vous retrouverez la version originale de ce tutoriel sur le site hackster.io sous le titre : Design IoT Solutions Using Python And Zerynth.

Nous remercions les membres de la rédaction de Developpez.com pour le travail de traduction et de relecture qu'ils ont effectué, en particulier : f-leb, Vincent PETIT et jacques_jean.