Getting Started with (Apache) NuttX RTOS Part 2 - Looking Inside and Creating Your Customized Image
This hands-on guide peels back the NuttX source tree and shows how to assemble a tailored firmware image. You will learn what each top-level directory does, how to enable apps with menuconfig and search tricks to resolve dependencies, and how to save a defconfig as a reusable board profile so you can rebuild the same image without repeating configuration steps.
Moulding the Embedded Systems Engineers of Tomorrow: Adapting to a Constantly Transforming Technological Terrain
Embedded systems engineers, previously focused on device architecture, are now steering the digital era, encompassing firmware, software, complex silicon, and cloud computing. To keep pace, mastery in new areas like cybersecurity, artificial intelligence (AI), machine learning (ML), and cloud technologies is critical. In today's highly connected world, security is foundational to design, necessitating knowledge in encryption, secure coding, and data protection laws. Additionally, expertise in AI and ML is essential for managing vast global data, requiring understanding of ethical implications and effective system design for data analysis. The advent of cloud technology mandates learning about cloud architectures and data security. In this fast-paced field, continuous learning and adapting these new skills is the key to staying relevant and spearheading future advancements.
Getting Started With Zephyr: Kconfig
In this blog post, we briefly look at Kconfig, one of the core pieces of the Zephyr infrastructure. Kconfig allows embedded software developers to turn specific subsystems on or off within Zephyr efficiently and control their behavior. We also learn how we can practically use Kconfig to control the features of our application using the two most common mechanisms.
An Iterative Approach to USART HAL Design using ChatGPT
Discover how to leverage ChatGPT and an iterative process to design and generate a USART Hardware Abstraction Layer (HAL) for embedded systems, enhancing code reusability and scalability. Learn the step-by-step journey, improvements made, and the potential for generating HALs for other peripherals.
Modern C++ in Embedded Development: (Don't Fear) The ++
While C is still the language of choice for embedded development, the adoption of C++ has grown steadily. Yet, reservations about dynamic memory allocation and fears of unnecessary code bloat have kept many in the C camp. This discourse aims to explore the intricacies of employing C++ in embedded systems, negotiating the issues of dynamic memory allocation, and exploiting the benefits of C++ offerings like std::array and constexpr. Moreover, it ventures into the details of the zero-overhead principle and the nuanced distinctions between C and C++. The takeaway? Armed with the right knowledge and a careful approach, C++ can indeed serve as a powerful, safer, and more efficient tool for embedded development.
Getting Started with (Apache) NuttX RTOS - Part 1
NuttX RTOS is used in many products from companies like Sony, Xiaomi, Samsung, Google/Fitbit, WildernessLabs and many other companis. So, probably you are already using NuttX even without knowing it, like the you was using Linux on your TV, WiFi router more than 10 years ago and didn't know too! Today you will have the chance to discover a little bit of this fantastic Linux-like RTOS! Are you ready? So, let's get started!
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.
Get Involved: Contribute Quiz Questions for the Embedded Systems Community for a Chance to Win a LAP-C Pro!
Submit a Quiz Question for a chance to win a Zeroplus Lac-C Pro!
Return of the Delta-Sigma Modulators, Part 1: Modulation
Jason Sachs returns to delta-sigma modulators with a hands-on, code-first treatment that focuses on the DAC side of things. Part 1 walks through first- and second-order kernels, linearized analysis, spectra, and practical coefficient choices while illustrating results with Python simulations. Expect clear rules of thumb for A, R, and B, a derivation of noise shaping behavior, and a useful error bound for RC filtering.
C to C++: Bridging the Gap from C Structures to Classes
Jacob Beningo walks through a practical, beginner-friendly path from C structures to C++ classes for embedded systems, using an LED example to make the ideas concrete. You will see how function pointers in C approximate methods, how C++ structs and classes let you place methods with data, and how access specifiers and constructors improve encapsulation and initialization. This gives a low-risk way to start adopting C++ features.
Went 280km/h (174mph) in a Porsche Panamera in Germany!
Those of you who've been following my blog lately already know that I am going through some sort of mid-life crisis that involves going out there to meet people and make videos. It all started with Embedded World early this year, then continued at ESC Boston a couple of months ago and the latest chapter just concluded as I returned from Germany after spending a week at SEGGER's headquarters to produce a video to highlight their 25th anniversary.
Dark Corners of C - The Comma Operator
Ever seen a line like if (!dry_run && ((stdout_closed = true), close_stream(stdout) != 0)) and wondered what that comma means? Stephen Friederichs unpacks the rarely-discussed C comma operator, shows a circular-buffer example where it seemed to simplify looping, then demonstrates how precedence and readability problems (and even MISRA C bans) make it dangerous in practice. Read on for practical uses and cautionary lessons.
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.
Launch of Youtube Channel: My First Videos - Embedded World 2017
Stephane Boucher turned his Embedded World 2017 trip into a debut YouTube series of short booth highlight videos. He walks through the steep learning curve of trade-show filming, the specific gear he bought and rented to cope with low light and noise, and the practical mistakes he plans to fix. The post lists filmed vendors and asks readers for feedback to improve future episodes.
Ten Little Algorithms, Part 1: Russian Peasant Multiplication
Jason Sachs revisits a centuries-old multiplication trick and shows why it still matters. He lays out Russian Peasant Multiplication with simple Python code, then reveals how the same shift-and-add pattern maps to GF(2) polynomial arithmetic and to exponentiation by squaring. The post mixes historical context with practical bitwise techniques that are useful for embedded and low-level math work.
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.
Coroutines in one page of C
Yossi Kreinin shows how to get usable coroutines in plain C by combining setjmp/longjmp with a bit of inline assembly. The post walks through a working iterator example, explains why you must allocate and switch a separate stack, and outlines the start/yield/next API. It also flags portability pitfalls like stack growth direction and frame pointers, and points to makecontext and Tony Finch alternatives.
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.
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.
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.
Levitating Globe Teardown, Part 2
Tim Wescott opens up a budget levitating globe and shows why it seems magical: a massive 30 mm rare-earth magnet and a deliberately cheap magnetic circuit. He documents a bolt used as the flux core, a likely microcontroller and hall sensor in the head, very fine winding in the electromagnet, and a single-transistor unidirectional drive. Part 3 will measure forces and sensor voltages to build a better controller.
C to C++: Bridging the Gap from C Structures to Classes
Jacob Beningo walks through a practical, beginner-friendly path from C structures to C++ classes for embedded systems, using an LED example to make the ideas concrete. You will see how function pointers in C approximate methods, how C++ structs and classes let you place methods with data, and how access specifiers and constructors improve encapsulation and initialization. This gives a low-risk way to start adopting C++ features.
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.
Introduction to Microcontrollers - More Timers and Displays
Mike Silva walks through using a single hardware timer to create the illusion of parallel tasks, combining a millisecond tick, deadline checks, and a cyclic executive to run time-driven and event-driven work. He shows safe deadline code that handles timer rollover and ISR races, and provides practical STM32 examples including SysTick-driven delays, atomic GPIO BSRR writes for LCD control, and a button-driven display demo.
Simulating Your Embedded Project on Your Computer (Part 1)
Having a simulation of your embedded project is like having a superpower that improves the quality and pace of your development ten times over! To be useful, though, it can't take longer to develop the simulation than it takes to develop the application code and for many simulation techniques "the juice isn't worth the squeeze"! In this two-part blog series, I'll share with you the arguments in favor of simulation (so, hopefully, you too believe in its value) and I'll show you what works (and what doesn't work) to help you to simply, easily, and quickly simulate your embedded project on your computer.
VGA Output in 7 Slices. Really.
Victor Yurkovsky shows how to generate VGA timing on a Xilinx Spartan3 using clever SRL16 tricks to squeeze the generator into just a few slices. By using 32-bit SRLs for line pulses, two mutually prime SRL lengths as a divide-by-99 timebase, and tapped SRLs to combine HSYNC and HBLANK, the approach achieves accurate-enough horizontal and vertical timing with minimal LUT usage.
Memory Mapped I/O in C
Interacting with memory mapped device registers is at the base of all embedded development. Let's explore what tools the C language - standard of the industry - provide the developer with to face this task.
C++ on microcontrollers 2 - LPCXpresso, LPC-link, Code Sourcery, lpc21isp, linkerscript, LPC1114 startup
Wouter van Ooijen walks you through getting C++ to run on a tiny LPC1114 board using LPCXpresso hardware and a command-line toolchain. He demonstrates a minimal linker script and startup code that initialize .data and .bss and call C++ global constructors, shows how to flash via the on-chip bootloader with lpc21isp when LPC-link is locked, and includes practical GPIO and SysTick LED examples.
Linear Feedback Shift Registers for the Uninitiated, Part VII: LFSR Implementations, Idiomatic C, and Compiler Explorer
Jason Sachs takes LFSR theory back to real hardware, showing multiple C implementations and dsPIC33E assembly to squeeze cycles out of Galois LFSR updates. He digs into idiomatic C pitfalls like rotate idioms, demonstrates tricks using unions and 16/32-bit views, and shows when inline assembly with SL/RLC and conditional-skip instructions pays off. The article also uses Compiler Explorer and supplies an MPLAB X test harness for verification.
10 Items of Test Equipment You Should Know
Jason Sachs walks through ten often-overlooked pieces of test gear that make debugging embedded hardware faster, safer, and more precise. From clamp-on and Rogowski current probes to spring-tip probes, IC test clips, and compact DAQ systems, each tool targets a common bench frustration. Practical buying notes and use cases help you choose tools that save time and reduce guesswork.
