Wiznet makers

zenoh-ros2-nostd — no_std ROS 2 Pub/Sub over Zenoh with WIZ630io Ethernet

PROJECT DESCRIPTION

📌 Overview

zenoh-ros2-nostd is a Rust no_std library for implementing ROS 2 topic pub/sub on embedded MCUs. The project uses CDR serialization over Zenoh Protocol v9 and is designed to communicate with standard ROS 2 nodes using rmw_zenoh_cpp. The README describes it as a no_std ROS 2 topic pub/sub library for embedded MCUs.

A ROS 2 topic is the basic publish/subscribe communication mechanism used by ROS 2 nodes. It is commonly used for continuous data streams such as sensor readings, robot states, and control commands.

Zenoh is a network protocol that combines publish/subscribe, query, and storage concepts. In this project, Zenoh acts as the transport layer that allows a small embedded device to participate in a ROS 2-style communication graph.

The key idea of this project is to bring ROS 2 communication down to a small MCU environment, without depending on a full Linux system or dynamic heap allocation. In other words, it enables a small embedded board to directly publish or subscribe to ROS 2 topics through Zenoh.

📌 What This Project Does

This project provides the core pieces needed for an MCU to handle ROS 2 topics directly.

Main functions include:

• #![no_std] operation
• fixed-size heapless collections
• minimal Zenoh Protocol v9 client implementation
• CDR Little Endian serialization
• rmw_zenoh_cpp-compatible key expression generation
• ROS 2 publisher / subscriber structure
• automatic reconnection policy
• Embassy-based async runtime support
• WASI target support for Gazebo simulation experiments

Among the examples, the most important hardware demo is bakerlink_wiz630io. This example connects a Baker link.dev board based on RP2040 to a WIZ630io Ethernet module over SPI, then exchanges the /chatter topic with ROS 2 running in Docker through rmw_zenoh_cpp.

This means the project is not only a Rust library. It also includes a working hardware path where an MCU communicates with a ROS 2 network through a WIZnet Ethernet module.

📌 Features

no_std ROS 2 pub/sub
The library is designed for no_std environments. It avoids heap allocation and uses fixed-size buffers based on heapless, making it suitable for memory-constrained MCU systems.

Zenoh Protocol v9 implementation
The README states that this crate implements a minimal client-mode subset of Zenoh Protocol v9. It handles message types such as InitSyn / InitAck, OpenSyn / OpenAck, KeepAlive, and Frame, along with TCP framing and session handshake logic.

ROS 2 message compatibility
ROS 2 messages are serialized using CDR. The project also generates key expressions and liveliness token formats compatible with rmw_zenoh_cpp, allowing communication with standard ROS 2 Zenoh RMW nodes.

Baker link.dev + WIZ630io example
The most practical example connects RP2040-based Baker link.dev to WIZ630io and publishes/subscribes to /chatter. The example README includes Python subscriber verification, firmware flashing, Docker networking, wiring diagrams, and troubleshooting notes.

WASI / Gazebo simulation support
The project also includes WASI examples for communication with Gazebo TurtleBot3 simulation. This allows the same ROS 2 topic model to be tested both in simulation and on real embedded hardware.

📌 System Architecture

The project can be understood in four layers.

At the top is the SDK layer, which exposes a user-facing API such as Node, PublisherHandle, and SubscriptionHandle. The design is intended to feel similar to rclpy, so ROS 2 developers can create nodes and register publishers/subscribers in a familiar style.

Below that is the ROS 2 adaptation layer. This layer handles ROS 2 topic key expressions, QoS, liveliness tokens, and message metadata. The key expression includes the domain ID, topic name, type name, and type hash so that it can interoperate with rmw_zenoh_cpp.

The next layer is the Zenoh session and transport layer. It manages Zenoh Protocol v9 handshake, keepalive, frame handling, and reconnection policy. The README describes an exponential backoff reconnection strategy that starts at 1 second and grows up to 30 seconds.

At the bottom is the transport abstraction. The project is built around the embedded-io-async Read + Write traits, so it can run over MCU TCP sockets, WASI sockets, and host-side test streams through the same abstraction.

In the bakerlink_wiz630io example, this architecture becomes a real Ethernet path. Baker link.dev and WIZ630io connect to the host PC over Ethernet, the device reaches port 7447, and a Docker network runs the Zenoh router and ROS 2 listener.

📌 Role and Application of the WIZnet's Chip

WIZnet product used: WIZ630io / W6300

The key WIZnet-related example in this project is bakerlink_wiz630io. It connects an RP2040-based Baker link.dev board to WIZ630io over SPI, then uses WIZ630io Ethernet to reach the ROS 2 Zenoh router.

One point needs to be handled carefully. Some README text refers to WIZ630io as using W5500, but the actual example code imports embassy_net_wiznet::chip::W6300 and performs a chip ID smoke test for W6300. Therefore, based on the implementation, this curation should treat the example as WIZ630io / W6300-based, while noting that the README wording appears inconsistent.

In this project, WIZ630io is not just a way to “add Ethernet.” It is the wired network path that allows the MCU to connect to a Zenoh router and participate in a ROS 2 communication graph.

The actual code path is clear. The example creates a WIZnet network device through embassy_net_wiznet, obtains an IP address through DHCP, opens a TCP socket, connects to the Zenoh router endpoint, creates a bakerlink_node, and publishes topics such as /baker_link/status, /baker_link/cpu_temp, and /baker_link/cpu_temp_raw.

