EmbeddedRelated.com
The 2026 Embedded Online Conference

Can an RTOS be really real-time?

Miro SamekMiro Samek February 7, 20262 comments

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?


Getting Started With Zephyr: DTS vs DTSI vs Overlays

Mohammed BillooMohammed Billoo October 3, 2025

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

Jacob BeningoJacob Beningo September 29, 2025

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

Lance HarvieLance Harvie April 21, 20252 comments

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.


Hidden Gems from the Embedded Online Conference Archives - Part 3

Tim GuiteTim Guite April 4, 20252 comments

Jack Ganssle shows us what we can learn by studying previous failures - and why this is essential for anyone working in embedded systems.


Vintage multi-core and “so long”

Colin WallsColin Walls April 3, 202514 comments

A personal and historical perspective on multi-core system design.


Working with Microchip PIC 8-bit Interrupts

Luther StantonLuther Stanton March 30, 2025

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

Tim GuiteTim Guite March 20, 20252 comments

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

Tim GuiteTim Guite March 5, 2025

Discussion of a "hidden gem" from the Embedded Online Conference archives!


3 Tips for Developing Embedded Systems with AI

Jacob BeningoJacob Beningo March 1, 2025

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.


Analyzing the Linker Map file with a little help from the ELF and the DWARF

Govind MukundanGovind Mukundan December 27, 201524 comments

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.


Chebyshev Approximation and How It Can Help You Save Money, Win Friends, and Influence People

Jason SachsJason Sachs September 30, 201221 comments

Are expensive math libraries or huge lookup tables eating CPU and flash on your microcontroller? In this practical guide Jason Sachs shows how Chebyshev polynomial approximation (with range reduction, splitting, and small interpolated tables) can give near-minimax accuracy while using far less code and runtime. The post compares Taylor series, plain and interpolated tables, and explains how to fit empirical sensor data and evaluate coefficients efficiently.


Understanding and Preventing Overflow (I Had Too Much to Add Last Night)

Jason SachsJason Sachs December 4, 2013

Integer overflow is stealthier than you think, and in embedded systems it can break control loops or corrupt data. Jason Sachs walks through the usual culprits, including addition, subtraction, multiplication, shifting and Q15 fixed-point traps, plus C-specific pitfalls such as undefined signed overflow and INT_MIN edge cases. He then lays out practical defenses: prefer fixed-width types, widen and saturate intermediates, enable wraparound where appropriate, and reason about modular congruence for compound arithmetic.


Zebras Hate You For No Reason: Why Amdahl's Law is Misleading in a World of Cats (And Maybe in Ours Too)

Jason SachsJason Sachs February 27, 20171 comment

Amdahl’s Law is a useful warning, but Jason Sachs argues it can be misleading if you stop at the equation. Using the Kittens Game as a playful model, he shows how Gustafson’s perspective, positive feedback loops, and system-level synergy can turn modest component speedups into big real-world wins. The article closes with concrete embedded-systems examples like ISR timing and developer productivity.


So You Want To Be An Embedded Systems Developer

Steve BranamSteve Branam February 5, 20205 comments

This is a practical, boots-on-the-ground roadmap of books, videos, and inexpensive dev boards you can actually use to become an embedded systems developer. It contrasts hobbyist platforms like Arduino and Raspberry Pi with professional ARM-based evaluation kits, lists must-read resources for firmware, real-time systems, and testing, and emphasizes hands-on practice and the safety responsibilities of working with real-world devices.


Using the Beaglebone PRU to achieve realtime at low cost

Fabien Le MentecFabien Le Mentec April 25, 20148 comments

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.


Coroutines in one page of C

Yossi KreininYossi Kreinin August 20, 201315 comments

Yossi Kreinin shows how to get usable coroutines in plain C by combining setjmp/longjmp with a bit of inline assembly. The post walks through a working iterator example, explains why you must allocate and switch a separate stack, and outlines the start/yield/next API. It also flags portability pitfalls like stack growth direction and frame pointers, and points to makecontext and Tony Finch alternatives.


Important Programming Concepts (Even on Embedded Systems) Part I: Idempotence

Jason SachsJason Sachs August 26, 20145 comments

Idempotence is a simple design principle that prevents duplicate effects when operations are retried or repeated. Jason Sachs shows why it matters in embedded systems, from HTTP submit buttons and capacitive touch inputs to garage-door remotes and SPI DAC writes. Read this post to learn three practical idempotent techniques and when redundant writes are a sensible reliability trade-off.


VHDL tutorial - A practical example - part 2 - VHDL coding

Gene BrenimanGene Breniman May 27, 2011

Gene Breniman walks through the VHDL coding for a CPLD-based data acquisition engine, turning the hardware spec into a working state machine and signal generators. The article explains SPI and I2S timing choices, an internal SPI peripheral latch, and counter-based timing (seqCount and CycleCnt) used to create LRCK, BCK, SPI SCK and nvSRAM write control. It’s a practical, implementation-focused guide for embedded designers.


Using the C language to program the am335x PRU

Fabien Le MentecFabien Le Mentec June 7, 201481 comments

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.


The 2026 Embedded Online Conference