VolksEEG: Rust Development On Adafruit nRF52840 Feather Express
Setting up Rust embedded development on an Adafruit Feather nRF52840 Express inside a VS Code devcontainer can save time, but the toolchain has a few gotchas. This post walks through using the VolksEEG prototype echo-server to verify the USB serial path, configuring probe-rs with J-Link and OpenOCD for on-chip debugging, and diagnosing a container build error fixed by adding libudev-dev. Expect step-by-step commands and troubleshooting tips.
Working With ESP-C3-32S-Kit Dev Board
This hands-on guide walks through setting up the ESP-C3-32S-Kit with ESP-IDF, from installing the toolchain to flashing and monitoring a hello-world example. It shows JTAG debugging with OpenOCD and GDB, how to use the NimBLE BLE stack for peripheral and central roles, and how to capture and filter BLE traffic with a Nordic sniffer and Wireshark so you can inspect pairing and connection behavior.
Learning Rust For Embedded Systems
Rust eliminates whole classes of memory and concurrency bugs, making it a compelling choice for embedded projects, and the author recommends it for the VolksEEG project after a rapid evaluation. The post connects Rust fundamentals such as ownership and borrowing, RAII, traits, and unsafe blocks to familiar embedded patterns. It also provides a curated on-ramp of videos, books, and tools like Cargo, RTIC, and probe-rs to get hands-on quickly.
Six Software Design Tools
Software design need not be mysterious, these six practical tools give a disciplined way to shape readable, testable, and maintainable code. The post walks through naming (DAMP), duplication control (DRY), complexity metrics (MCC), SOLID principles, API layering, and test-driven development, showing how each idea applies across languages and embedded systems. Use them as checklists for code reviews and design thinking.
Introducing The VolksEEG Project
VolksEEG is an open-source effort to build an FDA-cleared clinical EEG and publish every design so others can manufacture it. The volunteer-driven project centers on the TI ADS1299 8-channel, 24-bit biopotential ADC and combines medical and electrical engineering expertise to confront regulatory, safety, and usability challenges. This blog series will document technical decisions, isolation and safety concerns, and ways engineers can contribute.
Video-Based STEM Embedded Systems Curriculum, Part 2
Part 2 delivers three ready-to-run lesson plans for a video-based STEM embedded course, starting with Arduino hands-on projects using an Elegoo UNO starter kit and Bryan Vines video walkthroughs that explain the code. It then teaches Fritzing for pictorial and schematic circuit drawings, followed by Collin Cunningham videos that cover resistors, capacitors, transistors, schematics, and other core components. The sequence stresses design, draw, build, test to keep students engaged.
Video-Based STEM Embedded Systems Curriculum, Part 1
This curriculum shows how to teach introductory embedded systems using free online videos and low-cost kits, suitable for middle-school, high-school, college, or adult learners. It packages curated educator recommendations, a per-student equipment and book list, essential free software, and core lesson topics like Arduino, MicroPython, Kicad board design, soldering, and RTOS basics. The approach stresses hands-on labs, safety, backups, mentorship, and adapting to local budgets.
Review: Prototype to Product
Alan Cohen's Prototype to Product is a practical systems engineering playbook for anyone taking an embedded idea to market. The review emphasizes uncovering surprises early, disciplined planning, and cross-discipline collaboration across electrical, mechanical, software, and manufacturing domains. It highlights concrete topics such as prototyping, DFM/DFA, staged testing, and regulatory considerations that help avoid costly late-stage rework.
Dumb Embedded System Mistakes: Running The Wrong Code
Running the wrong firmware on a board can waste hours. This post shows a practical marking strategy for embedded Linux that embeds searchable proof-of-life strings into kernel, rootfs, overlay, and application code. It walks through choosing early-boot log points, using compile-time timestamps, and a small shell script to set, find, and clear marks so you can verify builds before flashing.
Simple Automated Log Processing
You don't need heavy tools to make sense of megabytes of embedded logs. This post shows a practical bash script that trims noisy serial and semihosting output, samples hourly heap-profile lines, and converts them into a CSV ready for graphing. It gives a simple, adaptable pattern you can reuse to spot memory leaks or triage recurring log signatures quickly.
Working With ESP-C3-32S-Kit Dev Board
This hands-on guide walks through setting up the ESP-C3-32S-Kit with ESP-IDF, from installing the toolchain to flashing and monitoring a hello-world example. It shows JTAG debugging with OpenOCD and GDB, how to use the NimBLE BLE stack for peripheral and central roles, and how to capture and filter BLE traffic with a Nordic sniffer and Wireshark so you can inspect pairing and connection behavior.
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.
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.
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.
Donald Knuth Is the Root of All Premature Optimization
Knuth's famous line "premature optimization is the root of all evil" has turned into a blunt rule on forums, Jason Sachs argues, and that overuse masks important nuance. He walks through concrete embedded examples, from dsPIC33E floating-point timings to an ROI analysis in the Kittens Game and a continuous optimization toy problem, to show when to measure, when to speculate, and why profilers can mislead.
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.
C++ on microcontrollers 1 - introduction, and an output pin class
Wouter van Ooijen shows how small C++ abstractions make GPIO code portable and reusable. Starting from a simple output_pin interface he implements concrete pins for an LPC2148 GPIO and a 74HC595 shift register, then composes behaviors with wrappers like tee and invert. The post demonstrates virtual methods, references, and constructor initialization lists to build drivers you can reuse across boards.
Delayed printf for real-time logging
Yossi Kreinin demonstrates delayed printf, a technique that records printf format pointers and raw argument words into a compact buffer so logging does not disturb real-time timing. He walks through a small C++11 writer using variadic templates and an atomic buffer plus a gdb Python reader that reconstructs formatted messages from executables or core dumps. The result is readable post-processed logs with minimal runtime overhead.
C Programming Techniques: Function Call Inlining
Fabien Le Mentec shows how you can keep clean C interfaces while recovering the cycles lost to function call overhead. The post demonstrates static inline and header inclusion techniques, then compares generated ARM assembly for an inlined versus non inlined bit test. Read it to see concrete assembly differences, compiler hints, and the practical trade off between speed and code size on embedded targets.
Hidden Gems from the Embedded Online Conference Archives - Part 1
Discussion of a "hidden gem" from the Embedded Online Conference archives!
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.
C++ on microcontrollers 4 – input pins, and decoding a rotary switch
Wouter van Ooijen shows how to extend a small C++ I/O library for microcontrollers to support input pins and mixed I/O, and how to decode a rotary switch reliably. The post walks through a safe class hierarchy for input, output, and bidirectional pins, then builds a quadrature decoder with a saturating counter and an HC595 seven-segment demo you can run on LPCXpresso hardware.
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.
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.
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.
Continuous Integration for Embedded Systems
Hardware dependencies make continuous integration for embedded systems harder than for pure software, yet it is essential for quality and faster feedback. This post explains the three CI types, host, non-host and hardware-in-the-loop, then compares trade-offs in cost, parallelism, timing accuracy and portability. It also outlines steps in a typical CI pipeline and highlights practical tools and plugins, including Jenkins and static analysis to automate builds and tests.
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.
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.
You Will Make Mistakes
Mistakes are inevitable in engineering, and they grow worse when teams are distributed and communication has long round-trip delays. Jason Sachs lays out practical, low-friction tactics to keep small errors from becoming project stoppers, from applying FMEA thinking to using issue trackers, event logging, clear interface specs, and better meeting habits. The post focuses on habits you can start using today to raise team reliability.
Understanding Yocto Project Layers: A Modular Approach to Embedded Systems Development
Managing metadata across embedded Linux builds gets messy fast, so the Yocto Project uses layers to keep things modular and reusable. This post walks through inspecting active layers with bitbake-layers, controlling overrides with BBFILE_PRIORITY, and creating a meta-yocto-splash-img layer that uses a .bbappend to replace psplash. It finishes by showing how to verify the custom splash screen in QEMU so you can test safely before deploying to hardware.
