ESP32/ESP8266 : mises à jour MicroPython OTA via le serveur PHP

Dans ce projet, nous allons vous montrer un exemple de la façon dont vous pouvez effectuer des mises à jour OTA (over-the-air) sur vos cartes ESP32/ESP8266 exécutant du code MicroPython via un serveur PHP. En résumé, vous allez créer un serveur PHP dans lequel vous pourrez soumettre un nouveau code que vous souhaitez exécuter sur l’ESP. Lorsqu’un nouveau code/mise à jour est disponible, l’ESP télécharge le nouveau code, redémarre et commence à exécuter le code nouvellement téléchargé.

Ce projet a été créé par l’un de nos lecteurs : David Flory. Merci pour vos contributions. Il a fourni les exemples de codes et quelques explications, et nous documentons l’ensemble du processus dans ce didacticiel.

Vous n’êtes pas familier avec MicroPython ? Commencez ici.

Aperçu du projet

La mise à jour OTA (Over-the-Air) est le processus de chargement d’un nouveau micrologiciel sur la carte ESP32 ou ESP8266 à l’aide d’une connexion Wi-Fi plutôt que d’une communication série. Cette fonctionnalité est extrêmement utile en cas d’absence d’accès physique au tableau.

Il existe différentes manières d’effectuer des mises à jour OTA. Nous avons plusieurs exemples de mises à jour OTA utilisant les cartes ESP32/ESP8266 avec Arduino IDE. Dans ce didacticiel, nous allons créer un serveur PHP qui hébergera le code nouveau/mis à jour. L’ESP communiquera périodiquement avec le serveur pour vérifier si un nouveau code mis à jour est disponible et le téléchargera sur la carte si tel est le cas.

Le diagramme suivant explique comment tout fonctionne.

1. L’ESP32 ou l’ESP8266 exécute toutes les tâches que vous définissez.
2. Pendant ce temps, vous téléchargez un nouveau fichier python que vous souhaitez exécuter sur votre ESP sur le serveur Rpi PHP.
3. L’ESP vérifie périodiquement les mises à jour en effectuant une requête à l’URL get_ESP_data.php pour rechercher un nouveau program.py.
4. Si un nouveau fichier est disponible, l’ESP le téléchargera sur son système de fichiers et redémarrera.
5. Lorsqu’il redémarrera, il exécutera le fichier python nouvellement téléchargé.
6. Ce nouveau fichier contient une instruction au début du code pour faire une requête à l’URL delete_ESP_data.php pour supprimer le fichier python du serveur PHP car il exécute déjà le code le plus mis à jour.
7. Lorsque vous téléchargez un nouveau code, le processus se répète. Notez que le nouveau fichier python doit également contenir les instructions pour supprimer le fichier précédent du serveur PHP et vérifier les mises à jour.

Méthode alternative :

Voici une méthode alternative qui ne nécessite pas de supprimer les fichiers précédents et vous permet de mettre à jour plusieurs tableaux.

1. L’ESP32 ou l’ESP8266 exécute toutes les tâches que vous définissez.
2. Les fichiers que vous téléchargez ont un numéro de version sur le nom.
3. L’URL des mises à jour provient directement du nouveau programme que vous téléchargez (elle doit indiquer le nom du prochain fichier téléchargé).
4. Vous n’avez pas besoin de supprimer de fichiers car toutes les versions ont un nom unique. Ainsi, plusieurs cartes exécutant le même code peuvent se mettre à jour automatiquement car nous ne supprimons plus les fichiers du code, le fichier delete_ESP_data.php peut donc être supprimé.

Nous fournissons les fichiers pour cette méthode à la fin du tutoriel.

Pour aller plus loin :

Une meilleure façon de procéder pourrait être de créer une base de données SQL sur votre serveur, avec un enregistrement pour chaque ESP avec des champs pour l’ID (peut être l’adresse MAC), la version en cours d’exécution, le fichier temporel téléchargé (instructions non incluses).

Le PHP pourrait être ajusté pour :

• Demandez une pièce d’identité;
• Fournissez la mise à jour ;
• Mettez à jour le dossier de l’ESP qui fait la demande.

Conditions préalables

Avant de continuer, assurez-vous de vérifier les conditions préalables suivantes.

1) Programmation MicroPython

