asyncio.start_server issue with Wiznet W5500

[DoubleVee73]

I am using a Wiznet dev board (EVB-W5500-PICO2) which essentially upgrades the previous EDVB-W5500-PICO from using a RP2040 MCU to the newer RP2350. I have tried both boards and am finding with the latest firmware v1.26, I am unable to get asyncio.start_server() to work. It results in a hard crash.

################################################
from machine import SPI, Pin
import network, uasyncio as asyncio

SPI0 = SPI(0, baudrate=5_000_000)
NIC = network.WIZNET5K(SPI0, Pin(17), Pin(20))
NIC.active(True)

if NIC.ifconfig()[0] == "0.0.0.0":
NIC.ifconfig("dhcp")

IP = NIC.ifconfig()[0]
print("[net] up:", NIC.ifconfig())

async def handle(r, w):
await r.read(256)
w.write(b"HTTP/1.0 200 OK\r\nContent-Length:2\r\n\r\nOK")
await w.drain()

async def main():
host = IP
srv = await asyncio.start_server(handle, host, 8080)
while True:
await asyncio.sleep(1)

asyncio.run(main())
################################################

This is the result:

################################################
File "asyncio/core.py", line 1, in run
File "asyncio/core.py", line 1, in run_until_complete
File "asyncio/core.py", line 1, in run_until_complete
File "", line 21, in main
File "asyncio/stream.py", line 1, in start_server
OSError: [Errno 107] ENOTCONN
################################################

Am I doing something obviously wrong here? Is there an issue with using the W5500 with asyncio?

I have searched in the forum but could not find anything applicable. Thanks in advance.

[Thildaugg]

When I try to use uasyncio.start_server() on the EVB-W5500-PICO2 with the RP2350 and firmware v1.26, it crashes with OSError: [Errno 107] ENOTCONN. The same code works on the older RP2040-based board. The error basically means the socket is being treated as “not connected” when asyncio tries to use it. The problem doesn’t come from the code itself but from the way the Wiznet W5500 Ethernet driver integrates with uasyncio. The W5500 sockets work fine in normal blocking mode, so if you call socket(), bind(), listen(), and accept() directly you can get connections just fine. The trouble is that uasyncio.start_server() expects the network driver to provide socket operations that work with the event loop, especially the ability to poll or select on the socket. The Wiznet driver doesn’t implement that fully, which is why asyncio fails when trying to set up a server. So it looks more like a limitation in the Wiznet driver’s async support than an issue with asyncio or with the user code.

here are two possible solutions
Manual Socket Loop (Raw)

import uasyncio as asyncio
import socket
from machine import SPI, Pin
import network

--- Ethernet Setup ---

SPI0 = SPI(0, baudrate=5_000_000)
NIC = network.WIZNET5K(SPI0, Pin(17), Pin(20))
NIC.active(True)
NIC.ifconfig("dhcp")
IP = NIC.ifconfig()[0]
print("[net] up:", NIC.ifconfig())

--- Server Loop ---

async def server():
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((IP, 8080))
s.listen(1)
s.setblocking(False)

print("[srv] listening on", IP, ":8080")

while True:
    try:
        conn, addr = s.accept()
    except OSError:
        await asyncio.sleep(0.05)
        continue
    print("[srv] client:", addr)
    asyncio.create_task(handle_client(conn))

async def handle_client(conn):
try:
req = conn.recv(256)
print("[cli] got:", req)
conn.send(b"HTTP/1.0 200 OK\r\nContent-Length:2\r\n\r\nOK")
except Exception as e:
print("[cli] error:", e)
finally:
conn.close()

asyncio.run(server())

This works today with Wiznet. No crash.

Wrapper Solution (Keep handle(r, w))
If you prefer the stream API (reader, writer like in your original code), we can wrap the raw socket in lightweight async streams.

import uasyncio as asyncio
import socket
from machine import SPI, Pin
import network

--- Ethernet Setup ---

SPI0 = SPI(0, baudrate=5_000_000)
NIC = network.WIZNET5K(SPI0, Pin(17), Pin(20))
NIC.active(True)
NIC.ifconfig("dhcp")
IP = NIC.ifconfig()[0]
print("[net] up:", NIC.ifconfig())

--- Stream Wrappers ---

class StreamReader:
def init(self, conn):
self.conn = conn
self.conn.setblocking(False)

async def read(self, n=256):
    while True:
        try:
            return self.conn.recv(n)
        except OSError:
            await asyncio.sleep(0.01)

class StreamWriter:
def init(self, conn):
self.conn = conn

def write(self, data):
    return self.conn.send(data)

async def drain(self):
    await asyncio.sleep(0)  # placeholder, nothing special here

def close(self):
    self.conn.close()

--- Your Original Style Handler ---

async def handle(reader, writer):
req = await reader.read(256)
print("[cli] got:", req)
writer.write(b"HTTP/1.0 200 OK\r\nContent-Length:2\r\n\r\nOK")
await writer.drain()
writer.close()

--- Async Server (manual accept loop + wrappers) ---

async def server():
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((IP, 8080))
s.listen(1)
s.setblocking(False)

print("[srv] listening on", IP, ":8080")

while True:
    try:
        conn, addr = s.accept()
    except OSError:
        await asyncio.sleep(0.05)
        continue
    print("[srv] client:", addr)
    reader = StreamReader(conn)
    writer = StreamWriter(conn)
    asyncio.create_task(handle(reader, writer))

asyncio.run(server())

Now you can use the same async def handle(r, w): ... style you wanted, without asyncio.start_server() blowing up.

[DoubleVee73]

Wow thank you so much for taking the time to reply and with that level of detail.

I will take a look at this today - you have given me hope 😊 As you say, with a synchronous setup it works and is rock solid but for a production environment I really want to avoid a synchronous IP front end. Thank you again.

[Thildaugg]

No biggie
this is what communities are made for

[DoubleVee73]

@Thildaugg it's interesting that you could get the asyncio.start_server() working on the previous Wiznet board - would this imply an issure with the interaction between W5500, RP2350 and v1.26 specifically? I assumed the SPI comms and handling would not have altered.

I was hoping to use Microdot with this solution, but clearly I will have to wait for some further development with the Rp2350 and Wiznet. Thank you again for taking the time to respond the way you did - it has been very helpful.

[peterhinch]

@Thildaugg A few queries about the robustness of this:

async def read(self, n=256):
    while True:
        try:
            return self.conn.recv(n)
        except OSError:
            await asyncio.sleep(0.01)

1. My understanding of nonblocking sockets is that their methods prioritise immediate return over complete message reception: short reads can occur. Should the code not check the amount of data received, accumulating bytes until n bytes have been received?
2. I think there should be a check for server disconnection.
3. Is it valid to keep trying when an OSError occurs? Or should the error propagate up to the application?
4. A timeout, raising an error to the application, might improve reliability.