Embedded Programming Video Course Teaches RTOS
From basic foreground/background loops to priority-inheritance protocols, this free video course walks you through building and improving an RTOS step by step. Lessons cover manual context switching, round-robin and preemptive priority schedulers, efficient thread blocking, and synchronization primitives. The series finishes with a practical port to a professional RTOS in the QP/C ecosystem, showing semaphores, mutexes, and ways to prevent priority inversion.
The Hardest Bug I Never Solved
A single overlooked sentence in the STM32 datasheet turned intermittent startup resets into a major time-leach. Senior engineers chased DMA buffers and overflows for hours until Unni discovered the ISR vector table had been relocated to RAM with only 256 byte alignment while the MCU required 512 bytes. The misalignment caused interrupts to jump to the reset handler, and fixing the alignment stopped the reboot loop for good.
Is it a Bug or an Error?
The famous moth-in-the-relay story helped 'bug' and 'debugging' become everyday terms, but this piece questions whether that cozy label softens accountability. It argues software failures usually come from human mistakes in requirements or implementation, not literal insects, and asks whether using words like 'error' or 'mistake' would push engineers to treat safety and reliability more seriously. Join the conversation.
Lazy Properties in Python Using Descriptors
Python descriptors let you outsource attribute lookup, and Jason Sachs walks through a practical use: lazy, cached properties. He presents a LazyProperty descriptor that defaults to a WeakKeyDictionary cache so computed results are stored on first access and automatically purged when objects are garbage collected. The post shows how to share caches by value using attrkey or swap cache classes for different use cases.
Android for Embedded Devices - 5 Reasons why Android is used in Embedded Devices
Android may seem like a phone OS, but it now solves real embedded product problems. This post outlines five practical reasons engineers pick Android for devices with displays, from built-in touch and GUI frameworks to simplified camera and wireless APIs. It also covers vendor BSP and driver support, a large developer pool, and how Android speeds prototyping by reusing phones or tablets as HMIs or processors.
Introduction to Deep Insight Analysis for RTOS Based Applications
Debugging can consume over 40% of a development cycle, and Jacob Beningo argues RTOS projects need more than breakpoints and assertions. He presents deep insight analysis as a trio of techniques—RTOS-aware debugging, run-time analysis, and profiling with coverage—that expose what the system is actually doing. These methods help engineers cut guesswork and speed verification of complex embedded applications.
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.
Tenderfoot: Embedded Software and Firmware Specialties
This post revisits an earlier Stack Overflow answer and breaks embedded firmware into practical specialties, from assembly optimization and device drivers to DSP, IoT networking, security, UI, and systems architecture. It outlines the core skills, tools, and math each specialty demands, and explains how product constraints and industries shape those roles. Newcomers get clear guidance on where to focus their learning and career development.
Embedded Toolbox: Source Code Whitespace Cleanup
Trailing whitespace and mixed end-of-line conventions can silently break preprocessing or bloat diffs, yet they are invisible in editors. QClean is a tiny, blazingly fast CLI utility that removes trailing spaces, normalizes EOLs, replaces tabs with spaces, and optionally flags long lines. It runs cross-platform or as a native binary in qtools/bin and is easy to customize and rebuild for your workflow.
Embedded Toolbox: Windows GUI Prototyping Toolkit
You can prototype and debug complex embedded device user interfaces on Windows using the tiny, free QWin toolkit. It runs the same C code you compile for the target by implementing a Windows BSP, letting you develop UI code quickly with MinGW or Visual C++ and a visual resource editor. The result is far faster compile-run-debug cycles and a simpler path around flaky prototype hardware.
Getting Started With Zephyr: Devicetrees
This blog post provides an introduction to the "Devicetree", another unique concept in The Zephyr Project. We learn about the basic syntax of a device tree and how its structure and hierarchy mirror hardware, from the SoC to the final board. We also see how hardware described in a devicetree can be referenced and controlled in the source code of a Zephyr-based application.
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.
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.
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.
Reverse engineering wireless wall outlets
Fabien Le Mentec reverse engineers a cheap set of wireless wall outlets to add them to his BANO home automation while avoiding uncertified mains hardware. He uses PCB inspection to identify a Holtek MCU and RF83C, captures 433.92 MHz OOK signals with an RTL-SDR and ookdump, then replays commands using an RFM22 in direct mode controlled by an ATmega328P. The post explains frame structure and links to a working GitHub implementation.
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.
Interfacing LINUX with microcontrollers
Fabien presents a practical pattern: put Internet- facing logic on a Linux board and keep time-critical I/O on a microcontroller, using a Raspberry Pi and a Teensy 3.0. He introduces MASL, a reusable userspace library that hides master-slave details and shows how to use userspace SPI, sysfs GPIO and epoll for programming, reset and event-driven signaling with working code examples.
10 Software Tools You Should Know
Unless you're designing small analog electronic circuits, it's pretty hard these days to get things done in embedded systems design without the help of computers. I thought I'd share a list of software tools that help me get my job done. Most of these are free or inexpensive. Most of them are also for working with software. If you never have to design, read, or edit any software, then you're one of a few people that won't benefit from reading this.
Disclaimer: the "best" software...
Embedded Toolbox: Programmer's Calculator
A tiny but powerful cross-platform tool, QCalc evaluates full C-syntax expressions so you can paste results straight into firmware. It handles bitwise ops, mixed hex/decimal/binary constants, and scientific math, and it automatically shows integer results in formatted hex and binary. The post explains key features, variable handling, error messages, and how to run qcalc.tcl with the wish Tk interpreter.
OOKLONE: a cheap RF 433.92MHz OOK frame cloner
Fabien Le Mentec built a pocket device that listens to and clones 433.92MHz OOK frames, automating the tedious reverse engineering of cheap wireless outlets. The prototype uses a Moteino with an RFM69 to sample demodulated OOK data, stores pulse durations in SRAM, and replays frames; the code and hardware notes are available on GitHub along with limitations and next steps.
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.
Tenderfoot: Embedded Software and Firmware Specialties
This post revisits an earlier Stack Overflow answer and breaks embedded firmware into practical specialties, from assembly optimization and device drivers to DSP, IoT networking, security, UI, and systems architecture. It outlines the core skills, tools, and math each specialty demands, and explains how product constraints and industries shape those roles. Newcomers get clear guidance on where to focus their learning and career development.
Understanding Microchip 8-bit PIC Configuration
The second post of a five part series picks up getting started developing with Microchip 8-bit PIC Microcontroller by examining the how and why of processor configuration. Topics discussed include selecting the oscillator to use during processor startup and refining the configuration once the application starts. A walk through of the code generated by the Microchip IDE provides a concrete example of the specific Configuration Word and SFR values needed to configure the project specific clock configuration.
Designing Embedded System with FPGA - 1
Getting an embedded system running on an FPGA is much simpler than it sounds when you use Xilinx EDK and a soft processor. Pragnesh Patel walks through a beginner-friendly approach using the MicroBlaze CPU, drag-and-drop IP cores, and a Spartan-3E starter kit so you can assemble peripherals without deep VHDL knowledge. The post focuses on the EDK base system builder and first setup steps to generate a working design.
C++ Assertion? Well Yes, But Actually No.
Assertions are a double-edged sword - on one side you enforce program correctness catching bugs close to their origin, on the other your application is subject to run-time error, like any interpreted language. This article explores what C++ can offer to get the advantages of assertions, without risking the crashes by moving contract checking at compile time.
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.
Cutting Through the Confusion with ARM Cortex-M Interrupt Priorities
ARM Cortex-M interrupt priorities are famously confusing because numeric priority values are inverted relative to urgency and several different conventions coexist. This post cuts through the mess by explaining NVIC register bit placement, the CMSIS NVIC_SetPriority convention, preempt versus subpriority grouping, and when to use PRIMASK or BASEPRI. Read on for practical rules to avoid subtle priority bugs in real-time firmware.
Getting Started With Zephyr: Devicetrees
This blog post provides an introduction to the "Devicetree", another unique concept in The Zephyr Project. We learn about the basic syntax of a device tree and how its structure and hierarchy mirror hardware, from the SoC to the final board. We also see how hardware described in a devicetree can be referenced and controlled in the source code of a Zephyr-based application.
NULL pointer protection with ARM Cortex-M MPU
This post explains how you can set up the ARM Cortex-M MPU (Memory Protection Unit) to protect thy code from dragons, demons, core dumps, and numberless other foul creatures awaiting thee after thou dereference the NULL pointer.
New book on Elliptic Curve Cryptography
New book on Elliptic Curve Cryptography now online. Deep discount for early purchase. Will really appreciate comments on how to improve the book because physical printing won't happen for a few more months. Check it out here: http://mng.bz/D9NA
