MicroPython : Gestionnaire Wi-Fi avec ESP32 et ESP8266

Dans ce didacticiel, nous allons vous montrer comment utiliser Wi-Fi Manager avec l’ESP32 à l’aide du micrologiciel MicroPython. Wi-Fi Manager vous permet de connecter votre ESP32 à différents points d’accès (différents réseaux) sans avoir à coder en dur vos informations d’identification et à télécharger un nouveau code sur votre carte.

Ce guide est également entièrement compatible avec la carte ESP8266. Cependant, comme la bibliothèque du gestionnaire Wi-Fi utilise beaucoup de mémoire, vous pouvez rencontrer une erreur de mémoire lors de l’enregistrement du script sur votre carte. D’après notre expérience, redémarrer la carte après avoir téléchargé le script, supprime l’erreur et fait fonctionner le projet après cela. Nous vous recommandons d’utiliser l’ESP32, mais vous pouvez également continuer ce tutoriel en utilisant une carte ESP8266.

Comment fonctionne le gestionnaire Wi-Fi

Avec le gestionnaire Wi-Fi, vous n’avez plus besoin de coder en dur vos identifiants réseau (SSID et mot de passe). L’ESP32 configurera un point d’accès que vous pourrez utiliser pour configurer les informations d’identification du réseau, ou il se joindra automatiquement à un réseau enregistré connu.

Voici comment fonctionne le processus :

• Lorsque l’ESP32 démarre pour la première fois, il est défini comme un point d’accès ;
• Vous pouvez vous connecter à ce point d’accès en établissant une connexion avec le réseau WiFiManager et en vous rendant à l’adresse IP 192.164.4.1 ;
• Une page Web s’ouvre qui vous permet de choisir et de configurer un réseau ;
• L’ESP32 enregistre ces informations d’identification réseau afin qu’il puisse plus tard se connecter à ce réseau (mode Station) ;
• Une fois qu’un nouveau SSID et un nouveau mot de passe sont définis, l’ESP32 redémarre, il est défini en mode Station et essaie de se connecter au réseau précédemment enregistré ;
• S’il établit une connexion, le processus est terminé avec succès. Sinon, il sera configuré en tant que point d’accès pour vous permettre de configurer de nouvelles informations d’identification réseau.

Pour configurer le gestionnaire Wi-Fi sur l’ESP32 à l’aide de MicroPython, nous utiliserons le Bibliothèque WiFiManager par tayfunulu. Dans la page GitHub de la bibliothèque, vous pouvez trouver le diagramme suivant qui montre un aperçu de la façon dont tout fonctionne.

Conditions préalables

Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé sur votre carte ESP. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

Pièces requises

Pour ce tutoriel, vous avez besoin d’un ESP32 (ou Carte ESP8266):

En savoir plus sur MicroPython : prenez notre eBook sur la programmation MicroPython avec ESP32 et ESP8266.

Bibliothèque MicroPython WiFiManager

La bibliothèque pour configurer Wi-Fi Manager sur l’ESP32 ne fait pas partie de la bibliothèque MicroPython standard par défaut. Donc, vous devez télécharger la bibliothèque suivante sur votre carte ESP (enregistrez-la avec ce nom exact wifimgr.py).

import network
import socket
import ure
import time

ap_ssid = "WifiManager"
ap_password = "tayfunulu"
ap_authmode = 3  # WPA2

NETWORK_PROFILES = 'wifi.dat'

wlan_ap = network.WLAN(network.AP_IF)
wlan_sta = network.WLAN(network.STA_IF)

server_socket = None


