Wiznet makers

Summary

The Soldered NULA Ethernet W55RP20 is a compact development board built around WIZnet’s W55RP20, which combines an RP2040-class dual-core microcontroller with the W5500 hardwired TCP/IP controller in one package. The board targets embedded systems that need normal RP2040 peripherals together with wired 10/100 Ethernet, without adding a separate Ethernet controller and a large software TCP/IP stack. Soldered positions it as part of its NULA development-board family, while upstream Raspberry Pi Pico SDK support makes it relevant beyond a one-off maker board.

What the Project Does

The NULA Ethernet W55RP20 is not an end application such as a sensor node or datalogger. It is a general-purpose embedded Ethernet platform.

Its purpose is to give a developer the normal RP2040 programming model—GPIO, UART, I²C, SPI and related peripherals—while integrating wired Ethernet into the same small board. Soldered describes the board as being based on WIZnet’s W55RP20, with the RP2040 processing section and W5500 hardwired TCP/IP controller combined in a single package.

That makes the board suitable as a starting point for applications such as:

• Ethernet-connected sensors and dataloggers,
• serial-to-Ethernet devices,
• laboratory or test equipment,
• small industrial controllers,
• building or environmental monitoring nodes,
• network-controlled actuators,
• gateways for UART, SPI or I²C peripherals,
• and prototypes intended to move later to a custom W55RP20 PCB.

The key architectural difference from a conventional Raspberry Pi Pico design is that Ethernet is not added as a separate external module.

A conventional design might look like:

RP2040 → SPI → separate W5500 → magnetics/RJ45

With W55RP20, the MCU and W5500 networking engine are combined into one SiP:

W55RP20 → Ethernet physical interface

That reduces the number of major ICs involved in the embedded networking portion of the design.

The board also has unusually strong software-platform positioning for a distributor-created development board. Raspberry Pi’s upstream pico-sdk now contains a dedicated board definition named:

soldered_nula_ethernet_w55rp20.h

The board definition was proposed in May 2026 and merged into the Pico SDK development branch in June 2026.

This matters because developers using the Pico SDK do not need to treat the NULA board as an unknown custom RP2040 target. Basic board-level definitions can be selected directly through the SDK.

Where WIZnet Fits

The WIZnet component is the core reason this board exists.

The W55RP20 is a System-in-Package integrating WIZnet's W5500 Ethernet controller and the RP2040 microcontroller architecture. WIZnet describes the networking portion as a hardware TCP/IP implementation, allowing Ethernet communication without requiring the MCU to execute a complete software TCP/IP stack for normal socket operation.

For an embedded Ethernet device, that creates a useful division of responsibility:

RP2040 side

• application logic,
• sensor acquisition,
• GPIO control,
• timers,
• UART,
• I²C,
• SPI,
• local processing.

W5500 side

• TCP/IP processing,
• socket management,
• Ethernet transmit/receive buffering.

That separation matters more than raw Ethernet bandwidth in many embedded products.

A temperature controller, environmental monitor or serial gateway may only exchange a few kilobytes per second. Its engineering problem is usually not throughput. The problem is making networking coexist predictably with the primary application.

A software TCP/IP implementation such as LwIP uses MCU RAM, execution time and interrupt handling for network processing. W55RP20 instead places the familiar W5500 hardware networking architecture alongside the RP2040 processing subsystem.

This makes the NULA board particularly suitable for prototyping systems where Ethernet is infrastructure rather than the main application.

Why the single-package approach matters

A Raspberry Pi Pico plus an external W5500 board can implement many of the same functions.

The difference is integration.

With a separate configuration, developers must account for two major ICs, the PCB connection between them, SPI routing and the board area associated with the external network controller.

W55RP20 combines the two functional blocks into one package. The resulting development board can therefore serve as a useful intermediate step between:

Pico + Ethernet breakout prototype

and

custom commercial Ethernet PCB

That is arguably the most important role of the NULA board.

It allows a developer to validate the application using an RP2040-compatible environment while working with essentially the same integrated MCU/network-controller architecture that could later be designed directly into a product.

Implementation Notes

Unlike the previous Geiger-Müller project, this board has implementation details that can be verified directly from an upstream source repository.

Raspberry Pi’s Pico SDK contains a dedicated board definition for the Soldered NULA Ethernet W55RP20:

pico-sdk/src/boards/include/boards/soldered_nula_ethernet_w55rp20.h

The following definitions are present in the upstream file:

#ifndef PICO_DEFAULT_UART #define PICO_DEFAULT_UART 0 #endif

#ifndef PICO_DEFAULT_UART_TX_PIN #define PICO_DEFAULT_UART_TX_PIN 0 #endif

#ifndef PICO_DEFAULT_UART_RX_PIN #define PICO_DEFAULT_UART_RX_PIN 1 #endif

This defines the board's default UART as UART0, using GPIO0 for TX and GPIO1 for RX.

The same board definition establishes its default I²C and SPI buses:

