Beryllium OS Micro: A Modular CircuitPython Environment with W5500 Ethernet

Beryllium OS Micro: Integrating W5500 Ethernet into a CircuitPython OS

Summary

Beryllium OS Micro, formerly known as ljinux, is a Unix-like operating environment for CircuitPython-powered microcontrollers. It is not a Linux distribution and cannot run Linux binaries. Instead, it provides an OS-style shell, device model, package manager, board configuration, and Python execution environment on small MCUs.

The project includes a dedicated W5500 SPI Ethernet driver at drivers/w5500spi.py. This is interesting because it attempts to make W5500 Ethernet a managed OS network interface rather than just a library used by one application.

The README estimates that roughly 70 KB of usable RAM is required, while the porting guide recommends at least 100 KB of free RAM. The actual memory budget should therefore be checked on each target board.

Why Beryllium OS Micro Is Useful

Beryllium OS Micro gives a CircuitPython board a more organized way to run commands, drivers, packages, and application scripts.

In simple terms, CircuitPython usually runs one main Python program on a board. Beryllium OS Micro adds a command environment, file structure, driver-loading method, and package rules around that program.

Typical CircuitPython project
One main application file
 ├─ Ethernet setup
 ├─ Sensor code
 ├─ Display code
 └─ Application logic

Beryllium OS Micro
OS environment
 ├─ Board configuration
 ├─ Reusable drivers
 ├─ Optional packages
 ├─ Diagnostic commands
 └─ Application scripts

This can make development easier when a project grows beyond a single experiment. Instead of rewriting Ethernet setup, pin definitions, and utility code for every application, developers can keep those functions as reusable system components.

How W5500 Fits Into the OS

The project includes a W5500 SPI driver that is intended to be loaded as a network module.

Beryllium OS Micro
        │
        │ loads the w5500spi driver
        ▼
CircuitPython WIZNET5K library
        │
        │ SPI: MOSI, MISO, SCLK, and CS
        ▼
W5500 hardware TCP/IP controller
        │
        ▼
Wired Ethernet network

The W5500 driver initializes the SPI interface, detects the W5500, and checks the Ethernet link status. Its intended role is to make wired Ethernet available to the OS as a reusable network function, rather than as code used by only one application.

Why This Helps in Practice

Micro is still an early-stage project, so this structure should be viewed as a useful development and integration model rather than a production-ready embedded OS.

What the current W5500 driver does

The W5500 driver imports adafruit_wiznet5k, creates an SPI bus and chip-select pin, then initializes a WIZNET5K interface.

self._cs = DigitalInOut(cs)
self._spi = SPI(clock=sclk, MOSI=mosi, MISO=miso)
self._interface = WIZNET5K(self._spi, self._cs, is_dhcp=dhc)
self._interface.detect_w5500()

The connect() function accepts:

mosi, miso, sclk, cs, ip, subnet_mask, gateway, dns, hostname, debug

It then performs these steps:

1. Creates the SPI and chip-select interfaces.
2. Initializes the W5500 interface.
3. Detects the W5500 chip.
4. Checks link_status.
5. Calls DHCP handling after a successful link check.
6. Returns status 0 on completion, 1 for a runtime error, 2 when the Ethernet link is missing, and 3 when required address arguments are incomplete.

The driver identifies itself as:

self.hw_name = "w5500"
self.interface_type = "ethernet"

This makes the intended role of W5500 clear: it is the wired Ethernet interface for Beryllium OS.

Current limitations and integration tasks

The project is more valuable as an early Ethernet OS-integration case than as a finished network stack. Several items need attention before it can be considered a complete W5500 platform.

The generic device model is already present, but the exact W5500 module-load command should be verified on hardware: the driver class is named driver_w5500spi, while its usage comment refers to w5500spi.

A practical target: W5500-EVB-Pico

CircuitPython already defines a wiznet_w5500_evb_pico board target. Its W5500 SPI pins map directly to the arguments expected by Beryllium OS’s driver.

The board also exposes W5K_RST on GPIO20 and W5K_INT on GPIO21. The current Beryllium OS driver does not use those signals. Adding reset support would improve Ethernet recovery, while interrupt support could reduce polling.

A useful next step would be a dedicated W5500-EVB-Pico Boardfile containing:

• Board LED settings
• Pinout map
• W5500 driver entry
• Updated adafruit_wiznet5k dependencies
• A verified DHCP test
• A verified static-IP test
• DNS, HTTP, and NTP validation

Suitable applications

What it is not yet suited for

Beryllium OS Micro should not be presented as a production-ready industrial network OS today.

• The project describes itself as early development.
• Its Kernel APIs are changing.
• The W5500 driver has unfinished networking methods.
• The Wi-Fi management path can start an AP and Telnet service by default, so network-access settings must be reviewed before any real deployment.
• The manual does not guarantee strict process-variable isolation.

The best description is therefore:

Beryllium OS Micro is an early but well-structured attempt to integrate W5500 Ethernet into a CircuitPython operating environment. It is strong as a learning, bring-up, and platform-development case; production use requires driver completion, validation, and security hardening.

Related Projects on WIZnet Maker

Ljinux
An earlier Maker entry for the same project under its former name. This article differs by focusing on the W5500 driver architecture, current library compatibility, and the path toward a W5500-EVB-Pico board port.

CircuitPython Wiznet5k: PR #178 Socket Reliability Update
Covers the adafruit_wiznet5k library layer that Beryllium OS uses underneath its W5500 driver. Library behavior directly affects the driver’s future DHCP, DNS, HTTP, and socket implementation.

How Does Pico 2W Use W5500 Ethernet for CircuitPython MQTT?
Demonstrates W5500 use at the application level with CircuitPython and MQTT. Beryllium OS takes a different direction by attempting to expose the same Ethernet stack as an OS-managed network interface.

How to Initialize W5500 Ethernet with CircuitPython on ESP32-S3?
A relevant reference for the SPI initialization and Ethernet bring-up stage, especially for ESP32-family boards supported by Beryllium OS.

References

• Beryllium OS Micro repository
• Beryllium OS Manual
• Beryllium OS W5500 driver
• Beryllium OS porting guide
• CircuitPython W5500-EVB-Pico pin definition
• Adafruit CircuitPython Wiznet5k library
• W5500 official documentation