MicroPython: administrador de Wi-Fi con ESP32 (compatible con ESP8266)

En este artículo aprenderás todo lo que necesitas saber sobre cómo utilizar MicroPython para administrar tu conexión Wi-Fi en dispositivos ESP32 (también compatible con ESP8266). Descubre cómo configurar y controlar tu red inalámbrica de forma sencilla y eficiente con esta potente herramienta de programación. ¡No te pierdas esta guía completa para sacar el máximo provecho de tus dispositivos IoT!

En este tutorial le mostraremos cómo usar Wi-Fi Manager con ESP32 usando el firmware MicroPython. Wi-Fi Manager le permite conectar su ESP32 a diferentes puntos de acceso (diferentes redes) sin tener que codificar sus credenciales y cargar un nuevo código en su placa.

Esta guía también es totalmente compatible con la placa ESP8266. Sin embargo, dado que la biblioteca de Wi-Fi Manager requiere bastante memoria, puede ocurrir un error de memoria al guardar el script en su placa. Según nuestra experiencia, reiniciar el tablero después de cargar el script corrige el error y hace que el proyecto funcione posteriormente. Recomendamos usar el ESP32, pero también puedes continuar este tutorial con una placa ESP8266.

Así funciona el Administrador de Wi-Fi

Con Wi-Fi Manager, ya no necesitará codificar sus credenciales de red (SSID y contraseña). El ESP32 configura un punto de acceso que le permite configurar credenciales de red o se conecta automáticamente a una red guardada conocida.

Así es como funciona el proceso:

• Cuando el ESP32 arranca por primera vez, se configura como punto de acceso.
• Puedes conectarte a este punto de acceso conectándote a la red WiFiManager y dirigiéndote a la dirección IP 192.164.4.1;
• Se abrirá una página web donde podrá seleccionar y configurar una red.
• El ESP32 almacena las credenciales de esta red para poder conectarse más tarde a esta red (modo estación).
• Una vez que se establezcan un nuevo SSID y contraseña, el ESP32 se reiniciará, ingresará al modo de estación e intentará conectarse a la red previamente guardada.
• Si se establece una conexión, el proceso se completa con éxito. De lo contrario, se configurará como un punto de acceso para que pueda configurar nuevas credenciales de red.

Para configurar el Administrador de Wi-Fi en el ESP32 con MicroPython usamos el Biblioteca WiFiManager de tayfunulu. En la página de GitHub de la biblioteca puede encontrar el siguiente diagrama que ofrece una descripción general de cómo funciona todo.

requisitos

Para seguir este tutorial, debe tener el firmware MicroPython instalado en su placa ESP. También necesitarás un IDE para escribir el código y subirlo a tu placa. Recomendamos utilizar Thonny IDE o uPyCraft IDE:

• IDE de Thonny:
  • Instalación y primeros pasos con Thonny IDE
  • Actualización del firmware MicroPython usando esptool.py
• IDE de UpyCraft:
  • Comenzando con uPyCraft IDE
  • Instale uPyCraft IDE (Windows, Mac OS X, Linux)
  • Flashear/cargar firmware MicroPython a ESP32 y ESP8266

Piezas requeridas

Para este tutorial necesitas un ESP32 (o placa ESP8266):

• Placa ESP32 DEVKIT DOIT – leer Prueba y comparación de placas de desarrollo ESP32

Obtenga más información sobre MicroPython: obtenga nuestro libro electrónico «Programación MicroPython con ESP32 y ESP8266».

Biblioteca WiFiManager MicroPython

De forma predeterminada, la biblioteca para configurar Wi-Fi Manager en ESP32 no forma parte de la biblioteca estándar de MicroPython. Por lo tanto, deberá cargar la siguiente biblioteca en su placa ESP (guárdela con este nombre exacto 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(200):
        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)
        time.sleep(1)
        wlan_ap.active(False)
        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():
            wlan_ap.active(False)
            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

            # Handle form data from Safari on macOS and iOS; it sends rnrnssid=<ssid>&password=<password>
            try:
                request += client.recv(1024)
                print("Received form data after \r\n\r\n(i.e. from Safari on macOS or iOS)")
            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()

Ver código sin formato

Siga las siguientes instrucciones para el IDE que está utilizando:

• A. Cargue la biblioteca WiFiManager con IDE de UpyCraft
• B. Cargue la biblioteca WiFiManager con IDE de Thonny

