Surprising Linux Real Time Scheduler Behavior
An embedded Linux data acquisition project ran into puzzling UART latency whenever heavy UI animations ran. Moving all app threads to SCHED_FIFO helped but did not eliminate delays. After reading about kernel worker thread interactions, Matthew moved the UI back to the normal scheduler and the jitter vanished. The post highlights an unexpected kernel level priority inversion risk and a pragmatic workaround.
From bare-metal to RTOS: 5 Reasons to use an RTOS
Most developers default to bare-metal, but Jacob Beningo argues an RTOS often simplifies modern embedded design. He outlines five practical reasons to move to an RTOS: easier integration of connectivity stacks and GUIs, true preemptive scheduling with priorities, tunable footprints, API-driven portability, and a common toolset for tasks and synchronization. The piece helps decide when RTOS adoption speeds development.
From Baremetal to RTOS: A review of scheduling techniques
Jacob Beningo walks through five common embedded scheduling techniques, showing how each scales from a single super loop to a full RTOS. He highlights practical trade-offs for round-robin, interrupt-driven, queued, cooperative, and RTOS approaches so you can spot when timing becomes fragile and when added complexity is justified. This primer sets up the next post on when to adopt an RTOS.
Choosing a Microcontroller for Your Vehicle
Picking the right microcontroller can make or break an autonomous vehicle project, and this post gives a practical checklist to help. It walks through voltage and power needs, memory and IO planning, cost and availability tradeoffs, and when to step up from an 8-bit MCU to a 32-bit controller or single-board computer. Real-world board examples illustrate the choices.
Modern Embedded Systems Programming: Beyond the RTOS
Blocking-based RTOS tasks make embedded systems brittle and hard to extend, this post argues, and presents a practical alternative: active objects organized as message pumps. It explains why one-blocking-call tasks and nonblocking event handlers improve responsiveness and reduce task proliferation, and recommends using frameworks plus hierarchical state machines and UML to enforce good architecture and make designs scalable.
Motion Sensor with Raspberry Pi and MPU6050 - Part 1
This blog will help you build your own, low cost 3-axis motion sensor using Raspberry Pi and Invensense MPU6050.
How to make a heap profiler
A heap profiler is surprisingly simple to build, and Yossi Kreinin walks through a compact working example called heapprof. The post shows how to intercept malloc/free, stash per-allocation metadata and call stacks into heap chunks, dump memory on crash or via JTAG, and map return addresses to source lines with addr2line or gdb. It also covers practical bootstrapping tricks for platforms without standard libc support.
Using the Beaglebone PRU to achieve realtime at low cost
Fabien Le Mentec shows how the BeagleBone Black's PRU coprocessors can run hard realtime control loops, removing the need for an FPGA or dedicated microcontroller. He walks through Linux setup, device tree enabling, assembler and loader tools, and a timer example that reads ADCs and drives PWM from PRU code. The post highlights community SDKs and a recent TI Code Composer Studio option for C-based PRU development.
Delayed printf for real-time logging
Yossi Kreinin demonstrates delayed printf, a technique that records printf format pointers and raw argument words into a compact buffer so logging does not disturb real-time timing. He walks through a small C++11 writer using variadic templates and an atomic buffer plus a gdb Python reader that reconstructs formatted messages from executables or core dumps. The result is readable post-processed logs with minimal runtime overhead.
Android Vs Embedded system
Android@Home and the ADK open a fast path to add rich UIs, multimedia, networking, and databases to embedded projects by leveraging phones, tablets, or dedicated Android boards. This post outlines the main benefits of using Android as a front end or as a full embedded OS, explains two integration approaches, and points to BeagleBoard as an affordable single-board option for one-platform designs.
A design non-methodology
Although writing an RTOS or kernel may be an interesting project, it is unlikely to be a wise course of action.
Embedded Developer’s New Year’s Resolution
Use the holiday pause to turn vague intentions into a practical embedded skills plan for the coming year. This post lays out concrete resolutions: adopt modern software design practices, pick up a modern language like C++ or Rust, and learn when to use RTOS, cooperative schedulers, or Zephyr. Small, focused improvements will pay off across firmware projects.
Basler pylon on Raspberry Pi with Yocto
Basler's pylon can be packaged into a minimal Raspberry Pi Yocto image in a few clear steps. This walkthrough shows how to clone poky with meta-openembedded, meta-raspberrypi and Basler's meta-basler-tools, tweak conf/local.conf to add OpenCV and accept the Basler EULA, build rpi-test-image and generate an SDK for cross-compilation. It finishes by cross-compiling a pylon_example binary, copying it to the Pi and testing with a Basler acA2440-20gm.
Interfacing LINUX with microcontrollers
Fabien presents a practical pattern: put Internet- facing logic on a Linux board and keep time-critical I/O on a microcontroller, using a Raspberry Pi and a Teensy 3.0. He introduces MASL, a reusable userspace library that hides master-slave details and shows how to use userspace SPI, sysfs GPIO and epoll for programming, reset and event-driven signaling with working code examples.
An overview of Linux Boot Process for Embedded Systems
Booting Linux on embedded hardware collapses PC boot stages into a single bootloader, and understanding the early steps helps troubleshoot low-level failures. Kunal Singh breaks down the sequence from the bootstrap firmware and primary/secondary bootloaders through zImage decompression, MMU and page table setup, start_kernel, and the initrd pivot to the root filesystem. Practical focus favors ARM examples.
Getting Started With Embedded Linux - From Nothing To A Login Prompt
This hands-on guide shows how to go from a blank board to a bootable embedded Linux system using Yocto and Docker. Follow the steps to build a reproducible Yocto environment, fetch Toradex manifests, set MACHINE to verdin-imx8mm, run bitbake, and produce the .wic.bmap image ready to flash. Ideal for engineers wanting a concise bringup path for a Verdin iMX8M Mini on a Dahlia carrier.
Motion Sensor with Raspberry Pi and MPU6050 - Part 1
This blog will help you build your own, low cost 3-axis motion sensor using Raspberry Pi and Invensense MPU6050.
Optimizing Real-Time Operating Systems for Efficient Edge Devices
Edge devices need real-time responsiveness but run on tight CPU, memory, and power budgets. This post breaks down what an RTOS brings to the edge: deterministic task scheduling, lean memory management, protocol support, and modular scalability, then tackles common challenges like synchronization and security. Read it for practical best practices on scheduling and protocols plus a look at future trends such as edge AI integration and interoperable infrastructure.
Android for Embedded Devices - 5 Reasons why Android is used in Embedded Devices
Android may seem like a phone OS, but it now solves real embedded product problems. This post outlines five practical reasons engineers pick Android for devices with displays, from built-in touch and GUI frameworks to simplified camera and wireless APIs. It also covers vendor BSP and driver support, a large developer pool, and how Android speeds prototyping by reusing phones or tablets as HMIs or processors.
Using (Apache) NuttX Buttons Subsystem
You do not need to poke GPIO registers to read switches in NuttX, the OS provides a Buttons subsystem that delivers named events, multi-button support, and optional software debouncing. This post walks through wiring two breadboard buttons on a Raspberry Pi Pico, enabling the input and buttons drivers via menuconfig, building nuttx.uf2, and testing the buttons over the usbnsh serial console. It highlights why a simple hardware debounce is still a good idea.
Using a board with NuttX RTOS as an RS-485 / Modbus Slave Device
This practical walk-through shows how to turn a NuttX-equipped board into an RS-485 Modbus RTU slave using a cheap MAX485 transceiver and an STM32F4Discovery board. It explains why a simple UART plus a GPIO for DE/RE is enough, why the RP2040 needs special handling, and gives step-by-step configuration in NuttX, wiring for the transceiver, and a quick test using FreeModbus and mbpoll.
A brief overview of flight control software
Open source flight control software can feel like a maze of forks, retirements, and overlapping projects. In this post, the author builds a chart and comparison table to map how drone flight controller software evolved over time, using git commit history and repository data. It is a handy starting point if you want a quick overview of the current landscape before diving deeper.
Finite State Machines (FSM) in Embedded Systems (Part 5) - From One FSM to Many
Traditionally, complex systems are implemented using multi-threading and mutexes. Trying to scale up this approach usually results in a nightmare of data races and hidden bugs. A single Finite State Machine may bring order to chaos in applications, but cannot be scaled beyond a limit. In this installment, we explore the Actor Model: a shift from shared state to communicating state machines. Discover how treating FSMs as independent, message-passing entities can eliminate concurrency issues, simplify testing, and improve your embedded architecture.
Who needs source code?
Many developers feel that the supplying source code is essential for licensed software components. There are other perspectives, including the possibility of it being an actual disadvantage. Even the definition of source code has some vagueness.
Optimizing Real-Time Operating Systems for Efficient Edge Devices
Edge devices need real-time responsiveness but run on tight CPU, memory, and power budgets. This post breaks down what an RTOS brings to the edge: deterministic task scheduling, lean memory management, protocol support, and modular scalability, then tackles common challenges like synchronization and security. Read it for practical best practices on scheduling and protocols plus a look at future trends such as edge AI integration and interoperable infrastructure.
Building Linux Kernel for Desktops
Kernel building for desktop Linux is less daunting than it used to be. In this short primer Kunal Singh introduces the distribution-specific tools and procedures that simplify compiling a desktop kernel, with focused pointers for Fedora, Ubuntu, and SUSE. Engineers will get a quick overview of where to start and which tools each distribution provides to streamline a custom kernel build.
A design non-methodology
Although writing an RTOS or kernel may be an interesting project, it is unlikely to be a wise course of action.
Hello Android
Getting Android Early SDK running on Fedora Core 7 sounds simple, until Java gets in the way. Kunal Singh walks through the exact setup he used, from installing Eclipse and the Android SDK to switching Fedora over from GNU Java to Sun Java so the tooling would work. It is a quick, practical note for anyone trying to get an old Linux dev box talking to early Android tools.
