Can an RTOS be really real-time?
Real-Time Operating Systems are meant for real-time applications. But with conventional shared-state concurrency and blocking, can you honestly know the worst-case execution time of an RTOS thread?
Project Log: Pixelblaze Christmas Lights
Festive fun and the hacker spirit combine in my janky attempt to adorn my house with addressable LEDs! In this post, I show you how I used a Pixelblaze and a cheap strip of WS2811 RGB LEDs (and not a little bit of hot glue and paper clips) to make a super cool set of Christmas lights.
Getting Started With Zephyr: DTS vs DTSI vs Overlays
Devicetrees can be daunting for traditional embedded software engineers that are new to Zephyr. In this blog post, I address these fears and show how navigating Devicetrees can be much easier if you understand that they represent the layered structure of the underlying hardware.
Why Containers Are the Cheat Code for Embedded DevOps
Embedded software teams have long accepted toolchain setup as “part of the job,” but it’s a hidden productivity killer. Manual installs waste days, slow onboarding, and derail CI pipelines with “works on my machine” issues. While enterprise software solved this years ago with containerization, many embedded teams are still stuck replicating fragile environments. Containers offer a proven fix: a portable, reproducible build environment that works identically on laptops and CI servers. No brittle scripts, mismatched versions, or wasted time—just code that builds. IAR has gone further by delivering pre-built, performance-tuned Docker images for Arm, RISC-V, and Renesas architectures, ready for GitHub Actions and CI/CD pipelines. For regulated industries, containers simplify audits and compliance by enabling validation once and reuse everywhere. The result: faster onboarding, consistent builds, and stronger safety assurance. Containers aren’t a luxury—they’re the cheat code embedded teams need to modernize DevOps and compete effectively.
How to Achieve Deterministic Behavior in Real-Time Embedded Systems
Ensuring deterministic behavior in real-time embedded systems is paramount for their reliability and performance. The ability to predict precisely how a system will respond to various inputs at any given time is crucial in critical applications such as medical devices, aerospace systems, and automotive safety mechanisms. Achieving deterministic behavior involves meticulous design, stringent testing, and adherence to strict timing constraints.
Working with Microchip PIC 8-bit Interrupts
This fifth and final post of the Getting Started with Microchip PIC 8 Bit Development series looks at interrupts on 8-bit PIC microcontrollers. After a review of basic interrupt functionality, an actual implementation is explored with the development of a four bit counter driven via Timer0 interrupts whose value is displayed through four LEDs on Microchip's Curiosity HPC Development Board.
Hidden Gems from the Embedded Online Conference Archives - Part 2
A look back at a deep dive into the Mars Perseverance flight software from one of the technical leads at JPL.
Hidden Gems from the Embedded Online Conference Archives - Part 1
Discussion of a "hidden gem" from the Embedded Online Conference archives!
3 Tips for Developing Embedded Systems with AI
Explore how to leverage AI in developing embedded systems with three practical tips, learn why documenting your workflows, supercharging testing and debugging, and adopting AI-assisted code generation can save time, reduce errors, and boost performance in your projects, and discover actionable insights to streamline development in resource-constrained environments, this blog explains how to prepare for AI integration while keeping the expertise of experienced engineers intact, offering real-world examples that show how even incremental AI adoption can revolutionize your development process, whether you’re new to AI or seeking to enhance existing practices, these strategies provide a clear roadmap to build smarter, more efficient embedded systems using AI.
Static or static
The keyword static in C and C++ has multiple uses, which are not always well understood.
Analyzing the Linker Map file with a little help from the ELF and the DWARF
Running out of Flash or RAM is a familiar pain for firmware engineers, and the linker map only tells part of the story. This post shows how to combine the linker MAP with ELF symbol tables and DWARF debug info to recover static symbols, sizes, and source files that the map omits. It also describes a C# WinForms viewer that automates the parsing with binutils and helps you spot module and symbol-level memory waste.
Memory Mapped I/O in C
Interacting with memory mapped device registers is at the base of all embedded development. Let's explore what tools the C language - standard of the industry - provide the developer with to face this task.
You Don't Need an RTOS (Part 2)
In this second article, we'll tweak the simple superloop in three critical ways that will improve it's worst-case response time (WCRT) to be nearly as good as a preemptive RTOS ("real-time operating system"). We'll do this by adding task priorities, interrupts, and finite state machines. Additionally, we'll discuss how to incorporate a sleep mode when there's no work to be done and I'll also share with you a different variation on the superloop that can help schedule even the toughest of task sets.
Endianness and Serial Communication
A single wrong byte order can cost you a day of debugging, and Stephen Friederichs walks through how to avoid that when sending multi-byte data over a byte-oriented serial link. He demonstrates an ATmega328P sending 16-bit ADC readings, capturing raw bytes with RealTerm, and plotting with Octave, showing how swapped endianness can produce plausible but incorrect results. The post gives practical steps to capture, test, and verify byte order.
3 Tips for Developing Embedded Systems with AI
Explore how to leverage AI in developing embedded systems with three practical tips, learn why documenting your workflows, supercharging testing and debugging, and adopting AI-assisted code generation can save time, reduce errors, and boost performance in your projects, and discover actionable insights to streamline development in resource-constrained environments, this blog explains how to prepare for AI integration while keeping the expertise of experienced engineers intact, offering real-world examples that show how even incremental AI adoption can revolutionize your development process, whether you’re new to AI or seeking to enhance existing practices, these strategies provide a clear roadmap to build smarter, more efficient embedded systems using AI.
Simulating Your Embedded Project on Your Computer (Part 1)
Having a simulation of your embedded project is like having a superpower that improves the quality and pace of your development ten times over! To be useful, though, it can't take longer to develop the simulation than it takes to develop the application code and for many simulation techniques "the juice isn't worth the squeeze"! In this two-part blog series, I'll share with you the arguments in favor of simulation (so, hopefully, you too believe in its value) and I'll show you what works (and what doesn't work) to help you to simply, easily, and quickly simulate your embedded project on your computer.
Introduction to Microcontrollers - Beginnings
Mike Silva's beginner tutorial series walks through core microcontroller concepts and practical steps to get started, from wiring an LED blinky to understanding startup code. He compares embedded and desktop programming, explains why C and assembly matter, and introduces AVR and STM32 Cortex-M3 toolchains and hardware. Expect clear examples, no-nonsense tool advice, and the essential hardware knowledge to move from simulator to a real board.
Implementing State Machines
Stephen walks through a practical state machine example using a dish-washing analogy to expose common implementation pitfalls and fixes. Starting from a straightforward superloop design he shows how blocking loops, global state, and interrupt races can break behavior, then refactors the code to use scoped enums, non-blocking state actions, and a simple interrupt flag to make embedded state machines safer and more maintainable.
Linear Feedback Shift Registers for the Uninitiated, Part XVI: Reed-Solomon Error Correction
Jason Sachs demystifies Reed-Solomon codes with hands-on examples and pragmatic tips for embedded engineers. The article shows why RS encoding is just polynomial division in GF(2^m), why decoding is mathematically heavier, and how to implement encoders in Python and in C-friendly form using LFSRs and table-driven methods. Read this for working code, generator-polynomial examples, and an embedded-minded view of RS practicalities.
Introduction to Microcontrollers - Interrupts
Interrupts are not magic, they are the practical tool that lets a microcontroller respond in microseconds while still doing background work. This introduction explains what an interrupt and an ISR are, how return addresses and CPU state are saved, and why ISRs must be short and carefully written. AVR and STM32 external-interrupt examples show real configuration steps and key gotchas to watch for.
Introduction to Microcontrollers - Driving WS2812 RGB LEDs
Mike Silva walks through a practical, cycle-counted AVR assembly implementation to bit-bang WS2812B RGB LEDs from an 8MHz AVR, hitting the chip's tight 1.25µs-per-bit timing. The post breaks down the WS2812B self-clocked protocol and GRB byte order, explains register and calling-convention choices, and includes a complete C example plus power-consumption warnings for driving LED strips.
Introduction to Microcontrollers - Interrupts
Interrupts are not magic, they are the practical tool that lets a microcontroller respond in microseconds while still doing background work. This introduction explains what an interrupt and an ISR are, how return addresses and CPU state are saved, and why ISRs must be short and carefully written. AVR and STM32 external-interrupt examples show real configuration steps and key gotchas to watch for.
Boot Sequence for an ARM based embedded system
Deeksha draws on five years in embedded systems to introduce the ARM boot sequence used on Boot ROM based platforms. The post outlines what the Boot ROM does at reset, how it probes boot media, and when control is passed to a software bootloader. It also highlights key differences between NOR XiP and NAND RAM-loading and the need for bad-block handling.
Introduction to Microcontrollers - Hello World
Mike Silva walks through the classic embedded hello world by blinking an LED on both an AVR and an STM32. The tutorial covers GPIO configuration, bit manipulation, simple software delay loops, and common pitfalls such as compiler optimizations that can remove empty delays unless you use volatile. Practical wiring tips and debugging advice with a scope make this an ideal first lab for embedded engineers.
Using the C language to program the am335x PRU
Assembly-language PRU development is tedious and error prone, so Fabien Le Mentec shows how to use TI's PRU C toolchain to simplify the workflow. He walks through installing the CGT package, integrating the compiler with a modified prussdrv loader to honor the _c_int00 start symbol, and provides a BeagleBone Black example with build scripts and sources on GitHub. The post also covers inline assembly constraints and code-size tradeoffs.
C++ on microcontrollers 1 - introduction, and an output pin class
Wouter van Ooijen shows how small C++ abstractions make GPIO code portable and reusable. Starting from a simple output_pin interface he implements concrete pins for an LPC2148 GPIO and a 74HC595 shift register, then composes behaviors with wrappers like tee and invert. The post demonstrates virtual methods, references, and constructor initialization lists to build drivers you can reuse across boards.
Endianness and Serial Communication
A single wrong byte order can cost you a day of debugging, and Stephen Friederichs walks through how to avoid that when sending multi-byte data over a byte-oriented serial link. He demonstrates an ATmega328P sending 16-bit ADC readings, capturing raw bytes with RealTerm, and plotting with Octave, showing how swapped endianness can produce plausible but incorrect results. The post gives practical steps to capture, test, and verify byte order.
How to Build a Fixed-Point PI Controller That Just Works: Part I
Jason Sachs digs into the implementation choices that make a fixed-point PI controller reliable in real embedded systems. He focuses on practical fixes rather than tuning: prefer scale-then-integrate, fold the timestep into the integral gain, and apply anti-windup so saturations and sensor noise do not break the loop. Part I covers discrete-time pitfalls and sets up fixed-point scaling issues for Part II.
Important Programming Concepts (Even on Embedded Systems) Part V: State Machines
State machines are not glamorous, but they solve a lot of real embedded problems. Jason Sachs uses a motorized couch example to show how FSMs and Harel statecharts expose corner cases, simplify timing constraints, and make behavior easier to specify and review. The article walks through hand-rolled switches, tabular implementations, the state pattern, libraries like QP and Boost, and tool tradeoffs.
Boot sequence for an ARM based embedded system -2
DM walks through the concrete steps of an ARM system startup, from the reset vector to handing control to C. The post explains what the early assembly reset code must do: set system registers, initialize stacks, set up the MMU, copy .data and clear .bss, and remap the vector table into RAM for faster interrupts. It finishes with external memory bring-up and loading an OS image.