def get_connection():
    """return a working WLAN(STA_IF) instance or None"""

    # First check if there already is any connection:
    if wlan_sta.isconnected():
        return wlan_sta

    connected = False
    try:
        # ESP connecting to WiFi takes time, wait a bit and try again:
        time.sleep(3)
        if wlan_sta.isconnected():
            return wlan_sta

        # Read known network profiles from file
        profiles = read_profiles()

        # Search WiFis in range
        wlan_sta.active(True)
        networks = wlan_sta.scan()

        AUTHMODE = {0: "open", 1: "WEP", 2: "WPA-PSK", 3: "WPA2-PSK", 4: "WPA/WPA2-PSK"}
        for ssid, bssid, channel, rssi, authmode, hidden in sorted(networks, key=lambda x: x[3], reverse=True):
            ssid = ssid.decode('utf-8')
            encrypted = authmode > 0
            print("ssid: %s chan: %d rssi: %d authmode: %s" % (ssid, channel, rssi, AUTHMODE.get(authmode, '?')))
            if encrypted:
                if ssid in profiles:
                    password = profiles[ssid]
                    connected = do_connect(ssid, password)
                else:
                    print("skipping unknown encrypted network")
            else:  # open
                connected = do_connect(ssid, None)
            if connected:
                break

    except OSError as e:
        print("exception", str(e))

    # start web server for connection manager:
    if not connected:
        connected = start()

    return wlan_sta if connected else None


def read_profiles():
    with open(NETWORK_PROFILES) as f:
        lines = f.readlines()
    profiles = {}
    for line in lines:
        ssid, password = line.strip("n").split(";")
        profiles[ssid] = password
    return profiles


def write_profiles(profiles):
    lines = []
    for ssid, password in profiles.items():
        lines.append("%s;%sn" % (ssid, password))
    with open(NETWORK_PROFILES, "w") as f:
        f.write(''.join(lines))


def do_connect(ssid, password):
    wlan_sta.active(True)
    if wlan_sta.isconnected():
        return None
    print('Trying to connect to %s...' % ssid)
    wlan_sta.connect(ssid, password)
    for retry in range(100):
        connected = wlan_sta.isconnected()
        if connected:
            break
        time.sleep(0.1)
        print('.', end='')
    if connected:
        print('nConnected. Network config: ', wlan_sta.ifconfig())
    else:
        print('nFailed. Not Connected to: ' + ssid)
    return connected


def send_header(client, status_code=200, content_length=None ):
    client.sendall("HTTP/1.0 {} OKrn".format(status_code))
    client.sendall("Content-Type: text/htmlrn")
    if content_length is not None:
      client.sendall("Content-Length: {}rn".format(content_length))
    client.sendall("rn")


def send_response(client, payload, status_code=200):
    content_length = len(payload)
    send_header(client, status_code, content_length)
    if content_length > 0:
        client.sendall(payload)
    client.close()


def handle_root(client):
    wlan_sta.active(True)
    ssids = sorted(ssid.decode('utf-8') for ssid, *_ in wlan_sta.scan())
    send_header(client)
    client.sendall("""
        <html>
            <h1 style="color: #5e9ca0; text-align: center;">
                <span style="color: #ff0000;">
                    Wi-Fi Client Setup
                </span>
            </h1>
            <form action="configure" method="post">
                <table style="margin-left: auto; margin-right: auto;">
                    <tbody>
    """)
    while len(ssids):
        ssid = ssids.pop(0)
        client.sendall("""
                        <tr>
                            <td colspan="2">
                                <input type="radio" name="ssid" value="{0}" />{0}
                            </td>
                        </tr>
        """.format(ssid))
    client.sendall("""
                        <tr>
                            <td>Password:</td>
                            <td><input name="password" type="password" /></td>
                        </tr>
                    </tbody>
                </table>
                <p style="text-align: center;">
                    <input type="submit" value="Submit" />
                </p>
            </form>
            <p>&nbsp;</p>
            <hr />
            <h5>
                <span style="color: #ff0000;">
                    Your ssid and password information will be saved into the
                    "%(filename)s" file in your ESP module for future usage.
                    Be careful about security!
                </span>
            </h5>
            <hr />
            <h2 style="color: #2e6c80;">
                Some useful infos:
            </h2>
            <ul>
                <li>
                    Original code from <a href="https://github.com/cpopp/MicroPythonSamples"
                        target="_blank" rel="noopener">cpopp/MicroPythonSamples</a>.
                </li>
                <li>
                    This code available at <a href="https://github.com/tayfunulu/WiFiManager"
                        target="_blank" rel="noopener">tayfunulu/WiFiManager</a>.
                </li>
            </ul>
        </html>
    """ % dict(filename=NETWORK_PROFILES))
    client.close()