Dans ce didacticiel, nous programmerons les cartes ESP32/ESP8266 à l’aide de MicroPython. Vos cartes doivent être gravées avec le firmware MicroPython et vous devez disposer d’un IDE MicroPython pour programmer vos cartes. Nous utiliserons Thonny IDE, mais vous pouvez utiliser n’importe quel autre logiciel compatible MicroPython.

1. Premiers pas avec MicroPython sur ESP32 et ESP8266
2. Choisissez un IDE MicroPython pour ESP32 et ESP8266
3. Graver le firmware MicroPyhon à l’aide de l’IDE sélectionné

2) Serveur PHP

L’ESP communiquera périodiquement avec le serveur PHP pour vérifier s’il y a des mises à jour (un nouveau fichier avec un nouveau code MicroPython). Vous pouvez par exemple créer un serveur PHP local sur un Raspberry Pi, ou bien créer un serveur PHP sur le cloud (hébergement + nom de domaine) accessible de n’importe où.

Serveur PHP local

Pour cet exemple, nous allons créer un serveur PHP local sur un Raspberry Pi. Donc, vous avez également besoin d’un Raspberry Pi pour ce tutoriel :

1. Obtenez une carte Raspberry Pi : consultez les meilleurs kits de démarrage Raspberry Pi

Après avoir obtenu un Raspberry Pi, suivez les instructions suivantes pour le configurer :

2. Installez le système d’exploitation Raspberry Pi, configurez le Wi-Fi, activez et connectez-vous avec SSH

Nous fournirons les instructions pour créer le serveur PHP local dans ce tutoriel. Vous aurez également besoin d’un moyen de télécharger des fichiers à distance sur votre serveur PHP. Nous utiliserons Filezilla. Vous pouvez utiliser toute autre méthode appropriée.

3. Pour télécharger Filezilla, cliquez ici et téléchargez le client FileZilla.

Serveur PHP Cloud

Alternativement, vous pouvez créer votre serveur PHP sur le cloud en utilisant un hébergement Web et un nom de domaine. Nous recommandons Bluehost ou Digital Ocean. Ce didacticiel ne fournit pas d’instructions pour cela, mais si vous êtes habitué à héberger votre serveur PHP, vous comprendrez facilement comment procéder.

PARTIE 1 – Création du serveur PHP

Dans ce tutoriel, nous allons créer un serveur PHP local sur un Raspberry Pi. Alternativement, vous pouvez créer un serveur cloud PHP (instructions non incluses).

Avant de continuer, assurez-vous d’avoir installé le système d’exploitation Raspberry Pi, configurez le Wi-Fi et SSH.

Vous pouvez soit exécuter les commandes suivantes sur un Raspberry Pi défini comme ordinateur de bureau, soit en utilisant une connexion SSH.

Mise à jour et mise à niveau

Exécutez les commandes suivantes pour mettre à jour votre Pi. Cela prendra quelques minutes.

pi@raspberrypi:~ $ sudo apt update && sudo apt upgrade -y

Modifiez les autorisations afin que l’utilisateur pi puisse apporter des modifications aux fichiers.

pi@raspberrypi:~ $ sudo chown pi:pi*

Installation d’Apache2

Ensuite, installez Apache2. Apache2 est le logiciel de serveur Web le plus utilisé. Pour installer Apache2 sur votre Raspberry Pi, exécutez la commande suivante :

pi@raspberrypi:~ $ sudo apt install apache2 -y

C’est ça! Apache est maintenant installé. Pour tester votre installation, accédez au répertoire /var/www/html et listez les fichiers :

pi@raspberrypi:~ $ cd /var/www/html
pi@raspberrypi:/var/www/html $ ls -al
index.html

Vous devriez avoir un fichier index.html dans ce dossier. Pour ouvrir cette page dans votre navigateur, vous devez connaître l’adresse IP du Raspberry Pi. Utiliser:

pi@raspberrypi:/var/www/html $ hostname -I

