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

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.

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.

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.

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.

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

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.

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.

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.

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.