A. Cargue la biblioteca WiFiManager usando uPyCraft IDE

Esta sección muestra cómo cargar una biblioteca usando uPyCraft IDE. Si está utilizando Thonny IDE, lea la siguiente sección.

1. Crea un nuevo archivo presionando archivo nuevo Botón.

2. Copie el código de la biblioteca WiFiManager a este archivo. El código de la biblioteca WiFiManager se puede copiar Aquí.

3. Después de copiar el código, guarde el archivo presionando el botón Ahorrar Botón.

4. Nombra este nuevo archivo “wifimgr.py» y presione DE ACUERDO.

5. presione eso Descargar y ejecutar Botón.

El archivo debe estar en la carpeta del dispositivo llamada «wifimgr.py“, como se destaca en la siguiente imagen.

Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.

B. Cargue la biblioteca WiFiManager con Thonny IDE

Si está utilizando Thonny IDE, siga los siguientes pasos:

1. Copie el código de la biblioteca en un archivo nuevo. El código de la biblioteca WiFiManager se puede copiar Aquí.

2Guarde el archivo como wifimgr.py.

3. Ir a Dispositivo > Cargar script actual con el nombre actual.

Y eso fue todo. La biblioteca se ha subido a tu tablero. Para asegurarse de que se haya cargado correctamente, puede escribir lo siguiente en el shell:

%lsdevice

Debería devolver los archivos actualmente almacenados en su tablero. Uno de ellos debería ser wifimgr.py Archivo.

Después de cargar la biblioteca en su tablero, puede usar las funciones de la biblioteca en su código importándola.

Código: configurar WLAN Manager con ESP32

El siguiente código implementa Wi-Fi Manager en el ESP32. Agregaremos la funcionalidad Wi-Fi Manager a un proyecto anterior de servidor web MicroPython. Al final del tutorial, debería poder implementar Wi-Fi Manager en sus propios proyectos.

Crear un… principal.py archivo y copie el siguiente código.

# Complete project details at https://RandomNerdTutorials.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="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')

Ver código sin formato

Cómo funciona el código

Este código se basa en un proyecto de servidor web MicroPython ESP32/ESP8266 anterior. Acabamos de realizar algunos cambios para agregar Wi-Fi Manager.

Para agregar Wi-Fi Manager, debes importar la biblioteca que subiste previamente a tu tablero.

import wifimgr

Las siguientes líneas de código administran Wi-Fi Manager por usted:

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

ACCESO INALÁMBRICO A INTERNET es uno que funciona red.WLAN(STA_IF) Instancia inicializada por la biblioteca. Por lo tanto, no es necesario incluirlo para configurar su ESP32 como estación.

Cuando el ESP32 se configura por primera vez como punto de acceso, deja un socket abierto, lo que genera un error y provoca que el ESP32 falle. Para asegurarnos de que esto no suceda, inicializamos y vinculamos el socket dentro intentar Y excepto Testificar.

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()

Si un socket permanece abierto, obtenemos un error del sistema operativo y reiniciamos el ESP32 con máquina.reset(). Esto hace que se «olvide» el enchufe abierto.

Cuando el código se ejecuta por segunda vez, las credenciales de red ya están guardadas, por lo que el ESP32 no está configurado como punto de acceso, no hay problema de socket abierto y el código continúa sin problemas.

Probando el administrador WiFi

Descargar el principal.py Archivo en su ESP32. Luego presione el botón RST (EN) integrado del ESP32 para iniciar el programa.

Debería recibir un mensaje similar en el shell de Python.

Esto significa que el ESP32 se ha configurado correctamente como punto de acceso. Ahora puede conectarse a este punto de acceso, seleccionar su red e ingresar sus credenciales. Para ello, sigue los siguientes pasos.

Abra la configuración de Wi-Fi en su computadora o teléfono inteligente y conéctese Administrador de WLAN Red.

La contraseña es Suscribirse a. Puede cambiar el SSID y la contraseña predeterminados en el código de la biblioteca.

Una vez que esté conectado exitosamente a la red WiFiManager, abra un navegador e ingrese 192.168.4.1. Debería cargarse la siguiente página:

Seleccione su red, ingrese la contraseña y haga clic Entregar. Después de unos segundos, debería recibir un mensaje de éxito.

