Always-On Intelligence Without the Cloud: Why it matters more than you think
Much of the AI conversation today is still focused on scale: larger models, more data, more compute. Embedded systems live in a different reality, where constraints are unavoidable, and efficiency is the priority. What’s emerging is not a smaller version of cloud AI, but a different approach altogether, the one that values locality, predictability, resilience, and trust. Always-on intelligence without the cloud isn’t just a technical milestone. It’s a change in how we think about where intelligence belongs.
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.
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.
Better Hardware Design Decisions, Faster: A Lean Team’s Guide to MDO
As design complexity grows, siloed decision-making often leads to late-stage surprises, costly rework, and missed opportunities for optimization. Multidisciplinary Design Optimization (MDO) offers a structured approach to solving this by enabling teams to evaluate trade-offs and impacts across the full system before implementation begins. Traditionally used in large, high-budget industries like aerospace, MDO is now within reach for lean teams, thanks to more accessible modeling tools and an urgent need for tighter collaboration. This article outlines how small hardware teams can adopt MDO in a practical way, starting simple, integrating key models early, and building toward a culture of systems thinking. The result is better design decisions, faster development, and more robust, manufacturable products with fewer surprises along the way.
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.
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.
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.
Sheep Bridge: In Praise of Generalists and System Engineers
Jason Sachs makes the case for hiring generalists and valuing system engineers, because they do more than take a high-level view. He explains how multi-scale thinking, arbitration among subsystems, and clear visualization prevent integration failures, using concrete examples from battery-voltage tradeoffs, Sheep Bridge map lessons, and encoder signal checks. Read this for practical rules that keep embedded projects coherent.
OS influence on power consumption
Power consumption of an embedded system may be influenced in software in general, but selection of an operating system can be key.
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.
Write Better Code with Block Diagrams and Flowcharts
Reading and writing code without architectural diagrams is like trying to follow complex instructions without any explanatory pictures: nigh impossible! By taking the time to draw out the block diagrams and flowcharts for your code, you can help identify problems before they arise and make your code easier to design, write, test, and debug. In this article, I'll briefly justify the importance of architectural drawings such as block diagrams and flowcharts and then teach you what they are and how to draw them. Using two simple examples, you'll see first-hand how these drawings can significantly amplify your understanding of a piece of code. Additionally, I'll give you a few tips for how to implement each drawing once you've completed it and I'll share with you a few neat tools to help you complete your next set of drawings.
How Embedded Linux is used in Spacecrafts !
This article dives into the application of Linux in spacecraft, examining the challenges it poses and proposing potential solutions. Real-life examples will be discussed, while also addressing the drawbacks of employing Linux in safety-critical missions.
Important Programming Concepts (Even on Embedded Systems) Part I: Idempotence
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.
Always-On Intelligence Without the Cloud: Why it matters more than you think
Much of the AI conversation today is still focused on scale: larger models, more data, more compute. Embedded systems live in a different reality, where constraints are unavoidable, and efficiency is the priority. What’s emerging is not a smaller version of cloud AI, but a different approach altogether, the one that values locality, predictability, resilience, and trust. Always-on intelligence without the cloud isn’t just a technical milestone. It’s a change in how we think about where intelligence belongs.
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.
C to C++: 3 Reasons to Migrate
Embedded C still powers most devices, but rising system complexity is revealing its limits. In this post Jacob Beningo kicks off a series on moving from C to C++, offering three practical reasons to start the migration now. He argues for an incremental approach that keeps low-level, hardware-dependent code in C while adopting C++ for higher-level, object-oriented application logic so teams can keep shipping during the transition.
Mutex vs. Semaphore - Part 1
Most forum answers get the semaphore versus mutex debate wrong. This post traces semaphores back to Dijkstra and Scholten, explains the difference between binary and counting semaphores, and highlights runtime hazards such as accidental release, recursive and task-death deadlocks, priority inversion, and misuse as signals. Read if you want to avoid common concurrency pitfalls in RTOS code.
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.
Margin Call: Fermi Problems, Highway Horrors, Black Swans, and Why You Should Worry About When You Should Worry
Jason Sachs walks through practical strategies for choosing engineering margin, from split-second Fermi estimates to industry-grade safety factors. He blends highway and boiler anecdotes with a MOSFET thermal example to show why probabilistic thinking, experiments, and documentation matter when you must decide fast or later justify your choices. Read this to learn how to balance conservatism, cost, and risk in real projects.
Important Programming Concepts (Even on Embedded Systems) Part I: Idempotence
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.
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.
Important Programming Concepts (Even on Embedded Systems) Part IV: Singletons
Singletons are convenient but often a modularity killer, especially in embedded firmware. Jason Sachs walks through the many faces of singletons, from static members and globals to hardware registers and user-visible application singletons, and shows practical ways to avoid tight coupling. Read this for concrete embedded examples and pragmatic fixes like passing state explicitly, using interfaces or factories, and isolating unavoidable globals in a HAL.
Important Programming Concepts (Even on Embedded Systems) Part II: Immutability
Immutable data can make embedded code easier to reason about, reduce concurrency bugs, and eliminate defensive copies. Jason Sachs walks through practical techniques that work in resource-constrained systems, from using const and pseudo-immutability to separating old and new state, to the limits of fully persistent data structures when you lack dynamic memory. The article also compares register-level state flow and advocates message passing as a concurrency alternative.
The CRC Wild Goose Chase: PPP Does What?!?!?!
Jason Sachs walks through a CRC rabbit hole and explains why ambiguous CRC names and incomplete specs lead to subtle protocol bugs. He demonstrates how XMODEM and KERMIT variants with a zero initial value can miss dropped leading-zero bytes, praises the X.25 standard for providing test vectors and a clear CRC16 definition, and warns that RFCs that ship only sample code are a poor substitute for a proper specification.
C to C++: 3 Reasons to Migrate
Embedded C still powers most devices, but rising system complexity is revealing its limits. In this post Jacob Beningo kicks off a series on moving from C to C++, offering three practical reasons to start the migration now. He argues for an incremental approach that keeps low-level, hardware-dependent code in C while adopting C++ for higher-level, object-oriented application logic so teams can keep shipping during the transition.
Write Better Code with Block Diagrams and Flowcharts
Reading and writing code without architectural diagrams is like trying to follow complex instructions without any explanatory pictures: nigh impossible! By taking the time to draw out the block diagrams and flowcharts for your code, you can help identify problems before they arise and make your code easier to design, write, test, and debug. In this article, I'll briefly justify the importance of architectural drawings such as block diagrams and flowcharts and then teach you what they are and how to draw them. Using two simple examples, you'll see first-hand how these drawings can significantly amplify your understanding of a piece of code. Additionally, I'll give you a few tips for how to implement each drawing once you've completed it and I'll share with you a few neat tools to help you complete your next set of drawings.
Important Programming Concepts (Even on Embedded Systems) Part III: Volatility
Jason Sachs takes volatility out of the basement and into practical embedded programming. He shows why data that can change outside your thread of control breaks assumptions, how the volatile qualifier in C/C++ and Java affects compiler and CPU behavior, and when to prefer shadow registers, locks, or proper concurrency libraries instead of ad hoc volatile usage.
How Embedded Linux is used in Spacecrafts !
This article dives into the application of Linux in spacecraft, examining the challenges it poses and proposing potential solutions. Real-life examples will be discussed, while also addressing the drawbacks of employing Linux in safety-critical missions.
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.
