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.
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.
A simple working I2C (TWI) level shifter
When interfacing 3.3V and 5V boards, Dr Cagri Tanriover shows a no-fuss MOSFET solution to keep I2C talking across voltages. The post walks through using the NXP MOSFET level-shifter idea with BS170 transistors and 10 kΩ pull-ups, notes it ran at 400 kbps for his setup, and includes a quick four-step test to verify the build before connecting microcontrollers.
MSP430 LaunchPad Tutorial - Part 4 - UART Transmission
Want to stream sensor or debug data from an MSP430 LaunchPad to a PC or Bluetooth module? Enrico swaps in an MSP430G2553 and shows how to configure SMCLK, P1 pin multiplexing, and UCA0 baud/dividers (with modulation) to approximate 115200 baud. The post also walks through interrupt-driven RX/TX handling and a low-power wait loop that sends a "Hello World" reply on demand.
Android Vs Embedded system
Android@Home and the ADK open a fast path to add rich UIs, multimedia, networking, and databases to embedded projects by leveraging phones, tablets, or dedicated Android boards. This post outlines the main benefits of using Android as a front end or as a full embedded OS, explains two integration approaches, and points to BeagleBoard as an affordable single-board option for one-platform designs.
Endianness and Serial Communication
A single wrong byte order can cost you a day of debugging, and Stephen Friederichs walks through how to avoid that when sending multi-byte data over a byte-oriented serial link. He demonstrates an ATmega328P sending 16-bit ADC readings, capturing raw bytes with RealTerm, and plotting with Octave, showing how swapped endianness can produce plausible but incorrect results. The post gives practical steps to capture, test, and verify byte order.
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.
A Working Real Time Clock (RTC) Implementation
When the GPRS modem would not provide network time, Dr Cagri Tanriover implemented a compact hardware real time clock using the NXP PCF8523T. The post highlights why automatic backup switching, I2C integration, BCD register handling, and alarm/timer features matter for embedded timestamps. It also shows battery-life math with a CR1225 and offers practical build notes after an initial ESD-related failure.
Help, My Serial Data Has Been Framed: How To Handle Packets When All You Have Are Streams
Framing byte streams is easier to get wrong than you think, and a bad scheme can leave your embedded device acting on the wrong packet. Jason Sachs walks through common plaintext and binary framing approaches, explains why CRCs alone can still permit false resynchronization, and demonstrates COBS as a simple, low-overhead byte-stuffing method that prevents delimiter collisions and guarantees resynchronization.
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.
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.
Optimizing Real-Time Operating Systems for Efficient Edge Devices
Edge devices need real-time responsiveness but run on tight CPU, memory, and power budgets. This post breaks down what an RTOS brings to the edge: deterministic task scheduling, lean memory management, protocol support, and modular scalability, then tackles common challenges like synchronization and security. Read it for practical best practices on scheduling and protocols plus a look at future trends such as edge AI integration and interoperable infrastructure.
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.
NXP LPC17xx/40xx: Decoding the Part ID
Richard Bennett explains how the LPC17xx/40xx part ID is not a simple model number but a packed set of capability flags. The post shows how to call the NXP IAP routine at 0x1FFF1FF1 with command 54 to read the part ID, and how to decode family, group, RAM, flash and feature bits with shifts and masks, including the important interrupt-disable gotcha.
Lightweight C++ Error-Codes Handling
The traditional C++ approach to error handling tends to distinguish the happy path from the unhappy path. This makes handling errors hard (or at least boring) to write and hard to read. In this post, I present a technique based on chaining operations that merges the happy and the unhappy paths. Thanks to C++ template and inlining the proposed technique is lightweight and can be used proficiently for embedded software.
An Iterative Approach to USART HAL Design using ChatGPT
Discover how to leverage ChatGPT and an iterative process to design and generate a USART Hardware Abstraction Layer (HAL) for embedded systems, enhancing code reusability and scalability. Learn the step-by-step journey, improvements made, and the potential for generating HALs for other peripherals.
Using a board with NuttX RTOS as an RS-485 / Modbus Slave Device
This practical walk-through shows how to turn a NuttX-equipped board into an RS-485 Modbus RTU slave using a cheap MAX485 transceiver and an STM32F4Discovery board. It explains why a simple UART plus a GPIO for DE/RE is enough, why the RP2040 needs special handling, and gives step-by-step configuration in NuttX, wiring for the transceiver, and a quick test using FreeModbus and mbpoll.
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.
Project Log: Pixelblaze Christmas Lights
Festive fun and the hacker spirit combine in my janky attempt to adorn my house with addressable LEDs! In this post, I show you how I used a Pixelblaze and a cheap strip of WS2811 RGB LEDs (and not a little bit of hot glue and paper clips) to make a super cool set of Christmas lights.
A simple working I2C (TWI) level shifter
When interfacing 3.3V and 5V boards, Dr Cagri Tanriover shows a no-fuss MOSFET solution to keep I2C talking across voltages. The post walks through using the NXP MOSFET level-shifter idea with BS170 transistors and 10 kΩ pull-ups, notes it ran at 400 kbps for his setup, and includes a quick four-step test to verify the build before connecting microcontrollers.
When a Mongoose met a MicroPython, part II
In the first part of this blog, we introduced this little framework to integrate MicroPython and Cesanta's Mongoose; where Mongoose runs when called by MicroPython and is able to run Python functions as callbacks for the events you decide in your event handler. Now we add MQTT to the equation, so we can subscribe to topics and publish messages right from MicroPython.
Bellegram, a wireless DIY doorbell that sends you a Telegram message
A wireless button that uses the M5 STAMP PICO and Mongoose to send a Telegram message when pressed. The code is written in C
How 5G impacts future IoT development
The Internet of Things (IoT) applications are ubiquitous today. IoT is used in almost every industrial, commercial, and consumer market segment, including autonomous driving, smart factories, automation and preventive maintenance, smart homes, smart cities, security, asset tracking, supply chain management, agriculture, farming, healthcare, smart medicine and remote surgery, augmented reality applications, activity monitoring, and more. The three most promising uses of IoT are smart manufacturing, autonomous driving, and healthcare, particularly remote surgery.
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.
VolksEEG Project: Initial Hardware Architecture
The VolksEEG prototype pairs an Adafruit Feather nRF52840 Sense MCU with an ADS1299 analog front end, organized into non-isolated and isolated domains to protect patients. The post explains why isolation is required, which chips bridge the domains, and why simple, high-level power and signal diagrams help clarify the KiCad schematics for engineers and reviewers.
Using a board with NuttX RTOS as an RS-485 / Modbus Slave Device
This practical walk-through shows how to turn a NuttX-equipped board into an RS-485 Modbus RTU slave using a cheap MAX485 transceiver and an STM32F4Discovery board. It explains why a simple UART plus a GPIO for DE/RE is enough, why the RP2040 needs special handling, and gives step-by-step configuration in NuttX, wiring for the transceiver, and a quick test using FreeModbus and mbpoll.
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.
Optimizing Real-Time Operating Systems for Efficient Edge Devices
Edge devices need real-time responsiveness but run on tight CPU, memory, and power budgets. This post breaks down what an RTOS brings to the edge: deterministic task scheduling, lean memory management, protocol support, and modular scalability, then tackles common challenges like synchronization and security. Read it for practical best practices on scheduling and protocols plus a look at future trends such as edge AI integration and interoperable infrastructure.
Designing IoT Wireless Sensor Nodes
Mahesh Balan outlines practical strategies for building tiny IoT wireless sensor nodes that run on harvested energy. The post explains using small solar cells with coin-cell or supercapacitor buffering, pairing sensors with Bluetooth Low Energy for short-range telemetry, and choosing PMICs with ultra-low quiescent and startup power. A Cypress PMIC example shows operation can be sustained under low-brightness conditions near 100 lx.
The Asimov Protocol
While the Internet is choke-full of explanations of basic data communication protocols, very little is said about the higher levels of packing, formatting, and exchanging information in a useful and practical way. This less-charted land is still fraught with strange problems, whose solutions may be found in strange places – in this example, a very short, 60 years old Science Fiction story.
