What to See at Embedded World 2023
Stephane Boucher is heading back to Embedded World 2023 in Nuremberg and is excited to feel the show’s post-pandemic buzz, with more than 900 vendors on the floor. He’s compiled a short list of vendors worth visiting and invites attendees to a casual meet-up on Tuesday evening at Hausbrauerei Altstadthof at 18:30. Join him to reconnect, network, and catch the latest industry trends.
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.
C to C++: 3 Proven Techniques for Embedded Systems Transformation
Jacob Beningo lays out a pragmatic, low-risk path for embedded teams to start using C++ without adding bloat or runtime cost. He recommends beginning by treating C++ as a cleaner C with namespaces, constexpr, and smart pointers, then adopting object-oriented design with composition, and finally introducing templates for static polymorphism where it makes sense. The post focuses on practical guardrails for resource-constrained firmware.
Libgpiod - Toggling GPIOs The Right Way In Embedded Linux
Accessing GPIOs through sysfs is simple but fragile, causing race conditions when multiple userspace processes touch the same line. This post explains libgpiod, introduced in Linux 4.8, and shows concise Python examples on a Toradex Verdin iMX8M Plus for requesting lines, tagging the consumer, using active_low flags, and reading or driving values. Learn why libgpiod provides safer, atomic GPIO handling.
Basler pylon on Raspberry Pi with Yocto
Basler's pylon can be packaged into a minimal Raspberry Pi Yocto image in a few clear steps. This walkthrough shows how to clone poky with meta-openembedded, meta-raspberrypi and Basler's meta-basler-tools, tweak conf/local.conf to add OpenCV and accept the Basler EULA, build rpi-test-image and generate an SDK for cross-compilation. It finishes by cross-compiling a pylon_example binary, copying it to the Pi and testing with a Basler acA2440-20gm.
Supply Chain Games: What Have We Learned From the Great Semiconductor Shortage of 2021? (Part 4)
The chip shortage didn't end with 2021, it moved into older process nodes where cars and industrial gear live. In this installment Jason Sachs explains why mature-node and trailing-edge capacity remain tightly constrained, how NCNR commitments and price increases are reshaping supplier behavior, and what companies like NXP and Microchip are doing to cope. He warns the imbalance could take multiple semiconductor cycles to fix.
Supply Chain Games: What Have We Learned From the Great Semiconductor Shortage of 2021? (Part 3)
Jason Sachs pulls back the curtain on Moore's Law and the foundry business to explain why the semiconductor shortage exposed brittle economics. He traces how roadmaps, depreciation schedules, and node mix force foundries to juggle expensive new fabs and mature capacity, and shows why leading-edge nodes punch above their volume share in revenue. Engineers get practical insight into how capacity and timing decisions ripple through the supply chain.
A Beginner's Guide to Embedded Systems
Embedded systems are everywhere, and this guide gives a practical, project-first roadmap for beginners. It explains what embedded systems are, the typical constraints you will face, and a clear learning sequence: circuit fundamentals, digital logic, C, and microcontrollers before moving on to RTOS or embedded Linux. The post also recommends hands-on dev boards and student clubs to accelerate real-world skills.
Peripheral Interaction Without a Linux Device Driver Using Spidev
Kernel-space drivers are not always necessary; many SPI peripherals can be handled from userspace using spidev. This post shows how to expose an SPI device through the device tree and kernel, wire a Bosch BMP388 to a Toradex Apalis iMX8 Ixora board, and implement a C userspace app that uses ioctl to read the chip ID. Practical tips on SPI settings and logic-analyzer validation are included.
In Memoriam: Frederick P. Brooks, Jr. and The Mythical Man-Month
Fred Brooks’ The Mythical Man-Month is still a surprisingly sharp guide to software projects, and Jason Sachs shows why it matters even more than its old mainframe setting suggests. He revisits Brooks’ ideas on surgical teams, conceptual integrity, throwaway prototypes, and schedule estimation, then maps them to modern embedded and software engineering realities. The result is a tribute, a book review, and a practical reminder that roles, architecture, and testing still make or break delivery.
From bare-metal to RTOS: 5 Reasons to use an RTOS
Most developers default to bare-metal, but Jacob Beningo argues an RTOS often simplifies modern embedded design. He outlines five practical reasons to move to an RTOS: easier integration of connectivity stacks and GUIs, true preemptive scheduling with priorities, tunable footprints, API-driven portability, and a common toolset for tasks and synchronization. The piece helps decide when RTOS adoption speeds development.
Square root in fixed point VHDL
In this blog we will design and implement a fixed point square root function in VHDL. The algorithm is based on the recursive Newton Raphson inverse square root algorithm and the implementation offers parametrizable pipeline depth, word length and the algorithm is built with VHDL records and procedures for easy use.
Jaywalking Around the Compiler
Messing with inline assembly can feel powerful until the compiler silently undoes you. Jason Sachs walks through a real bug on a Microchip dsPIC33E where pushing CORCON and writing a fixed value corrupts compiler-managed state and produces wrong results when the compiler reorders code. The post shows why the stack and certain registers are off-limits to raw inline asm, and gives practical, safe patterns to save and restore mode bits.
How to use I2C devices in (Apache) NuttX: Adding support for an I2C device in your board
You can add an I2C sensor to NuttX with a few file edits, menuconfig tweaks, and a standard build-and-flash cycle. This guide shows how the BMP280 barometer was integrated into the Raspberry Pi Pico bringup by copying and adapting an existing board driver, wiring the sensor to I2C0, enabling the BMP280 option in menuconfig, and compiling and flashing the resulting nuttx.uf2. It includes exact wiring and build tips.
Elliptic Curve Cryptography - Security Considerations
The security of elliptic curve cryptography is determined by the elliptic curve discrete log problem. This article explains what that means. A comparison with real number logarithm and modular arithmetic gives context for why it is called a log problem.
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.
Using the C language to program the am335x PRU
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.
How to Build a Fixed-Point PI Controller That Just Works: Part I
Jason Sachs digs into the implementation choices that make a fixed-point PI controller reliable in real embedded systems. He focuses on practical fixes rather than tuning: prefer scale-then-integrate, fold the timestep into the integral gain, and apply anti-windup so saturations and sensor noise do not break the loop. Part I covers discrete-time pitfalls and sets up fixed-point scaling issues for Part II.
Polynomial Math
This post walks through squaring and inversion in a tiny finite field to make ECC math tangible. Using GF(2^5) with primitive polynomial beta^5 + beta^2 + 1 it shows why squaring cancels cross terms so you only need half the lookup table, and how Fermat exponentiation computes inverses via repeated squarings and multiplies. It also demonstrates the Extended Euclid polynomial inverse and compares FPGA and CPU tradeoffs.
Libgpiod - Toggling GPIOs The Right Way In Embedded Linux
Accessing GPIOs through sysfs is simple but fragile, causing race conditions when multiple userspace processes touch the same line. This post explains libgpiod, introduced in Linux 4.8, and shows concise Python examples on a Toradex Verdin iMX8M Plus for requesting lines, tagging the consumer, using active_low flags, and reading or driving values. Learn why libgpiod provides safer, atomic GPIO handling.
Code Metrics - SLOC Count
Metrics and SLOC can trigger flashbacks for experienced engineers, but counting source lines of code still has practical uses when applied sensibly. This post clarifies physical versus logical lines in C, explains how SLOC can be misused to judge developer productivity, and shows how to run cloc to produce accurate per-file SLOC reports for estimation and codebase analysis.
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.
7 Essential Steps for Reducing Power Consumption in Embedded Devices
Reducing the amount of power your embedded device is consuming is not trivial. With so many devices moving to battery operations today, maximizing battery life can be the difference between a happy, raving customer and an unhappy one that ruins your company's reputation. This post explores seven steps for optimizing your embedded systems' power consumption. You'll gain insights into the steps and techniques necessary along with receiving a few resources to help you on your journey.
You Don't Need an RTOS (Part 2)
In this second article, we'll tweak the simple superloop in three critical ways that will improve it's worst-case response time (WCRT) to be nearly as good as a preemptive RTOS ("real-time operating system"). We'll do this by adding task priorities, interrupts, and finite state machines. Additionally, we'll discuss how to incorporate a sleep mode when there's no work to be done and I'll also share with you a different variation on the superloop that can help schedule even the toughest of task sets.
Linear Feedback Shift Registers for the Uninitiated, Part VIII: Matrix Methods and State Recovery
Matrix methods for LFSRs look intimidating, but Jason Sachs walks through companion-matrix representations and shows why they matter for time shifts and state recovery. He derives lookahead masks from powers of the companion matrix, then translates those matrix insights into efficient bitwise and finite-field algorithms. The article includes two simple state-recovery methods and working Python/libgf2 examples you can run and adapt.
Linear Feedback Shift Registers for the Uninitiated, Part V: Difficult Discrete Logarithms and Pollard's Kangaroo Method
Most discrete-log problems are hopeless by brute force, but clever algorithms cut that cost to feasible levels. This installment walks through baby-step giant-step, Pollard’s rho and kangaroo methods, and how Silver-Pohlig-Hellman and index calculus leverage group structure to speed attacks on GF(2^n) fields. Jason Sachs includes Python examples, heuristics, and complexity nuggets so you can see when each method is practical.
Mutex vs. Semaphores – Part 2: The Mutex & Mutual Exclusion Problems
Mutexes tackle many semaphore pitfalls by enforcing ownership and pairing lock and unlock operations, making mutual exclusion safer in RTOS code. This post explains how ownership enables recursion, priority inheritance and death detection, and why mutexes do not automatically solve circular deadlock or non-cooperative access. Read on for practical protocols such as Priority Inheritance and Priority Ceiling and a brief note on monitors.
Basic hand tools for electronics assembly
Though the software tools vary with different microcontrollers, many hardware tools are the same.
Scorchers, Part 3: Bare-Metal Concurrency With Double-Buffering and the Revolving Fireplace
Jason Sachs presents a practical, low-overhead concurrency pattern for tiny bare-metal systems where an ISR (Speedy) must safely exchange data with a nonreal-time main loop (Poky). He describes the "revolving fireplace", a double-buffering variant that swaps ownership of two shared memory regions, and walks through C examples, atomic/volatile considerations, and testing strategies so you can implement it on RAM-constrained MCUs.
Finite State Machines (FSM) in Embedded Systems (Part 4) - Let 'em talk
No state machine is an island. State machines do not exist in a vacuum, they need to "talk" to their environment and each other to share information and provide synchronization to perform the system functions. In this conclusive article, you will find what kind of problems and which critical areas you need to pay attention to when designing a concurrent system. Although the focus is on state machines, the consideration applies to every system that involves more than one execution thread.