def handle_configure(client, request):
    match = ure.search("ssid=([^&]*)&password=(.*)", request)

    if match is None:
        send_response(client, "Parameters not found", status_code=400)
        return False
    # version 1.9 compatibility
    try:
        ssid = match.group(1).decode("utf-8").replace("%3F", "?").replace("%21", "!")
        password = match.group(2).decode("utf-8").replace("%3F", "?").replace("%21", "!")
    except Exception:
        ssid = match.group(1).replace("%3F", "?").replace("%21", "!")
        password = match.group(2).replace("%3F", "?").replace("%21", "!")

    if len(ssid) == 0:
        send_response(client, "SSID must be provided", status_code=400)
        return False

    if do_connect(ssid, password):
        response = """
            <html>
                <center>
                    <br><br>
                    <h1 style="color: #5e9ca0; text-align: center;">
                        <span style="color: #ff0000;">
                            ESP successfully connected to WiFi network %(ssid)s.
                        </span>
                    </h1>
                    <br><br>
                </center>
            </html>
        """ % dict(ssid=ssid)
        send_response(client, response)
        try:
            profiles = read_profiles()
        except OSError:
            profiles = {}
        profiles[ssid] = password
        write_profiles(profiles)

        time.sleep(5)

        return True
    else:
        response = """
            <html>
                <center>
                    <h1 style="color: #5e9ca0; text-align: center;">
                        <span style="color: #ff0000;">
                            ESP could not connect to WiFi network %(ssid)s.
                        </span>
                    </h1>
                    <br><br>
                    <form>
                        <input type="button" value="Go back!" onclick="history.back()"></input>
                    </form>
                </center>
            </html>
        """ % dict(ssid=ssid)
        send_response(client, response)
        return False


def handle_not_found(client, url):
    send_response(client, "Path not found: {}".format(url), status_code=404)


def stop():
    global server_socket

    if server_socket:
        server_socket.close()
        server_socket = None


def start(port=80):
    global server_socket

    addr = socket.getaddrinfo('0.0.0.0', port)[0][-1]

    stop()

    wlan_sta.active(True)
    wlan_ap.active(True)

    wlan_ap.config(essid=ap_ssid, password=ap_password, authmode=ap_authmode)

    server_socket = socket.socket()
    server_socket.bind(addr)
    server_socket.listen(1)

    print('Connect to WiFi ssid ' + ap_ssid + ', default password: ' + ap_password)
    print('and access the ESP via your favorite web browser at 192.168.4.1.')
    print('Listening on:', addr)

    while True:
        if wlan_sta.isconnected():
            return True

        client, addr = server_socket.accept()
        print('client connected from', addr)
        try:
            client.settimeout(5.0)

            request = b""
            try:
                while "rnrn" not in request:
                    request += client.recv(512)
            except OSError:
                pass

            print("Request is: {}".format(request))
            if "HTTP" not in request:  # skip invalid requests
                continue

            # version 1.9 compatibility
            try:
                url = ure.search("(?:GET|POST) /(.*?)(?:\?.*?)? HTTP", request).group(1).decode("utf-8").rstrip("/")
            except Exception:
                url = ure.search("(?:GET|POST) /(.*?)(?:\?.*?)? HTTP", request).group(1).rstrip("/")
            print("URL is {}".format(url))

            if url == "":
                handle_root(client)
            elif url == "configure":
                handle_configure(client, request)
            else:
                handle_not_found(client, url)

        finally:
            client.close()

Afficher le code brut

Suivez les instructions suivantes pour l’IDE que vous utilisez :

• A. Téléchargez la bibliothèque WiFiManager avec IDE uPyCraft
• B. Téléchargez la bibliothèque WiFiManager avec Thonny IDE

A. Télécharger la bibliothèque WiFiManager avec uPyCraft IDE

Cette section montre comment télécharger une bibliothèque à l’aide de l’IDE uPyCraft. Si vous utilisez Thonny IDE, lisez la section suivante.