#define PICO_DEFAULT_I2C 1 #define PICO_DEFAULT_I2C_SDA_PIN 2 #define PICO_DEFAULT_I2C_SCL_PIN 3

#define PICO_DEFAULT_SPI 0 #define PICO_DEFAULT_SPI_SCK_PIN 6 #define PICO_DEFAULT_SPI_TX_PIN 7 #define PICO_DEFAULT_SPI_RX_PIN 4 #define PICO_DEFAULT_SPI_CSN_PIN 5

These definitions matter because Pico SDK libraries and examples can reference the board defaults instead of requiring each project to repeat the physical pin mapping.

The board definition also declares a user button on GPIO8 and specifies the board's flash configuration, including the W25Q080 boot-stage selection.

Soldered also documents Arduino support. With the Earle Philhower RP2040 core installed, the board can be selected directly under:

Raspberry Pi RP2040 Boards → Soldered NULA Ethernet W55RP20

That gives developers a second entry point alongside the native Pico SDK.

Why upstream SDK support is significant

This is one of the more interesting aspects of the project.

Many distributor boards technically work with an MCU ecosystem but remain dependent on locally maintained pin files, examples or forked libraries.

The NULA Ethernet W55RP20 has a board definition in the Raspberry Pi Pico SDK repository itself.

For commercial prototyping, that reduces a small but real source of friction.

A development team evaluating the platform can use a recognized Pico SDK target rather than maintaining its own custom board configuration from the first day.

It does not mean Raspberry Pi certifies the board for industrial use, nor does it make the hardware itself production-qualified. It simply means the software integration is more mature than an unsupported custom RP2040 board.

Practical Tips / Pitfalls

• Treat the NULA board as a development platform, not automatically as the production PCB. It is useful for validating firmware and Ethernet architecture, but a volume product may integrate W55RP20 directly onto its own PCB.
• Choose hardware TCP/IP because the application benefits from it, not merely because Ethernet is available. W55RP20 is most compelling where the MCU must continue servicing sensors, control loops or peripherals while networking remains active.
• Plan socket usage early. W55RP20 inherits W5500-style hardware socket networking, so applications should define how many simultaneous TCP or UDP connections they actually require rather than treating sockets as unlimited OS resources. 
• Use the upstream board definition when working with Pico SDK. It already contains the standard UART, I²C, SPI, button and flash definitions for the board. 
• Validate the higher-level protocol separately from basic Ethernet operation. Industrial applications may still require MQTT, Modbus TCP, HTTPS, a proprietary protocol or a serial-to-Ethernet transport layer.
• Consider failure behaviour from the beginning. A commercial node should recover from cable removal, DHCP failure, switch restart, server loss and socket timeout without requiring a power cycle.
• For industrial deployments, the board is only one part of the qualification problem. Power protection, isolation requirements, ESD/EMC, connectors, enclosure, temperature range and long-duration firmware reliability still belong to the finished product design.

FAQ

Q: Why use W55RP20 on the Soldered NULA instead of a normal RP2040?

The W55RP20 integrates the RP2040 processing architecture with WIZnet's W5500 hardwired TCP/IP controller. A normal RP2040 requires an additional Ethernet controller or another network interface, whereas W55RP20 places the MCU and hardware TCP/IP networking in one package. This is useful when the application must run sensors, control logic or peripheral interfaces while Ethernet operates independently through the W5500 networking engine.

Q: How does the NULA W55RP20 connect to sensors and peripherals?

The board remains an RP2040-style embedded platform. Its upstream Pico SDK definition assigns UART0 to GPIO0/1, I²C1 to GPIO2/3 and SPI0 to GPIO4–7, with GPIO8 defined for the user button. Developers can therefore connect ordinary UART, I²C, SPI and GPIO peripherals while using the W55RP20 for Ethernet networking.

Q: What role does W55RP20 play in this board?

It provides both the application's microcontroller and its wired networking subsystem. The RP2040 portion executes the application, while the W5500-derived networking portion handles hardware TCP/IP sockets and Ethernet buffering. The NULA board packages those functions into a compact development platform intended for Ethernet-connected embedded systems.

Q: Can beginners use the NULA Ethernet W55RP20?

Yes, provided they already have basic microcontroller experience. Arduino support allows the board to be selected directly from the RP2040 board package, while more advanced developers can use the Raspberry Pi Pico SDK, which now includes a native board definition. Ethernet programming still requires an understanding of IP addressing, TCP/UDP and whichever application protocol the project uses.

Q: How does NULA W55RP20 compare with a Raspberry Pi Pico plus an external W5500?

Functionally, both architectures can combine RP2040 processing with W5500 Ethernet. The important difference is integration. With a Pico plus W5500, the MCU and network controller are separate devices connected externally, normally through SPI. W55RP20 integrates those functional blocks into one package, making it more attractive when the prototype is expected eventually to become a smaller custom product. A separate Pico and W5500 can still be preferable when modularity, replaceability or an existing Pico design matters more than integration.