Micropython: ESP-Now avec ESP32 (démarrage)

Apprenez à utiliser le protocole de communication ESP-NOW avec l’ESP32 programmé avec Micropython. ESP-Now est un protocole de communication sans connexion créé par EspressIF, conçu pour une transmission courte des paquets. C’est l’un des moyens les plus simples de communiquer entre les planches ESP32 sans fil. Actuellement, le micrologiciel Micropython pour l’ESP32 comprend deux modules intégrés, ESPNow et Aioespnow, qui fournissent des classes et des fonctions pour travailler avec ESP-Now.

Utiliser Arduino IDE? Suivez ce tutoriel à la place: commencez avec ESP-Now (ESP32 avec Arduino IDE).

Prérequis – Firmware Micropython

Pour suivre ce tutoriel, vous avez besoin de micro-firmware Micropython installé sur vos cartes ESP32. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous suggérons d’utiliser Thonny IDE:

Nouveau sur Micropython? Consultez notre ebook: Micropython Programming avec ESP32 et ESP8266 Ebook (2e édition)

Présentation ESP-NOW

ESP-Now est un protocole de communication sans fil développé par ESPRESSIF qui permet à plusieurs cartes ESP32 ou ESP8266 d’échanger de petites quantités de données sans utiliser Wi-Fi ou Bluetooth. ESP-Now ne nécessite pas de connexion Wi-Fi complète (bien que le contrôleur Wi-Fi doit être activé), ce qui le rend idéal pour les applications de faible puissance et de faible latence comme les réseaux de capteurs, les télécommandes ou l’échange de données entre les cartes.

ESP-Now utilise un modèle de communication sans connexion, ce qui signifie que les périphériques peuvent envoyer et recevoir des données sans se connecter à un routeur ou configurer un point d’accès (contrairement à la communication HTTP entre les cartes). Il prend en charge unicast (envoyer des données à un appareil spécifique à l’aide de son adresse MAC) et diffuser (envoyer des données à tous les appareils à l’aide d’une adresse MAC diffusée).

ESP-Now prend en charge les fonctionnalités suivantes:

• Soutient à la fois la communication unicast cryptée et non cryptée.
• Communication directe entre jusqu’à 20 pairs enregistrés ou 6 pairs cryptés.
• Peut communiquer avec un mélange de dispositifs cryptés et non cryptés en même temps.
• Permet d’envoyer des paquets de données jusqu’à 250 octets.

ESP-Now est très polyvalent et vous pouvez avoir une communication unidirectionnelle ou bidirectionnelle dans différentes configurations. Par exemple:

• Une carte ESP32 envoyant des données à une autre carte ESP32;
• ESP-now communication bidirectionnelle entre deux conseils;
• Une ESP32 recevant des données de plusieurs planches;
• Une carte ESP32 envoyant des données à plusieurs planches;
• Plusieurs cartes ESP32 envoyant et recevant des données de plusieurs cartes ESP32 pour créer quelque chose qui ressemble à un réseau.

Concepts de base dans ESP-Now

Il y a quelques concepts de base que vous devez comprendre dans ESP-Now:

• Expéditeur: l’appareil qui envoie des données à l’aide d’ESP-Now.

• Récepteur: l’appareil qui reçoit les données envoyées par l’expéditeur.

• Adresse MAC: une adresse matérielle unique de 6 octets attribuée à l’interface Wi-Fi de chaque appareil. ESP-Now utilise des adresses MAC pour identifier les appareils. Si vous souhaitez envoyer des données à une carte spécifique, vous devez connaître son adresse MAC.

• Adresse MAC diffusée: une adresse MAC comme celle FF: FF: FF: FF: FF: FF est utilisé pour envoyer un message à tous les appareils à proximité. Tout ESP32 ou ESP8266 à portée peut le recevoir.

• Peer: un appareil spécifique (identifié par son adresse MAC) que vous vous inscrivez sur votre périphérique ESP-Now afin qu’il puisse envoyer ou recevoir des données avec cet appareil.

• Paquet: les données envoyées d’un appareil à un autre. Les paquets ESP-Now peuvent transporter jusqu’à 250 octets de données.

Exigences pour ESP-now

Avant d’utiliser ESP-Now, il y a quelques exigences importantes:

