Dawn is a new open-source project for building embedded data acquisition and control devices on top of Apache NuttX.

It started from a common problem: many embedded projects need the same kind of firmware infrastructure, and too much of that work still gets rebuilt from scratch. I wanted to turn more of that repeated work into something reusable.

Dawn is the result of that effort. It took much longer than I expected, changed shape several times, and grew far beyond the original idea, but it has finally reached a point where it is worth introducing publicly.

Read more →

Developing and testing embedded applications involving multiple devices running dedicated firmware is always a challenge—especially for networked system where many nodes must collaborate. This process can be simplified by shifting part of the development workflow to a simulated environment, where hardware-related issues can be ignored and the focus remains on application logic.

In this post, we'll demonstrate how to simplify the workflow for CAN network application development by simulating the entire network on a Linux host—no physical hardware required. We'll run several Apache NuttX images that communicate over a simulated CAN bus using the host's SocketCAN interface. This approach allows for faster development iteration, easier debugging, and a significantly smoother developer experience—especially useful when working with complex multi-node systems. Thanks to NuttX's portable interfaces, applications developed in a simulated environment can be easily ported to real hardware.

This post marks the beginning of a new series on this blog, focused on host-based development with NuttX. Throughout the series, we'll explore practical techniques for building, testing, and debugging embedded applications directly on your development machine.

Read more →

It’s time for another hands-on example of using NuttX in small embedded systems! This time, we’ll dive into implementing a simple application with Modbus RTU, a lightweight and cost-effective industrial protocol. Thanks to its low implementation cost, Modbus RTU is a great choice for cheap, resource-constrained microcontrollers.

In this example, we’ll demonstrate how to use Modbus for remote reading of analog inputs, a common task in industrial applications that can be use to read sensor signals or measure electrical parameters. We’ll take a closer look at the memory footprint of the Modbus slave stack in NuttX and the resources requirements to support ADC on STM32 devices.

Read more →

The previous posts in this series provided useful information about small systems and NuttX, but the code examples lacked practical value. Now, we move on to more practical, real-life applications that actually do something useful.

We begin with a simple CAN Bus node, which can be used to test CAN network setups or drivers, making it a handy tool for developers. Additionally, it can serve as a ready-to-use foundation for more complex applications.

Our goal here is to check and compare the resource usage of two CAN implementations available in NuttX: one based on the CAN character device and the other using the SocketCAN network interface. This comparison may be useful for developers deciding which solution to choose when working with CAN Bus on NuttX.

The entire test setup is built using accessible development kits, and thanks to NuttX's architecture, the implementation can be easily portable across different hardware.

Read more →

In earlier posts in this series, we explored the resource requirements of trivial examples. Now, it's time to dive deeper and examine how specific NuttX interfaces affect resource consumption in small embedded systems.

As part of this analysis, we'll develop small applications that utilize specific NuttX features and evaluate the memory footprint of each. This knowledge can be useful when designing new applications, helping to define initial constraints and requirements for the OS interfaces.

Read more →

We continue our exploration of Apache NuttX for small embedded systems. In the previous post, we examined a simple "Hello, World!" example and explored how small it could be on NuttX.

Now, we take it a step further by disabling all possible NuttX features, allowing the toolchain to remove as much code as possible. This approach leaves us with the core of NuttX—components that can't be eliminated through configuration options and compiler optimizations.

Finally, we implement a trivial application using two different approaches—the POSIX-compliant method and the non-portable alternative—highlighting the trade-offs between achieving portability and minimal system size.

Read more →

In the world of small embedded systems, balancing functionality with strict resource limitations is a constant challenge. Apache NuttX, with its scalable and modular design, allows developers to select only the features needed for a given application and then fine-tune the system to minimize resource usage. However, the vast number of configuration options can be overwhelming, and without exploring the OS implementation or analyzing the generated binaries, it can be difficult to effectively optimize resource consumption.

I've been curious for some time about how minimal we can make NuttX while still implementing useful applications. It's time to check it out. This is the first post in the series "Apache NuttX and small systems", where we'll experiment with reducing the size of the final NuttX image, explore how low we can push resource requirements, and, if all goes well, implement some useful applications that fit into some small embedded targets.

We're going to start with the classic "Hello, World!" example, examine its memory consumption, and see how different configuration options influence the final result.

Read more →

NxScope in Apache NuttX is a universal tool that allows you to capture and transfer time series data to your host machine. In this post, I'll demonstrate its use based on the SensorScope application, which enables the streaming of data from sensors and their subsequent visualization.

For this purpose, the Thingy:53 board from Nordic Semiconductor is used. It has several sensors on board and almost all of them are already supported in NuttX (BME688 is still missing).

Read more →

One of my favorite things when working with Segger J-Link is RTT support which significalntly improves my debugging experience. With a single interface (one USB cable), I can run:

• RTT serial console to communicate with the target

• SystemView to capture system events

• gdb for general debugging

The latest addition to this list is real-time data streaming with the NuttX NxScope library and RTT channel as a communication interface. This feature is supported with nxscli tool since version 0.5.1. Now we can visualize and debug complex data relations much more simpler.

This post discusses how to configure the NxScope example with NuttX to work over an RTT channel with an RTT serial console and SystemView support.

For demonstration, we use Nordic nRF52832-DK board with a built-in J-Link OB interface, so there is no need to connect any external device.

Read more →

PlotJuggler is a cool tool for visualizing time series data, supporting live data streaming. Since version 0.5.1, my nxscli tool has included support for data streaming over UDP port, which can be easily captured by PlotJuggler.

Let's see how to set up both tools and plot data from the NuttX NxScope library.

Read more →