Getting Started With Zephyr: Bluetooth Low Energy
In this blog post, I show how to enable BLE support in a Zephyr application. First, I show the necessary configuration options in Kconfig. Then, I show how to use the Zephyr functions and macros to create a custom service and characteristic for a contrived application.
++i and i++ : what’s the difference?
Although the ++ and -- operators are well known, there are facets of their operation and implementation that are less familiar to many developers.
Using GPIO in (Apache) NuttX RTOS
Blinking an LED is the embedded Hello World, and this tutorial walks through using GPIOs on NuttX running on a Raspberry Pi Pico. It shows how to enable the GPIO driver and example in menuconfig, build and flash the nuttx.uf2, and use NSH gpio device files to read and write pins. The post also explains polling versus interrupt-driven inputs and the pull-up/edge setup needed for button interrupts.
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.
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.
Designing Communication Protocols, Practical Aspects
When your MCU must talk to a PC or smartphone, a clear protocol saves time and headaches. This post gives practical guidance for fast bring-up: how to structure a compact header, keep payloads byte-aligned and debug-friendly, and reserve bits for future use. It also covers CRCs for integrity, timeout and retry strategies for resynchronisation, and the simple start code trick that makes debugging easier.
How to Estimate Encoder Velocity Without Making Stupid Mistakes: Part II (Tracking Loops and PLLs)
Jason Sachs explains why simple differentiation of encoder counts often fails and how tracking loops and PLLs give more robust velocity estimates. Using a pendulum thought experiment and Python examples, he shows how a PI-based tracking loop reduces noise and eliminates steady-state ramp error, and why vector PLLs with quadrature mixing avoid cycle slips and atan2 unwrap pitfalls in noisy or analog sensing.
On hardware state machines: How to write a simple MAC controller using the RP2040 PIOs
Hardware state machines are nice, and the RP2040 has two blocks with up to four machines each. Their instruction set is limited, but powerful, and they can execute an instruction per cycle, pushing and popping from their FIFOs and shifting bytes in and out. The Raspberry Pi Pico does not have an Ethernet connection, but there are many PHY boards available… take a LAN8720 board and connect it to the Pico; you’re done. The firmware ? Introducing Mongoose…
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.
Finite State Machines (FSM) in Embedded Systems (Part 3) - Unuglify C++ FSM with DSL
Domain Specific Languages (DSL) are an effective way to avoid boilerplate or repetitive code. Using DSLs lets the programmer focus on the problem domain, rather than the mechanisms used to solve it. Here I show how to design and implement a DSL using the C++ preprocessor, using the FSM library, and the examples I presented in my previous articles.
Lost Secrets of the H-Bridge, Part III: Practical Issues of Inductor and Capacitor Ripple Current
Jason Sachs cuts through the math to show what ripple current actually does to H-bridge hardware. He explains why peak current is the limiting factor for inductors, why capacitor ESR usually dominates DC-link voltage ripple, and how center-aligned PWM and duty selection reduce harmonics and ripple. Read this if you want practical rules of thumb and calculation templates for real power-electronics designs.
Never use Float or Integer
Ada treats numbers as more than just numbers, and that changes how embedded code fails. This post shows why you should avoid using Float and Integer directly, then demonstrates how distinct types, ranges, and subtypes let the compiler catch unit mix-ups and out-of-range values before runtime. It also shows the same code running on a Raspberry Pi Pico, and briefly introduces SPARK for proving correctness.
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.
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.
Cortex-M Exception Handling (Part 2)
Exception entry and return on Cortex-M look simple, but the hardware does a lot to preserve context, enforce privilege, and pick the right stack. This post walks through the processor actions after an exception is accepted: which registers get pushed, how CONTROL, MSP and PSP affect stack selection, how EXC_RETURN encodes the return path, and why VTOR and vector table alignment matter for handler lookup.
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.
Review: Embedded Software Design: A Practical Approach to Architecture, Processes, and Coding Techniques
Jacob Beningo's Embedded Software Design is a practical, discipline-first guide to building reliable embedded systems. It frames development around a software triad: architecture, Agile/DevOps processes, and coding techniques, with security integrated from the start. The book mixes principles with hands-on recipes and includes appendices that walk through GitLab CI/CD and TDD examples you can reuse on real projects.
Another 10 Circuit Components You Should Know
Jason Sachs walks through ten underrated circuit components every embedded engineer should know, from bus switches and thermocouple signal ICs to PCB stiffeners and opto-FET isolators. He mixes practical part examples, high-current hardware tips, and MCU features like CTMU and Peripheral Pin Select so you can pick the right trick when space, isolation, or precision matter.
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.
Elliptic Curve Cryptography - Basic Math
An introduction to the math of elliptic curves for cryptography. Covers the basic equations of points on an elliptic curve and the concept of point addition as well as multiplication.
Someday We’ll Find It, The Kelvin Connection
Low-ohm measurements will fool your multimeter unless you use Kelvin connections. Jason Sachs walks through four-wire sensing using a current-limited supply and two DMMs, explains thermoelectric and connector-related errors, and shows why schematics and PCB layout must reflect Kelvin sense pads to avoid subtle measurement and circuit problems.
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.
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.
