A Sneak Peek at the 2024 Embedded Online Conference
Keeping embedded skills current is non-negotiable in 2024, and the Embedded Online Conference brings keynotes, workshops, and talks to help you do it affordably. Jacob Beningo highlights a lineup that includes Elecia White, Jack Ganssle, Phillip Koopman, hands-on workshops like GitLab CI/CD and Modern C++ interface design, plus talks on Linux hardening and safety. Early-bird pricing and on-demand access make this a practical way to learn continuously.
The Asimov Protocol
While the Internet is choke-full of explanations of basic data communication protocols, very little is said about the higher levels of packing, formatting, and exchanging information in a useful and practical way. This less-charted land is still fraught with strange problems, whose solutions may be found in strange places – in this example, a very short, 60 years old Science Fiction story.
Ten Little Algorithms, Part 7: Continued Fraction Approximation
In this article we explore the use of continued fractions to approximate any particular real number, with practical applications.
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.
Remember Y2K?
There was fear that the turn of the century at the end of 1999 would cause problems with many embedded systems. There is evidence that the same issue may occur in 2038.
Getting Started With Zephyr: Writing Data to EEPROM
In this blog post, I show how to implement a Zephyr application to interact with EEPROM. I show how the Zephyr device driver model allows application writers to be free of the underlying implementation details. Unfortunately, the application didn't work as expected, and I'm still troubleshooting the cause.
My TDD Journey Started Dec 6, 1999
My story of learning Test-Driven Development started 23 years ago today. TDD has helped me exercise my code well before there is target hardware to run on. TDD helps me prevent defects. It can help you too.
More than just a pretty face - a good UI is essential
A user interface can make or break a device - determining its success in the marketplace. With careful design, the UI can make the product compelling and result in a high level of satisfaction from new and experienced users.
Getting Started with NuttX RTOS on Three Low Cost Boards
You can get Linux-like power on cheap microcontroller boards using NuttX, not a full Linux system. This article walks through building and flashing NuttX on three low-cost targets: Raspberry Pi Pico (RP2040), ESP32-DevKitC, and STM32F4Discovery, covering SDKs, toolchains, and serial access. Follow the provided commands to configure, compile, and connect to the NuttShell so you can start experimenting with NuttX quickly.
Elliptic Curve Cryptography - Multiple Signatures
Point pairings let you compress many independent elliptic-curve signatures into a single verification, reducing n checks to one. This post explains how each signer derives a coefficient from the ordered list of public keys, aggregates signatures on the base group and public keys on the extension group, and verifies everything with one pairing computation. It also flags practical cautions like key validation and agreed ordering.
Jumping from MCUs to FPGAs - 5 things you need to know
Are you a microcontroller expert beckoned by the siren song of the FPGA? Not long ago, that was me. FPGA-expert friends of mine regularly extolled the virtues of these mysterious components and I wanted in. When I made the leap, I found a world seemingly very familiar, but in reality, vastly different. I found that my years of C programming and microcontroller use often gave pre preconceived interpretations of FPGA resource material which resulted in eye-roll class mistakes in my code. I’ve gleaned five things of vital importance to help you make that transition faster than I did.
Slew Rate Limiters: Nonlinear and Proud of It!
Slew-rate limits are a small nonlinear detail that often decides whether a controller behaves nicely or wrecks hardware. Jason Sachs walks through why slew limits appear in electronics and actuators, then shows two practical digital ways to impose limits: constraining input increments and constraining input around the output. He compares performance on underdamped second-order systems, gives closed-form intuition for overshoot, and demonstrates simulations with scipy and ODE solvers.
Patterns of Thinking: Metaphors in Programming
Why do some programming ideas click while others confuse engineers? This post shows that the metaphors you choose — from biological classification for inheritance to a “quantum” analogy for hierarchical state machines — shape how developers learn, design, and communicate. It also explains the surprising power of anthropomorphic (“naïve psychology”) language in team discussions and gives practical cautions about when metaphors help or mislead.
Unit Tests for Embedded Code
Unit tests are one of the most effective ways to catch logic bugs early and protect embedded firmware against regressions. Stephen Friederichs explains why unit testing matters for microcontroller code, when to test, and the trade-offs between on-target and hosted approaches, with practical advice on stubbing, using the Check framework, simulators, and coverage tools to make testing realistic for embedded projects.
How to Estimate Encoder Velocity Without Making Stupid Mistakes: Part I
Encoder velocity estimation is easy to get wrong, and Jason Sachs walks through the traps engineers fall into. He demolishes the common advice to time between encoder edges, shows how encoder quantization and state-width errors break that approach, and argues for fixed-rate sampling with sensible filtering for most control uses. Part II will cover more advanced estimators for higher performance needs.
Lost Secrets of the H-Bridge, Part I: Ripple Current in Inductive Loads
Jason Sachs digs into what PWM switching actually does to current in an H-bridge with an inductive load, and why that ripple matters for motors and power converters. He derives closed-form ripple formulas, shows how to compute a reference current I_R0 = VDC·T/L, and uses Python and sympy to plot and verify results. Read it for practical rules to halve ripple and raise its frequency.
FPGA skills for the modern world
FPGA demand is booming across industries from automotive to edge AI, and employers want engineers who can think in hardware. This post explains the mindset shift to RTL-level, concurrent design, waveform-based debugging with ILAs, and modern verification flows. It also highlights the practical skills that make you marketable, including HDLs, SoC/Linux integration, RISC-V know-how, and high-speed design techniques.
C to C++: Using Abstract Interfaces to Create Hardware Abstraction Layers (HAL)
In C to C++, we've been exploring how to transition from a C developer to a C++ developer when working in embedded system. In this post, we will explore how to leverage classes to create hardware abstraction layers (HAL). You'll learn about the various inheritance mechanisms, what an virtual function is, and how to create an abstract class.
Metal detection: beat frequency oscillator
Fabien Le Mentec walks through a practical beat frequency oscillator metal detector, from the LC oscillator theory to the Arduino-based frequency counter. He shows how changes in coil inductance reveal nearby metal, and why capacitor choice matters when you want a stable detector. The post focuses on the BFO sensing stage, with enough detail to help you build and test one yourself.
Lost Secrets of the H-Bridge, Part II: Ripple Current in the DC Link Capacitor
DC link capacitor ripple often determines capacitor life, yet the H-bridge waveform has a lot more structure than you might expect. Jason Sachs separates capacitor current into ramp and pulse components, derives closed-form peak and RMS expressions for edge and center PWM, and shows harmonic amplitudes. The post includes Python simulation so you can visualize the waveforms and apply the formulas to capacitor selection and EMI analysis.
Best Firmware Architecture Attributes
A poor firmware architecture makes future product variants and team work costly; Dr. Tayyar GUZEL outlines the attributes that avoid that fate. The post emphasizes modularity, low coupling, and encapsulation, and shows how a hardware abstraction layer, blackboard pattern, and CI-based unit testing improve extensibility, portability, and robustness. Practical tips include using setter/getter APIs, Doxygen for dependency graphs, and nightly regression to catch interface breaks early.
Lessons Learned from Embedded Code Reviews (Including Some Surprises)
Jason Sachs recounts a round of motor-controller code reviews and the practical lessons his team learned about quality and tooling. He explains how a simple "ready for review" checklist and automated style checks kept meetings focused on substantive issues, and why choosing the right review tool matters after discovering lost comments in Stash. Read for concrete tips on process, subgit mirroring, vera++, and Upsource.
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.
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.
Recruiting New Bloggers!
EmbeddedRelated is expanding its blogging team, and Stephane Boucher is inviting engineers, students, hobbyists, and researchers to contribute. He points to the success of earlier contributors and says the community has already read their articles more than 1,250,000 times. If you have knowledge to share, this post explains how to pitch a topic and get started.
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.
Levitating Globe Teardown, Part 1
Tim Wescott buys a $30 floating-globe desk toy and walks through first impressions, hands-on magnet experiments, and a frank critique of its control system. He highlights the toy's underdamped response, uni-polar electromagnet tradeoffs, and simple hacks that reveal clues about the pole pieces and magnet layout. This is a practical, engineer-forward preview before the actual teardown in part two.
Practical CRCs for Embedded Systems
Stephen Friederichs shows a practical way to get correct CRC code quickly by using PyCRC to generate C implementations, then verifying them on the desktop and an AVR ATMega328P. The post walks through the common generation algorithms, how to self-test with the standard "123456789" check value, and a real timing comparison that exposes the speed versus memory tradeoffs for embedded systems.
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.
Discrete-Time PLLs, Part 1: Basics
In this series of tutorials on discrete-time PLLs we will be focusing on Phase-Locked Loops that can be implemented in discrete-time signal proessors such as FPGAs, DSPs and of course, MATLAB.