Même canal Wi-Fi: tous les appareils communiquant via ESP-Now doivent être sur le même canal Wi-Fi. Si ce n’est pas le cas, ils ne pourront pas recevoir et se envoyer des paquets les uns aux autres. Habituellement, cela se fait automatiquement dans le code, sauf si l’un des appareils est également connecté à un réseau Wi-Fi.

Adresse MAC: Pour envoyer des messages à un appareil spécifique, l’expéditeur doit connaître l’adresse MAC du récepteur à l’avance.

Enregistrement des pairs: vous devez enregistrer un pair avant de lui envoyer des données, sauf lorsque vous utilisez l’adresse MAC diffusée sur les cartes ESP32.

Wi-Fi: l’interface Wi-Fi (mode de station ou de point d’accès) doit être active, même si elle n’est pas connectée.

ESP32: obtenir une adresse MAC à la carte

Pour communiquer via ESP-Now, vous devez connaître l’adresse MAC de vos conseils. Pour obtenir l’adresse MAC de votre carte, vous pouvez copier le code suivant sur Thonny IDE et l’exécuter sur votre carte.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp-now-esp32/
 
import network

wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# Get MAC address (returns bytes)
mac = wlan.config('mac')

# Convert to human-readable format
mac_address=":".join('%02x' % b for b in mac)

print("MAC Address:", mac_address)

Afficher le code brut

Après avoir exécuté le code, il devrait imprimer l’adresse MAC de la carte sur le shell.

Nous vous recommandons d’ajouter une étiquette ou un autocollant à chaque carte afin que vous puissiez les identifier clairement.

ESP-NOW Point à point de communication point (module ESPNow)

Pour vous lancer avec ESP-Now Wireless Communication, nous allons construire un projet simple qui montre comment envoyer un message d’un ESP32 à un autre. Un ESP32 sera «l’expéditeur» et l’autre ESP32 sera le «récepteur».

Code de l’expéditeur ESP32 (ESP-Now avec micropopython)

Le code suivant envoie un message à chaque seconde à une carte réceptrice ESP32. Copiez-le sur votre IDE Thonny, puis exécutez-le ou téléchargez-le à la carte.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp-now-esp32/

import network
import espnow
import time

# Stats tracking
last_stats_time = time.time()
stats_interval = 10  # Print stats every 10 seconds

# Initialize Wi-Fi in station mode
sta = network.WLAN(network.STA_IF)
sta.active(True)
#sta.config(channel=1)  # Set channel explicitly if packets are not delivered
sta.disconnect()

# Initialize ESP-NOW
e = espnow.ESPNow()
try:
    e.active(True)
except OSError as err:
    print("Failed to initialize ESP-NOW:", err)
    raise

# Receiver's MAC address
receiver_mac = b'\x30\xae\xa4\xf6\x7d\x4c'
#receiver_mac = b'\xff\xff\xff\xff\xff\xff' #broadcast

# Add peer
try:
    e.add_peer(receiver_mac)
except OSError as err:
    print("Failed to add peer:", err)
    raise

def print_stats():
    stats = e.stats()
    print("\nESP-NOW Statistics:")
    print(f"  Packets Sent: {stats[0]}")
    print(f"  Packets Delivered: {stats[1]}")
    print(f"  Packets Dropped (TX): {stats[2]}")
    print(f"  Packets Received: {stats[3]}")
    print(f"  Packets Dropped (RX): {stats[4]}")
    
# Main loop to send messages
message_count = 0
while True:
    try:
        # Create a sample message with a counter
        message = f"Hello! ESP-NOW message #{message_count}"
        # Send the message with acknowledgment
        try:
            if e.send(receiver_mac, message, True):
                print(f"Sent message: {message}")
            else:
                print("Failed to send message (send returned False)")
        except OSError as err:
            print(f"Failed to send message (OSError: {err})")
        
        message_count += 1
        
        # Print stats every 10 seconds
        if time.time() - last_stats_time >= stats_interval:
            print_stats()
            last_stats_time = time.time()
        
        time.sleep(1)  # Send every 1 second
        
    except OSError as err:
        print("Error:", err)
        time.sleep(5)
        
    except KeyboardInterrupt:
        print("Stopping sender...")
        e.active(False)
        sta.active(False)
        break

Afficher le code brut

