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.
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.
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.
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.
MSP430 LaunchPad Tutorial - Part 3 - ADC
Enrico Garante walks through practical ADC use on the MSP430G2231, from a single-channel read that toggles LaunchPad LEDs to multi-channel repeated conversions. The post includes complete code, an ADC10 interrupt example to wake from low-power mode, and a DTC-backed array transfer so you can collect samples without polling. A short CCS debugging tip shows how to watch ADC variables while running.
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.
MSP430 Launchpad Tutorial - Part 2 - Interrupts and timers
Interrupts let the MSP430 respond to events without wasting CPU time, and this tutorial walks through using TimerA and Port 1 interrupts on the LaunchPad. Enrico shows how to configure TACTL, CCR0 and CCTL0 to generate a periodic TimerA interrupt, and how to set up P1IE, P1IES and P1IFG to catch a button press. The code toggles LEDs and enters LPM0 while waiting for interrupts.
An Introduction to Embedded Development
Peter Johansson launches a beginner-friendly series that teaches embedded development from the ground up, using the TI MSP430 while keeping lessons portable to other microcontrollers. No prior embedded experience is assumed, though a solid grasp of C and basic electronics will help. The series covers tool selection, the MSP430 LaunchPad, recommended books and online resources, and a hands-on roadmap toward writing your first program.
MSP430 Launchpad Tutorial - Part 1 - Basics
A working button-driven LED on the MSP430 LaunchPad is only a few steps away. Enrico Garante walks through creating a CCS project, setting P1.0 as the LED output and enabling P1.3 button interrupts, then shows the interrupt service routine that toggles the LED. The short tutorial covers stopping the watchdog, configuring P1DIR/P1OUT, clearing flags, and launching the code so you can get blinking quickly.
Embedded Systems Co-design for Object Recognition: A Synergistic Approach
Embedded systems co-design for object recognition is essential for real-time image analysis and environmental sensing across various sectors. This methodology harmonizes hardware and software to optimize efficiency and performance. It relies on hardware accelerators, customized neural network architectures, memory hierarchy optimization, and power management to achieve benefits like enhanced performance, lower latency, energy efficiency, real-time responsiveness, and resource optimization. While challenges exist, co-designed systems find applications in consumer electronics, smart cameras, industrial automation, healthcare, and autonomous vehicles, revolutionizing these industries. As technology advances, co-design will continue to shape the future of intelligent embedded systems, making the world safer and more efficient.
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.
Boot sequence for an ARM based embedded system -2
DM walks through the concrete steps of an ARM system startup, from the reset vector to handing control to C. The post explains what the early assembly reset code must do: set system registers, initialize stacks, set up the MMU, copy .data and clear .bss, and remap the vector table into RAM for faster interrupts. It finishes with external memory bring-up and loading an OS image.
Byte and Switch (Part 2)
Running a thermistor front end from a single AA cell exposes problems you might not expect. Jason Sachs walks through a switchable-gain divider using a P-channel MOSFET and shows how MOSFET off-state leakage and low supply voltages can corrupt high-impedance temperature readings. The post compares bipolar transistors and analog switch ICs as fixes and gives practical component guidance for one-cell designs.
An overview of Linux Boot Process for Embedded Systems
Booting Linux on embedded hardware collapses PC boot stages into a single bootloader, and understanding the early steps helps troubleshoot low-level failures. Kunal Singh breaks down the sequence from the bootstrap firmware and primary/secondary bootloaders through zImage decompression, MMU and page table setup, start_kernel, and the initrd pivot to the root filesystem. Practical focus favors ARM 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.
MSP430 LaunchPad Tutorial - Part 3 - ADC
Enrico Garante walks through practical ADC use on the MSP430G2231, from a single-channel read that toggles LaunchPad LEDs to multi-channel repeated conversions. The post includes complete code, an ADC10 interrupt example to wake from low-power mode, and a DTC-backed array transfer so you can collect samples without polling. A short CCS debugging tip shows how to watch ADC variables while running.
Getting Started With CUDA C on an Nvidia Jetson: GPU Architecture
In the previous blog post (Getting Started With CUDA C on Jetson Nvidia: Hello CUDA World!) I showed how to develop applications targeted at a GPU on a Nvidia Jetson Nano. As we observed in that blog post, performing a calculation on a 1-D array on a GPU had no performance benefit compared to a traditional CPU implementation, even on an array with many elements. In this blog post, we will learn about the GPU architecture to better explain the behavior and to understand the applications where a GPU shines (hint: it has to do with graphics).
How to install Ubuntu 12.04 Precise, Xubuntu-desktop and Open JDK-7 on Beagleboard Rev. C2
Want to run Java GUI apps on a BeagleBoard Rev C2? This hands-on post walks through installing Ubuntu 12.04, adding the Xubuntu desktop, and getting OpenJDK-7 running, including SD flashing, u-boot and network setup, display and audio tweaks, and a fix for XFCE login ownership problems. Follow the exact commands and small workarounds the author used to get a monitor, sound, and Java VM working on the board.
Getting Started With CUDA C on an Nvidia Jetson: A Meaningful Algorithm
In this blog post, I demonstrate a use case and corresponding GPU implementation where meaningful performance gains are realized and observed. Specifically, I implement a "blurring" algorithm on a large 1000x1000 pixel image. I show that the GPU-based implementation is 1000x faster than the CPU-based implementation.
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.
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 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.
Getting Started with the Microchip PIC® Microcontroller
This first post of a five part series looks at the available hardware options for getting started with Microchip 8-bit PIC® Microcontroller, explores the MPLAB® X Integrated Development Environment and walks through setting up a project to expose the configured clock to an external pin and implement a single output GPIO to light an LED.
AI at the Edge - Can I run a neural network in a resource-constrained device?
AI at the edge is no longer science fiction, it can run on tiny, resource-constrained devices like Arm Cortex-M4 and M7 microcontrollers. This post introduces inference-only neural networks on MCUs, explains why edge AI matters for power, latency, and privacy, and points to practical toolchains such as STM32Cube.AI, Arm NN, and AWS Greengrass to get started quickly.
Deeply embedded design example - Logic replacement
Gene Breniman shows how a tiny PIC10F200 can replace a forest of discrete timing components to control six 10A H-bridges, letting firmware tune sequencing to cut EMI and reduce cost. He walks through analyzing the original RC/inverter delays, choosing the PIC, pinout and timer setup, and implementing compact assembly firmware that reproduces and improves the timing behavior. The result is fewer parts, saved board space, and better EMI control.
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.
Hidden Gems from the Embedded Online Conference Archives - Part 2
A look back at a deep dive into the Mars Perseverance flight software from one of the technical leads at JPL.
STM32 B-CAMS-OMV Walkthrough
Want to prototype embedded vision quickly? This walkthrough shows how the STM32 B-CAMS-OMV camera module pairs with the STM32H747I-DISCO discovery kit and the FP-AI-VISION1 function pack to get you running in minutes. The video covers the camera connection interface, key software functions to control and process data, and the ISP features that let image processing run inside the camera. The STM32 H7 project with B-CAMS-OMV drivers is available on GitHub.
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.