1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton.

2. Copiez le code de la bibliothèque WiFiManager dans ce fichier. Le code de la bibliothèque WiFiManager peut être copié ici.

3. Après avoir copié le code, enregistrez le fichier en appuyant sur la touche Sauvegarder bouton.

4. Nommez ce nouveau fichier « wifimgr.py » et appuyez sur d’accord.

5. Clique le Télécharger et exécuter bouton.

Le fichier doit être enregistré dans le dossier de l’appareil sous le nom « wifimgr.py», comme le montre la figure suivante.

Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

B. Télécharger la bibliothèque WiFiManager avec Thonny IDE

Si vous utilisez Thonny IDE, suivez les étapes suivantes :

1. Copiez le code de la bibliothèque dans un nouveau fichier. Le code de la bibliothèque WiFiManager peut être copié ici.

2. Enregistrez ce fichier sous wifimgr.py.

3. Aller à Appareil > Télécharger le script actuel avec le nom actuel.

Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, dans le Shell, vous pouvez taper :

%lsdevice

Il devrait renvoyer les fichiers actuellement enregistrés sur votre tableau. L’un d’eux devrait être le wifimgr.py déposer.

Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

Code – Configuration du gestionnaire Wi-Fi avec l’ESP32

Le code suivant implémente Wi-Fi Manager sur l’ESP32. Nous ajouterons les fonctionnalités de Wi-Fi Manager à un précédent projet de serveur Web MicroPython. À la fin du didacticiel, vous devriez être en mesure d’implémenter Wi-Fi Manager dans vos projets gagnés.

Créer un main.py fichier et copiez le code suivant.

# Complete project details at https://Raspberryme.com

import wifimgr
from time import sleep
import machine

try:
  import usocket as socket
except:
  import socket

led = machine.Pin(2, machine.Pin.OUT)

wlan = wifimgr.get_connection()
if wlan is None:
    print("Could not initialize the network connection.")
    while True:
        pass  # you shall not pass 😀

# Main Code goes here, wlan is a working network.WLAN(STA_IF) instance.
print("ESP OK")

def web_page():
  if led.value() == 1:
    gpio_state="ON"
  else:
    gpio_state="OFF"
  
  html = """<html><head> <title>ESP Web Server</title> <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" href="https://www.raspberryme.com/micropython-wi-fi-manager-esp32-esp8266/data:,"> <style>html{font-family: Helvetica; display:inline-block; margin: 0px auto; text-align: center;}
  h1{color: #0F3376; padding: 2vh;}p{font-size: 1.5rem;}.button{display: inline-block; background-color: #e7bd3b; border: none; 
  border-radius: 4px; color: white; padding: 16px 40px; text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}
  .button2{background-color: #4286f4;}</style></head><body> <h1>ESP Web Server</h1> 
  <p>GPIO state: <strong>""" + gpio_state + """</strong></p><p><a href="/?led=on"><button class="button">ON</button></a></p>
  <p><a href="/?led=off"><button class="button button2">OFF</button></a></p></body></html>"""
  return html
  
try:
  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  s.bind(('', 80))
  s.listen(5)
except OSError as e:
  machine.reset()

while True:
  try:
    if gc.mem_free() < 102000:
      gc.collect()
    conn, addr = s.accept()
    conn.settimeout(3.0)
    print('Got a connection from %s' % str(addr))
    request = conn.recv(1024)
    conn.settimeout(None)
    request = str(request)
    print('Content = %s' % request)
    led_on = request.find('/?led=on')
    led_off = request.find('/?led=off')
    if led_on == 6:
      print('LED ON')
      led.value(1)
    if led_off == 6:
      print('LED OFF')
      led.value(0)
    response = web_page()
    conn.send('HTTP/1.1 200 OKn')
    conn.send('Content-Type: text/htmln')
    conn.send('Connection: closenn')
    conn.sendall(response)
    conn.close()
  except OSError as e:
    conn.close()
    print('Connection closed')

Afficher le code brut

Comment fonctionne le code