In short, WIZ630io/W6300 acts as a wired Ethernet gateway for MCU-based ROS 2 nodes. It allows a small embedded device to join a ROS 2 / Zenoh network without relying on Wi-Fi or a Linux SBC.

📌 Implementation Notes

The bakerlink_wiz630io example documents the SPI wiring between Baker link.dev and WIZ630io in detail. GP16, GP17, GP18, and GP19 are used for SPI and chip select. GP14 is used for reset, and GP15 is used as the interrupt pin. The module is powered from the 3.3V output of Baker link.dev.

In the firmware, SPI0 is configured first, then the reset pin is toggled to perform a hardware reset. After that, the example reads the W6300 CIDR2 register as a smoke test. The expected value is 0x11, which the code comments describe as the expected chip ID for W6300.

The network setup uses DHCP. Once an IP address is assigned, the device creates a TCP socket and connects to the Zenoh router specified in config.json. If the connection fails, the reconnect policy retries. Once the connection succeeds, the node registers its publishers/subscribers and enters the spin loop.

The example also publishes real embedded telemetry. It sends a heartbeat message on /baker_link/status and reads the RP2040 internal temperature sensor to publish /baker_link/cpu_temp and /baker_link/cpu_temp_raw. This makes the example more than a simple “Hello world” demo.

📌 Market & Application Value

The most direct application of this project is ROS 2 integration for robots, sensor nodes, and embedded control devices.

ROS 2 is often associated with Linux SBCs or PCs, but this project shows a path where a smaller MCU can directly participate in ROS 2 topic communication. That is valuable for compact embedded nodes that do not need to run a full Linux system.

The no_std design is especially important. By avoiding heap allocation and using fixed-size buffers, the project targets predictable memory behavior on constrained embedded devices. This makes it suitable for small sensor modules, motor controllers, telemetry nodes, robot peripheral boards, and monitoring devices.

The WIZ630io Ethernet example is also meaningful for real robot networks. In laboratories, factories, and robot testbeds, wired Ethernet can be preferred over Wi-Fi for stability and repeatability. This project shows how an MCU can connect directly to a Zenoh router over Ethernet and become part of a ROS 2 communication graph.

The WASI/Gazebo examples also improve the development flow. A developer can test ROS 2 topic behavior in simulation first, then move the same communication model to RP2040 + WIZnet Ethernet hardware later.

📌 External Indicators

The README clearly marks this project as early development. It warns that the API may change in breaking ways and that production use is not recommended. This should be treated as an experimental or prototyping library rather than a finished production stack.

At the same time, the implementation scope is broad. The roadmap lists completed items such as Zenoh handshake, CDR serializer/deserializer, static buffer pool, publisher/subscriber handles, reconnect policy, liveliness token generation, WASI target support, service client, action client, and derive macro support.

The bakerlink_wiz630io example is also marked active and includes concrete wiring, flashing, Docker verification, and troubleshooting instructions. This gives the project practical value for developers who want to reproduce the embedded Ethernet path.

📌 WIZnet Strategic Value

This project shows that a WIZnet Ethernet module can be used for more than generic MCU networking. Here, WIZ630io/W6300 is used as the wired transport path that lets a small MCU participate in a ROS 2 / Zenoh robotics network.

That is meaningful because many ROS 2 systems still depend on Linux-class compute nodes for network communication. This example shows a different path: a microcontroller can publish telemetry, subscribe to topics, and communicate through a Zenoh router over Ethernet.

For WIZnet, this is a good example of an Ethernet module being used in a robotics middleware context, not only in simple TCP demos or IoT dashboards. It connects WIZnet hardware with modern embedded Rust, no_std, Zenoh, and ROS 2 integration.

📌 Summary

zenoh-ros2-nostd is a Rust no_std library for implementing ROS 2 topic pub/sub on MCU-class devices. It uses Zenoh Protocol v9, CDR serialization, and rmw_zenoh_cpp-compatible key expressions so embedded nodes can communicate with ROS 2 networks.

The key hardware example is bakerlink_wiz630io. It connects RP2040-based Baker link.dev to WIZ630io/W6300 Ethernet and communicates with a Docker-based ROS 2 Zenoh router through topics such as /chatter, status, and CPU temperature.

The project is still in early development and not recommended for production use. Even so, it is a strong example of how WIZnet Ethernet hardware can help MCU-class devices join ROS 2 / Zenoh networks through a stable wired connection.

📌 FAQ

Q1. What is this project?
It is a Rust no_std library for ROS 2 topic pub/sub on embedded MCUs. It communicates with ROS 2 nodes through Zenoh and CDR serialization.

Q2. What is Zenoh?
Zenoh is a networking protocol that supports publish/subscribe, query, and storage patterns. In this project, it is used as the transport layer for ROS 2-style topic communication.

Q3. What is a ROS 2 topic?
A ROS 2 topic is a publish/subscribe communication channel used by nodes to exchange data such as sensor readings, robot states, and control commands.

Q4. Which WIZnet product is used?
The hardware example uses WIZnet WIZ630io. Based on the actual code, it should be treated as a WIZ630io/W6300 example.

Q5. The README mentions W5500. Is that correct?
The README has wording that refers to W5500, but the implementation imports W6300 and reads a W6300 chip ID. Therefore, the actual code path points to WIZ630io/W6300.

Q6. What does the hardware example actually do?
Baker link.dev + WIZ630io connects over Ethernet to a Zenoh router on port 7447, then publishes and subscribes to ROS 2 topics such as /chatter, /baker_link/status, and CPU temperature topics.

Q7. Is it production-ready?
No. The README clearly marks the project as early development and does not recommend production use.