Vous devez insérer l’adresse MAC de la carte du récepteur ou utiliser l’adresse MAC de diffusion.

Dans mon cas, l’adresse MAC du tableau du récepteur est de 30: AE: A4: F6: 7d: 4c. J’ai donc besoin de le convertir au format d’octets comme suit:

• 30: ae: a4: f6: 7d: 4c> b ‘\ x30 \ xae \ xa4 \ xf6 \ x7d \ x4c’

Faites de même pour l’adresse MAC de votre tableau de récepteur.

# Receiver's MAC address
receiver_mac = b'\x30\xae\xa4\xf6\x7d\x4c'

Comment fonctionne le code?

Voyons rapidement comment le code fonctionne et les fonctions ESP-Now les plus pertinentes.

Modules d’importation

Tout d’abord, importez les modules requis. Pour cet exemple, nous utilisons le module ESPNow pour utiliser les fonctions et classes ESP-Now.

import network
import espnow
import time

Initialiser l’interface Wi-Fi

Ensuite, nous devons initialiser le Wi-Fi (même si nous ne l’utilisons pas) pour utiliser ESP-Now. Nous pouvons utiliser la station (STA_IF) ou le mode Point d’accès (AP_IF).

# Initialize Wi-Fi in station mode
sta = network.WLAN(network.STA_IF)
sta.active(True)
#sta.config(channel=1)  # Set channel explicitly if packets are not delivered
sta.disconnect()

Plus tard, lors des tests si les paquets ne sont pas livrés, vous devrez peut-être expliciter manuellement le canal Wi-Fi à utiliser. Il doit être le même sur les cartes du récepteur et des expéditeurs.

#sta.config(channel=1)  # Set channel explicitly if packets are not delivered

Initialiser ESP-now

Ensuite, nous pouvons initialiser ESP-Now. Tout d’abord, créez une instance ESPNow appelée e. Puis activez-le en utilisant la méthode active () et en passant la valeur vraie en tant qu’argument.

# Initialize ESP-NOW
e = espnow.ESPNow()
try:
    e.active(True)
except OSError as err:
    print("Failed to initialize ESP-NOW:", err)
    raise

Pour désactiver ESP-Now, passez FALSE à la méthode active (). Si vous utilisez la méthode active () sans aucun argument, il renverra l’état ESP-Now actuel.

Nous activons ESP-NOW à l’intérieur d’un essai et sauf des instructions afin que nous puissions prendre des erreurs en cas d’échec de l’initialisation.

Ajouter un pair ESP-now

Ajoutez l’adresse MAC du récepteur (ou utilisez l’adresse MAC de diffusion pour envoyer le message à tous les périphériques de sa plage):

# Receiver's MAC address
receiver_mac = b'\x30\xae\xa4\xf6\x7d\x4c'
#receiver_mac = b'\xff\xff\xff\xff\xff\xff' #broadcast

Ensuite, nous pouvons ajouter l’adresse MAC du récepteur en tant que pair à l’aide de la méthode add_peer ().

# Add peer
try:
    e.add_peer(receiver_mac)
except OSError as err:
    print("Failed to add peer:", err)
    raise

Imprimez les statistiques ESP-Now

Ensuite, nous créons une fonction à appeler plus tard dans le code, appelé print_stats () qui imprime les statistiques actuelles sur les paquets ESP-Now. Pour obtenir le nombre de paquets envoyés / reçus et perdus, nous pouvons appeler la méthode statistiques () sur l’objet ESP-Now E.

Cela renvoie un 5-Tuple contenant le nombre de paquets envoyés / reçus / perdus:

(tx_pkts, tx_responses, tx_failures, rx_packets, rx_dropped_packets)

Ensuite, nous imprimons chacun de ces résultats:

print("\nESP-NOW Statistics:")
print(f"  Packets Sent: {stats[0]}")
print(f"  Packets Delivered: {stats[1]}")
print(f"  Packets Dropped (TX): {stats[2]}")
print(f"  Packets Received: {stats[3]}")
print(f"  Packets Dropped (RX): {stats[4]}")

Envoi du message ESP-Now

Nous créons une boucle principale pour envoyer un message avec un compteur (message_count) chaque seconde.

