Data Hiding in C
You can get C++-style data hiding in plain ANSI C, Stephen Friederichs demonstrates how with a FIFO stack example. He shows opaque pointer typedefs to hide struct layouts, const-qualified handles to catch accidental writes, static file-local functions for private helpers, and a canary field to detect tampering. The pattern keeps the public header stable while letting you change implementations behind the scenes.
Chebyshev Approximation and How It Can Help You Save Money, Win Friends, and Influence People
Are expensive math libraries or huge lookup tables eating CPU and flash on your microcontroller? In this practical guide Jason Sachs shows how Chebyshev polynomial approximation (with range reduction, splitting, and small interpolated tables) can give near-minimax accuracy while using far less code and runtime. The post compares Taylor series, plain and interpolated tables, and explains how to fit empirical sensor data and evaluate coefficients efficiently.
Welcome to my life!
Self-employed embedded engineer Morten Dramstad mixes industrial microcontroller work with hands-on hobbies and community projects. He describes AVR-based livestock automation, a current LPC1788 Cortex-M3 project and practical compiler choices like Keil and Imagecraft. Outside engineering he restores a 1952 AJS, built an electronic injection prototype on a Motorola 68HC16, trains for a private pilot license, and runs DMX512 workshops at his church.
10 Software Tools You Should Know
Embedded work gets a lot easier when you have the right software stack, and Jason Sachs lays out the tools he leans on every day. From revision control and file comparison to build systems, scripting, analysis, documentation, QA, and command-line utilities, he focuses on practical picks that save time and reduce mistakes. The list is opinionated, but it is full of the kind of workflow advice that helps engineers stay productive.
Lightweight hardware abstraction
Hardware pin reassignments turned a small firmware tweak into a tangled mess of #ifdefs and scattered port references. Gene Breniman shows how a lightweight hardware abstraction, implemented with per-board include headers and meaningful macros like MODE_LED and LED_ON, cleans up the code and makes it easy to target multiple prototypes. The post emphasizes keeping changes local to configuration headers to reduce validation scope and maintenance.
Embedded Software Creation II - European Normative & Legislation
If you are building a product for the European market, standards and directives can determine whether it can legally ship with a CE mark. Maykel Alonso breaks down how European normative and legislation fit together, what “New Approach” and “Global Approach” mean, and which directives commonly affect embedded products. The post also points engineers to the Official Journal of the European Union and a useful directive reference table.
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.
Modulation Alternatives for the Software Engineer
Jason starts with a hardware curiosity, the 7497 synchronous rate multiplier, and turns it into a practical lesson for firmware engineers. He contrasts conventional PWM with a simple accumulator-based method called "synthetic division," showing how it implements first-order delta-sigma behavior in software. The post explains when to pick PWM or delta-sigma and why the accumulator trick can give higher effective resolution at low update rates.
C++ on microcontrollers 3 – a first shot at an hc595 class with 8 output pins
A simple HC595 wrapper turns into a nice C++ lesson in how to build reusable I/O abstractions for microcontrollers. Wouter van Ooijen shows how to expose all eight shift-register outputs as regular output pin objects, then generalizes the same pattern to MCU ports and even daisy-chained HC595 chips. Along the way, he runs into a classic class dependency problem and resolves it with forward declarations and out-of-class method definitions.
A true pioneer passes away... A farewell to Ritchie.
Dennis Ritchie's work on C and UNIX quietly shaped the tools we use every day. Gene Breniman recalls becoming a convert after reading Kernighan and Ritchie's The C Programming Language and how C replaced assembly in his embedded projects. This personal farewell explains why K&R remains a near-biblical reference for many engineers and why Ritchie's influence still matters.
[ C Programming Techniques: integer type optimization ]
Microcontroller integer width can make or break ISR performance on AVR. In this post Fabien Le Mentec compares using uint8_t versus unsigned int for a timer counter on an ATmega328P and shows how the smaller type cuts instruction and cycle count in the ISR. He also walks through the trade offs: reduced capacity, volatile access costs, and simple portability fixes such as uint_fast8_t or an architecture-aware typedef.
Tenderfoot: Introduction to Magic (Numbers that is...)
A source-code review revealed repeated numeric literals in C, exposing the classic problem of magic numbers in embedded software. This post explains what magic numbers are, why they are especially painful in firmware, and simple fixes using named constants and comments tied to specs. Read this if you want clearer, safer embedded C code and fewer surprises during maintenance.
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.
Vala applications on Embedded Linux: maybe a clever choice [part 1]
If you need a high-level language for constrained embedded Linux devices, Vala is worth a look. It compiles to C and relies mainly on GLib, giving you native performance and minimal runtime dependencies. With reference counting instead of a garbage collector, modern language features, and a small storage footprint, Vala can outperform Python, Java, or Qt on low-RAM, low-storage boards. This first part focuses on dependencies, ABI compatibility, runtime characteristics, and a real-world example.
Favorite Tools: C++11 std::array
Firmware teams that avoid malloc or new need safer alternatives, and this post makes a strong case for C++11 std::array as that alternative. It highlights zero-overhead, type-safe, compile-time buffers and points to an ESP32 LED-strip demo where NUM_PIXELS_ fixes RAM usage at build time. Read it to see std::array used with std::rotate, passed to C libraries via data(), and as a low-risk path to std::vector later.
Embedded Software Creation II - European Normative & Legislation
If you are building a product for the European market, standards and directives can determine whether it can legally ship with a CE mark. Maykel Alonso breaks down how European normative and legislation fit together, what “New Approach” and “Global Approach” mean, and which directives commonly affect embedded products. The post also points engineers to the Official Journal of the European Union and a useful directive reference table.
Short Circuit Execution vs. Unit Testing
Short-circuit evaluation in C can make perfectly logical code behave differently than you expect, especially during unit testing. Stephen Friederichs walks through a simple if statement where a conditional function is never called because of short-circuiting, causing surprising test failures and hidden side effects. He shows why stubs reveal the issue and recommends using a temporary variable to ensure the call always occurs.
Product quality: belief or proof?
Embedded software development is a challenging activity, so it is essential to have tools and IP that is of the best quality. However, assessing that quality can be, in itself, a challenge.
Size matters - System success depends on initial design
A seemingly small UI choice can reshape an entire embedded system. Gene Breniman uses a real product example to show how picking a graphic touchscreen instead of a character LCD can multiply CPU, memory, OS, and licensing needs. The post explains why capturing requirements early and planning for growth paths keeps complexity and cost under control, and how to size hardware to fit real needs.
Embedded Software Creation I - Methodologies
Maykel Alonso lays out the principal methodologies used to build embedded software, from cascade and incremental to iterative and spiral. The post walks through common stages, including requirements, analysis, design, implementation, integration, testing and maintenance, and highlights when each model fits firmware projects. Read this for a practical lens on picking a development approach that matches hardware constraints and regulatory demands.
Can an RTOS be really real-time?
Real-Time Operating Systems are meant for real-time applications. But with conventional shared-state concurrency and blocking, can you honestly know the worst-case execution time of an RTOS thread?
Thumb Rules for Effective Meetings
Too many meetings waste engineers' time while too few kill communication, and Kunal Singh proposes seven practical thumb rules to fix both extremes. He outlines how to identify meeting types, publish and stick to an agenda, clarify roles, eliminate ambiguity, conclude items or mark them open, and circulate minutes. These simple practices help make meetings concise, accountable, and decision-oriented.
Tracing code and checking timings
When you cannot afford logs or to stop the CPU, GPIO toggles become a powerful real-time tracer. Richard shows how driving IO pins and watching them with an oscilloscope or logic analyzer reveals control flow, function timings, and ISR activity with very little overhead. He also explains using direct port writes and conditional compilation to keep measurements noninvasive and easy to enable or disable.
Who needs source code?
Many developers feel that the supplying source code is essential for licensed software components. There are other perspectives, including the possibility of it being an actual disadvantage. Even the definition of source code has some vagueness.
A true pioneer passes away... A farewell to Ritchie.
Dennis Ritchie's work on C and UNIX quietly shaped the tools we use every day. Gene Breniman recalls becoming a convert after reading Kernighan and Ritchie's The C Programming Language and how C replaced assembly in his embedded projects. This personal farewell explains why K&R remains a near-biblical reference for many engineers and why Ritchie's influence still matters.
Remember Y2K?
There was fear that the turn of the century at the end of 1999 would cause problems with many embedded systems. There is evidence that the same issue may occur in 2038.
Building Linux Kernel for Desktops
Kernel building for desktop Linux is less daunting than it used to be. In this short primer Kunal Singh introduces the distribution-specific tools and procedures that simplify compiling a desktop kernel, with focused pointers for Fedora, Ubuntu, and SUSE. Engineers will get a quick overview of where to start and which tools each distribution provides to streamline a custom kernel build.
Embedded Software Creation I - Methodologies
Maykel Alonso lays out the principal methodologies used to build embedded software, from cascade and incremental to iterative and spiral. The post walks through common stages, including requirements, analysis, design, implementation, integration, testing and maintenance, and highlights when each model fits firmware projects. Read this for a practical lens on picking a development approach that matches hardware constraints and regulatory demands.
Software Prototyping
Software prototypes can save a lot of pain during bring-up, and Gene Breniman argues they deserve a place in the development process. He revisits an earlier post, then points readers to Jack G. Ganssle’s article on creating software prototypes, where test code becomes the model for the real product software. It is a short but practical reminder that early code can do more than just validate hardware.
“Smarter” cars, unintended acceleration – and unintended consequences
Smarter cars are arriving fast, but the software tricks behind them may be creating new safety and compliance risks. This post connects Tesla’s autopilot, the VW emissions scandal, and a reported Porsche throttle-delay case to ask whether automotive standards and regulations are keeping pace with increasingly intelligent vehicle control systems.
