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.
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.
STM32 VS Code Extension Under The Hood
ST's STM32 VS Code extension hides useful CMake projects and VS Code tasks behind a friendly UI, but understanding what it generates lets you bend it to your needs. This video peels back the layers to show the generated CMake files, how to modify them, how to add a VS Code-invokable flash task, and how to enable C++ support alongside C. The STM32 F0 example and flash task are available on GitHub.
Visual Studio Code Extensions for Embedded Software Development
Visual Studio Code can be a solid embedded development environment, if you equip it with the right extensions. Jacob Beningo walks through tools for Cortex-M debugging, register and RTOS inspection, build system support, formatting, linting, and vendor-specific workflows. It is a practical tour of the extensions that help VS Code feel much less like a general-purpose editor and more like an embedded IDE.
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.
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.
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 Overlooked Embedded Software Elements
Jacob Beningo points out three often-overlooked elements that can make embedded projects less painful and faster to ship. He highlights model-generated code for off-target iteration, configuration-generated code to manage SKUs and avoid fragile conditional compilation, and automated test harnesses to catch regressions early. The post gives practical reasons to consider each approach and how they fit into modern embedded DevOps.
Learning A New Microcontroller
Learning a new microcontroller becomes manageable with a repeatable, stepwise process that focuses on common peripherals, tools, and example programs. This post lays out hands-on exercises from blinky and UART echoes through I2C/SPI, PWM and ADC to DMA and RTOS variations, and shows how to evolve prototype code into reusable HAL and OSAL layers. Practical tips cover hardware setup, logic analyzers, and keeping an engineering notebook.
MSP430 Launchpad Tutorial - Part 1 - Basics
A working button-driven LED on the MSP430 LaunchPad is only a few steps away. Enrico Garante walks through creating a CCS project, setting P1.0 as the LED output and enabling P1.3 button interrupts, then shows the interrupt service routine that toggles the LED. The short tutorial covers stopping the watchdog, configuring P1DIR/P1OUT, clearing flags, and launching the code so you can get blinking quickly.
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.
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.
Debug, visualize and test embedded C/C++ through instrumentation
Instrumenting a firmware is a highly effective methodology for debugging and testing an embedded softwares. In this article, I will present a way of achieving this using Scrutiny, an open-source software suite developed as a personal initiative, designed to streamline debugging, telemetry, and hardware-in-the-loop (HIL) testing for embedded devices.
Important Programming Concepts (Even on Embedded Systems) Part II: Immutability
Immutable data can make embedded code easier to reason about, reduce concurrency bugs, and eliminate defensive copies. Jason Sachs walks through practical techniques that work in resource-constrained systems, from using const and pseudo-immutability to separating old and new state, to the limits of fully persistent data structures when you lack dynamic memory. The article also compares register-level state flow and advocates message passing as a concurrency alternative.
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.
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.
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.
Important Programming Concepts (Even on Embedded Systems) Part III: Volatility
Jason Sachs takes volatility out of the basement and into practical embedded programming. He shows why data that can change outside your thread of control breaks assumptions, how the volatile qualifier in C/C++ and Java affects compiler and CPU behavior, and when to prefer shadow registers, locks, or proper concurrency libraries instead of ad hoc volatile usage.
Round-robin or RTOS for my embedded system
Manuel Herrera walks through the practical tradeoffs between bare-metal round-robin loops and adopting an RTOS for embedded projects. He outlines two round-robin styles, explains how an RTOS gives independent threads and synchronization primitives, and highlights added code, licensing, interrupt latency, and the learning curve. Read this to sharpen decision criteria around timing guarantees, reuse, and whether an RTOS truly adds value to your firmware.
Learning A New Microcontroller
Learning a new microcontroller becomes manageable with a repeatable, stepwise process that focuses on common peripherals, tools, and example programs. This post lays out hands-on exercises from blinky and UART echoes through I2C/SPI, PWM and ADC to DMA and RTOS variations, and shows how to evolve prototype code into reusable HAL and OSAL layers. Practical tips cover hardware setup, logic analyzers, and keeping an engineering notebook.
Bit-Banged Async Serial Output And Disciplined Engineering
This post covers implementing asynchronous serial output directly on a GPIO with bit-banging. This can be a valuable debug tool for getting information out of a system. It also covers disciplined engineering, using the bit-banging module as an example and template you can apply to other projects.
Important Programming Concepts (Even on Embedded Systems) Part VI : Abstraction
Abstraction is essential, but it is not free. Jason Sachs walks through the many faces of abstraction—pattern recognition, generalization, simplification, and indirection—and shows how each helps and hurts real projects. Using examples from math, API design, UI toolkits, schematics, and embedded C, he gives practical context so firmware engineers can apply abstractions without causing maintenance or debugging headaches.
Linux Kernel Development - Part 1: Hello Kernel!
Skip userland and run code inside the kernel with a tiny "Hello Kernel" module that prints messages on load and unload. This introduction walks through required headers, the init and exit hooks, MODULE_* metadata, a kernel-friendly Makefile, and the basic workflow to build, insmod, rmmod and inspect messages with dmesg. It’s a hands-on first step into Linux kernel module development.
Ada 2012 Comes to ARM Cortex M3/M4
Ada is not dead, and Mike Silva shows why by walking through Ada 2012 running on ARM Cortex‑M3/M4 hardware. He demos an STM32F4 LED-and-button example that highlights Ada advantages: strong typing, modular types, built-in time and tasking, and protected objects for safe concurrency without an RTOS. The post also notes AdaCore's GNAT tooling and links to further resources to get started.
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.
Project Directory Organization
A tidy project tree can make a bigger difference than you might think. Stephen Friederichs lays out a practical directory scheme for small software projects, using familiar folders like src, obj, bin, test, reports, docs, and conf to keep builds, tests, and documentation from turning into a mess. He also explains why the root directory should welcome contributors, not confuse them.
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.
Trust, but Verify: Examining the Output of an Embedded Compiler
Jason Sachs argues embedded engineers should read their compiler's assembly even if they rarely write assembly. He walks through Microchip XC16 output for dsPIC33 devices, showing how simple C variants and optimization flags produce very different code. The article demonstrates practical verification techniques and a tiny Python helper, pyxc16, to quickly inspect assembly for timing-sensitive firmware without rewriting everything in assembly.
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.