message_count = 0
while True:
    try:
        # Create a sample message with a counter
        message = f"Hello! ESP-NOW message #{message_count}"

Nous envoyons le message à l’aide de la méthode Send () sur l’objet ESP-Now E. Cette fonction accepte comme arguments l’adresse MAC de la carte récepteur, le message et le dernier paramètre est une valeur booléenne (vrai pour envoyer un message au pair et attendre une réponse; ou un faux retourne immédiatement).

try:
    if e.send(receiver_mac, message, True):
        print(f"Sent message: {message}")
    else:
        print("Failed to send message (send returned False)")
except OSError as err:
    print(f"Failed to send message (OSError: {err})")

Après avoir envoyé le message, nous incrémentons le compteur et vérifions s’il est temps d’imprimer de nouvelles statistiques.

# Print stats every 10 seconds
if time.time() - last_stats_time >= stats_interval:
    print_stats()
    last_stats_time = time.time()
        
time.sleep(1)  # Send every 1 second

En résumé…

En résumé, ce sont les étapes:

• Initialiser l’interface Wi-Fi;
• Initialiser ESP-Now;
• Ajouter un pair;
• Envoyer un message.

Exécution du code

Après avoir connecté la carte à votre ordinateur et établi une communication avec Thonny IDE, vous pouvez télécharger le code en tant que main.py sur la carte ou l’exécuter à l’aide du bouton d’exécution verte.

Il commencera à imprimer des messages dans le shell. Il ne parviendra pas à envoyer le message car nous n’avons pas encore préparé le récepteur.

Code récepteur ESP32 (ESP-NOW avec micropython)

Le code suivant écoute les paquets ESP-Now entrants de son pair (la carte d’expéditeur que nous avons programmée précédemment). Ouvrez une autre fenêtre de Thonny Ide (indépendamment du premier).

Activer deux instances de thonny ide

Accédez à des outils> Options et décochez l’option autorisez uniquement l’instance Thonny.

Copiez le code sur votre IDE Thonny, puis exécutez-le ou téléchargez-le à la carte.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp-now-esp32/

import network
import espnow
import time

# Stats tracking
last_stats_time = time.time()
stats_interval = 10  # Print stats every 10 seconds

# Initialize Wi-Fi in station mode
sta = network.WLAN(network.STA_IF)
sta.active(True)
sta.config(channel=1)  # Set channel explicitly if packets are not received
sta.disconnect()

# Initialize ESP-NOW
e = espnow.ESPNow()
try:
    e.active(True)
except OSError as err:
    print("Failed to initialize ESP-NOW:", err)
    raise

# Sender's MAC address
sender_mac = b'\x30\xae\xa4\x07\x0d\x64'  # Sender MAC

# Add peer (sender) for unicast reliability
# You don't need to add peer for broadcast
#try:
#    e.add_peer(sender_mac)
#except OSError as err:
#    print("Failed to add peer:", err)
#    raise

def print_stats():
    stats = e.stats()
    print("\nESP-NOW Statistics:")
    print(f"  Packets Sent: {stats[0]}")
    print(f"  Packets Delivered: {stats[1]}")
    print(f"  Packets Dropped (TX): {stats[2]}")
    print(f"  Packets Received: {stats[3]}")
    print(f"  Packets Dropped (RX): {stats[4]}")

print("Listening for ESP-NOW messages...")
while True:
    try:
        # Receive message (host MAC, message, timeout of 10 seconds)
        host, msg = e.recv(10000)
        
        # Print stats every 10 seconds
        if time.time() - last_stats_time >= stats_interval:
            print_stats()
            last_stats_time = time.time()
        
    except OSError as err:
        print("Error:", err)
        time.sleep(5)
        
    except KeyboardInterrupt:
        print("Stopping receiver...")
        e.active(False)
        sta.active(False)
        break

Afficher le code brut

Comment fonctionne le code?

Le code est similaire à la carte des expéditeurs. La seule différence est la boucle, où nous écouterons les paquets entrants.

L’insertion de l’adresse MAC de la carte de l’expéditeur et l’ajouter en tant que pair est facultative. Cependant, il est bon de l’implémenter pour une meilleure fiabilité, surtout si vous ne recevez pas les paquets.

Dans mon cas, l’adresse MAC de la carte de l’expéditeur est de 30: AE: A4: 07: 0D: 64. J’ai donc besoin de le convertir au format d’octets comme suit:

• 30: ae: a4: 07: 0d: 64> b ‘\ x30 \ xae \ xa4 \ x07 \ x0d \ x64 ′

Faites de même pour l’adresse MAC de votre tableau d’expéditeur.

# Sender's MAC address
sender_mac = b'\x30\xae\xa4\x07\x0d\x64'  # Sender MAC

Si vous souhaitez ajouter l’expéditeur en tant que pair, ignorez la partie suivante du code:

#try:
#    e.add_peer(sender_mac)
#except OSError as err:
#    print("Failed to add peer:", err)
#    raise

Recevoir des messages ESP-now

Pour recevoir des messages, nous pouvons utiliser la méthode recv () sur l’objet ESP-Now E.

host, msg = e.recv(10000)

Cette méthode attend un message entrant et renvoie l’adresse MAC du pair (enregistré dans la variable hôte) et le message (enregistré dans la variable MSG). Il n’est pas nécessaire d’enregistrer un pair (en utilisant add_peer ()) pour recevoir un message de ce pair.

Il accepte comme arguments le temps mort en millisecondes. Le délai d’attente fait référence au temps que la fonction attendra pour recevoir un message entrant avant d’abandonner et de retourner. Il peut avoir les valeurs suivantes

• 0: pas de temps mort. Retournez immédiatement si aucune donnée n’est disponible.
• > 0: spécifiez une valeur de délai d’expiration en millisecondes;
• <0: Ne pas délasser: attendez pour toujours les nouveaux messages;
• Aucun: utilise la valeur de délai d’expiration par défaut avec ESPNow.config ()

Lorsque nous recevons un nouveau message, nous imprimons l’adresse MAC hôte et le message.

if msg:
    print(f"Received from {host.hex()}: {msg.decode()}")

Exécution du code

Avec une nouvelle fenêtre sur Thonny IDE Open, établissez une connexion avec cette carte réceptrice. Téléchargez et / ou exécutez le code du récepteur sur cette nouvelle carte.

Il commencera à recevoir les paquets ESP-Now de l’autre planche.

En même temps, vous verrez que la carte des expéditeurs imprimera les messages de réussite maintenant.

Toutes les 10 secondes, l’expéditeur et le récepteur impriment les statistiques ESP-Now sur le shell.

Vous pouvez combiner les fonctions utilisées dans les deux croquis et établir une communication bidirectionnelle. Vous pouvez également ajouter plus de cartes à votre configuration et créer un réseau.

ESP-NOW Point à Point Communication (module Aioespnow)

Il existe un autre module qui prend en charge ESP-Now de manière asynchrone à l’aide du module Asyncio – c’est le module Aioespnow. Dans cette section, nous allons créer le même exemple que le précédent, mais en utilisant le module AIOESPNow, qui prend en charge la programmation asynchrone.

Avant de continuer, nous vous recommandons d’apprendre la programmation asynchrone avec Micropython: Micropython: ESP32 / ESP8266 Programmation asynchrone – exécutez plusieurs tâches.

Code de l’expéditeur ESP32 (ESP-Now avec micropopython)

Le code suivant fait de même que celui de l’exemple précédent, mais il utilise le module AIOESPNow si vous souhaitez utiliser la programmation asynchrone à la place.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp-now-esp32/
 
import network
import aioespnow
import asyncio
import time

# Stats tracking
last_stats_time = time.time()
stats_interval = 10  # Print stats every 10 seconds

# Initialize Wi-Fi in station mode
sta = network.WLAN(network.STA_IF)
sta.active(True)
sta.disconnect()

# Initialize AIOESPNow
e = aioespnow.AIOESPNow()
try:
    e.active(True)
except OSError as err:
    print("Failed to initialize AIOESPNow:", err)
    raise

# Receiver's MAC address (broadcast for testing)
#receiver_mac = b'\x30\x0e\xa4\xf6\x7d\x4c'
receiver_mac = b'\xff\xff\xff\xff\xff\xff'

# Add peer
try:
    e.add_peer(receiver_mac)
except OSError as err:
    print("Failed to add peer:", err)
    raise

def print_stats():
    stats = e.stats()
    print("\nESP-NOW Statistics:")
    print(f"  Packets Sent: {stats[0]}")
    print(f"  Packets Delivered: {stats[1]}")
    print(f"  Packets Dropped (TX): {stats[2]}")
    print(f"  Packets Received: {stats[3]}")
    print(f"  Packets Dropped (RX): {stats[4]}")

# Async function to send messages
async def send_messages(e, peer):
    message_count = 0
    while True:
        try:
            message = f"Hello! AIOESPNow message #{message_count}"
            if await e.asend(peer, message, sync=True):
                print(f"Sent message: {message}")
            else:
                print("Failed to send message")
            
            message_count += 1
            
            # Print stats every 10 seconds
            if time.time() - last_stats_time >= stats_interval:
                print_stats()
            
            await asyncio.sleep(1)  # Send every 1 second
        
        except OSError as err:
            print("Error:", err)
            await asyncio.sleep(5)

# Main async function
async def main(e, peer):
    await send_messages(e, peer)

# Run the async program
try:
    asyncio.run(main(e, receiver_mac))
except KeyboardInterrupt:
    print("Stopping sender...")
    e.active(False)
    sta.active(False)

Afficher le code brut

Code récepteur ESP32 (ESP-NOW avec micropython)

De même, le code suivant reçoit des paquets ESP-Now entrants de la carte des expéditeurs, mais il utilise le module Aioespnow pour la programmation asynchrone.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp-now-esp32/

import network
import aioespnow
import asyncio
import time

# Initialize Wi-Fi in station mode
sta = network.WLAN(network.STA_IF)
sta.active(True)
sta.config(channel=1)  # Set channel explicitly if packets are not received
sta.disconnect()

# Initialize AIOESPNow
e = aioespnow.AIOESPNow()
try:
    e.active(True)
except OSError as err:
    print("Failed to initialize AIOESPNow:", err)
    raise

# Sender's MAC address
sender_mac = b'\x30\xae\xa4\x07\x0d\x64'  # Sender MAC for unicast

# Add peer (sender) for unicast reliability
# You don't need to add peer for broadcast
#try:
#    e.add_peer(sender_mac)
#except OSError as err:
#    print("Failed to add peer:", err)
#    raise

# Async function to receive messages
async def receive_messages(e):
    while True:
        try:
            async for mac, msg in e:
                print(f"Received from {mac.hex()}: {msg.decode()}")
        except OSError as err:
            print("Error:", err)
            await asyncio.sleep(5)

# Async function to print stats periodically
async def print_stats(e):
    global last_stats_time
    last_stats_time = time.time()
    stats_interval = 10  # Print stats every 10 seconds
    while True:
        if time.time() - last_stats_time >= stats_interval:
            stats = e.stats()
            print("\nESP-NOW Statistics:")
            print(f"  Packets Sent: {stats[0]}")
            print(f"  Packets Delivered: {stats[1]}")
            print(f"  Packets Dropped (TX): {stats[2]}")
            print(f"  Packets Received: {stats[3]}")
            print(f"  Packets Dropped (RX): {stats[4]}")
            last_stats_time = time.time()
        await asyncio.sleep(1)  # Check every second

# Main async function
async def main(e):
    # Run receive and stats tasks concurrently
    await asyncio.gather(receive_messages(e), print_stats(e))

# Run the async program
try:
    asyncio.run(main(e))
except KeyboardInterrupt:
    print("Stopping receiver...")
    e.active(False)
    sta.active(False)

Afficher le code brut

Pour plus d’informations sur les modules ESP-Now, les fonctions et les classes pour Micropython, consultez la documentation.

Emballage

Dans ce tutoriel, nous vous avons présenté les bases du protocole de communication ESP-Now avec l’ESP32 programmé avec Micropython.

ESP-Now est un protocole très polyvalent qui peut être utile pour transférer les données sans fil entre les cartes, comme les lectures de capteurs ou les commandes pour contrôler les sorties. Vous pouvez ajouter plusieurs cartes ESP32 à votre configuration et créer un réseau de cartes qui échangent des données entre elles.

Si vous êtes intéressé par ce sujet, nous pouvons créer plus de tutoriels sur ESP-Now avec Micropython. Faites-nous savoir dans la section des commentaires.

Pour en savoir plus sur Micropython, vous pouvez consulter nos ressources:

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