--- title: "W55RP20-EVB-MKR MicroPython Tutorial (5)：Quick UDP Communication" url: "https://maker.wiznet.io/ronpang/projects/w55rp20-evb-mkr-micropython-tutorial-5-quick-udp-communication/" markdown_url: "https://maker.wiznet.io/ronpang/projects/w55rp20-evb-mkr-micropython-tutorial-5-quick-udp-communication/md" type: "WCC: WIZnet Created Content" author: "WIZnet HK" editor: "WIZnet" editor_url: "https://maker.wiznet.io/" original_author: "WIZnet HK" published: "2026-06-15" language: "en" likes: 0 views: 442 comments: 0 source: "WIZnet Makers (https://maker.wiznet.io/)" --- # W55RP20-EVB-MKR MicroPython Tutorial (5)：Quick UDP Communication > This is Part 5 of the WIZnet W55RP20 MicroPython tutorial series, written based on the latest official firmware. Original author: WIZnet HK ## Article ## **W55RP20-EVB-MKR MicroPython Tutorial (5)：Quick UDP Communication** > This is Part 5 of the WIZnet W55RP20 MicroPython tutorial series, written based on the latest official firmware. All code has been tested and verified, and can be flashed and run directly. Copyright Notice: This article is an original WIZnet technical article. Please credit the source when reprinting. --- ### **Introduction** In the previous tutorial, we completed the development of a **TCP Server**, achieving connection-oriented, stable, and reliable TCP data exchange. In scenarios such as fast device communication within a LAN or low-latency command delivery, the **UDP protocol**—with its lighter weight and higher efficiency—becomes an essential choice for embedded development. When combined with the WIZnet W5500 network module, the development potential of MicroPython and the Raspberry Pi Pico is further amplified. The W5500 module features a built-in hardware TCP/IP stack, eliminating the burden of protocol stack porting and parsing on the MCU, enabling rapid connectionless UDP data exchange. UDP, with its low latency, lightweight nature, and high efficiency, is widely used in IoT scenarios such as sensor data reporting, LAN device interaction, and industrial short-command communication. This article will use the W55RP20-EVB-MKR development board to quickly build a UDP server using minimal wrapper code, implementing data reception and automatic reply functionality. This article will walk you through the UDP communication practice for the W55RP20 chip. After completing this article, you will master: Core principles of the UDP protocol and its connectionless workflow Rapid setup of the W55RP20-EVB-MKR development environment Minimal code implementation for UDP server send/receive communication Joint debugging and testing with a network debugging tool One-stop troubleshooting for UDP communication and network issues Core advantages of the WIZnet hardware protocol stack in short-packet communication --- ### **Series Tutorial Learning Path** This series consists of 16 parts, progressively covering everything from basic networking to industrial-grade applications: Part 1: Static IP Configuration and Network Basics Part 2: DHCP Automatic Networking and Network Diagnostics Part 3: TCP Client Communication Part 4: TCP Server Communication Part 5: UDP Unicast Data Communication (this article) Part 6: UDP Multicast/Broadcast Data Communication Part 7: DNS Domain Name Resolution Part 8: NTP — Getting Time from the Network Part 9: HTTP Client Requests Part 10: HTTP Server Setup Part 11: HTTP Protocol & OneNET Cloud Data Upload Part 12: MQTT Protocol Basic Communication Verification Part 13: MQTT Protocol & Alibaba Cloud Integration Part 14: MQTT Protocol & OneNET Platform Integration Part 15: MQTT Protocol & ThingSpeak Integration Part 16: Modbus Industrial Protocol Communication > We recommend bookmarking this series and following along step by step. All code will be synchronized to the official Gitee repository. --- ### **Table of Contents** 1 UDP Communication Principles 1.1 Introduction to UDP 1.2 UDP Workflow 1.3 Core Advantages of UDP 1.4 Typical Application Scenarios 2 Preparation 2.1 Software Preparation 2.2 Hardware Preparation 3 Flashing the W55RP20-EVB-MKR Dedicated MicroPython Firmware 4 Hardware Connections & Development Environment Setup 4.1 Hardware Connections 4.2 Thonny IDE Configuration 5 Core Code Analysis 5.1 Complete Code 5.2 Key Code Explanation 5.3 Extension: Static IP Manual Configuration 6 Running Results & Test Verification 6.1 Serial Output Results 6.2 UDP Joint Debugging Method 7 One-Stop Troubleshooting Guide 7.1 Flashing & Port Issues 7.2 Network Connectivity Issues 7.3 UDP Send/Receive Issues 8 WIZnet Hardware Protocol Stack — Core Advantage Comparison 9 Typical Application Scenarios 10 Summary 11 Series Preview & Resources 11.1 Series Preview 11.2 Resources --- ### **1. UDP Communication Principles** #### **1.1 Introduction to UDP** UDP (User Datagram Protocol) is a **connectionless** transport-layer communication protocol. Unlike TCP's connection-oriented nature, UDP requires no three-way handshake and does not need to maintain a connection state; it sends and receives data in the form of independent datagrams. The protocol structure is streamlined with minimal header overhead, sacrificing some reliability in exchange for ultra-low latency and high-speed transmission, making it the preferred protocol for short-message interaction in embedded IoT applications. Compared to TCP, UDP has no handshake process for connection establishment and teardown. Each packet is sent independently; the receiver does not need to acknowledge, and the sender does not wait for a response, resulting in lower latency and higher efficiency. #### **1.2 UDP Workflow** The complete workflow for implementing UDP communication on the W55RP20-EVB-MKR module is as follows: Board powers on → Initialize SPI interface → Activate the W55RP20-EVB-MKR network module Complete network access via DHCP / static IP Create a UDP datagram socket and bind a fixed listening port Continuously block and listen, waiting for client data from the LAN Receive data packets, simultaneously obtaining the client's IP and port information Package reply data and send it directionally back to the sender Loop listening, continuously handling multiple rounds of UDP interaction #### **1.3 Core Advantages of UDP** Connectionless communication — no handshake required, fast response Lightweight protocol — minimal network bandwidth and MCU resource usage Supports unicast, broadcast, and multicast communication modes Suitable for short-frame, high-frequency, real-time data transmission Simple code implementation, low debugging cost in embedded development #### **1.4 Typical Application Scenarios** | **Scenario** | **Description** | | --- | --- | | IoT sensor periodic data reporting | Low latency, low power consumption, suitable for frequent short-packet reporting | | LAN device discovery & batch control | Supports broadcast mode — one send, multiple devices respond | | Industrial device lightweight command interaction | Strong real-time performance, suitable for bidirectional short-command communication | | Smart home real-time status synchronization | Multi-device multicast communication, efficient status sync | | Embedded network protocol introductory learning | Clean code, suitable for rapid network functionality verification | --- ### **2. Preparation** ![Insert image description here](https://i-blog.csdnimg.cn/direct/6813b9665a3c4d7d8df2232d7b10d09b.png) #### **2.1 Software Preparation** | **Software** | **Version Requirement** | **Download Link** | **Description** | | --- | --- | --- | --- | | Thonny | 4.0 or later | [Thonny Official Download](https://thonny.org) | Lightweight MicroPython IDE supporting code editing, flashing, and serial debugging — beginner-friendly | | W55RP20-EVB-MKR MicroPython Firmware | Latest stable version | [WIZnet Official Firmware Download](https://www.w5500.com/chip/W55RP20) | Specifically written for the W55RP20-EVB-MKR module, with WIZnet hardware drivers and protocol stack integrated | #### **2.2 Hardware Preparation** The following hardware is required: W55RP20-EVB-MKR development board × 1 Micro USB cable (must support data transfer; charging-only cables will not work) × 1 Standard Ethernet cable × 1 Router/switch with DHCP enabled × 1 > Tip: The W55RP20-EVB-MKR module already integrates all Ethernet-related components — no additional soldering or jumper wires are needed. Combined with the RP2040 board, you can quickly set up the development environment, greatly reducing the probability of wiring errors and hardware failures. --- ### **3. Flashing the W55RP20-EVB-MKR Dedicated MicroPython Firmware** Before running the UDP example, you need to flash the corresponding MicroPython firmware onto the W55RP20-EVB-MKR. The W55RP20-EVB-MKR module is fully compatible with the Raspberry Pi Pico UF2 firmware flashing method. The steps are as follows: Press and hold the `BOOTSEL` button on the RP2040 board Connect the board to your computer using the Micro USB cable Once the computer recognizes a USB drive named `RPI-RP2`, release the BOOTSEL button Drag the downloaded `.uf2` firmware file into the `RPI-RP2` USB drive The board will automatically restart, and the firmware flashing is complete > Note: If the computer does not recognize the `RPI-RP2` USB drive, try reconnecting the USB cable, use a different USB cable that supports data transfer, or switch to a different USB port (preferably a USB 2.0 port). --- ### **4. Hardware Connections & Development Environment Setup** #### **4.1 Hardware Connections** Connecting the W55RP20-EVB-MKR is extremely simple — just two steps: Use the Micro USB cable to connect the RP2040 board to the computer (for power, code flashing, and serial debugging) Use the Ethernet cable to connect the W55RP20-EVB-MKR module's Ethernet port to the router's LAN port ![Insert image description here](https://i-blog.csdnimg.cn/direct/aec74f203f1149d0a10c23cd3f479525.jpeg) #### **4.2 Thonny IDE Configuration** Open Thonny, click the top menu bar: "Run" → "Configure Interpreter" Switch to the "Interpreter" tab In the "Interpreter" dropdown, select `MicroPython (Generic)` In the "Port" dropdown, select the serial port corresponding to the W55RP20-EVB-MKR (usually displayed as `Board CDC @ COMx`) Check "Restart interpreter before running code" and "Sync device's real-time clock" Click "OK" to complete the configuration > If the board does not appear in the port list, try: > > Re-plugging the USB cable > > Using a different USB cable that supports data transfer > > Closing other software that occupies the serial port (e.g., serial monitor, Arduino IDE, etc.) > > Re-flashing the MicroPython firmware > > Installing the Raspberry Pi Pico USB driver --- ### **5. Core Code Analysis** The W55RP20-EVB-MKR module's MicroPython library has already encapsulated all low-level details. Implementing UDP communication requires only a small amount of core code — no need to write complex low-level drivers or protocol parsing logic. #### **5.1 Complete Code** Open the UDP example file, or enter the following code in Thonny: ``` from wiznet_init import wiznet import usocket as socket import time ​ # Initialize network nic = wiznet("W55RP20-EVB-MKR", dhcp=True) local_ip = nic.ifconfig()[0] local_port = 8087 ​ print("==================================") print(" UDP Server Started") print(" Local IP:", local_ip) print(" Local Port:", local_port) print("==================================") ​ # Create UDP socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.bind(("0.0.0.0", local_port)) # Bind to all addresses ​ # Loop receive & reply while True: data, addr = s.recvfrom(1024) # Wait for data from the computer print("Received from", addr, ":", data) # Reply to the computer s.sendto(b"UDP Server reply: " + data, addr) ``` #### **5.2 Key Code ExplanationNetwork Initialization**: Based on the officially wrapped `wiznet` utility library, a single line of code completes W55RP20-EVB-MKR hardware driver loading, Ethernet activation, and DHCP automatic networking — avoiding complex low-level SPI and register configuration. **UDP Socket Creation**: Uses `SOCK_DGRAM` to declare datagram mode for dedicated UDP communication, distinguishing it from TCP stream sockets and adapting to UDP's connectionless nature. **Port Binding Configuration**: Binds to `0.0.0.0` to listen on all network segments, ensuring any device on the LAN can access the W55RP20-EVB-MKR module's UDP server port. **Bidirectional Communication Logic**: `recvfrom` blocks waiting to receive data, automatically carrying the client address; `sendto` sends a directional reply based on the target address, achieving a request-response closed-loop communication suitable for embedded short-message interaction scenarios. #### **5.3 Extension: Static IP Manual Configuration** In environments without a DHCP router, you can disable automatic networking and manually set a fixed IP, gateway, and DNS: ``` # Disable DHCP, manually configure static network parameters (W55RP20-EVB-MKR module) nic = wiznet("W55RP20-EVB-MKR", dhcp=False) nic.ifconfig(("192.168.1.100","255.255.255.0","192.168.1.1","114.114.114.114")) ``` > Note: The static IP must be in the same subnet as your computer/server; otherwise, UDP communication and network interaction will not be possible. --- ### **6. Running Results & Test Verification** Once the hardware connections and Thonny IDE are configured, you can run the UDP example program and check whether the **W55RP20-EVB-MKR** successfully sends and receives UDP data. --- #### **6.1 Serial Output Results** Click the Run button in Thonny, or press `F5` to run the program. After running, the Shell window will output something similar to: ``` Waiting for the network to connect... MAC Address: 02:90:86:88:4d:56 IP Address: ('192.168.1.118', '255.255.255.0', '192.168.1.1', '202.96.134.33') ================================== UDP Server Started Local IP: 192.168.1.118 Local Port: 8087 ================================== Received from ('192.168.1.141', 8087) : b'Hello WIZnet\r\n' Received from ('192.168.1.141', 8087) : b'Hello WIZnet\r\n' ``` > Note: The resolved IP address may vary slightly depending on the network environment and router configuration — this is normal. If no IP address is displayed, check the network connection and firmware configuration. The actual running result is shown below: [video(video-71bs2TMl-1781145289458)(type-csdn)(url-[https://live.csdn.net/v/embed/524092)(image-](https://live.csdn.net/v/embed/524092%29%28image-)[https://i-blog.csdnimg.cn/img_convert/baf330f27f1b20d72f7ebf7aef04583d.jpeg)(title-UDP](https://i-blog.csdnimg.cn/img_convert/baf330f27f1b20d72f7ebf7aef04583d.jpeg%29%28title-UDP))] #### **6.2 UDP Joint Debugging Method** Open a network debugging tool and select **UDP Client Mode** Enter the local IP printed by the W55RP20-EVB-MKR module and port `8087` Manually enter test data and click Send Thonny's serial monitor prints the received content in real time, while the debugging tool simultaneously receives the module's reply If data sending and receiving are normal, the W55RP20-EVB-MKR UDP communication setup is complete --- ### **7. One-Stop Troubleshooting Guide** #### **7.1 Flashing & Port Issues** | **Issue** | **Troubleshooting Steps** | | --- | --- | | Computer cannot recognize `RPI-RP2` USB drive | 1. Confirm you are holding `BOOTSEL` before connecting USB 2. Use a different USB cable that supports data transfer 3. Try a different USB port on the computer 4. Try another computer | | Board port not found in Thonny | 1. Re-plug the USB cable 2. Use a different USB cable that supports data transfer 3. Close other software occupying the serial port 4. Check Device Manager for a new serial device 5. Re-flash the MicroPython firmware | --- #### **7.2 Network Connectivity Issues** | **Issue** | **Troubleshooting Steps** | | --- | --- | | Ethernet port LED not lit | 1. Check Ethernet cable integrity 2. Try a different router LAN port 3. Re-plug the Ethernet cable to ensure a secure connection | | DHCP acquisition failed | 1. Switch to static IP configuration with same-subnet parameters 2. Confirm the router has DHCP enabled 3. Restart the router and W55RP20-EVB-MKR module | | IP address is 0.0.0.0 | 1. Re-flash the W55RP20-EVB-MKR dedicated firmware 2. Restart the device 3. Check network connection and wiring | --- #### **7.3 UDP Send/Receive Issues** | **Issue** | **Troubleshooting Steps** | | --- | --- | | Client cannot connect | 1. Confirm both devices are on the same LAN 2. Ensure server and client use the same port number 3. Disable the computer's firewall | | Data received is empty | 1. Limit single-packet size to within 1024 bytes 2. Check that the receive logic in the code is correct 3. Re-flash the code and restart the module | | Severe packet loss | 1. Disable the computer's firewall to reduce network interference 2. Use a high-quality Ethernet cable 3. Reduce high-frequency continuous sending; add short delays | --- ### **8. WIZnet Hardware Protocol Stack — Core Advantage Comparison** To give you a clearer picture of the W55RP20's value, we compare the three mainstream embedded Ethernet solutions: | **Dimension** | **W5500 Hardware Stack Solution** | **External PHY Chip Solution** | **Serial-to-Ethernet Module Solution** | | --- | --- | --- | --- | | BOM Cost | Medium (MCU + network module, no extra components) | Medium-High (MCU + PHY chip + peripheral components) | High | | PCB Footprint | Small (high module integration, only needs space for the module) | Large (requires chip, trace space, and peripheral circuits) | High | | Development Difficulty | Low (MicroPython firmware already encapsulates the low level; minimal code for UDP communication) | Medium-High (requires debugging the protocol stack and writing low-level drivers; high R&D capability needed) | Low | | Network Stability | Extremely high (WIZnet has focused on hardware TCP/IP stacks for 25 years; strong anti-interference, low UDP packet loss) | Variable (depends on the developer's mastery of the protocol stack and network development; UDP is prone to packet loss) | Variable (depends on the vendor's capability) | | CPU Resource Usage | **0%** (protocol stack fully handled by hardware; no MCU resources consumed; does not affect data send rate) | 50%+ (protocol stack runs on the MCU, consuming significant CPU and memory, impacting UDP send efficiency) | 0% | | Hardware Socket Count | W5500: **8** independent hardware sockets, supporting simultaneous multicast/broadcast | Depends on MCU capability; theoretically supports multiple channels, but limited by CPU resources in practice | Generally single-channel pass-through | | Network Throughput | W5500: up to **15 Mbps**, smooth UDP data transfer with no noticeable latency | Depends on MCU capability; generally lower than hardware stack solutions; multi-device communication prone to stuttering | approx. 3–5 Mbps | | Interface Usability | SPI interface — simple wiring, compatible with most MCUs, supports high-speed communication | Requires MCU with MII/RMII dedicated interfaces — limited compatibility | TTL interface | | Deployment Difficulty | Low (mature MicroPython firmware, libraries for application-layer protocols, rapid multi-device networking) | High (application-layer protocols require manual porting of open-source libraries for adaptation; high debugging cost) | Depends on module integration; functionality not built-in requires custom packet assembly/disassembly | The **W55RP20-EVB-MKR development board** already has an onboard Ethernet interface, making it ideal for rapid Ethernet functionality verification. For the UDP example, the advantage of the **W55RP20-EVB-MKR development board** is that you don't need to connect an external Ethernet module or manually configure complex low-level drivers — just a few lines of MicroPython example code are enough to complete UDP communication testing. --- ### **9. Typical Application Scenarios** The W55RP20-EVB-MKR module, combining MicroPython's rapid development advantages with the stability of the WIZnet hardware protocol stack, is well-suited for the following scenarios: Periodic sensor data collection and reporting in industrial field sites Rapid discovery and unified control of multiple devices within a LAN Bidirectional interaction of embedded lightweight control commands Short-message communication for IoT low-power nodes Embedded networking hands-on teaching cases for universities and enterprises In these scenarios, UDP's low latency and lightweight characteristics allow the development board to perform data exchange more efficiently, reducing the extra overhead of network communication. --- ### **10. Summary** Starting from UDP protocol principles, this article systematically demonstrated how to quickly implement UDP communication using the W55RP20-EVB-MKR development board. With the WIZnet hardware TCP/IP stack, only a small amount of MicroPython code is needed to build a UDP server and handle data transmission and reception. Key takeaways from this article: **UDP Protocol Principles**: Understood UDP's core characteristics — connectionless, lightweight, low-latency — as well as unicast, broadcast, and multicast operating modes **Development Environment Setup**: Completed the W55RP20-EVB-MKR dedicated firmware flashing and Thonny IDE configuration **UDP Server Implementation**: Used `socket.SOCK_DGRAM` to create a UDP socket, bound the listening port, and implemented data reception with automatic reply **Joint Debugging & Testing**: Verified bidirectional communication between a UDP client and server using a network debugging tool **Troubleshooting**: Summarized troubleshooting methods for three major categories — flashing, network connectivity, and UDP send/receive issues **Solution Comparison**: Compared the W5500 hardware protocol stack, external PHY chip, and serial-to-Ethernet module solutions; the W55RP20 demonstrates significant advantages in development convenience, CPU resource usage, and network stability The W55RP20-EVB-MKR development board combines WIZnet's 25 years of hardware protocol stack expertise with MicroPython's rapid development advantages, making embedded network development simpler than ever. After mastering the UDP communication fundamentals in this article, you will be able to easily extend to more advanced network applications — such as multicast communication, HTTP services, and MQTT cloud integration covered in subsequent tutorials. --- ### **11. Series Preview & Resources** #### **11.1 Series Preview** The next tutorial will cover **UDP Multicast & Broadcast Communication with the W55RP20-EVB-MKR Module using MicroPython**, taking you through: Multicast address configuration Broadcast command sending Key mechanisms like multi-device synchronized response Mastering core capabilities for multi-device cluster control within a LAN --- #### **11.2 Resources** Complete code for this article: [WIZnet Pico MicroPython Example Project](https://gitee.com/wiznet-hk/wiznet_pico_micropython) W55RP20 Chip Datasheet: [WIZnet Official Resources Page](https://www.w5500.com/chip/W55RP20) > If this article was helpful, feel free to like, bookmark, and follow — your support is our motivation to keep updating! > > If you have any questions, please leave a comment, and we will respond as soon as possible. --- Source: https://maker.wiznet.io/ronpang/projects/w55rp20-evb-mkr-micropython-tutorial-5-quick-udp-communication/