Ce code est basé sur un précédent projet de serveur Web ESP32/ESP8266 MicroPython. Nous venons d’apporter quelques modifications pour ajouter le gestionnaire Wi-Fi.

Pour ajouter le gestionnaire Wi-Fi, vous devez importer la bibliothèque que vous avez précédemment téléchargée sur votre tableau.

import wifimgr

Les lignes de code suivantes gèrent le gestionnaire Wi-Fi pour vous :

wlan = wifimgr.get_connection()
if wlan is None:
    print("Could not initialize the network connection.")
    while True:
        pass  # you shall not pass :D

réseau sans fil est un travail réseau.WLAN(STA_IF) instance qui est initialisée par la bibliothèque. Ainsi, vous n’avez pas besoin de l’inclure pour définir votre ESP32 en tant que station.

Lorsque l’ESP32 est défini pour la première fois en tant que point d’accès, il laisse un socket ouvert, ce qui entraîne une erreur et fait planter l’ESP32. Pour s’assurer que cela ne se produise pas, nous initialisons et lions le socket à l’intérieur essayer et à l’exception déclarations.

try:
  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  s.bind(('', 80))
  s.listen(5)
except OSError as e:
  machine.reset()

Au cas où il y aurait un socket ouvert, nous obtiendrons une erreur de système d’exploitation et réinitialiserons l’ESP32 avec machine.reset(). Cela « oubliera » le socket ouvert.

Lorsque le code s’exécute pour la deuxième fois, les informations d’identification du réseau sont déjà enregistrées, de sorte que l’ESP32 n’est pas défini comme un point d’accès, il n’y a aucun problème avec les sockets ouverts et le code se déroule sans problème.

Tester le WiFiManager

Téléchargez le main.py fichier sur votre ESP32. Après cela, appuyez sur le bouton RST (EN) embarqué de l’ESP32 pour lancer l’exécution du programme.

Sur le Python Shell, vous devriez obtenir un message similaire.

Cela signifie que l’ESP32 a été configuré avec succès en tant que point d’accès. Maintenant, vous pouvez vous connecter à ce point d’accès pour choisir votre réseau et saisir vos informations d’identification. Pour ce faire, suivez les étapes suivantes.

Sur votre ordinateur ou smartphone, ouvrez les paramètres Wi-Fi et connectez-vous au Gestionnaire Wifi réseau.

Le mot de passe est tayfunulu. Vous pouvez modifier le SSID et le mot de passe par défaut sur le code de la bibliothèque.

Une fois que vous êtes connecté avec succès au réseau WiFiManager, ouvrez un navigateur et tapez 192.168.4.1. La page suivante devrait se charger :

Sélectionnez votre réseau, tapez le mot de passe et cliquez sur Soumettre. Après quelques secondes, vous devriez recevoir un message de réussite.

Ce message signifie que votre ESP32 est configuré comme une station Wi-Fi et qu’il est connecté à votre réseau local. Maintenant, pour accéder à l’ESP32, allez à nouveau dans vos paramètres Wi-Fi dans votre ordinateur ou smartphone et connectez-vous à nouveau à votre réseau.

Dans le shell Python, l’adresse IP ESP32 doit être imprimée.

Noter: dans un scénario du monde réel, vous n’aurez probablement pas accès au shell Python. Dans ce cas, nous vous recommandons d’imprimer l’adresse IP sur un écran OLED.

Ouvrez votre navigateur et saisissez cette adresse IP. Vous aurez accès au serveur Web suivant et vous pourrez contrôler l’ESP32 GPIO.

Conclusion

Avec la bibliothèque WiFiManager, vous n’avez plus besoin de coder en dur vos informations d’identification réseau. L’ESP32 définit un point d’accès qui affiche les réseaux Wi-Fi disponibles. Il vous suffit de choisir votre réseau et de saisir votre mot de passe pour paramétrer l’ESP32 en station Wi-Fi.

Nous espérons que vous avez trouvé ce tutoriel utile. Tu pourrais aussi aimer:

En savoir plus sur MicroPython avec notre eBook : Programmation MicroPython avec ESP32 et ESP8266

Merci d’avoir lu.