Arduino robotics #1 - motor control
Clusterbot is Lonnie Honeycutt's first autonomous robot, built on a tight budget to teach practical motor control. This post explains why you cannot drive motors directly from an Arduino, how to wire and enable the Toshiba TB6612FNG motor driver, and offers hands-on PWM and calibration tips for getting smooth motion from cheap Mabuchi FA-130 toy motors.
Introduction to Microcontrollers - Adding Some Real-World Hardware
Two blinking LEDs only teach you so much, so Mike designed a docking board that adds a 4x20 HD44780 LCD, a 4x4 button matrix, four LEDs, DIP switches and an ADC potentiometer for AVR and STM32 experiments. This post shows how to wire and drive the HD44780 in 4-bit mode, calibrate microsecond and millisecond software delays, use the busy flag to speed writes, and includes AVR example code to get the display running.
Introduction to Microcontrollers - Timers
Time is everything in embedded systems, and Mike Silva walks through how microcontroller timers turn clock pulses into dependable events. He covers prescalers, counter bit widths, overflow versus compare modes, atomic multi-byte register access, the "-1 rule", input capture and compare leapfrogging, with concrete AVR and STM32 code that highlights common pitfalls and reliable patterns for precise ticks.
Introduction to Microcontrollers - More On Interrupts
Interrupts are powerful but dangerous, and Mike Silva breaks down how they actually behave on microcontrollers and why they can corrupt data. This post explains latched flags, pending and priority behavior, ISR nesting, and common read-modify-write hazards, then shows practical fixes like targeted interrupt masking and using atomic GPIO hardware so you can stop chasing sporadic bugs.
Introduction to Microcontrollers - Interrupts
Interrupts are not magic, they are the practical tool that lets a microcontroller respond in microseconds while still doing background work. This introduction explains what an interrupt and an ISR are, how return addresses and CPU state are saved, and why ISRs must be short and carefully written. AVR and STM32 external-interrupt examples show real configuration steps and key gotchas to watch for.
Introduction to Microcontrollers - More On GPIO
Polarity matters: an output '1' does not always mean an LED lights, and inputs are just as picky. This post walks through LED driving basics, pull resistors for buttons, and practical bitwise techniques to read and write individual GPIO pins on AVR and STM32 boards. It also explains why polling rates and mechanical bounce make button handling trickier than it looks and what to watch for next.
Introduction to Microcontrollers - Hello World
Mike Silva walks through the classic embedded hello world by blinking an LED on both an AVR and an STM32. The tutorial covers GPIO configuration, bit manipulation, simple software delay loops, and common pitfalls such as compiler optimizations that can remove empty delays unless you use volatile. Practical wiring tips and debugging advice with a scope make this an ideal first lab for embedded engineers.
Introduction to Microcontrollers - Further Beginnings
Mike Silva walks through the CPU plumbing every embedded engineer needs to know before writing their first LED blinky. The post explains registers (data, address, stack pointer, link), the fetch-execute cycle, and the main instruction classes such as arithmetic, logic, shifts, branches, and call/return mechanics. Read this to see how C maps to CPU operations and why stack versus link register choices matter.
Introduction to Microcontrollers - Beginnings
Mike Silva's beginner tutorial series walks through core microcontroller concepts and practical steps to get started, from wiring an LED blinky to understanding startup code. He compares embedded and desktop programming, explains why C and assembly matter, and introduces AVR and STM32 Cortex-M3 toolchains and hardware. Expect clear examples, no-nonsense tool advice, and the essential hardware knowledge to move from simulator to a real board.
Intro to Microcontrollers Part 2: AVR Microcontrollers
This follow-up explores getting an AVR Dragon working with an ATtiny24A, covering the necessary cables, BOM choices, and Atmel Studio setup. It walks through firmware updates, an ADC-based internal temperature sensor example using reduced-noise ADC and ISR handling, and practical debugging tips including debugWire versus ISP and high-voltage recovery. Expect candid hardware caveats like weak drive strength and 5V power quirks.
Five Embedded Linux Topics for Newbies !
Are you an embedded systems enthusiast looking to broaden your horizons with embedded Linux? explore those 5 topics.
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.
Picowoose: The Raspberry Pi Pico-W meets Mongoose
This example application describes the way to adapt the George Robotics CYW43 driver, present in the Pico-SDK, to work with Cesanta's Mongoose. We are then able to use Mongoose internal TCP/IP stack (with TLS 1.3), instead of lwIP (and MbedTLS).
Absolute Beginner's Guide To Getting Started With Raspberry Pi
Getting started with Raspberry Pi can feel overwhelming. This guide strips the noise and shows the simplest path from unboxing to a working desktop. It recommends buying a preloaded NOOBS microSD to avoid imaging hassles, lists exact parts and suppliers, and walks through booting, recovery, and making a backup. If you want embedded electronics it also lists starter parts and ESD safety tips.
Introduction to Microcontrollers - Buttons and Bouncing
Mechanical buttons lie to your microcontroller, producing bounces and occasional noise that look like multiple presses. Mike Silva walks through practical ways to represent buttons, simple and robust software debounce strategies, and how to convert states into single-use events. The post includes ready-to-use C patterns: N-sample filters, shift-accumulator filtering, per-button data structures, and keypad debouncing examples.
Coding Step 1 - Hello World and Makefiles
Stephen Friederichs walks through compiling a C Hello World using GCC on Windows, then shows how a simple makefile can automate the process. You will see how output naming, project layout, and makefile targets work, and learn dependency rules based on timestamps plus how to force rebuilds with clean and FORCE targets. This is a practical first step to escape the IDE and use Unix-style build tools.
Real-time clocks: Does anybody really know what time it is?
Most RTC chips still expose calendar fields rather than seconds-since-epoch, forcing embedded engineers to write ugly conversion code. Jason Sachs makes the case for offset encoding, subseconds, and an explicit snapshot feature to simplify interval math, raise precision, and avoid rare timing bugs. Read this practical take on RTC trade-offs and a short wishlist for chip makers.
Introduction to Microcontrollers - Further Beginnings
Mike Silva walks through the CPU plumbing every embedded engineer needs to know before writing their first LED blinky. The post explains registers (data, address, stack pointer, link), the fetch-execute cycle, and the main instruction classes such as arithmetic, logic, shifts, branches, and call/return mechanics. Read this to see how C maps to CPU operations and why stack versus link register choices matter.
Introduction to Microcontrollers - More On Interrupts
Interrupts are powerful but dangerous, and Mike Silva breaks down how they actually behave on microcontrollers and why they can corrupt data. This post explains latched flags, pending and priority behavior, ISR nesting, and common read-modify-write hazards, then shows practical fixes like targeted interrupt masking and using atomic GPIO hardware so you can stop chasing sporadic bugs.
Getting Started With Zephyr: Writing Data to EEPROM
In this blog post, I show how to implement a Zephyr application to interact with EEPROM. I show how the Zephyr device driver model allows application writers to be free of the underlying implementation details. Unfortunately, the application didn't work as expected, and I'm still troubleshooting the cause.
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.
How to Arduino - a video toolbox
Lonnie Honeycutt is kicking off a practical Arduino video series aimed at hobbyists who want the fastest, simplest way to get things working. The first few lessons cover the Arduino IDE, breadboards, a 16x2 LCD, servos, potentiometers, and analogRead. He also shares a behind-the-scenes look at his multi-camera filming setup and how it helps him focus on the project instead of the shot.
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.
Getting Started With Zephyr: West Manifest Customization
Create a reproducible Zephyr development baseline by customizing a West manifest, so your team avoids surprises from upstream changes. This post walks through forking Zephyr and MCUBoot when you need local changes, adapting Nordic Semiconductor's west.yml as a template, and updating remotes and defaults to point at your forks. Finish by running west init -m
Coding Step 2 - Source Control
Version control felt unnecessary to Stephen Friederichs when he was starting out, but this article shows why Git quickly becomes essential even for solo firmware work. He walks through installing Git on Windows, creating a repository for a simple Hello World project, making the first commit, and using reset to recover from a broken build. The post also captures a few early habits that save a lot of pain later, like committing often and keeping important files under source control.
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.
How to make a heap profiler
A heap profiler is surprisingly simple to build, and Yossi Kreinin walks through a compact working example called heapprof. The post shows how to intercept malloc/free, stash per-allocation metadata and call stacks into heap chunks, dump memory on crash or via JTAG, and map return addresses to source lines with addr2line or gdb. It also covers practical bootstrapping tricks for platforms without standard libc support.
Arduino robotics #2 - chassis, locomotion and power
Lonnie Honeycutt walks through building Clusterbot's round differential-drive chassis, showing how a circular base and Tamiya gearbox simplify turning and torque tradeoffs. The post covers motor selection, wheel fit, balance issues, and a practical two-battery power arrangement with VMOT for the motors and a separate 9V for the Arduino. Expect hands-on tips and lessons learned from a first-time robot build.
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.
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.