Dans mon cas, l’adresse IP du Raspberry Pi est 192.168.1.86. Si vous ouvrez votre adresse IP RPi dans n’importe quel navigateur de votre réseau local, une page Web similaire devrait se charger (http://192.168.1.86) :

Installer PHP sur Raspberry Pi

PHP est un langage de script côté serveur. PHP (Hypertext Preprocessor) est utilisé pour développer des applications Web dynamiques. Un fichier PHP contient des balises et se termine par l’extension .PHP.

Pour installer PHP sur Raspberry Pi, exécutez :

pi@raspberrypi:/var/www/html $ sudo apt install php -y

Vous pouvez supprimer le fichier index.html et créer un script PHP pour tester l’installation :

pi@raspberrypi:/var/www/html $ sudo rm index.html
pi@raspberrypi:/var/www/html $ sudo nano index.php

Dans votre fichier index.php, ajoutez le code suivant pour faire écho au message « hello world » :

Pour enregistrer votre fichier : appuyez sur Ctrl+X, suivi de y, et appuyez sur Entrée pour quitter.

Enfin, redémarrez Apache2 :

pi@raspberrypi:/var/www/html $ sudo service apache2 restart

Pour tester si Apache2 sert des fichiers .php, ouvrez l’adresse IP du Raspberry Pi et il devrait afficher le message « hello world » du script index.php créé précédemment.

Si tout fonctionne, vous pouvez supprimer le fichier index.php du répertoire /var/www/html :

pi@raspberrypi:/var/www/html $ sudo rm index.php

Création du serveur php – get_ESP_data.php

Maintenant, créez un fichier appelé get_ESP_data.php.

pi@raspberrypi: sudo nano get_ESP_data.php

Saisissez le code PHP suivant :

Appuyez sur Ctrl+X, suivi de y, puis appuyez sur Entrée pour quitter et enregistrer le fichier. Ce script précédent lit le fichier mis à jour (nouveau code téléchargé dans le même répertoire que celui où se trouvent ces fichiers) et le renvoie en réponse à une requête faite par l’ESP lorsqu’il appelle la fonction check_for_updates comme nous le verrons plus tard.

Création du serveur php – delete_ESP_data.php

Créez un autre fichier appelé delete_ESP_data.php.

pi@raspberrypi: sudo nano delete_ESP_data.php

Saisissez le code PHP suivant :

Appuyez sur Ctrl+X, suivi de y, puis appuyez sur Entrée pour quitter et enregistrer le fichier. Ce fichier supprimera le fichier de mise à jour du serveur PHP une fois que l’ESP l’aura téléchargé.

C’est ça. Le serveur PHP est créé et capable de renvoyer un nouveau fichier à l’ESP et de le supprimer en réponse à différentes requêtes.

PARTIE 2 – Programmation de l’ESP32/ESP8266

Avant de continuer, assurez-vous d’avoir gravé vos cartes avec le firmware MicroPython.

Pour tester le serveur PHP et l’intégrer aux cartes ESP pour effectuer des mises à jour OTA, nous allons vous montrer un exemple simple. Cet exemple nécessite trois fichiers : boot.py, main.py et program.py.

boot.py

À l’aide de votre IDE MicroPython préféré, créez un fichier appelé boot.py avec le contenu suivant et téléchargez-le sur votre tableau.

# OTA updater for ESP32 running Micropython by David Flory
# Tutorial: https://www.raspberryme.com/esp32-esp8266-micropython-ota-updates/

try:
  import usocket as socket
except:
  import socket

try:
  import urequests as requests
except:
  import requests
import os 
import sys
import esp
esp.osdebug(None)
import gc
gc.collect()
from utime import sleep
from utime import sleep_ms
import network

OTA = 0

Afficher le code brut

Ce fichier importe les bibliothèques requises pour la connexion réseau. Il crée également une variable booléenne appelée OTA qui indique s’il est temps d’effectuer une mise à jour OTA (télécharger le nouveau fichier depuis le serveur PHP).

OTA = 0

L’ESP exécute d’abord boot.py. Lors de sa première exécution, aucune mise à jour n’est disponible, nous définissons donc la variable OTA sur 0.

main.py

Créez un fichier appelé main.py avec le contenu suivant et téléchargez-le sur votre tableau. Vous devez modifier le fichier pour inclure vos propres informations d’identification réseau et l’URL du serveur PHP pour les mises à jour.

"""
OTA updater for ESP32 running Micropython by David Flory.
Tutorial: https://www.raspberryme.com/esp32-esp8266-micropython-ota-updates/

This is a simple way to run a python program on the ESP32 and download updates or a different program
to run from an HTTP server, either from the web or your local network.

Put all the imports needed for internet in boot, plus a global variable called OTA
The main file creates the internet connection then runs whatever program is required. I call the program 'program.py'

program.py is the main program, and can be whatever you want. The only requisite for this to work with OTA is that
it must be imported into the module 'main' and it must check periodically for updates.
The Program should have a function that can be called by 'main' to start it.

We can overwrite program.py while it is running, because it has been imported on boot into the namespace of 'main'.
All that is required is a reboot after a new Program.py is downloaded. In this case the deep sleep function will reboot the ESP32.

"""
#When prog.py finishes, if OTA = True, main downloads it and overwrites program.py, then effectively reboots.
#If OTA is false main just exits.

#this is the program to be executed. Note we do not use the '.py' extension.
import program

import machine #needed for the deep sleep function

#URLs for the updates
#replace with your PHP server URL or local IP address (Raspberry Pi IP Address)
upd_url="http://192.168.1.XXX/get_ESP_data.php?file=program.py"


#change your wifi credentials here. 
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'

print('OTA is ' + str(OTA))#debug

#here we set up the network connection
station = network.WLAN(network.STA_IF)
station.active(False)
station.active(True)
#station.config(reconnects = 5)

station.connect(ssid,password)

while station.isconnected() == False:
  pass

#print board local IP address
print(station.ifconfig())

if OTA == 0:
    print('starting program')
    OTA = program.mainprog(OTA)
    
#mainprog() is the starting function for my program. OTA is set to 0 on boot so the first time this code
#is run, it sets up the network connection and then runs the program.
#The following code only runs when program.py exits with OTA = 1

if OTA == 1:
    print('Downloading update')
    #download the update and overwrite program.py
    response = requests.get(upd_url)
    x = response.text.find("FAIL")
    if x > 15:
        #download twice and compare for security
        x = response.text
        response = requests.get(upd_url)
        if response.text == x:
            f = open("program.py","w")
            f.write(response.text)
            f.flush()
            f.close
            
            #soft reboot 
            print('reboot now')
            machine.deepsleep(5000)

Afficher le code brut

Voici un résumé de ce que fait ce fichier :

• connecte votre tableau à Internet ;
• exécute les tâches de votre programme (quoi que vous définissiez dans le fichier program.py, nous y reviendrons plus tard)
• lorsque vous avez terminé vos tâches, s’il y a une mise à jour, elle la téléchargera et écrasera le fichier program.py existant
• après cela, il s’endort profondément pendant quelques secondes ;
• après le réveil d’un sommeil profond, tout recommence avec le nouveau code téléchargé (mise à jour OTA réussie).

Jetons un coup d’œil rapide au code.

La ligne suivante importe le fichier program.py> : il s’agit du programme à exécuter, il doit contenir les tâches que vous souhaitez que votre ESP effectue. Notez que nous n’utilisons pas l’extension .py.

import program

Ensuite, importez le module de machine nécessaire à la fonction de veille profonde.

import machine

Modifiez la variable upd_url avec l’adresse IP ou l’URL de votre serveur PHP. Dans mon cas, l’adresse PHP du serveur Raspberry Pi est 192.168.1.86, donc upd_url devrait être comme suit :

upd_url="http://192.168.1.86/get_ESP_data.php?file=program.py"

Insérez vos informations d’identification réseau dans les variables suivantes, afin que l’ESP puisse se connecter à votre réseau.

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'

La ligne suivante imprime l’état actuel de la variable OTA à des fins de débogage.

print('OTA is ' + str(OTA))

L’extrait de code suivant connecte la carte à votre réseau local et imprime son adresse IP :

#here we set up the network connection
station = network.WLAN(network.STA_IF)
station.active(False)
station.active(True)
station.config(reconnects = 5)

station.connect(ssid,password)

while station.isconnected() == False:
  pass

#print board local IP address
print(station.ifconfig())

Enfin, il vérifie la valeur de la variable OTA. S’il vaut 0, il exécute le programme principal qui contient vos tâches (main.py).

mainprog() est la fonction de démarrage de notre programme. OTA est défini sur 0 au démarrage, donc la première fois que ce code s’exécute, il configure la connexion réseau puis exécute le programme.

if OTA == 0:
    print('starting program')
    OTA = program.mainprog(OTA)

Le code suivant ne s’exécute que lorsque program.py se termine avec OTA = 1. Cette section du code récupère le contenu du program.py qui se trouve sur le serveur PHP et l’enregistre sur la carte dans le programme program.py, afin qu’il écrase le fichier program.py actuellement existant. Après cela, il se met en veille pendant cinq secondes (c’est comme un redémarrage en douceur). Au prochain redémarrage de la carte, elle exécutera le nouveau code.

if OTA == 1:
    print('Downloading update')
    #download the update and overwrite program.py
    response = requests.get(upd_url)
    x = response.text.find("FAIL")
    if x > 15:
        #download twice and compare for security
        x = response.text
        response = requests.get(upd_url)
        if response.text == x:
            f = open("program.py","w")
            f.write(response.text)
            f.flush()
            f.close
            
            #soft reboot 
            print('reboot now')
            machine.deepsleep(5000)

programme.py

Créez un fichier appelé program.py. Modifiez le code pour inclure l’adresse IP de votre serveur local. Ensuite, téléchargez-le sur votre tableau.

Il s’agit d’un programme simple pour démontrer la fonctionnalité de mise à jour OTA en conjonction avec main.py. Le programme peut être aussi simple ou compliqué que vous le souhaitez mais doit contenir ces fonctions : check_for_updates(), mainprog() et program_tasks().

"""
OTA updater for ESP32 running Micropython by David Flory.
Tutorial: https://www.raspberryme.com/esp32-esp8266-micropython-ota-updates/

A simple program to demonstrate OTA update functionality in conjunction with main.py
The program can be as simple or complicated as you like, but must contain these functions.
The variable 'url' should be the full web address to the location of the update file and the PHP script which
returns it. below is the PHP script, named 'get_ESP_data.php'.



The script reads the update file and echo's it back in response to the request made by the
'check_for_updates' function.

Here is the delete script for deleting the updates.


"""
import urequests
from utime import sleep
#The URL to use to get updates, full path to the PHP script (Raspberry Pi IP Address). The update file must be in the same
#directory as the PHP script.
#REPLACE WITH YOUR RASPBERRY PI IP ADDRESS
upd_url="http://192.168.1.XXX/get_ESP_data.php?file=program.py"
del_url = "http://192.168.1.XXX/delete_ESP_data.php?file=program.py"

def check_for_updates(OTA):
    try:
        #print ('Checking for updates')
        response = urequests.get(upd_url)
        x = response.text.find("FAIL")
        if x > 15:
            OTA = 1
            print('There is an update available')
            return(OTA)
        else:
            print('There are no updates available.')
            return(OTA)

    except:
        print('unable to reach internet')
        return(OTA)


def mainprog(OTA):
    print('Mainprog - OTA is' + str(OTA))
    #This is the entry point for your program code
    #first delete any update files on server. The reasoning here is that if this program is an update we
    #do not want to download it again. If this program is not an update, it is unlikely there will be an
    #update present anyway. If we do not delete it, the program will keep on updating on every loop and rebooting.
    response = urequests.get(del_url)
    print('Program start')
    while OTA == 0:
        program_tasks()
        OTA = check_for_updates(OTA)
        if OTA == 1:
           return(OTA)
        print('OTA = ' + str(OTA))

def program_tasks():
    #do program tasks. If continuous loop, use counter or sleep to pass some time between
    #update checks. At your designated point, check for updates.
    sleep(2)
    print('Tasks completed, entering loop 2')
    sleep(2)
    print('Tasks completed, entering loop 3')
    sleep(2)
    print('Tasks completed, entering loop 4')
    sleep(2)
    print('Tasks completed, entering loop 5')
    sleep(2)
    print('5 loops completed, checking for updates')

Afficher le code brut

Jetons un coup d’œil rapide au code pour voir comment il fonctionne.

Tout d’abord, importez tous les modules qui pourraient être nécessaires à vos tâches. Vous devez inclure la bibliothèque urequests pour que l’ESP puisse faire des requêtes au serveur PHP.

import urequests
from utime import sleep

Mettez à jour les variables suivantes pour inclure l’adresse IP de votre serveur PHP local ou l’URL de votre serveur Web cloud. Modifiez uniquement la section avec l’adresse IP. Le reste de l’URL doit rester tel qu’indiqué.

upd_url="http://192.168.1.86/get_ESP_data.php?file=program.py"
del_url = "http://192.168.1.86/delete_ESP_data.php?file=program.py"

La fonction check_for_updates() vérifie si des mises à jour sont disponibles en faisant une requête sur upd_url. Il renvoie la valeur de la variable OTA : 0 s’il n’y a pas de mise à jour, ou 1 s’il y a une mise à jour :

def check_for_updates(OTA):
    try:
        #print ('Checking for updates')
        response = urequests.get(upd_url)
        x = response.text.find("FAIL")
        if x > 15:
            OTA = 1
            print('There is an update available')
            return(OTA)
        else:
            print('There are no updates available.')
            return(OTA)

    except:
        print('unable to reach internet')
        return(OTA)

Le mainprog() est le point d’entrée de votre code de programme (cette fonction est appelée sur le fichier main.py).

def mainprog(OTA):
    print('Mainprog - OTA is' + str(OTA))
    response = urequests.get(del_url)
    print('Program start')
    while OTA == 0:
        program_tasks()
        OTA = check_for_updates(OTA)
        if OTA == 1:
           return(OTA)
        print('OTA = ' + str(OTA))

Tout d’abord, il supprime tous les fichiers de mise à jour sur le serveur en effectuant une requête sur del_url. Le raisonnement ici est que si ce programme est une mise à jour, nous ne voulons pas le télécharger à nouveau. Si ce programme n’est pas une mise à jour, il est peu probable qu’une mise à jour soit disponible de toute façon. Si nous ne le supprimons pas, le programme continuera à se mettre à jour à chaque boucle et redémarrage.

Enfin, la fonction program_tasks() doit inclure les tâches que vous souhaitez effectuer avec votre carte, comme les lectures de capteurs, l’enregistrement des données, le contrôle des sorties ou toute autre tâche. Pour plus de simplicité, nous imprimons simplement les messages sur le shell MicropPython.

def program_tasks():
    #do program tasks. If continuous loop, use counter or sleep to pass some time between
    #update checks. At your designated point, check for updates.
    sleep(2)
    print('Tasks completed, entering loop 2')
    sleep(2)
    print('Tasks completed, entering loop 3')
    sleep(2)
    print('Tasks completed, entering loop 4')
    sleep(2)
    print('Tasks completed, entering loop 5')
    sleep(2)
    print('5 loops completed, checking for updates')

Si vous utilisez une boucle continue, utilisez un compteur ou dormez pour passer un certain temps entre les vérifications de mise à jour. À l’endroit désigné, vérifiez les mises à jour.

Si vous ne l’avez pas encore fait, téléchargez tous les fichiers précédents sur votre tableau dans cet ordre : boot.py, main.py et program.py. Réinitialisez votre carte pour qu’elle commence à exécuter le code. Il devrait imprimer les messages suivants sur le shell (c’est dans la fonction program_tasks).

Laissez la carte connectée à votre ordinateur afin que nous puissions voir sur la coque si les mises à jour ont réussi et que vous compreniez son fonctionnement. Cet exemple est uniquement à des fins de démonstration car le but de l’OTA est que vous n’ayez pas besoin de connecter votre carte à votre ordinateur.

PARTIE 3 – Démonstration : mises à jour OTA

Maintenant, créez un nouveau fichier également appelé program.py et enregistrez-le sur votre ordinateur. Ce fichier contiendra le code mis à jour. Dans notre cas, nous modifierons uniquement les messages imprimés sur le Shell. Nous téléchargerons ce code en direct sur votre carte ESP via le serveur PHP.

# OTA updater for ESP32 running Micropython by David Flory
# Tutorial: https://www.raspberryme.com/esp32-esp8266-micropython-ota-updates/

#This program essentially identical to program1, except the tasks are slightly
#different to demonstrate a different program is now running.

import urequests
from utime import sleep
#The URL to use to get updates, full path to the PHP script (Raspberry Pi IP Address). The update file must be in the same
#directory as the PHP script.
#REPLACE WITH YOUR RASPBERRY PI IP ADDRESS
upd_url="http://192.168.1.XXX/get_ESP_data.php?file=program.py"
del_url = "http://192.168.1.XXX/delete_ESP_data.php?file=program.py"

def check_for_updates(OTA):
    try:
        #print ('Checking for updates')
        response = urequests.get(upd_url)
        x = response.text.find("FAIL")
        if x > 15:
            OTA = 1
            print('There is an update available')
            return(OTA)
        else:
            print('There are no updates available.')
            return(OTA)

    except:
        print('unable to reach internet')
        return(OTA)


def mainprog(OTA):
    print('Mainprog - OTA is' + str(OTA))
    #This is the entry point for your program code
    #first delete any update files on server. The reasoning here is that if this program is an update we
    #do not want to download it again. If this program is not an update, it is unlikely there will be an
    #update present anyway. If we do not delete it, the program will keep on updating on every loop and rebooting.
    response = urequests.get(del_url)
    print(response)
    print('Program start')
    while OTA == 0:
        program_tasks()
        OTA = check_for_updates(OTA)
        if OTA == 1:
           return(OTA)
        print('OTA = ' + str(OTA))

def program_tasks():
    #do program tasks. If continuous loop, use counter or sleep to pass some time between
    #update checks. At your designated point, check for updates.
    sleep(2)
    print('Updated Program 2, entering loop 2')
    sleep(2)
    print('Updated Program 2, entering loop 3')
    sleep(2)
    print('Updated Program 2, entering loop 4')
    sleep(2)
    print('Updated Program 2, entering loop 5')
    sleep(2)
    print('5 loops completed, checking for updates')

Afficher le code brut

Remarque : dans une application pratique, assurez-vous que votre code fonctionne correctement avant d’effectuer une mise à jour en direct. Si le nouveau code plante, vous devrez peut-être reconnecter votre carte à votre ordinateur pour pouvoir résoudre le problème.

Pour télécharger le nouveau programme sur le serveur PHP, nous utiliserons Filezilla. Vous pouvez utiliser n’importe quelle autre méthode appropriée. Gardez simplement à l’esprit que vous devez placer le fichier program.py dans le même répertoire que les fichiers PHP que nous avons créés précédemment. Si vous avez tout suivi comme dans le tutoriel, le fichier doit être placé dans le répertoire /var/www/html.

Pour établir une communication avec le Pi, voici les paramètres (par défaut) :

• Hôte : framboisepi
• Nom d’utilisateur : pi
• Mot de passe : Raspberry Pi
• Port : 22

Après avoir téléchargé le nouveau fichier sur Filezilla, l’ESP devrait détecter la présence d’un nouveau fichier et le téléchargera. Ensuite, il se mettra en veille profonde et commencera à exécuter le code nouvellement téléchargé. Ce nouveau code imprime un message différent du précédent.

Méthode alternative

Comme mentionné précédemment, voici une méthode alternative qui ne nécessite pas de supprimer les fichiers précédents et vous permet de mettre à jour plusieurs cartes.

1. L’ESP32 ou l’ESP8266 exécute toutes les tâches que vous définissez.
2. Les fichiers que vous téléchargez ont un numéro de version.
3. L’URL des mises à jour provient directement du nouveau programme que vous téléchargez (elle doit indiquer le nom du prochain fichier téléchargé).
4. Vous n’avez pas besoin de supprimer de fichiers car toutes les versions ont un nom unique. Ainsi, plusieurs cartes exécutant le même code peuvent se mettre à jour car nous ne supprimons plus les fichiers du code, le fichier delete_ESP_data.php peut donc être supprimé.
5. Les utilisateurs devront supprimer périodiquement leurs propres fichiers une fois que tous les tableaux auront été mis à jour.

Les fichiers précédents ont été modifiés pour cette méthode alternative. Voici les fichiers :

Conclusion

Dans ce tutoriel, vous avez appris à mettre à jour un nouveau code par liaison radio sur vos cartes ESP32 ou ESP8266 (programmées avec MicroPython) à l’aide d’un serveur PHP. À titre d’exemple, nous avons construit un serveur Web PHP local sur un Raspberry Pi.

Nous espérons que vous avez trouvé ce tutoriel utile. Si vous souhaitez en savoir plus sur MicroPython, consultez nos ressources :

Merci d’avoir lu.

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :