Enable esp-now and WiFi at the same time

[tadejales]

I have a problem with using esp-now and WiFi together. I am able to use them both separately with success. If I enable only one of those two protocols everything works fine. I have no problem sending and receiving esp-now measages between boards and on the other hand I can execute Wi-Fi get requests succesfuly. The moment I turn them both on esp-now part is failing. I have tried researching this toppic but I am unable to understand what is wrong.

I started here
https://forum.micropython.org/viewtopic.php?t=11420
but I am unable to understand what I have to do.

I will post the code if anyone will get a sense what is the problem.

main.py

import espnow
from machine import Pin
import network
from config import pinOut
import uasyncio
import ujson
from SdHandler import SdHandler
import uasyncio
from aswitch import Pushbutton
from EspNowNode import EspNowNode
from WifiNode import WifiNode

# Pin definitions.
position_1_pin = Pin(pinOut.POSITION_SW_1, Pin.IN, Pin.PULL_UP)
position_2_pin = Pin(pinOut.POSITION_SW_2, Pin.IN, Pin.PULL_UP)

# Constructirs.
position_1 = Pushbutton(position_1_pin)
position_2 = Pushbutton(position_2_pin)

espnow = EspNowNode()
wifi_node = WifiNode()

def button_callback(command: str):
    espnow.send_command_to_clients(command)
    print(command)

async def main():
    # Button callbacks.
    position_1.press_func(button_callback, ("MEASURE_SENSOR_VALUE",))  # Note how function and args are passed
    position_2.press_func(button_callback, ("TOGGLE_LED", ))  # Note how function and args are passed
    function_button.press_func(toggle_led, (warning_led_pin, ))  # Note how function and args are passed

    # Check if wifi is connected.
    is_connectd = wifi_node.connect("SSID", "PASS")
    print("Is connected: " + str(is_connectd))

    # Esp-Now callback
    espnow.node.irq(espnow.recv_cb)

    # Test Wi-fi.
    response = wifi_node.get_request('http://jsonplaceholder.typicode.com/albums/1')
    print(response)

# Start the main coroutine.
loop = uasyncio.get_event_loop()
loop.create_task(main())  # Schedule the main coroutine to run
loop.run_forever()  # Run main application code

EspNowNode.py

import espnow
import network
import ujson

MAC_ADDR_2 = 'C8:F0:9E:F4:39:34'
MAC_ADDR_3 = 'C8:F0:9E:F3:B8:E0'
MAC_ADDR = [bytes([int(i, 16) for i in mac.split(':')]) for mac in [MAC_ADDR_2, MAC_ADDR_3]]

class EspNowNode:

    def __init__(self) -> None:
        # Init ESP-Now.
        # A WLAN interface must be active to send()/recv()
        sta_ap = network.WLAN(network.AP_IF)  # Or network.AP_IF
        sta_ap.active(True)

        # Create ESP-NOW object.
        self.node = espnow.ESPNow()  # Returns AIOESPNow enhanced with async support
        self.node.active(True)

        for peer_mac in MAC_ADDR:
            #peer = bytes([int(i, 16) for i in mac.split(':')])   # MAC address of peer's wifi interface
            try:
                self.node.add_peer(peer_mac)      # Must add_peer() before send()
            except OSError:
                print("Peer already exists")

    def recv_cb(self, e):
        host, msg = e.recv()
        if msg:             # msg == None if timeout in recv()
            msg = ujson.loads(msg)
            print(host, msg)

    def send_command_to_clients(self, command: str, client_mac: str = None) -> bool:
        msg = {"command": command}
        response = self.node.send(client_mac, ujson.dumps(msg), True)
        print(response)

WifiNode.py

  import network
  import urequests
  
  class WifiNode:
  
      def __init__(self)->None:
          self.sta = network.WLAN(network.STA_IF)
          self.sta.active(True)
  
      def connect(self, ssid: str, password: str)->bool:
          self.sta.connect(ssid, password)
          while not self.sta.isconnected():
              pass
          return True
      
      def get_request(self, url: str)->str:
          response = urequests.get(url)
          return response.text

I would really apreciate any help what I have to change in order to make it work.

[tadejales]

I also tried implementing the ESPNow and Wifi Operation section of the support for the ESP-NOW wireless protocol(https://micropython-glenn20.readthedocs.io/en/latest/library/espnow.html#espnow-and-wifi-operation) from @glenn20.

Master board:
main.py

from aswitch import Pushbutton
from config import pinOut
from machine import Pin
import uasyncio

from EspNowNode import EspNowNode
from SdHandler import SdHandler
from WifiNode import WifiNode

# Pin definitions.
position_1_pin = Pin(pinOut.POSITION_SW_1, Pin.IN, Pin.PULL_UP)
position_2_pin = Pin(pinOut.POSITION_SW_2, Pin.IN, Pin.PULL_UP)

# Constructirs.
position_1 = Pushbutton(position_1_pin)
position_2 = Pushbutton(position_2_pin)

warning_led_pin = Pin(pinOut.WARNING_LED, Pin.OUT)
error_led_pin = Pin(pinOut.ERROR_LED, Pin.OUT)

wifi_node = WifiNode( <SSID> , <PASSWORD> )
espnow = EspNowNode()

def button_callback(command: str):
    espnow.send_command_to_clients(command)
    print(command)

async def main():
    # Button callbacks.
    position_1.press_func(button_callback, ("MEASURE_SENSOR_VALUE",))  # Note how function and args are passed
    position_2.press_func(button_callback, ("TOGGLE_LED", ))  # Note how function and args are passed
   
    espnow.node.irq(espnow.recv_cb)

    response = wifi_node.get_request('http://jsonplaceholder.typicode.com/albums/1')
    print(response)

    data = sd_handler.get_data(sd_handler.volume_path + "/test_1.txt", last_line_only=True)
    print(data)

# Start the main coroutine.
loop = uasyncio.get_event_loop()
loop.create_task(main())  # Schedule the main coroutine to run
loop.run_forever()  # Run main application code

WifiNode.py

import network
import urequests
import time

class WifiNode:

    def __init__(self, ssid: str, password: str)->None:
        self.sta, self.ap = self._wifi_reset()
        self.sta.connect(ssid, password)
        while not self.sta.isconnected():  # Wait until connected...
            time.sleep(0.1)
        self.ap.active(True)         # Disable power-saving mode

    def _wifi_reset(self) -> list[network.WLAN]:   # Reset wifi to AP_IF off, STA_IF on and disconnected
        sta = network.WLAN(network.STA_IF); sta.active(False)
        ap = network.WLAN(network.AP_IF); ap.active(False)
        sta.active(True)
        while not sta.active():
            time.sleep(0.1)
        sta.disconnect()   # For ESP8266
        while sta.isconnected():
            time.sleep(0.1)
        return sta, ap
    
    def get_request(self, url: str)->str:
        response = urequests.get(url)
        return response.text

EspNowNode.py

import espnow
import network
import ujson

MAC_ADDR_2 = 'C8:F0:9E:F4:39:34'
MAC_ADDR_3 = 'C8:F0:9E:F3:B8:E0'
MAC_ADDR = [bytes([int(i, 16) for i in mac.split(':')]) for mac in [MAC_ADDR_2, MAC_ADDR_3]]

class EspNowNode:

    def __init__(self) -> None:
        # Init ESP-Now.
        # A WLAN interface must be active to send()/recv()
        # Create ESP-NOW object.
        self.node = espnow.ESPNow()  # Returns AIOESPNow enhanced with async support
        self.node.active(True)

        for peer_mac in MAC_ADDR:
            try:
                self.node.add_peer(peer_mac)      # Must add_peer() before send()
            except OSError:
                print("Peer already exists")

    def recv_cb(self, e):
        host, msg = e.recv()
        if msg:             # msg == None if timeout in recv()
            msg = ujson.loads(msg)
            print(host, msg)

    def send_command_to_clients(self, command: str, client_mac: str = None) -> bool:
        msg = {"command": command}
        response = self.node.send(client_mac, ujson.dumps(msg), True)
        print(response)

Client board:
main.py

import espnow
from machine import Pin, ADC
import network
import time
import ujson

MAC_ADDR_1 = 'C8:F0:9E:F3:7E:90'

sensor_pin = ADC(Pin(34))
led_pin = Pin(23, Pin.OUT)

def wifi_reset(self) -> list[network.WLAN]:   # Reset wifi to AP_IF off, STA_IF on and disconnected
    sta = network.WLAN(network.STA_IF); sta.active(False)
    ap = network.WLAN(network.AP_IF); ap.active(False)
    sta.active(True)
    while not sta.active():
        time.sleep(0.1)
    sta.disconnect()   # For ESP8266
    while sta.isconnected():
        time.sleep(0.1)
    return sta, ap

# A WLAN interface must be active to send()/recv()
sta, ap = wifi_reset()   # Reset wifi to AP off, STA on and disconnected
sta.config(channel=6)    # Change to the channel used by the proxy above.

# Create ESP-NOW object.
e = espnow.ESPNow()  # Returns AIOESPNow enhanced with async support
e.active(True)

peer = bytes([int(i, 16) for i in MAC_ADDR_1.split(':')])   # MAC address of peer's wifi interface
e.add_peer(peer)      # Must add_peer() before send()

def send_command_to_clients(command: str, client_mac: str = None) -> bool:
    msg = {"command": command}
    response = e.send(client_mac, ujson.dumps(msg), True)
    print(response)

def send_sensor_data_to_master(msg: dict[str,str], client_mac: str = None) -> bool:
    response = e.send(client_mac, ujson.dumps(msg), True)
    print(msg)
    print(response)

def execute_master_command(command: str) -> dict[str,str]:
    msg = {}
    if command == "MEASURE_SENSOR_VALUE":
        sensor_value = sensor_pin.read()
        #sensor_value = 1
        msg["command"] = command
        msg["sensor_value"] = sensor_value
        send_sensor_data_to_master(msg)
    elif command == "TOGGLE_LED":
        led_pin.value(not led_pin.value())
        sensor_value = led_pin.value()
        #sensor_value = 2
        msg["command"] = command
        msg["sensor_value"] = sensor_value
        send_sensor_data_to_master(msg)
    else:
        sensor_value = "X"
        msg["command"] = command
        msg["sensor_value"] = sensor_value
        send_sensor_data_to_master(msg)

def recv_cb(e):
    host, msg = e.recv()
    if msg:             # msg == None if timeout in recv()
        msg = ujson.loads(msg)
        print(host, msg)
        command = msg["command"]
        print(command)
        execute_master_command(command)

e.irq(recv_cb)

def main():
    pass

When I implemented that part on the docu I mentioned above Esp-Now completely stopped working. I am able to use WiFi to perform get request and I succesfuly get the response. I see the send request over Esp-Now on master, but I do not recieve the comand over on the client side.

Can maybe someone spor the problem. For the reference I am using 2x ESP32 DevKit V1 boards. I must also say that I am not very experienced in microcontrollers. I have worked on this boards for the past half a year as hoby. Started with C++ and moved to micropython month ago. I am mechanical engeneer by degree and have intermediate knowlege of python, but am self tought. So the code maybe looks a bit ugly and not realy structured how it should be.

[glenn20]

On the master, what does send_command_to_clients() print - ie. does e.send() return True or False?

If it prints True, then all the clients acknowledged the message (that tells us the correct mac addresses are used and the devices are on the same channel and their wifi is set active(True). It if prints False, at least one of the clients did not acknowledge the message. These acknowledgements are sent from deep down in the Espressif software stack.

A few things to check/double-check:

• The master is really running on channel 6 after connecting to wifi AP (eg. print f"Channel {sta.config('channel')}").

A few other tips that I don't believe are related to the probelem, but are good practice:

• I recommend using e.recv(0) (or e.irecv(0)) in the callbacks (recv_cb()) to be absolutely sure the callback does not block on the read.
• As it stand, your master code is not really running async code (main() does not await anything, so you could just make it an ordinary function and call it at the end of main.py without invoking the asyncio loop).
  • However, I do understand you may be preparing to add asyncio features later.

[tadejales]

Are you familiar with the following error @glenn20

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3fff0030,len:4432
load:0x40078000,len:14236
load:0x40080400,len:3332
entry 0x40080618
Traceback (most recent call last):
  File "boot.py", line 6, in <module>
  File "main.py", line 8, in <module>
  File "WifiNode.py", line 4, in <module>
  File "wifi.py", line 63, in <module>
AttributeError: 'module' object has no attribute 'WIFI_PS_NONE'
Traceback (most recent call last):
  File "main.py", line 8, in <module>
ImportError: can't import name WifiNode
MicroPython v1.20.0-2-gcc4c716f6 on 2023-04-27; 4MB/OTA module with ESP32

I have tried using your wifi.py module from micropython-espnow-utils. I just copy pasted the code so it should not be a problem. I tried seaching for this issue but not found any evidence.

I have also found that set_channel() that is required in scan_for_peer.py does not exists in wifi.py. Am I missing something here.

Other comments on the work done:

• Master board was on channel=4 so I tried changing client to the same channel. It still did not work.
• send_command_to_clients() returns False so I assume that master and client do not get connected.

Will proceed with the work and follow up with findings.

[glenn20]

Are you familiar with the following error @glenn20

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3fff0030,len:4432
load:0x40078000,len:14236
load:0x40080400,len:3332
entry 0x40080618
Traceback (most recent call last):
  File "boot.py", line 6, in <module>
  File "main.py", line 8, in <module>
  File "WifiNode.py", line 4, in <module>
  File "wifi.py", line 63, in <module>
AttributeError: 'module' object has no attribute 'WIFI_PS_NONE'

Yes - I had neglected to remove those calls to manage the wifif power management. Those have been moved out into their own PR (merged a few hours ago) and the options renamed.

Traceback (most recent call last):
File "main.py", line 8, in
ImportError: can't import name WifiNode
MicroPython v1.20.0-2-gcc4c716f6 on 2023-04-27; 4MB/OTA module with ESP32

I have tried using your wifi.py module from [micropython-espnow-utils](https://github.com/glenn20/micropython-espnow-utils). I just copy pasted the code so it should not be a problem. I tried seaching for this issue but not found any evidence.

I have also found that `set_channel()` that is required in _scan_for_peer.py_ does not exists in _wifi.py_. Am I missing something here.

You are right - thanks for reporting this. I have pushed a commit to the repo to fix this and the power management issue above (and a few other things). Apologies for leaving it in an inconsistent state.

Other comments on the work done:

• Master board was on channel=4 so I tried changing client to the same channel. It still did not work.
• send_command_to_clients() returns False so I assume that master and client do not get connected.

Will proceed with the work and follow up with findings.

[tadejales]

Thank you. I will try later.

But here is a quick question that came to my mind. So if I understand the configuration correctly. Master board will be enabled in AP_IF and STA_IF modes. The client will be enabled as STA_IF only. So if I understand it correctly Esp-Now protocol will go over AP_IF on master board. But in my case I want to send command requests from master to the client so the cient can know which event I want to execute.

So my question would be if is even possible to send Esp-Now send() command from AP configured device, or can this device only recieves the data.

[glenn20]

As far as I can tell, your master code only sets the STA_IF active. However, espnow messages can be sent and received on either AP_IF or STA_IF interfaces.

[glenn20]

The symptoms you have seen are exactly as I would expect when you connect to a wifi access point and espnow together (see the docs at https://docs.micropython.org/en/latest/library/espnow.html#espnow-and-wifi-operation). Re. the channels, all wifi networks operate on a set of well-defined radio frequency channels (for 2.4GHz wifi, there are up to 14 channels). Each wifi access point decides what channel it is going to operate on and all the clients that connect to the AP use that channel. If your device is not connected to a wifi AP, espnow will operate on channel 1 by default (but you can change that with sta.config(channel=x).

So, everything works when you just test the wifi (master will operate on the wifi network's channel), and when you just test the espnow connections (no wifi network, so master and clients operate on channel 1). When you try them both together, the master is operating on the wifi network's channel and the clients are running on channel 1. So, you should double check which channel your master device is operating on when connected to the wifi network and make sure your clients also operate on the same network (with sta.config(channel=x)).

Also - check the notes in the espnow module docs about the wifi power save mode. Even when all devices are running on the same channels many messages from the clients will be lost unless you disable the power saving mode. If you are using one of my pre-compiled images you can use sta.config(pm=0) on the master after you have connected to the wifi network to turn off the power saving mode.

Good luck.

[davefes]

When I use wifi.py with the standard ESP32 images I have to comment-out these lines:

def connect(*args, **kwargs):
    sta.active(True)
    disconnect()
    sta.connect(*args, **kwargs)
    wait_for(lambda: sta.isconnected())
#    ssid, chan = sta.config("essid"), channel()
#    print('Connected to "{}" on wifi channel {}'.format(ssid, chan))

because of that same message.

And only put in the following :

timeout = 20 #  seconds

class TimeoutError(Exception):
    pass

def wifi_reset()
def disconnect()
def connect()
def wait_for()

[glenn20]

Thanks for the reminder - the "essid" names has been deprecated in micropython for "ssid". I'll fix, test and post an update for wifi.py.

[glenn20]

I've made a few updates to my utilities at micropython-espnow-utils to fix some issues due to some changes to the api as espnow has been merged into the main branch.

As a diagnostic, try adding the following to your client board code (eg. at end of the code or in main()):

import espnow_scan
espnow_scan.scan(peer)

That will scan for the master board and set the device to operate on the correct channel. You can get espnow_scan.py at: https://github.com/glenn20/micropython-espnow-utils/blob/main/src/espnow_scan.py.

[davefes]

Anything that makes connecting/working alongside WiFi easier I am sure will be appreciated by new users of ESPNow.

[tadejales]

That will be a big and very welcome improvement. A library that would allow to configure wifi and esp-now at the same time would be really helpful. I think that this can be useful in many projects.

Another question for you guys. So I want to send JSON object over esp-now. The basic structure of the message will loke something like

{'command': 'MEASURE_SENSOR_VALUE', 'response_required': True}

or

{'command': 'TOGGLE_LED', 'response_required': False}

There will also be aditional parameters and commands. As I want to post command messages over esp-now I want to return the value from recieved msg and execute events based on requested command.

At the moment I am using callback function to sacn for incoming messages. This does not allow me to return anything as far as I know(I may be wrong).

EspNowNode.py

class EspNowNode:

    def __init__(self, peers_mac: list[str]) -> None:
        self.node = espnow.ESPNow()  # Returns AIOESPNow enhanced with async support
        self.node.active(True)
        self.peers_mac = peers_mac

        for peer_mac in self.peers_mac:
            try:
                self.node.add_peer(peer_mac)      # Must add_peer() before send()
            except OSError:
                print("Peer already exists")

main.py

...

espnow_node = EspNowNode(espnow_cfg.MAC_ADDR)

...

espnow_node.node.irq(espnow_node.recv_cb)

...

Another option would be to use while True and only call .recv() (same as example in the documentation). I am not a big fan of this, because it keeps the board busy all the time. Or I do not know how to implement it correctly - LOL.

But as last option I was thinking of implementing it as async and wait for the message to arive, but I am not sure what is the corect way of doing it or if it is even possible, as I was unableto find any documentation on this subject.

Can someone give me some guidance and explanation.

[glenn20]

There will also be aditional parameters and commands. As I want to post command messages over esp-now I want to return the value from recieved msg and execute events based on requested command.

At the moment I am using callback function to sacn for incoming messages. This does not allow me to return anything as far as I know(I may be wrong).

Another option would be to use while True and only call .recv() (same as example in the documentation). I am not a big fan of this, because it keeps the board busy all the time. Or I do not know how to implement it correctly - LOL.

I understand what you mean here, but the microcontroller is actually "busy" in any case - it will be polling on something.

In the callback method, you need to maintain state between each message in global variables (not so clean as your logic gets more complex, but a valid option). For a simple app I always use the recv()/irecv() methods for receiving messages. It lets me manage state more easily and use timeouts to run housekeeping tasks or ping the peer if I haven't heard from it in a while. Also - the callback queue can overflow (see https://micropython-glenn20.readthedocs.io/en/latest/library/espnow.html#espnow.ESPNow.irq).

But as last option I was thinking of implementing it as async and wait for the message to arive, but I am not sure what is the corect way of doing it or if it is even possible, as I was unableto find any documentation on this subject.

I highly recommend asyncio methods and works really well with the aioespnow module - but there is a learning curve. (See the aioespnow docs for an example). Note, until the micropython-lib gets an update, you may need to mpremote mip install aioespnow to get aioespnow on your module. Peter Hinch has some great resources for using asyncio on micropython.

[tadejales]

I've made a few updates to my utilities at micropython-espnow-utils to fix some issues due to some changes to the api as espnow has been merged into the main branch.

As a diagnostic, try adding the following to your client board code (eg. at end of the code or in main()):

import espnow_scan
espnow_scan.scan(peer)

That will scan for the master board and set the device to operate on the correct channel. You can get espnow_scan.py at: https://github.com/glenn20/micropython-espnow-utils/blob/main/src/espnow_scan.py.

Would it make sense to create this scaning function async and send out requests on all channels all at once and then wait for the replys. The same logic as you can do in gathering multiple get requests in python and sending them out at once and waiting then, or are here other bariers that I am not aware of?

[glenn20]

The wifi radio can only operate on one channel at a time, so you need to send on a channel and wait for the replies on that channel to be sure you don't miss the replies. It is pretty quick on the esp32 (slower on the esp8266 because it is more complicated to change the channel - though that could be sped up).

[davefes]

When I want to assign a static IP on the ESPNow devices I have been adding sta.ifconfig(()) as below:

#  set up the WiFi interface
sta, ap = wifi.reset()

sta.ifconfig((config.WiFi_device, '255.255.255.0', config.gateway, '8.8.8.8'))
wifi.status()  #  print details to confirm settings
wifi.connect(config.hotspot, config.password)

I think you said this was the right place to do this in your wifi.py. Still OK?

Thanks,
Dave

[glenn20]

Yes - I think that should work - assuming config.WiFi_device is actually your desired IP address (the name is a bit unexpected).

[davefes]

Yes, it is ... I will try to think of a better name!

[davefes]

When using lightsleep one has to follow a disconnect() with a sta.active(False).

On my non-ESPNow systems I have always followed a disconnect with same statement.

Are there situations where one would disconnect() and not do a sta.active(False)?

[glenn20]

You should always call sta.active(False) (and ap.active(False) if it is on) before lightsleep when using wifi (not just espnow systems). This is the advice from Espressif (see https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/sleep_modes.html).

In practice, I have found that sometimes it works fine without turning off the wifi peripheral, but not reliably so and the wifi gets in a bad state after resuming.

[tadejales]

Based on this discussion and some of the ideas given to me I have come to the solution that is working for me on my 3 ESP32 boards (Master + 2 x Clients). So for anyone starting with this problem it will be easier to get to the final result faster and maybe easier. Example is based on the wifi.py and espnow_scan.py (link) from @glenn20.

Codebase is divided in to master and client part. I also divided the code to multiple files for easier possibility to expand the project.

Master
main.py

from espnow_node import EspNowNode
from wifi_node import WiFiNode
import urequests

MAC_0 = 'AA:BB:CC:DD:EE:FF'
MAC_1 = 'AA:BB:CC:DD:EE:FF'
b_MAC = [bytes([int(i, 16) for i in mac.split(':')]) for mac in [MAC_0, MAC_1]]

espnow = EspNowNode(peers_mac=b_MAC)
wifi = WiFiNode(<SSID>, <PASSWORD>)

def main():
    # Test GET request.
    response = urequests.get('http://jsonplaceholder.typicode.com/albums/1')
    print(response.text)

    # Test ESP-NOW.
    for i, peer in enumerate(b_MAC):
        payload = f"Hello peer {i}!"
        response = espnow.node.send(peer, payload, True)
        print(f"msg recieved on {peer} -> {response}")

main()

espnow_node.py

import espnow

class EspNowNode:

    def __init__(self, peers_mac: list[str]) -> None:
        self.node = espnow.ESPNow()  # Returns AIOESPNow enhanced with async support
        self.node.active(True)
        self.peers_mac = peers_mac

        for peer_mac in self.peers_mac:
            try:
                self.node.add_peer(peer_mac)      # Must add_peer() before send()
            except OSError:
                print("Peer already exists")

wifi_node.py

import time
import wifi as wifi

class WiFiNode:

    def __init__(self, ssid: str=None, password: str=None) -> None:
        self.sta, self.ap = wifi.reset(sta=True, ap=True)
        wifi.connect(ssid, password)

        # Wait until connected...
        while not self.sta.isconnected():  
            time.sleep(0.1)

        wifi.status()

        # Disable power saving mode. 
        self.sta.config(pm=0)

Client
main.py

from espnow_node import EspNowNode
from wifi_node import WiFiNode

MAC = 'AA:BB:CC:DD:EE:FF'
b_MAC = bytes([int(i, 16) for i in MAC.split(':')])

wifi = WiFiNode()
espnow = EspNowNode(peer_mac=b_MAC)

def main():
    espnow.node.irq(espnow.recv_cb)

main()

espnow_node.py

import espnow
import espnow_scan

class EspNowNode:

    def __init__(self, peer_mac: bytes):
        self.node = espnow.ESPNow()
        self.node.active(True)
        self.peer_mac = peer_mac

        # Scan network for existing master devices.
        espnow_scan.scan(peer=self.peer_mac, enow=self.node)

    def recv_cb(self, node) -> None:
        host, msg = node.recv(0)
        if msg:             # msg == None if timeout in recv()
            print(host, msg)

wifi_node.py

import wifi as wifi

class WiFiNode:

    def __init__(self) -> None:
        self.sta, self.ap = wifi.reset(sta=True, ap=False)

        # Disable power saving mode.     
        self.sta.config(pm=0)

        wifi.status()

If the libraries get updated in the future Iam adding the codebase from this date so that the example will be relavant in the future as a good starting point.
wifi+espnow example.zip

@glenn20 fell free to add any comments. Thank you once more!

[glenn20]

Looks good. The magic ingredients to using wifi with espnow are:

• Use sta.config(pm=sta.PM_NONE) on the devices connecting to WiFi (the "server" devices)
  • (or sta.config(pm=0) for older micropython images)
• Make sure espnow devices which don't connect to wifi (the "clients") are using the same channel, EITHER:
  • Use espnow_scan.scan(peer) to find the right channel for your server device, OR
  • Check what channel your wifi uses and hard code that channel on the "clients"
    • ...and make sure your wifi access point is set to manual channel selection

Finally, your code won't handle if the wifi router changes channels. You will need to restart the client if that happens. So, either setup your router to a fixed channel OR add something like this to the end of your client "main.py":

def check_peer(peer, retries=12):
    # Check we still have contact with the peer
    for _ in range(retries):
        if espnow.node.send(peer, b'ping'):
            return True
        time.sleep(10)
    # We have lost the peer - scan channels looking for it
    while not espnow_scan.scan(peer):  # Keep scanning till we find the peer
        time.sleep(20)

while True:
    time.sleep(60)
    check_peer(espnow.peer_mac)

[AaronBoshMacsimus]

sir how to do the reverse process in esp8266 where the master is the receiver and the client is the sender @glenn20

[glenn20]

The procedure should be the same, regardless of which device is the "sender" or "receiver". Once the devices are correctly configured, they will be able to send or receive messages.

For esp8266 devices there are some other caveats due to the limitation of the device or issues in the underlying implementation in the SDK. There is more detail about that in https://docs.micropython.org/en/latest/library/espnow.html#espnow-and-wifi-operation.

[AaronBoshMacsimus]

Sir I have tried it but I am receiving many errors my final goal is achieve espnow wifi and mqtt in the esp8266 as mqtt_as doesn't work I am trying this method but I am getting lot of error could please give me a code that works bulletproof @glenn20

[glenn20]

It is hard to help without some indication of what is going wrong and/or some code to inspect.

Peter Hinch has a fine document (and module) decribing how to bridge mqtt access over espnow via an esp32 gateway.

[AaronBoshMacsimus]

this is the sender side code which works well for now @glenn20

from espnow_node import EspNowNode
from wifi_node import WiFiNode
import time
MAC = b'\x2C\xF4\x32\x63\x93\x90'  # Ensure this is 6 bytes
b_MAC = [MAC]

wifi = WiFiNode()
espnow = EspNowNode(peers_mac=b_MAC)

def main():
    for i, peer in enumerate(b_MAC):
        payload = f"Hello"
        response = espnow.node.send(peer, payload, True)
        print(f"msg recieved on {peer} -> {response}")
while True:
    main()
    time.sleep(5)

and the saved files in the memory are esp_node.py, wifi.py , wifi_node.py
this is the output

MPY: soft reboot
#5 ets_task(4020f540, 28, 3fff91e8, 10)
#6 ets_task(4020f578, 29, 3fff9b10, 10)
#7 ets_task(4020f578, 29, 3fff93f8, 10)
Connected to "Vaideh_2.4G" on wifi channel 5
STA: on,  mac= 8c:aa:b5:69:6a:ce (b'\x8c\xaa\xb5ij\xce')
AP : on,  mac= 8e:aa:b5:69:6a:ce (b'\x8e\xaa\xb5ij\xce')
     connected: Vaideh_2.4G, channel=5, pm=2 (PM_PERFORMANCE), protocol=3 ()
     ifconfig: ('192.168.20.6', '255.255.255.0', '192.168.20.1', '192.168.20.1')
msg recieved on b',\xf42c\x93\x90' -> False #this is returned when the master esp8266 is off
msg recieved on b',\xf42c\x93\x90' -> False
msg recieved on b',\xf42c\x93\x90' -> True #and this is when it is on
msg recieved on b',\xf42c\x93\x90' -> True

[AaronBoshMacsimus]

where as on the master side which requires a different set of esp8266 codes @glenn20
where wifi_node.py is given by

import time
import wifi as wifi

class WiFiNode:

    def __init__(self, ssid: str=None, password: str=None) -> None:
        self.sta, self.ap = wifi.reset(sta=True, ap=True)
        wifi.connect(ssid, password)

        # Wait until connected...
        while not self.sta.isconnected():  
            time.sleep(0.1)

        wifi.status()

        # Disable power saving mode. 
        self.sta.config(pm=0)

espnow_node.py

import espnow
import espnow_scan

class EspNowNode:

    def __init__(self, peer_mac: bytes):
        self.node = espnow.ESPNow()
        self.node.active(True)
        self.peer_mac = peer_mac

        # Scan network for existing master devices.
        espnow_scan.scan(peer=self.peer_mac, enow=self.node)

    def recv_cb(self, node) -> None:
        host, msg = node.recv(0)
        if msg:             # msg == None if timeout in recv()
            print(host, msg)

this is the main code and it returns

from espnow_node import EspNowNode
from wifi_node import WiFiNode
import urequests
MAC = b'\x2C\xF4\x32\x63\x93\x90'  # Ensure this is 6 bytes
b_MAC = [MAC]


espnow = EspNowNode(peer_mac=b_MAC)
wifi = WiFiNode('Vaideh_2.4G', 'meghadooth@449')

def main():
    espnow.node.irq(espnow.recv_cb)

main()
while True:
    main()

MPY: soft reboot
Traceback (most recent call last):
  File "<stdin>", line 8, in <module>
  File "espnow_node.py", line 12, in __init__
TypeError: unexpected keyword argument 'enow'
>>> 

[glenn20]

Ah, I see. The espnow_scan.scan() does not need (or accept) the enow aegument. Just change the line from: espnow_scan.scan(peer=self.peer_mac, enow=self.node) to espnow_scan.scan(self.peer_mac). There was an earlier version of espnow_scan which did take that argument (see https://github.com/glenn20/micropython-espnow-utils/blob/main/src/espnow_scan.py#L49).

[AaronBoshMacsimus]

SIR @glenn20 I HAVE corrected the esp_node.py

import espnow
import espnow_scan

class EspNowNode:

    def __init__(self, peer_mac: bytes):
        self.node = espnow.ESPNow()
        self.node.active(True)
        self.peer_mac = peer_mac

        # Scan network for existing master devices.
        espnow_scan.scan(self.peer_mac)

    def recv_cb(self, node) -> None:
        host, msg = node.recv(0)
        if msg:             # msg == None if timeout in recv()
            print(host, msg)

and this my code main.py

from espnow_node import EspNowNode
from wifi_node import WiFiNode
import urequests

MAC = '8E:AA:B5:69:6A:CE'#8caab5696ace
b_MAC = bytes([int(i, 16) for i in MAC.split(':')])



espnow = EspNowNode(peer_mac=b_MAC)
wifi = WiFiNode('Vaideh_2.4G', 'meghadooth@449')

def main():
    espnow.node.irq(espnow.recv_cb)

while True:
    main()

now i am getting this error what should i to do to fix it

MPY: soft reboot
Traceback (most recent call last):
  File "<stdin>", line 10, in <module>
  File "espnow_node.py", line 12, in __init__
  File "espnow_scan.py", line 79, in scan
  File "espnow_scan.py", line 78, in <listcomp>
  File "espnow_scan.py", line 39, in ping_peer
  File "espnow_scan.py", line 17, in set_channel
OSError: can not set channel when connected to wifi network.
>>> 

[glenn20]

If I understand correctly, you intend that the "master' is connected to wifi AND will recieve espnow messages from other devices which are not connected to wifi.

If this is the case, then the "master" node does not need to scan for the other devices. It will automatically use the wifi channel of your wifi network. So, on the master node you do not need to run the espnow_scan.scan(). Just delete that line from the esp_node.py on the master. You only need to run the channel scan on your other non-wifi devices so they find the correct channel of your master node.

(You can skip scanning altogether if you know the channel your wifi network runs on - scanning is only necessary if you dont know, or if your wifi network changes channel sometimes).

Also, in your main.py change the last lines from:

def main():
    espnow.node.irq(espnow.recv_cb)

while True:
    main()

to

def main():
    espnow.node.irq(espnow.recv_cb)
    while True:  # loop forever handling incoming messages
        time.sleep(1)

main()

You should only set the recv_cb once in your program.

[glenn20]

Also, the espnow channel scanning is not foolproof as itr can be fooled by cross-channel interference, so it is better not to use it if you dont need it.

[AaronBoshMacsimus]

still not working @glenn20 it responds to a new error now

MPY: soft reboot
#5 ets_task(4020f540, 28, 3fff91e8, 10)
#6 ets_task(4020f578, 29, 3fff9b10, 10)
#7 ets_task(4020f578, 29, 3fff92b0, 10)
Connected to "Vaideh_2.4G" on wifi channel 8
STA: on,  mac= 2c:f4:32:63:93:90 (b',\xf42c\x93\x90')
AP : on,  mac= 2e:f4:32:63:93:90 (b'.\xf42c\x93\x90')
     connected: Vaideh_2.4G, channel=8, pm=2 (PM_PERFORMANCE), protocol=3 ()
     ifconfig: ('192.168.20.4', '255.255.255.0', '192.168.20.1', '192.168.20.1')
Traceback (most recent call last):
  File "<stdin>", line 18, in <module>
  File "<stdin>", line 14, in main
AttributeError: 'ESPNow' object has no attribute 'irq'

[glenn20]

Whoops, I overlooked that one. If you check the documentation, you will see that the .irq() method is only supported on ESP32. It is easy to change your code so that it doesn't rely on callbacks. Change your main function to:

def main():
    while True:  # loop forever handling incoming messages
        host, msg = espnow.node.irecv()
        if msg:             # msg == None if timeout in recv()
            print(host, msg) 

[AaronBoshMacsimus]

Connected to "Vaideh_2.4G" on wifi channel 8
STA: on,  mac= 2c:f4:32:63:93:90 (b',\xf42c\x93\x90')
AP : on,  mac= 2e:f4:32:63:93:90 (b'.\xf42c\x93\x90')
     connected: Vaideh_2.4G, channel=8, pm=2 (PM_PERFORMANCE), protocol=3 ()
     ifconfig: ('192.168.20.4', '255.255.255.0', '192.168.20.1', '192.168.20.1')
bytearray(b'\x8c\xaa\xb5ij\xce') bytearray(b'Hello')

i have sussfully received the message but the output does not loop @glenn20

[glenn20]

Have you checked that the sending node is continuing to send messages, ie. continuing to print msg recieved on b',\xf42c\x93\x90' -> True?

[AaronBoshMacsimus]

no its says false continously and on the server side this is the output @glenn20

#7 ets_task(4020f578, 29, 3fff92b0, 10)
Connected to "Vaideh_2.4G" on wifi channel 8
STA: on,  mac= 2c:f4:32:63:93:90 (b',\xf42c\x93\x90')
AP : on,  mac= 2e:f4:32:63:93:90 (b'.\xf42c\x93\x90')
    connected: Vaideh_2.4G, channel=8, pm=2 (PM_PERFORMANCE), protocol=3 ()
    ifconfig: ('192.168.20.4', '255.255.255.0', '192.168.20.1', '192.168.20.1')

[AaronBoshMacsimus]

SIR @glenn20 here is the issue when i stop the program and run it again , at that exact moment the client returns true and master displays the output then onwartds the client side returns false and the master side gives a dead output
This is my wifi_node.py under the master side
import time

import wifi as wifi

class WiFiNode:

    def __init__(self, ssid: str=None, password: str=None)->None:
        self.sta, self.ap = wifi.reset(sta=True, ap=True)
        wifi.connect(ssid, password)

        # Wait until connected...
        while not self.sta.isconnected():  
            time.sleep(0.1)

        wifi.status()

        # Disable power saving mode. 
        self.sta.config(pm=0)