Arduino robotics #4 - HC-SR04 ultrasonic sensor
Lonnie Honeycutt shows how to turn a $50 mobile platform into a simple autonomous robot by adding an HC-SR04 ultrasonic sensor to an Arduino. The post walks through wiring, a minimal test sketch and the integration code used on Clusterbot, plus practical tips on range limits, motor choices and library options to make obstacle avoidance reliable for hobby builds.
Arduino robotics #3 - wiring, coding and a test run
Lonnie Honeycutt walks through wiring, coding, and the first test run of Clusterbot, a budget Arduino robot build costing about $50. The post provides a clear pin-mapping to the TB6612FNG motor driver, ready-to-upload Arduino movement functions, and practical tips like tinning thin battery wires. You also get PWM calibration values and the measured RPM timing the author used to make reliable turns.
Introduction to Microcontrollers - More Timers and Displays
Mike Silva walks through using a single hardware timer to create the illusion of parallel tasks, combining a millisecond tick, deadline checks, and a cyclic executive to run time-driven and event-driven work. He shows safe deadline code that handles timer rollover and ISR races, and provides practical STM32 examples including SysTick-driven delays, atomic GPIO BSRR writes for LCD control, and a button-driven display demo.
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.
Ada 2012 for ARM M3/M4 Released for Download
AdaCore's initial Ada 2012 port for ARM Cortex M3/M4 is now downloadable, and Mike Silva walks it through a hands-on demo on an STM32F4 Discovery board. He shows an Ada-written LCD driver, LED multitasking, and how Ada language features like Ada.Realtime, array slices, and unchecked conversions make low-level GPIO and timing code clearer and safer. The post highlights atomic BSRR GPIO writes and Ravenscar runtime details.
Handling latency in data acquisition systems
In recent projects, I found myself working with data acquisition systems. For instance: PCIe/10GbE readouts for 2D XRay detectors (RASHPA slides, RASHPA paper) instruments mixing 1D signal acquisition and triggering, microcontroller based system for audio transmission: (NRF spearker)
Getting Started With CUDA C on an Nvidia Jetson: Hello CUDA World!
In this blog post, I introduce CUDA, which is a framework designed to allow developers to take advantage of Nvidia's GPU hardware acceleration to efficiently implement certain type of applications. I demonstrate an implementation to perform vector addition using CUDA C and compare it against the traditional implementation in "regular" C.
How to use SPI devices in NuttX RTOS
You can get an SPI sensor running on NuttX in minutes by following a concrete RP2040 example. This post walks through the board glue code, Makefile and header edits, menuconfig settings, wiring, and flash steps needed to register a MAX6675 thermocouple on a Raspberry Pi Pico. Read it to learn where to add board-level code, enable drivers, and test the device from NSH.
Essential Elements to choose a right Processor
Choosing the right processor can feel overwhelming, especially after a project with many viable parts. In this post Sathyanarayana Hadadi condenses practical criteria into a usable checklist for embedded designers, covering speed, hardware accelerators, peripherals, memory, power, security, availability, and tooling. Read on to turn a long shortlist into a confident selection and avoid costly redesigns.
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.
Using (Apache) NuttX USERLED Subsystem
Controlling an LED with raw GPIO works, but NuttX's USERLED subsystem makes it cleaner and portable. This post walks through enabling the LED driver in menuconfig, mapping the RaspberryPi Pico LED in the board files, and using the /dev/userleds device with printf to set up to 32 LEDs with a single write. It finishes with a hands-on challenge to expand the setup to eight LEDs on a breadboard.
Using (Apache) NuttX Buttons Subsystem
You do not need to poke GPIO registers to read switches in NuttX, the OS provides a Buttons subsystem that delivers named events, multi-button support, and optional software debouncing. This post walks through wiring two breadboard buttons on a Raspberry Pi Pico, enabling the input and buttons drivers via menuconfig, building nuttx.uf2, and testing the buttons over the usbnsh serial console. It highlights why a simple hardware debounce is still a good idea.
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.
Getting Started With Embedded Linux - From Nothing To A Login Prompt
This hands-on guide shows how to go from a blank board to a bootable embedded Linux system using Yocto and Docker. Follow the steps to build a reproducible Yocto environment, fetch Toradex manifests, set MACHINE to verdin-imx8mm, run bitbake, and produce the .wic.bmap image ready to flash. Ideal for engineers wanting a concise bringup path for a Verdin iMX8M Mini on a Dahlia carrier.
How to Design Reliable Reset Circuits for Embedded Microcontrollers
In the world of embedded systems, the reset circuit is a critical component that ensures the microcontroller starts up correctly and recovers gracefully from unexpected events like power fluctuations or software crashes. A poorly designed reset circuit can lead to erratic behavior, system lockups, or even permanent damage to the microcontroller. For embedded engineers, designing a reliable reset circuit is essential for ensuring the stability and robustness of the system.
Using GPIO in (Apache) NuttX RTOS
Blinking an LED is the embedded Hello World, and this tutorial walks through using GPIOs on NuttX running on a Raspberry Pi Pico. It shows how to enable the GPIO driver and example in menuconfig, build and flash the nuttx.uf2, and use NSH gpio device files to read and write pins. The post also explains polling versus interrupt-driven inputs and the pull-up/edge setup needed for button interrupts.
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 Microchip PIC 8-bit Interrupts
This fifth and final post of the Getting Started with Microchip PIC 8 Bit Development series looks at interrupts on 8-bit PIC microcontrollers. After a review of basic interrupt functionality, an actual implementation is explored with the development of a four bit counter driven via Timer0 interrupts whose value is displayed through four LEDs on Microchip's Curiosity HPC Development Board.
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.
Embedded Systems - free EdX course by UT-Austin!
Lonnie shares a free edX Embedded Systems course from UT Austin that teaches hands-on firmware using the TI Tiva Launchpad. The class centers on practical projects, culminating in an arcade-style shooter built with an 80 MHz ARM Cortex-M4 board and inexpensive peripherals like the Nokia 5110 display. It’s a low-cost path to move from hobby tools to industry-style microcontroller development.
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).
Metal detection: building the detector
Fabien Le Mentec turns a bench-validated BFO stage into a field-ready metal detector using scavenged parts and straightforward fabrication. He moves the circuit from breadboard to a through-hole prototyping PCB, swaps the Arduino Nano for a lower-power Mini, and builds an ABS control box with buttons and a buzzer. The build uses a 2S LiPo pack with a 5V LDO and a nonmagnetic coil mount, with practical notes on tradeoffs and safety.
Get your microcontroller and PC to talk
Projects often need a quick PC interface for an otherwise standalone microcontroller, but learning VB or Visual C++ can feel like overkill. Jayaraman Kiruthi Vasan shows how Processing, an open source, C like environment with serial and Arduino libraries, gives embedded engineers a fast, low friction way to build GUIs and COM links to chips like the 8051 and Renesas R8C. The post promises a hands on example connecting Processing to a 8051.
When a Mongoose met a MicroPython, part I
This is more a framework than an actual application, with it you can integrate MicroPython and Cesanta's Mongoose.
Mongoose runs when called by MicroPython and is able to run Python functions as callbacks for the events you decide in your event handler. The code is completely written in C, except for the example Python callback functions, of course. To try it, you can just build this example on a Linux machine, and, with just a small tweak, you can also run it on any ESP32 board.