Este mensaje significa que su ESP32 está configurado como una estación WiFi y conectado a su red local. Ahora, para acceder al ESP32, vaya nuevamente a la configuración de Wi-Fi de su computadora o teléfono inteligente y vuelva a conectarse a su red.

En el shell de Python, se debe imprimir la dirección IP de ESP32.

Nota: En un escenario del mundo real, probablemente no tengas acceso al shell de Python. En esta situación, recomendamos imprimir la dirección IP en una pantalla OLED.

Abra su navegador e ingrese esta dirección IP. Obtiene acceso al siguiente servidor web y puede controlar el ESP32 GPIO.

Envolver

Con la biblioteca WiFiManager, ya no necesitará codificar sus credenciales de red. El ESP32 configura un punto de acceso que muestra las redes WiFi disponibles. Sólo necesita seleccionar su red e ingresar su contraseña para configurar el ESP32 como una estación WiFi.

Esperamos que este tutorial te haya resultado útil. Usted también puede estar interesado en:

• Servidor web ESP32/ESP8266 MicroPython: salidas de control
• MicroPython: Punto de acceso (AP) ESP32/ESP8266
• MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22
• MicroPython: pantalla OLED con ESP32 y ESP8266

Obtenga más información sobre MicroPython con nuestro libro electrónico: Programación MicroPython con ESP32 y ESP8266

Gracias por leer.

MicroPython: administrador de Wi-Fi con ESP32 (compatible con ESP8266)

En este tutorial aprenderemos cómo utilizar Wi-Fi Manager con el ESP32 utilizando el firmware de MicroPython. Wi-Fi Manager te permite conectar tu ESP32 a diferentes puntos de acceso (redes diferentes) sin tener que codificar tus credenciales y subir un nuevo código a tu placa.

Cómo funciona Wi-Fi Manager

Con Wi-Fi Manager ya no necesitas codificar tus credenciales de red (SSID y contraseña). El ESP32 configurará un Punto de Acceso que puedes utilizar para configurar las credenciales de red, o se unirá automáticamente a una red guardada previamente.

1. Cuando el ESP32 se inicia por primera vez, se configura como un Punto de Acceso.
2. Puedes conectarte a ese Punto de Acceso estableciendo una conexión con la red WiFiManager e ingresando a la dirección IP 192.164.4.1.
3. Se abrirá una página web que te permite elegir y configurar una red.
4. El ESP32 guarda esas credenciales de red para que después pueda conectarse a esa red (modo Estación).
5. Una vez que se establece un nuevo SSID y contraseña, el ESP32 se reinicia, se configura en modo Estación y trata de conectarse a la red guardada previamente.
6. Si establece una conexión, el proceso se completa con éxito. De lo contrario, se configurará como un Punto de Acceso para que puedas configurar nuevas credenciales de red.

Para configurar el Wi-Fi Manager en el ESP32 utilizando MicroPython, utilizaremos la biblioteca WiFiManager de tayfunulu.

Referencia: WiFiManager Library

Preparativos

Para seguir este tutorial necesitas tener el firmware de MicroPython instalado en tu placa ESP. También necesitas un IDE para escribir y cargar el código en tu placa. Te recomendamos utilizar Thonny IDE o uPyCraft IDE.

Enlaces útiles:

• Thonny IDE: Instalación y primeros pasos con Thonny IDE
• uPyCraft IDE: Guía de inicio con uPyCraft IDE

Partes requeridas

Para este tutorial necesitas una placa ESP32 (o ESP8266).

Placa ESP32 recomendada: ESP32 DEVKIT DOIT

Biblioteca WiFiManager para MicroPython

La biblioteca para configurar Wi-Fi Manager en el ESP32 no forma parte de la biblioteca estándar de MicroPython por defecto. Por lo tanto, necesitas subir la siguiente biblioteca a tu placa ESP (guárdala con este nombre exacto wifimgr.py).

Código – Configuración del Wi-Fi Manager con el ESP32

El siguiente código implementa Wi-Fi Manager en el ESP32. Agregaremos las capacidades de Wi-Fi Manager a un proyecto anterior de servidor web con MicroPython. Al final del tutorial, deberías poder implementar Wi-Fi Manager en tus propios proyectos

Completa los detalles del proyecto en Random Nerd Tutorials

Para ver el código completo, puedes consultarlo en este enlace.