Scorchers, Part 4: Burned by the Happy Path (Simon Says)
Designs that only work along the happy path break in real use, causing frustration and sometimes safety risks. Jason M. Sachs uses everyday examples from microwaves to car Auto Park logic to show how mutable software and physical state create brittle behavior. He outlines practical firmware fixes such as clear state machines, sensor or user-driven resynchronization, soft-start delays, and a ‘‘Drunken Happy Path’’ fuzzing approach to find real-world failure modes.
Graphical medicine
Although an appealing user interface is a good option for any device, in medical applications it can be a life saver.
Product quality: belief or proof?
Embedded software development is a challenging activity, so it is essential to have tools and IP that is of the best quality. However, assessing that quality can be, in itself, a challenge.
Linear Feedback Shift Registers for the Uninitiated
Jason Sachs assembled an eighteen-part deep dive into linear feedback shift registers, connecting the simple shift-register circuit to finite-field algebra and practical tools. The series walks through primitive polynomials, Berlekamp-Massey state recovery, libgf2-based analysis, discrete-log methods, and real-world uses from PRNGs and Gold codes to Reed-Solomon and CRC reverse-engineering. It’s a single reference for engineers who want both theory and working code.
C++ Assertion? Well Yes, But Actually No.
Assertions are a double-edged sword - on one side you enforce program correctness catching bugs close to their origin, on the other your application is subject to run-time error, like any interpreted language. This article explores what C++ can offer to get the advantages of assertions, without risking the crashes by moving contract checking at compile time.
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.
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.
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.
Elliptic Curve Cryptography - Extension Fields
An introduction to the pairing of points on elliptic curves. Point pairing normally requires curves over an extension field because the structure of an elliptic curve has two independent sets of points if it is large enough. The rules of pairings are described in a general way to show they can be useful for verification purposes.
Elliptic Curve Cryptography - Key Exchange and Signatures
Elliptic curve mathematics over finite fields helps solve the problem of exchanging secret keys for encrypted messages as well as proving a specific person signed a particular document. This article goes over simple algorithms for key exchange and digital signature using elliptic curve mathematics. These methods are the essence of elliptic curve cryptography (ECC) used in applications such as SSH, TLS and HTTPS.
New book on Elliptic Curve Cryptography
New book on Elliptic Curve Cryptography now online. Deep discount for early purchase. Will really appreciate comments on how to improve the book because physical printing won't happen for a few more months. Check it out here: http://mng.bz/D9NA
Elliptic Curve Cryptography - Extension Fields
An introduction to the pairing of points on elliptic curves. Point pairing normally requires curves over an extension field because the structure of an elliptic curve has two independent sets of points if it is large enough. The rules of pairings are described in a general way to show they can be useful for verification purposes.
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.
Linear Feedback Shift Registers for the Uninitiated, Part XVIII: Primitive Polynomial Generation
Jason Sachs walks through how to find primitive polynomials for GF(2) LFSRs, moving from naive exhaustive checks to smarter synthetic constructions. The article compares sieve and constructive methods, shows practical optimizations like parity checks and companion-matrix updates, and demonstrates decimation plus Berlekamp-Massey to generate all primitives from one seed; it also teases a novel Falling Coyote Algorithm for additional speedups.
Working with Strings in Embedded C++
This article discusses the use of strings in embedded systems. It explains how the need for and use of strings in embedded systems has changed with the advent of cheaper, full graphic displays and the growth of the ‘Internet of Things’ (IoT). The article also covers character literals, C-Strings and string literals, and the difference in memory models between them. It also highlights the safety and security issues that arise from using strings in embedded systems. Finally, it explains how C++11 introduced a Raw string literal type that is useful for storing file paths or regular expressions.
Introduction to Microcontrollers - Ada - 7 Segments and Catching Errors
Mike demos an Ada implementation of a multiplexed 7-segment driver on the STM32F407 Discovery board, highlighting Ada idioms like protected objects for ISRs and packed-boolean GPIO mapping. The post shows practical timer setup for Timer 6, how to avoid ARR/CNT races, and how Ada's runtime range checks plus a last-chance handler surface out-of-range errors with file and line diagnostics.
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.
Elliptic Curve Cryptography - Key Exchange and Signatures
Elliptic curve mathematics over finite fields helps solve the problem of exchanging secret keys for encrypted messages as well as proving a specific person signed a particular document. This article goes over simple algorithms for key exchange and digital signature using elliptic curve mathematics. These methods are the essence of elliptic curve cryptography (ECC) used in applications such as SSH, TLS and HTTPS.
Ten Little Algorithms, Part 8: Miller-Rabin Primality Test (and Living with Uncertainty)
Part 8 of the Ten Little Algorithms series: A look at the Miller-Rabin primality test, along with Pollard's rho algorithm for factoring, and some perspectives on very low levels of uncertainty.
Breaking AES with an Oscilloscope
AES is a powerful encryption algorithm that protects some our most important secrets. But did you know that many devices are inadvertently leaking the value of their private key through their power pins?! Join me in this special preview of my upcoming workshop at the Embedded Systems Summit (14-16 October 2025 in San Jose, CA) as we explore the world of hardware security and discover just how easy it could be to break AES encryption with only an oscilloscope and some math.
Linear Feedback Shift Registers for the Uninitiated, Part XVII: Reverse-Engineering the CRC
Jason Sachs shows how to pry CRC parameters out of a black-box oracle and reimplement the checksum yourself. By canceling the affine offsets, probing single-bit basis messages, and treating per-bit outputs as LFSR sequences, you can recover the generator polynomial, bit and byte order, and init/final XOR values. The post includes working Python code, a 4-message shortcut, and real-world tests such as zlib CRC32.
Favorite Tools: C++11 std::array
Firmware teams that avoid malloc or new need safer alternatives, and this post makes a strong case for C++11 std::array as that alternative. It highlights zero-overhead, type-safe, compile-time buffers and points to an ESP32 LED-strip demo where NUM_PIXELS_ fixes RAM usage at build time. Read it to see std::array used with std::rotate, passed to C libraries via data(), and as a low-risk path to std::vector later.
Linear Feedback Shift Registers for the Uninitiated, Part XV: Error Detection and Correction
CRCs and Hamming codes look a lot less magical when you view them as redundancy with a purpose. Jason Sachs walks from parity bits and checksums into finite-field polynomial arithmetic, then shows how CRCs map cleanly onto LFSRs and how Hamming codes use syndromes to locate single-bit errors. It is a practical tour of error detection and correction, with enough worked examples to make the theory feel usable.
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.
Are We Shooting Ourselves in the Foot with Stack Overflow?
Most traditional, beaten-path memory layouts allocate the stack space above the data sections in RAM, even though the stack grows “down” (towards the lower memory addresses) in most embedded processors. This arrangement puts your program data in the path of destruction of a stack overflow. In other words, you violate the first Gun Safety Rule (ALWAYS keep the gun pointed in a safe direction!) and you end up shooting yourself in the foot. This article shows how to locate the stack at the BEGINNING of RAM and thus point it in the "safe" direction.
Watchdog Timer Anti-patterns
A watchdog timer can be useless or even harmful when misused. This post catalogs the most common watchdog anti-patterns, including feeding the watchdog unconditionally from a timer ISR, suspending it during long operations, sprinkling resets across code, timeout auctions, incomplete reset trees, and treating process supervision as a substitute for hardware. It finishes with practical rules to design watchdogs that genuinely improve embedded system reliability.
Coding Step 3 - High-Level Requirements
Stephen Friederichs turns the series toward embedded code by showing how to write a single high-level requirement for an embedded Hello World. He explains when requirements pay off, how they support testing and scope control, and why you should not write them for every small script. He then lays out five practical rules and applies them to a concrete EHW-001 serial transmission requirement.
C++ Assertion? Well Yes, But Actually No.
Assertions are a double-edged sword - on one side you enforce program correctness catching bugs close to their origin, on the other your application is subject to run-time error, like any interpreted language. This article explores what C++ can offer to get the advantages of assertions, without risking the crashes by moving contract checking at compile time.
Developing software for a safety-related embedded system for the first time
Developing a safety-related embedded product is not the same as writing ordinary firmware, and this article lays out eight practical steps to get you started. Using a washing-machine controller as a running example, it covers scoping, key requirements, hazard analysis, applicable standards, platform and MCU choices, runtime monitoring, and prototyping. The checklist helps teams prepare for verification, testing, and later certification work.
Global Variables vs. Safe Software
10,000 global variables is a striking code smell, and Stephen Friederichs uses the Toyota unintended-acceleration case to show why. He argues the issue was not mere coding style but absent processes: poor testing, lack of enforced standards, incorrect stack analysis, and unowned autogenerated code. Read this for a practical take on why globals and weak processes in safety-critical systems are a much bigger danger than style debates suggest.
