Forem: Alex Mo

How to Edit Boot Config for Raspberry Pi 5 USB Boot

Alex Mo — Wed, 01 Apr 2026 10:20:48 +0000

If you're using a Raspberry Pi 5 for anything beyond quick testing, booting from a USB drive is one of the best upgrades you can make.

A USB SSD is usually faster, more reliable, and better suited for long-running projects than a microSD card. That matters if you're using your Pi as a home server, a Docker box, a media center, or even just a daily Linux machine.

In this post, I'll walk through how Raspberry Pi 5 USB boot works, what config you actually need to edit, how to change the boot order, and how to troubleshoot common issues.

Why boot Raspberry Pi 5 from USB?

The default Raspberry Pi workflow is still heavily centered around microSD cards. They work, but they also come with a few obvious downsides:

slower read/write performance
lower durability under heavy use
easier to corrupt during bad shutdowns
usually less storage space than an SSD

USB boot solves most of that.

With a USB SSD or even a decent USB flash drive, you can get:

faster boot times
better app and package install performance
improved responsiveness
larger storage capacity
a more reliable setup for 24/7 workloads

On Raspberry Pi 5, USB boot is supported, and once it's configured properly, it works very well.

What you need

Before you start, make sure you have:

Raspberry Pi 5
USB SSD or USB flash drive
Raspberry Pi OS installed somewhere for setup
a stable power supply, ideally the official one
optional microSD card for first-time configuration

And most importantly: make sure the firmware and OS are up to date.

sudo apt update
sudo apt full-upgrade
sudo reboot

If your system is outdated, you can end up debugging problems that are really just firmware issues.

Important: config.txt is not the main USB boot setting

This is the part that confuses a lot of people.

There are two different things involved in Raspberry Pi boot configuration:

config.txt

This file controls hardware-related boot options such as:

display settings
overlays
interface options
device tree parameters
GPU-related settings

You can edit it with:

sudo nano /boot/config.txt

On some newer Raspberry Pi OS versions, the path may be:

sudo nano /boot/firmware/config.txt

EEPROM bootloader config

This is what controls boot order.

So if your real goal is "make Raspberry Pi 5 boot from USB first", the key setting is usually not in config.txt, but in the EEPROM bootloader config.

That setting is called:

BOOT_ORDER

So yes, you can edit config.txt, but if USB boot priority is the issue, the real change usually happens elsewhere.

Step 1: Edit config.txt if needed

You may still want to inspect or edit config.txt, especially if your setup depends on custom boot-time hardware settings.

Open it with:

sudo nano /boot/config.txt

Or:

sudo nano /boot/firmware/config.txt

If you're editing the boot partition from another computer, just mount the SD card and open config.txt in any text editor.

Again, this is useful for general boot config, but not the main place for changing USB boot order.

Step 2: Change boot order with raspi-config

The easiest way to enable USB boot is through raspi-config.

Run:

sudo raspi-config

Then go to:

Advanced Options > Boot Order > USB Boot

Select the USB boot option, save, and reboot:

sudo reboot

This is the simplest approach and probably the best one if you just want it to work.

Step 3: Manually edit EEPROM bootloader config

If you want to change the bootloader settings directly, use:

sudo -E rpi-eeprom-config --edit

Look for this line:

BOOT_ORDER=0xf41

If it doesn't exist, add it.

What does 0xf41 mean?

The value is read as a boot sequence.

f = try all supported boot modes
4 = USB mass storage
1 = SD card

So:

BOOT_ORDER=0xf41

means the Pi will prioritize USB boot while still keeping SD card as a fallback.

That makes it a good default for most users.

After saving the config, reboot:

sudo reboot
Step 4: Verify the bootloader config

After rebooting, verify the current setting:

vcgencmd bootloader_config

Check the output for:

BOOT_ORDER=0xf41

If you don't see the value you expect, then the boot order was not updated correctly.

This step is worth doing before you start blaming the USB drive.

Step 5: Prepare a bootable USB drive

Changing boot order alone is not enough. The USB drive also needs a valid Raspberry Pi OS image.

You have two common options.

Option A: Use Raspberry Pi Imager

This is the easiest and cleanest method.

Open Raspberry Pi Imager
Select Raspberry Pi OS
Choose the USB drive as the target
Write the image

Done.

Option B: Clone an existing SD card

If you already have a working Raspberry Pi install and want to move it to USB, you can clone it.

sudo dd if=/dev/mmcblk0 of=/dev/sda bs=4M status=progress

Make sure the device names are correct.

/dev/mmcblk0 = SD card
/dev/sda = USB drive

Before doing this, check devices with:

lsblk

Because if you get the paths wrong, dd will happily overwrite the wrong disk.

Step 6: Test USB boot

Now test the actual setup.

Shut down the Raspberry Pi
Remove the microSD card
Connect the USB drive
Power on the Pi

If everything is configured correctly, the Raspberry Pi 5 should boot directly from USB.

If it only works with the SD card still inserted, then you're not really booting from USB yet.

Common issues and fixes

Here are the most common reasons Raspberry Pi 5 USB boot fails.

USB drive is not detected

This is often a power or adapter issue.

Try:

official Raspberry Pi power supply
powered USB hub
different USB port
different SSD enclosure or adapter
BOOT_ORDER is wrong

Check it again:

vcgencmd bootloader_config

If it doesn't show the expected boot order, fix that first.

USB drive is not actually bootable

Reflash it using Raspberry Pi Imager.

If you cloned with dd, double-check that the target drive was correct and the clone completed successfully.

Pi hangs during boot

This can happen if:

the drive isn't compatible
the OS image is broken
the power supply is weak
the bootloader config is incorrect
Need more USB debug info?

Use:

dmesg | grep -i usb

This can help confirm whether the drive is being detected during boot or after startup.

Best practices

A few things make USB boot setups much more reliable:

Use an SSD if possible

A proper SSD is usually much better than a cheap USB flash drive.

Keep firmware updated

Bootloader and compatibility improvements show up in firmware updates, so don't skip system maintenance.

Use a good power supply

A weak power source causes weird, inconsistent problems that are hard to diagnose.

Keep an SD card as a fallback

Even if you move to USB boot full-time, an SD card is still useful for recovery.

Final thoughts

USB boot on Raspberry Pi 5 is one of those upgrades that is absolutely worth doing if you care about speed or reliability.

The main thing to remember is:

config.txt handles general boot-time hardware config
BOOT_ORDER in the EEPROM bootloader controls boot priority

So if you're trying to make the Pi boot from USB, the EEPROM setting is the part that matters most.

The basic flow looks like this:

update the system
check or edit config.txt if needed
set BOOT_ORDER for USB boot
verify the bootloader config
flash or clone a USB drive
test without the SD card

Once that's done, your Raspberry Pi 5 should be able to boot cleanly from USB storage, and in most cases, it'll be a better experience than booting from microSD.

Example commands recap
sudo apt update
sudo apt full-upgrade
sudo reboot
sudo nano /boot/config.txt
sudo nano /boot/firmware/config.txt
sudo raspi-config
sudo -E rpi-eeprom-config --edit
vcgencmd bootloader_config
sudo dd if=/dev/mmcblk0 of=/dev/sda bs=4M status=progress
lsblk
dmesg | grep -i usb

ESP32-C3 AI Text-to-Speech System: Build a Cloud Voice Output Device with I2S Audio and Wit.ai

Alex Mo — Wed, 18 Mar 2026 06:36:52 +0000

Adding natural voice output to embedded systems used to require expensive processors, large memory, or offline speech engines that were too heavy for small microcontrollers. Today, that limitation is much easier to overcome. With an ESPRESSIF ESP32-C3 board, a simple I2S amplifier, and a cloud speech service, you can build a compact device that speaks clearly without doing the hard speech synthesis work locally.

In this project, the ESP32-C3 connects to Wi-Fi, sends text to the Wit.ai-based TTS workflow, receives the generated audio stream, and plays it through a speaker using an I2S digital amplifier. This architecture is practical for voice prompts, smart alerts, robotics, accessibility devices, and interactive IoT products because the microcontroller only handles networking and audio playback, while the cloud handles the heavy speech generation.

Why Use Cloud TTS on ESP32-C3?
Text-to-speech sounds simple, but high-quality speech generation requires text normalization, phoneme generation, prosody control, and waveform synthesis. Those tasks are easy for modern phones and PCs, but not for small embedded boards with limited RAM and storage. That is why cloud-based TTS is such a good fit for the ESP32-C3: the device stays lightweight, while the voice quality remains much more natural than most tiny offline solutions.

The ESP32-C3 is especially well suited to this role because it combines Wi-Fi connectivity, a RISC-V core, low power operation, and a useful peripheral set in a compact, affordable platform. If you want a broader overview of the chip family before starting, this ESP32 guide and this ESP32-C3 overview are good supporting references for architecture, wireless features, and typical IoT applications.

How the System Works
The full workflow is straightforward:

The user types a sentence into the Serial Monitor.
The ESP32-C3 sends that text over HTTPS to the cloud TTS service.
The remote server synthesizes speech.
The audio stream is returned to the board in real time.
The ESP32-C3 outputs digital audio over I2S.
An I2S amplifier drives the speaker and plays the spoken result.
Because the audio is streamed instead of stored as a full local file first, memory usage stays low and playback can begin quickly. That makes this design ideal for responsive embedded voice feedback.

Hardware Required
ESPRESSIF ESP32-C3 development board
MAX98357A I2S digital audio amplifier
4Ω or 8Ω speaker
Breadboard
Jumper wires
USB cable for programming and power
If you are new to the platform, MOZ also has beginner-friendly ESP32-C3 project content such as this ESP32-C3 starter tutorial and this Wi-Fi and MQTT upgrade project, which are useful for understanding board setup, flashing, Wi-Fi configuration, and serial debugging before you add cloud voice output.

Why MAX98357A Is a Good Match
The MAX98357A is a popular digital audio amplifier for maker projects because it accepts I2S audio directly and can drive a small speaker without a complicated analog output stage. That means the ESP32-C3 can stay fully in the digital domain all the way to the amplifier input, reducing design complexity and making the build cleaner for prototyping. This general I2S-amplifier approach is exactly what recent ESP32/WitAITTS guides use for practical cloud voice playback.

ESP32-C3 to MAX98357A Wiring
For the current ESP32-C3 WitAITTS example, use the following default I2S pin mapping:

GPIO7 → BCLK
GPIO6 → LRC
GPIO5 → DIN
5V → VIN
GND → GND
Then connect the speaker to the amplifier output terminals.

This pinout is important because some older ESP32 examples use GPIO27 / GPIO26 / GPIO25, but those are the default pins for the standard ESP32 example rather than the ESP32-C3 example. Using the ESP32-C3-specific mapping saves setup time and avoids “no audio” troubleshooting later.

Setting Up the Wit.ai TTS Workflow
To build the project, create a Wit.ai account, create an application, and copy the server access token used for authenticated requests. In the Arduino environment, the WitAITTS library is designed to simplify this workflow by handling the network request, audio streaming, and I2S playback pipeline for supported ESP32 boards.

In practical terms, your setup process looks like this:

Create a Wit.ai account and app.
Copy your server access token from the project settings.
Install the WitAITTS library in Arduino IDE.
Open the ESP32-C3 example sketch.
Enter your Wi-Fi SSID, Wi-Fi password, and token.
Upload the firmware to the board.
The current WitAITTS project documents dedicated examples for ESP32, ESP32-C3, ESP32-S3, and Pico W platforms, including separate default pin mappings for each board family.

Firmware Behavior
Once powered on, the ESP32-C3 connects to Wi-Fi and waits for text input from the Serial Monitor. When you enter a sentence, the firmware sends that text request to the cloud service and begins receiving streamed speech audio. The audio is forwarded directly to the MAX98357A over I2S, allowing playback to begin without waiting for the full clip to download first. This streaming model reduces memory pressure and improves response time, which is a major advantage on embedded hardware.

Testing the Project
After uploading the sketch:

Open the Serial Monitor.
Wait for the ESP32-C3 to join Wi-Fi.
Type a short sentence such as Hello, this is my ESP32-C3 voice assistant.
Press Enter.
Listen for the streamed audio output through the speaker.
If everything is configured correctly, the device should speak the sentence almost immediately after the request is sent. Response speed and playback smoothness depend on Wi-Fi stability, power integrity, and speaker quality, just as recent implementation guides note.

Troubleshooting Tips

No Audio Output
Double-check the I2S connections, confirm the speaker is attached properly, and verify that your ESP32-C3 pins match the correct example sketch rather than a generic ESP32 wiring table. The current library documentation explicitly separates ESP32 and ESP32-C3 default pins.
Wi-Fi Connection Fails
Verify your SSID and password, confirm you are using a 2.4 GHz network, and make sure the board has a stable USB power source. Weak Wi-Fi will also affect stream quality and startup latency.
HTTP 401 or Authentication Errors
A wrong or expired Wit.ai token will prevent the cloud request from succeeding. Recheck the token copied from your Wit.ai settings and update the sketch if needed.
Distorted or Choppy Sound
Inspect the amplifier wiring, confirm the speaker impedance is appropriate, use a stable 5V supply for the amplifier, and test closer to the router. In streaming TTS projects, poor network quality often shows up as glitches or stuttering audio.

Project Ideas and Real-World Applications
This kind of cloud-connected voice node can be used in many embedded products:

Smart home voice notifications
Talking control panels
Industrial alert terminals
Interactive museum or kiosk displays
Voice-enabled robotics projects
Accessibility aids and educational devices
It also fits naturally into broader ESP32 DIY projects and can be extended with sensors, dashboards, MQTT, or local UI elements. For example, you could combine spoken alerts with the workflow shown in this ESP32-C3 Wi-Fi dashboard project to build a sensor node that not only publishes data online but also speaks warnings locally.

Design Advantages of This Approach
Natural voice quality from cloud-based AI speech synthesis
Low local resource usage on the microcontroller
Fast prototyping with simple firmware structure
Flexible expansion into larger IoT systems
Clean digital audio path using I2S output
For makers and engineers, this is one of the most practical ways to add voice to small wireless devices without moving up to a much larger Linux-class processor. The ESP32-C3 stays focused on control, connectivity, and streaming, while the cloud delivers the speech intelligence.

Conclusion
An ESP32-C3 AI text-to-speech system is a smart way to bring natural voice output into embedded designs without the overhead of running a full speech engine on-device. By combining Wi-Fi connectivity, the Wit.ai-based TTS workflow, I2S audio output, and a MAX98357A amplifier, you can build a compact voice-enabled module for alerts, automation, education, and interactive electronics.

If you are planning a more advanced design, start with an ESPRESSIF ESP32-C3 platform, validate your networking and I2S audio path, and then scale the project into a full smart device with sensors, dashboards, or cloud control.

I Built a Camera That Turns Reality Into Pixel Art

Alex Mo — Thu, 12 Mar 2026 08:18:18 +0000

I built a camera that captures the real world as low-resolution, retro-style pixel art photos.

This is the first version (v1) of the project, and everything was made by me from scratch — both the 3D model and the code.

For this version, my goal was simple:
to build the cheapest and most accessible version possible, so anyone could recreate it without needing expensive parts or complicated tools.

This is just the starting point. In future versions, I’m planning to add:

an internal battery

a built-in screen

more features and a better overall user experience

Why I Made It

I wanted to create something playful, minimal, and a little nostalgic — a camera that doesn’t try to compete with modern image quality, but instead embraces limitations as part of its charm.

Rather than capturing reality in perfect detail, this camera transforms it into something that feels more like a memory from an old game.

What You Need to Build It

The current version only requires 4 basic electronic components, and they’re all either very cheap or easy to find.

Components

ESPRESSIF ESP32-CAM + TTL programmer

6x6mm push button

USB Type-C to 5V breakout

Wire

Build Guide

Here’s how to assemble your own Pixel Art Camera.

Tools Required

Soldering iron (essential)

Hot glue gun or super glue

Step 1 — Upload the Code

Before assembling the hardware, the first step is to get the system running.

Connect the ESP32-CAM to your computer using the USB-TTL programmer.

Open Arduino IDE.

Select the correct board and port, then upload the code from this repository.

Once the upload is complete, disconnect the board and remove the ESP32-CAM module from the programmer.

From this point on, you’ll only need the camera board itself for the build.

Step 2 — Prepare the Parts

Now solder the wires you’ll need for power and input.

USB Type-C breakout

Solder two wires to the breakout board:

one wire to V / VCC

one wire to G / GND

Button

Solder one wire to each leg of the push button.

Step 3 — Assemble the Case
Mount the external parts first

Glue the Type-C breakout board into the bottom-left slot

Glue the button into the top-right slot

Make sure both parts are firmly secured before moving on.

Install the ESP32-CAM board

Place the ESP32-CAM into the case.

Important: before applying glue, insert the SD card and make sure it can slide in and out freely.
If the board is positioned incorrectly, the case may block access to the card slot.

Once everything is aligned properly, secure the board with a small amount of glue.

Be careful: only apply glue to the corners of the board, especially around the top corners and the lower area near the antenna. Avoid getting glue on the central electronic components.

Step 4 — Wiring

This is the most important part of the assembly.

Power connection

Connect the Type-C breakout to the ESP32-CAM like this:

V / 5V → 5V pin

G / GND → GND pin

Warning: double-check polarity before powering it on. Reversed power wiring can permanently damage the board.

Button connection

Connect one wire from the button to GPIO 13

Connect the other wire to any GND pin

Note: GPIO 13 is the 4th pin from the top on the same side as the 5V pin.

Step 5 — Power On

Once everything is soldered and mounted, close the case, insert the SD card into the top-left slot, and connect the camera to a power source using a USB Type-C cable.

You can use either:

a power bank

a USB wall adapter

Quick Start
How to Use It

Power on: connect the camera to power

Wake the system: after plugging it in, press the button once

Take a photo: each button press captures one image

1 click = 1 photo

LED Status Guide

The LED gives feedback about what the camera is doing.

1 short blink — photo captured and stored in temporary memory

solid light — writing images to the SD card, do not unplug

2 fast blinks — save complete, safe to disconnect power

chaotic / strobe blinking — error, SD card missing or not detected correctly

3 slow blinks — camera is going to sleep automatically

How Image Saving Works

To make shooting faster, the camera uses a temporary RAM buffer.

That means photos are not written to the SD card immediately after every shot.

The write process starts automatically in one of these two situations:

Buffer full

After 15 photos, the camera starts writing everything to the SD card.

Session timeout

If you stop shooting and wait 10 seconds, the camera saves the buffered photos automatically.

Depending on how many photos are waiting, writing may take a few seconds.

Important Warning — How to Avoid Losing Photos

This part matters.

Before images are written to the SD card, they only exist in temporary memory.

Never disconnect power or remove the SD card:

while the LED is solid

while the LED is off but you just finished shooting and the camera is still waiting for the 10-second auto-save trigger

When is it safe to unplug?

Only after the solid light finishes and you see 2 fast blinks.

That signal means the save process is complete.

If power is removed before that, all photos still in the buffer will be permanently lost.

About the Image Format

The camera currently saves all images as BMP files.

That works, but it’s not ideal for sharing online or posting on social media.
To make that easier, I also created a helper script called upscale.bat.

Just place it on the SD card and run it on your computer.

The script will automatically:

create a new folder with today’s date

generate 3 subfolders inside it:

Originals

Stores the raw BMP files

Converted

Converts the images into JPEG for easier sharing

Upscaled

Creates 4x enlarged versions of the images

This upscaling increases the image dimensions to make details easier to see, but it does not increase the original image quality.

What’s Next

This is only v1, but it proves the core idea works:

a tiny DIY camera that turns everyday reality into pixel art.

The next versions will be more refined and more self-contained, with better usability and additional hardware features. But I wanted the first release to stay true to the original idea — simple, cheap, hackable, and fun.

If you like weird little devices, retro aesthetics, or hardware projects built around constraints, this one might be for you.

What Is ESP32 and Complete Guide for ESP32

Alex Mo — Sat, 28 Feb 2026 06:14:55 +0000

The ESP32 is one of the most popular microcontrollers in the world for IoT, embedded systems, and smart device development. Whether you're a beginner learning electronics or a professional engineer building connected products, the ESP32 offers powerful features at an affordable price.

In this complete guide, we’ll cover everything you need to know about the ESP32 boards— from basic concepts to development tools and real-world applications.

What Is ESP32?

The ESP32 is a low-cost, high-performance microcontroller developed by Espressif Systems. It integrates:

A dual-core processor

Built-in Wi-Fi

Bluetooth (Classic + BLE)

Multiple GPIOs

Rich peripheral interfaces

Unlike traditional microcontrollers that require external communication modules, the ESP32 has wireless connectivity built directly into the chip, making it ideal for IoT applications.

It is widely used in:

Smart home devices

Industrial monitoring

Wearable electronics

Wireless sensors

Robotics

Automation systems

Core Features of ESP32

Here are the main features that make the ESP32 stand out:

Dual-Core Processor

The ESP32 typically uses a dual-core Tensilica Xtensa LX6 processor running up to 240 MHz. This allows multitasking and efficient handling of networking and real-time tasks simultaneously.

Built-in Wi-Fi

802.11 b/g/n support

Station, Access Point, and mixed modes

Ideal for web servers, IoT dashboards, and cloud communication

Bluetooth & BLE

Bluetooth Classic for audio and legacy devices

Bluetooth Low Energy (BLE) for low-power IoT communication

Rich GPIO & Peripheral Interfaces

The ESP32 supports:

Digital I/O (GPIO)

ADC (Analog-to-Digital Converter)

DAC (Digital-to-Analog Converter)

PWM

UART, SPI, I2C

CAN (on some variants)

Touch sensors

Hall sensor

This makes it flexible enough for complex embedded projects.

Low Power Modes

ESP32 supports deep sleep and light sleep modes, enabling battery-powered IoT designs.

Popular ESP32 Development Boards

There are many ESP32-based boards available:

ESP32 DevKit V1

ESP32-WROOM-32 module

ESP32-WROVER (with PSRAM)

ESP32-S3 (AI and USB features)

ESP32-C3 (RISC-V based, low cost)

Each version targets different project requirements such as AI processing, USB connectivity, or ultra-low power consumption.

How to Get Started with ESP32
Step 1: Install Arduino IDE

The easiest way to begin is by using the Arduino IDE.

Download and install Arduino IDE.

Add ESP32 board support via Board Manager.

Select your ESP32 board from the Tools menu.

Install USB drivers if needed.

Step 2: Upload Your First Program (Blink Example)

Here’s a simple LED blink example:

void setup() {
pinMode(2, OUTPUT);
}

void loop() {
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(1000);
}

Upload the code, and your onboard LED should blink.

Common ESP32 Applications

The ESP32 is extremely versatile. Here are some common use cases:

IoT Web Server

Create a web dashboard to control relays or monitor sensors remotely.

MQTT Communication

Send sensor data to cloud platforms like AWS, Azure, or private MQTT brokers.

Bluetooth Projects

Build BLE beacons, wireless sensors, or mobile-controlled devices.

Smart Home Automation

Control lights, fans, and appliances through Wi-Fi or mobile apps.

Industrial Monitoring

Use ESP32 for data acquisition, remote monitoring, and predictive maintenance.

ESP32 vs Arduino: What’s the Difference?
Feature ESP32 Arduino Uno
CPU Speed Up to 240 MHz 16 MHz
Wi-Fi Built-in No
Bluetooth Yes No
ADC Resolution 12-bit 10-bit
Multi-core Yes No

ESP32 offers significantly more performance and connectivity compared to traditional Arduino boards.

Why ESP32 Is So Popular

Affordable price

Strong community support

Massive documentation

Flexible development ecosystem

Ideal for IoT and wireless projects

It bridges the gap between simple microcontrollers and full embedded Linux systems.

Final Thoughts

The ESP32 is more than just a microcontroller — it’s a complete IoT development platform. With built-in wireless connectivity, powerful processing capability, and a rich set of peripherals, it is suitable for beginners and professionals alike.

If you're planning to build connected devices, smart systems, or wireless automation projects, learning ESP32 is a smart investment.

Start with simple GPIO projects, move into Wi-Fi and Bluetooth applications, and gradually explore advanced features like FreeRTOS and OTA updates.

The ESP32 opens the door to endless possibilities in embedded and IoT development.

What Gaming Operating Systems Can You Install on a Raspberry Pi?

Alex Mo — Tue, 24 Feb 2026 10:26:23 +0000

A Professional, In-Depth Guide to Retro, Native, and Cloud Gaming Platforms

The Raspberry Pi has evolved far beyond its original mission as an educational microcomputer. With the release of the Raspberry Pi 4 and especially the Raspberry Pi 5, the platform now offers enough processing power, graphics capability, and I/O bandwidth to support serious gaming use cases.

That said, the Raspberry Pi is no longer the only viable single-board computer for gaming projects. A growing number of higher-performance SBCs now compete in the same space, and depending on your performance expectations, exploring some of the Best Raspberry Pi Alternatives may provide additional CPU power, improved GPU acceleration, or expanded connectivity options for more demanding emulation or streaming setups.

However, “gaming on Raspberry Pi” can mean very different things depending on your expectations. Are you building a living-room retro console? A portable arcade system? A lightweight Linux gaming station? Or a streaming terminal for modern AAA titles?

The answer depends heavily on the operating system you install.

Broadly speaking, Raspberry Pi gaming operating systems fall into three major categories:

Console-style all-in-one retro gaming distributions

General-purpose Linux OS with gaming software added

Cloud gaming and streaming-focused setups

This guide provides a professional, technically grounded comparison of each option, including strengths, tradeoffs, Raspberry Pi 5 compatibility considerations, and use-case recommendations.

All-in-One “Console-Style” Retro Gaming Operating Systems

These distributions are purpose-built to transform your Raspberry Pi into a dedicated game console. You flash the OS to an SD card, boot the system, and immediately enter a console-like interface optimized for controller navigation.

They are designed for simplicity, appliance-like reliability, and living-room deployment.

1.1 Recalbox
Overview

Recalbox is a Linux-based retro gaming operating system that integrates:

EmulationStation (frontend UI)

RetroArch (emulation framework)

Libretro cores

Kodi (optional media center functionality)

Controller auto-detection

Built-in scraping tools

The primary philosophy behind Recalbox is ease of use. It minimizes configuration friction and is particularly attractive for users who want immediate functionality without deep Linux interaction.

Strengths

Extremely Simple Setup Installation is straightforward:

Download image

Flash to SD card

Boot

Add ROMs

Minimal command-line interaction is required.

Controller Auto-Configuration
Most USB and Bluetooth controllers are automatically detected and mapped.
Stable, Living-Room Experience
The interface is optimized for television display and couch gaming.
Raspberry Pi 5 Support
Recalbox provides specific documentation and images targeting Raspberry Pi 5. While performance optimization is ongoing, the experience is functional and stable for most 8-bit, 16-bit, and many 32-bit systems.

Performance Considerations

On Raspberry Pi 5, Recalbox can comfortably emulate:

NES, SNES, Genesis

Game Boy family

PlayStation 1

Many arcade systems

Some Nintendo 64 titles (with tuning)

Dreamcast and PSP performance varies depending on emulator core and configuration.

Tradeoffs

Less flexible than a full Linux distribution

Not ideal for advanced custom emulator configurations

Limited suitability for modern native Linux gaming

Best For

Users who want:

A plug-and-play retro console

A polished TV experience

Minimal configuration effort

For commercial deployments — such as arcade cabinets in public venues, industrial HMIs, or long-running embedded gaming kiosks — durability and long-term availability become more important than raw performance. In these cases, developers often evaluate Industrial Raspberry Pi Alternatives, which typically offer extended lifecycle guarantees, enhanced thermal design, vibration resistance, and broader voltage tolerance compared to consumer-focused boards.

1.2 Batocera
Overview

Batocera is another widely adopted retro gaming distribution. Architecturally similar to Recalbox, it provides:

EmulationStation frontend

RetroArch backend

Standalone emulators where appropriate

Broad hardware compatibility

Batocera’s philosophy emphasizes cross-platform support and performance optimization.

Strengths

Polished User Interface
Batocera’s UI is highly refined, with excellent theme support and metadata scraping.
Broad Device Support
Batocera runs on:

Raspberry Pi (multiple generations)

x86 PCs

Single-board computers

Handheld devices

This makes it attractive for users maintaining multiple retro systems.

Advanced Configuration Options
While still user-friendly, Batocera exposes more performance tuning options than Recalbox.
Community and Documentation
Strong community presence and active development.

Raspberry Pi 5 Status

Batocera documentation has described Raspberry Pi 5 support as “beta” in some releases. In practice, this typically means:

The system is usable

Performance improvements are ongoing

Some cores may require manual tweaking

Performance Profile

On Raspberry Pi 5, Batocera can handle:

8-bit / 16-bit consoles flawlessly

PS1 smoothly

N64 with mixed results

Dreamcast moderately well

PSP depending on title

Tradeoffs

Slightly more complex than Recalbox

Pi 5 support may not always be labeled “final” in documentation

Less ideal for non-gaming workloads

Best For

Users who want:

A highly polished UI

Greater customization control

Cross-device retro ecosystem compatibility

1.3 Lakka
Overview

Lakka is a minimalist Linux distribution built entirely around RetroArch.

Unlike Recalbox and Batocera, which add layers of user experience features, Lakka focuses on delivering a streamlined RetroArch-first environment.

Architectural Philosophy

RetroArch is the interface

Libretro cores provide emulation

Minimal OS overhead

Console-like boot experience

Strengths

Lightweight
Lakka is lean and efficient.
RetroArch Purity
For users already comfortable with RetroArch, this is ideal.
Direct Control
Fine-grained emulator configuration through RetroArch menus.

Tradeoffs

Less “appliance-like” than Batocera

ROM management and scraping not as automated

UI less visually rich

Raspberry Pi 5 Considerations

Support depends on kernel and GPU driver maturity. Performance is generally strong for classic systems but may require manual tuning.

Best For

Users who:

Prefer RetroArch’s native workflow

Want a lightweight environment

Value low overhead over visual polish

RetroPie (A Special Case)

RetroPie has historically been synonymous with Raspberry Pi gaming.

Overview

RetroPie is not a standalone OS in the same way as Recalbox or Batocera. It is:

A software stack

Built on top of Raspberry Pi OS (or other Debian-based systems)

Featuring EmulationStation + emulator packages

Historical Strength

RetroPie dominated earlier Raspberry Pi generations because:

It was stable

Highly configurable

Strongly community-supported

Raspberry Pi 5 Reality

As of recent development discussions:

No guaranteed official Raspberry Pi 5 image

Installation may require manual or community-based methods

Kernel and GPU changes complicate legacy support

This does not mean RetroPie is unusable — only that it is less turnkey on Pi 5 compared to previous generations.

Advantages

Mature documentation

Highly customizable

Good emulator coverage

Disadvantages

More complex setup on Pi 5

Less appliance-like than Recalbox

Requires Linux familiarity

Best For

Users who:

Already know RetroPie

Enjoy configuration control

Are comfortable troubleshooting

Raspberry Pi OS + Gaming Software (Maximum Flexibility)

This approach treats the Raspberry Pi as a general-purpose Linux computer rather than a dedicated gaming console.

Overview

Install Raspberry Pi OS (Bookworm recommended for Pi 5), then add:

RetroArch

Standalone emulators

Open-source game ports

Steam Link

Moonlight

Media center software

Development tools

Strengths

Full Linux Environment You retain access to:

Terminal

Package managers

System services

Development tools

Multi-Purpose Use Your Pi can serve as:

NAS

Media server

Development machine

Gaming console

Streaming Compatibility You can install:

Steam Link

Moonlight (NVIDIA GameStream)

Parsec (where supported)

This enables modern AAA gaming via streaming from a powerful PC.

Native Gaming Possibilities

Some Linux games and open-source ports run directly on ARM:

Doom ports

Quake ports

OpenTTD

SuperTuxKart

Various indie games

Performance varies depending on GPU driver maturity and ARM compatibility.

Tradeoffs

More setup required

Not a boot-into-console experience

Requires Linux familiarity

Best For

Users who want:

A hybrid workstation + gaming machine

Streaming capability

Maximum customization

Cloud Gaming and Streaming-Focused Setups

For users who want modern AAA games on Raspberry Pi hardware, emulation is not enough. Streaming becomes the solution.

Steam Link

Steam Link can be installed on Raspberry Pi OS. It streams games from:

A Windows/Linux PC running Steam

Over local network (best)

Over internet (with proper bandwidth)

Requirements

Strong local network

Ethernet preferred

Host PC with sufficient GPU

Moonlight (NVIDIA GameStream)

Moonlight enables streaming from:

NVIDIA GPU-equipped PCs

Advantages:

Low latency

High image quality

Efficient encoding

Cloud Services via Browser

Using Chromium on Raspberry Pi OS, users can access:

Xbox Cloud Gaming

NVIDIA GeForce NOW

Other browser-based streaming services

Performance depends heavily on:

Network speed

Browser optimization

Video decoding acceleration

Performance Considerations on Raspberry Pi 5

The Raspberry Pi 5 introduces:

Improved CPU architecture

Better I/O

Updated VideoCore GPU

Enhanced power requirements

However, software optimization lags behind hardware capability in early lifecycle stages.

Key factors affecting gaming performance:

GPU driver maturity

Emulator optimization

Cooling solution

Storage speed (USB 3 SSD vs SD card)

For demanding emulation:

Active cooling is recommended

SSD storage improves load times

Proper power supply is critical

Quick Decision Matrix

If your goal is:

“I want a console experience immediately.”

Choose: Recalbox

“I want polish and strong community support.”

Choose: Batocera

“I prefer lightweight RetroArch control.”

Choose: Lakka

“I know RetroPie and enjoy customization.”

Choose: RetroPie

“I want flexibility beyond gaming.”

Choose: Raspberry Pi OS + gaming software

“I want modern AAA games.”

Choose: Streaming via Steam Link or Moonlight

Final Recommendation Strategy

For most users in 2026:

Raspberry Pi 5 + Recalbox or Batocera offers the best balance of ease and performance.

Advanced users may prefer Raspberry Pi OS for hybrid functionality.

Streaming unlocks modern gaming beyond the hardware limits of ARM emulation.

The Raspberry Pi is not a replacement for a gaming PC. Instead, it excels as:

A retro console

A portable arcade

A streaming endpoint

A hobbyist experimentation platform

Selecting the right gaming OS depends less on “which is best” and more on your intended experience.

How DDR5 Memory Really Works (Beginner-Friendly Guide)

Alex Mo — Tue, 10 Feb 2026 06:26:20 +0000

DDR5 is the newest generation of DDR system memory, and it is already becoming the standard for modern computers.

While most people know that DDR5 is “faster than DDR4,” very few actually understand what changed inside the memory itself.

DDR5 is not just about higher speed numbers.

It introduces new architecture, new power delivery methods, and built-in reliability features that fundamentally change how memory works.

In this beginner-friendly guide, we will explore:

How DDR5 is different from DDR4
Why DDR5 uses dual 32-bit channels
What On-Die ECC really does
Why power management moved onto the memory module
This project is written for beginners, PC builders, students, and electronics enthusiasts who want a clear and practical understanding of DDR5—without diving into complex standards or equations.

If you have ever wondered what makes DDR5 special, this guide is for you.

Supplies
This project is mainly educational, so no special lab equipment is required.

However, the following items are helpful for understanding DDR5 memory more clearly:

Hardware (Optional but Recommended)
A DDR5 memory module (any brand or capacity)
A DDR5-compatible motherboard
A modern CPU that supports DDR5
A PC case with side panel access (for observation)
Tools
Phillips screwdriver
Smartphone or camera (for taking reference photos)
Good lighting (recommended)
Software (Optional)
CPU-Z or similar hardware information tool
BIOS/UEFI access (to view memory settings)
Knowledge Requirements
Basic understanding of computer hardware
No prior memory design experience required
⚠️ Note:
You do not need to power on the system or remove memory modules while the system is running.
Always follow basic PC safety practices.

Step 1: The Biggest Change – Dual 32-bit Channels
The Biggest Change – Dual 32-bit Channels
One of the most important differences in DDR5 is its dual-channel design inside a single memory module.
DDR4:
One 64-bit wide data channel
All data travels through the same “road”
DDR5:
Two independent 32-bit sub-channels
Data can move in parallel
Simple analogy:
Think of DDR4 as a single wide highway.

DDR5 splits that highway into two separate roads, allowing traffic to flow more smoothly.

This design:

Improves efficiency
Reduces latency in real workloads
Helps modern CPUs access memory more effectively
Please refer to DDR4 vs DDR5 – A Quick Comparison side by side

Step 2: What Is On-Die ECC? (And What It Is NOT)
This is one of the most misunderstood features of DDR5.

What On-Die ECC is:
Error correction inside the memory chip
Automatically fixes small internal errors
Improves reliability and manufacturing yield
What On-Die ECC is NOT:
It is NOT the same as server-grade ECC memory
It does not provide system-level error reporting
The CPU cannot see or access this ECC data
In short:

On-Die ECC helps the memory chip take care of itself.
This is one reason DDR5 can run at much higher speeds than previous generations.

Step 3: PMIC – Why Power Control Moved Onto the Memory Module
DDR5 introduces a major power delivery change:

the Power Management Integrated Circuit (PMIC) is now located on the memory module itself.

Why this matters:
More precise voltage regulation
Cleaner power at high frequencies
Less stress on the motherboard
Advantages:
Better stability
Improved overclocking behavior
More efficient power delivery
Trade-offs:
Slightly higher memory cost
More heat on the DIMM
This change is one of the key enablers for DDR5’s high-speed operation.

Step 4: Speed, Bandwidth, and Power – What Actually Improves?
DDR5 improves performance in multiple ways:

Higher bandwidth thanks to increased data rates
Better efficiency due to lower voltage (1.1 V vs 1.2 V)
Improved parallelism from dual sub-channels
However, higher frequency does not always mean instantly better performance.

Real-world gains depend on:

CPU architecture
Memory controller
Software workload
DDR5 shines most in modern platforms and multi-threaded applications.

Step 5: Common DDR5 Mistakes Beginners Make
Here are a few common misunderstandings:

❌ “DDR5 works in DDR4 slots”

✔️ DDR4 and DDR5 are physically incompatible

❌ “Higher MHz always means faster PC”

✔️ Latency, architecture, and workload all matter

❌ “DDR5 On-Die ECC = Server ECC”

✔️ These are completely different technologies

Understanding these points can save a lot of frustration.

Step 6: Conclusion – Is DDR5 Worth It?
DDR5 is not just an incremental upgrade.

It represents a new memory architecture designed for future CPUs and workloads.

DDR5 is ideal for:
New PC builds
Hardware enthusiasts
Learning modern memory design concepts
If you are interested in how computers really work at the hardware level, DDR5 is a fascinating place to start.

Thanks for reading, and feel free to leave questions or suggestions in the comments!

How to Program STM32 with STM32CubeIDE - The Complete Guide

Alex Mo — Thu, 18 Sep 2025 06:59:12 +0000

TL;DR (Quick Start)
Install STM32CubeIDE (Windows/macOS/Linux).
Create Project: File → New → STM32 Project → pick your MCU or Board (e.g., NUCLEO-L053R8).
Configure Peripherals: in Device Configuration Tool (a.k.a. CubeMX-in-IDE).
Generate Code → open Core/Src/main.c.
Write Code inside /* USER CODE BEGIN / … / USER CODE END */ blocks.
Build (hammer icon).
Program/Debug (green bug ▶️). Press the board button, watch the LED respond. 🎉

What Is STM32?
STM32 is STMicroelectronics’ family of 32-bit microcontrollers based on ARM Cortex-M cores (M0/M0+, M3, M4, M7, M33…). The range spans ultra-low-power parts to high-performance models with rich peripherals (ADC/DAC, timers, SPI/I²C/UART, USB, CAN, Ethernet, SDMMC, etc.). ST’s MCU Finder helps you filter by power, speed, memory, package, peripherals, and price.

What You Need
1) Documentation (keep it handy)
Datasheet (device features, electricals, pinout)
Reference Manual (peripheral registers & behavior)
Board User Manual (Nucleo/Discovery pin maps, LED/button labels)
You don’t have to memorize it all—just know where things live.

2) Language
C is the right place to start on STM32. (You can mix in C++ later.) Learn the basics of types, pointers, headers, and build systems.

3) Hardware
Nucleo (recommended): On-board ST-LINK debugger/programmer; Arduino headers for shields.
Discovery: Often includes sensors/displays; also has on-board ST-LINK.
BluePill / custom board: Use an external ST-LINK/V2 (or a Nucleo as a programmer). Connect SWDIO, SWCLK, GND, 3V3; set BOOT0=0 for normal boot.

Tip: On Nucleo boards, keep the ST-LINK jumpers in the default “on-board target” position. You can remove them later to use the Nucleo as an external programmer.

4) Software (free)
STM32CubeIDE = Eclipse + CubeMX + GCC + GDB + ST-LINK tools in one install. It handles:
MCU/Board selector
Pin/peripheral configurator
Code generator (HAL/LL)
Compiler, linker
Debugger & programmer

5) Framework Options (how you code)
Bare-metal registers (“pure C”)
Max control & speed; steep learning curve; live in the Reference Manual. Great for experts and ultra-tight targets.

Arduino core for STM32
Easy for small demos; limited board support and quality varies. Not ideal if you plan to move to professional workflows.

Mbed OS
C/C++ with online/offline tooling and drivers. Feels heavier and opinionated; fine if you want its RTOS/driver ecosystem.

LL (Low-Layer) drivers
Thin, close to registers; efficient; more work than HAL.

HAL (Hardware Abstraction Layer) ✅ Recommended for beginners
High-level, readable APIs; fast to prototype; plenty of examples.
You can mix HAL and LL per peripheral in Cube settings.

The STM32CubeIDE Workflow (End-to-End)
Step 0 — Install STM32CubeIDE

Download from ST’s website, install with defaults. On Windows, the installer can also add ST-LINK drivers. On macOS/Linux, you’re generally good out of the box.

Step 1 — Create a New Project
File → New → STM32 Project
Board Selector: search your exact Nucleo/Discovery (e.g., NUCLEO-L053R8) and select it.
Peripherals like LED and USER button are pre-mapped for you.
Name your project (e.g., hello_world) → Finish.
When asked, accept Initialize all peripherals with default.

Step 2 — Configure Peripherals (Device Configuration Tool)

You’re now in the integrated CubeMX view:
Pinout & Configuration: Enable what you need (GPIO, UART, I²C, SPI, timers…). Cube assigns pins automatically; you can remap if needed.
Clock Configuration: Adjust PLL and bus clocks if you’re using an external crystal or need specific peripheral clocks.

Project Manager → Code Generator:
✅ Check “Generate peripheral initialization as a pair of .c/.h per peripheral” for a cleaner structure.

Example: Enable SPI1 as Full Duplex Master; Cube maps SCK/MISO/MOSI and creates spi.c/h with init code.

Step 3 — Generate the Project
Project → Generate Code. This writes the Core/ and Drivers/ scaffolding and peripheral init functions.

Step 4 — Understand the Files
Typical structure:

Core/
  Inc/      // headers (main.h, gpio.h, ... )
  Src/      // sources (main.c, gpio.c, ... )
Drivers/
  STM32xx_HAL_Driver/ // HAL sources
  CMSIS/               // Cortex & device headers

Your entry point is Core/Src/main.c.

Only write inside the marked regions:

/* USER CODE BEGIN Includes */
...
/* USER CODE END Includes */

Anything outside can be overwritten the next time you regenerate code.

Step 5 — “Hello World”: Button → LED

Goal: When the button is pressed, turn the LED on; otherwise off.
Open main.c and in the main loop add:

/* USER CODE BEGIN WHILE */
while (1)
{
  if (HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin))
    HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET);
  else
    HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
}
/* USER CODE END WHILE */

Notes:
B1_* and LD2_* macros are board-specific and come from the Board setup. You don’t need to hard-code ports/pins.
To toggle instead, you can use:
HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
HAL_Delay(200); // 200 ms

Step 6 — Build & Flash
Build: click the hammer (or Project → Build All). Zero errors? Great.
Program/Debug: click the bug. STM32CubeIDE will:
Detect ST-LINK, suggest a debug config, and offer firmware update if needed.
Load your .elf to the target and start a debug session.
You can now set breakpoints, step, watch variables, and hit Resume to run.
Going Deeper (Quick Wins)

A) Debounce the Button (simple)

uint32_t t0 = 0;
while (1) {
  GPIO_PinState s = HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin);
  if (s == GPIO_PIN_SET && (HAL_GetTick() - t0) > 30) {
    HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    t0 = HAL_GetTick();
  }
}

B) Use External Interrupt (EXTI)
In Pinout, set the button pin to GPIO_EXTI.
Cube generates HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin). In it:

if (GPIO_Pin == B1_Pin) {
  HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
}

NVIC tab: ensure EXTI interrupt is enabled.

C) Print Debug Text
Easiest: enable USART in Cube; in retarget.c or syscalls.c map printf to UART.
Alternative: SWV ITM (single-wire viewer) for printf-like tracing without using a UART (supported on many cores).

D) Mix HAL & LL
In Project Manager → Advanced Settings, set specific peripherals to LL for tighter control/latency, while keeping others on HAL for convenience.
Common Pitfalls & Fixes
“Target not found” / connect fails
Use a good USB cable.
Board powered (USB) and ST-LINK jumpers in default position.
Try a slower SWD frequency in the debug config.
On custom boards: verify SWDIO/SWCLK/GND/3V3 and NRST.
My code disappeared after regenerating
You edited outside /* USER CODE */ blocks. Move your code into the blocks and regenerate.

LED/Buttons don’t match pins
Check your board’s User Manual and the Pinout view. Board names (LD2, B1) map correctly when you picked the right Board in the selector.
HAL_Delay blocks everything
Use timers or interrupts for accurate, non-blocking tasks.
Adapting to a BluePill or Custom Board
In New Project, choose the exact MCU (e.g., STM32F103C8Tx) instead of a Board.
Manually enable GPIO, clocks, and any peripherals you need.

Program via external ST-LINK/V2 (SWDIO, SWCLK, GND, 3V3).

If you used an external crystal, configure it in Clock Configuration.

On first connect, do a Full Chip Erase from the debugger if needed.

A Clean Project Template You Can Reuse

Core/Inc/app.h, Core/Src/app.c for your application logic.

Leave main.c minimal (init + scheduler loop).

One module per peripheral/feature (e.g., led.c, buttons.c, uart.c).

Keep code inside USER CODE blocks; add your own blocks within your modules for consistency.

FAQ
Q: HAL vs. LL vs. Registers—what should I pick?
A: Start with HAL. Move hot paths or special cases to LL, and only drop to registers when you truly need it.

Q: Can I reuse my code across STM32 families?
A: Yes—HAL helps a lot. Pin names/peripheral instances may change; keep hardware-dependent bits isolated.

Q: Do I need an RTOS?
A: Not for simple apps. For multiple time-sensitive tasks, consider FreeRTOS (Cube can add it for you).

Next Steps (Mini Roadmap)

UART: send/receive text and logs.

I²C/SPI: talk to sensors and displays.

Timers/PWM: measure signals, drive motors/LEDs.

ADC/DAC: read analog sensors, generate waveforms.

FreeRTOS: structure complex apps with tasks, queues, timers.

Bootloaders & OTA: production-grade updates.

Low-Power modes: for battery devices (STOP/STANDBY, RTC wakeups).

Sample “Hello Button–LED” (Complete Minimal Main Loop)

Where to paste: Core/Src/main.c inside the /* USER CODE BEGIN WHILE */ loop.

/* USER CODE BEGIN WHILE */
while (1)
{
  if (HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin) == GPIO_PIN_SET) {
    HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET);
  } else {
    HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
  }
}
/* USER CODE END WHILE */

What Programming Language Is Used for Raspberry Pi? (A Practical, No-Nonsense Guide)

Alex Mo — Wed, 17 Sep 2025 02:44:55 +0000

If you’re holding a Raspberry Pi and wondering which programming language you’re “supposed” to use…good news: you’re not locked into one. The Raspberry Pi is a Linux computer (Pi 5/4/3/Zero) and, in the case of the Raspberry Pi Pico, a microcontroller board (RP2040). That means you can choose from many languages depending on what you’re building—automation scripts, full web apps, low-level robotics, data dashboards, or classroom projects.

This guide walks you through the most common languages on Raspberry Pi, why you’d pick each one, and how they fit into real projects. You’ll also see bite-size code snippets and a quick decision flow to help you choose confidently.

TL;DR — Pick by Project Goal

IoT/automation, quick prototypes, AI experiments: Python

Highest performance, real-time control, drivers: C/C++ (and increasingly Rust)

Web servers, REST APIs, dashboards, cloud glue: JavaScript/Node.js (and Go)

Enterprise/long-lived apps with strong tooling: Java (Pi4J, Spring Boot on ARM)

Learning/education & visual coding: Scratch

Tiny microcontroller projects (Raspberry Pi Pico): MicroPython/CircuitPython or C SDK

System scripting, glue code, cron jobs: Bash (with modern libgpiod tools)

The Big Picture: Pi vs. Pico

Raspberry Pi (5/4/3/Zero) runs Linux. You can install and run Python, C/C++, JavaScript/Node.js, Java, Go, Rust, Ruby, PHP, .NET (C#) and more.

Raspberry Pi Pico is not a Linux computer; it’s a microcontroller (RP2040). Typical languages here are C/C++ (official SDK) and MicroPython/CircuitPython. You flash firmware to the chip rather than running a full OS.

Keep this distinction in mind as you pick a stack.

Python — The Friendly Default (and Often the Fastest Path to Working)

Why Python: Raspberry Pi OS ships with Python, the community is massive, and hardware libraries (GPIO, I²C, SPI, UART) are beginner-friendly. For many automation and IoT tasks, Python gets you from idea to working prototype in minutes.

Great for:

GPIO control (LEDs, buttons, relays), small robots

Reading sensors (temperature, motion, distance)

AI/ML demos (TensorFlow Lite, ONNX Runtime)

Quick web dashboards (Flask/FastAPI + Chart.js)

Home automation (MQTT, Home Assistant integrations)

Starter snippet (blink an LED on GPIO 17) with gpiozero:

pip install gpiozero

from gpiozero import LED
from time import sleep

led = LED(17)
while True:
led.on(); sleep(0.5)
led.off(); sleep(0.5)

Pros

Batteries-included standard library, rich third-party ecosystem

Simple syntax; easy to teach, maintain, and share

Covers 80% of hobby/IoT use cases without touching C

Trade-offs

Slower than compiled languages for CPU-intensive or tight real-time loops

Long-running services benefit from structuring with systemd, venv, and logging

C and C++ — Maximum Performance and Control

Why C/C++: When you need deterministic timing, low latency, or direct access to peripherals, C/C++ is still king. This is also where you’ll write device drivers, performance-critical code paths, and robust robotics control.

Great for:

Real-time motor control, high-rate sensor fusion

Writing/porting libraries and daemons

Multimedia acceleration, video pipelines, SIMD jobs

Typical stacks: pigpio (C interface), libgpiod (modern GPIO), POSIX I/O, or talking to hardware over /dev/i2c-, /dev/spidev.

Tiny example (conceptual):

// Compile with: gcc -o blink blink.c -lpigpio -lrt

include

int main() {
if (gpioInitialise() < 0) return 1;
int pin = 17;
gpioSetMode(pin, PI_OUTPUT);
for (;;) {
gpioWrite(pin, 1); usleep(500000);
gpioWrite(pin, 0); usleep(500000);
}
gpioTerminate();
return 0;
}

Pros

Speed, determinism, and mature tooling (gdb, valgrind)

Huge existing codebase across embedded/Linux domains

Trade-offs

More lines of code and lower-level debugging

Memory safety and concurrency require discipline (or…see Rust)

JavaScript (Node.js) — Webby by Nature, Great for APIs & Dashboards

Why Node.js: If you think in web apps, sockets, and JSON, Node on a Pi feels natural. It’s perfect for exposing device data over HTTP/WebSocket, serving a dashboard, or piping events to the cloud.

Great for:

REST APIs and realtime dashboards (Express, Socket.IO)

MQTT brokers/clients, cloud integrations (AWS/GCP/Azure)

Lightweight automation services with npm ecosystem

Blink with onoff:

// npm i onoff express
const Gpio = require('onoff').Gpio;
const led = new Gpio(17, 'out');

// Tiny REST API to toggle LED
const express = require('express');
const app = express();
app.post('/led/:state', (req, res) => {
led.writeSync(req.params.state === 'on' ? 1 : 0);
res.json({ ok: true });
});
app.listen(3000, () => console.log('Listening on 3000'));

Pros

Massive ecosystem (npm), async I/O is a natural fit for IoT

Pairs nicely with React/Vue/Svelte front-ends

Trade-offs

Single-threaded event loop needs care under CPU load

Native modules require ARM builds when needed

Java — Industrial-Strength with a Mature IoT Tooling Story

Why Java: For teams that want structured, long-lived services and excellent observability, Java on ARM works well. You can use Spring Boot for web services and Pi4J for GPIO/I²C/SPI.

Great for:

Enterprise IoT gateways, OTA-updateable services

Complex state machines and integrations

Multi-module projects with strong testing suites

GPIO (Pi4J-style) sketch:

// Pseudo-style to show the idea
var pi4j = Pi4J.newAutoContext();
var led = pi4j.dout().create(17);

while (true) {
led.high(); Thread.sleep(500);
led.low(); Thread.sleep(500);
}

Pros

Excellent tooling, profiling, packaging, CI/CD

Strong type system and libraries

Trade-offs

Heavier footprint than Python/Go for tiny tasks

Startup time and memory need tuning for small Pis

Go — Fast, Simple, Deployable as a Single Binary

Why Go: Compiled performance, easy concurrency (goroutines), and static binaries make Go a favorite for resilient device agents, brokers, and network services.

Great for:

Telemetry collectors and MQTT gateways

Concurrency-heavy services (many sockets, sensors)

Command-line tools and daemons

Blink with periph.io (conceptual):

// go get periph.io/x/conn/v3 periph.io/x/host/v3 periph.io/x/host/v3/rpi
package main
import (
"time"
"periph.io/x/host/v3"
"periph.io/x/host/v3/rpi"
)

func main() {
host.Init()
pin := rpi.P1_11 // GPIO17
for {
pin.Out(true); time.Sleep(500 * time.Millisecond)
pin.Out(false); time.Sleep(500 * time.Millisecond)
}
}

Pros

Memory-safe, fast, great cross-compile story

Easy to ship (single binary + systemd service)

Trade-offs

Fewer electronics-specific libs than Python/C, but growing strong

Rust — Performance with Memory Safety

Why Rust: If you want C-class performance with modern safety guarantees, Rust is compelling. On Pi, the rppal crate gives access to GPIO, I²C, SPI, and UART. It’s excellent for reliable, long-running device services.

Great for:

Robust daemons needing low-level access without GC

Concurrency and correctness with fearless refactors

Performance-critical workloads

Blink with rppal:

// Cargo.toml: rppal = "0.16"
use rppal::gpio::Gpio;
use std:🧵:sleep;
use std::time::Duration;

fn main() -> rppal::gpio::Result<()> {
let mut pin = Gpio::new()?.get(17)?.into_output();
loop {
pin.set_high(); sleep(Duration::from_millis(500));
pin.set_low(); sleep(Duration::from_millis(500));
}
}

Pros

Memory safety, expressive types, great perf

Ecosystem for embedded (embedded-hal), Linux (tokio, axum)

Trade-offs

Steeper learning curve; compile times can be longer

Scratch — Visual Coding for Fast Learning

Why Scratch: It’s block-based, kid-friendly, and terrific for workshops. You can control GPIO through extensions or bridge tools and show immediate feedback on physical hardware.

Great for:

Education, clubs, first-time makers

Quick demos without typing syntax

Pros

Minimal barrier to entry

Visual logic helps teach fundamentals

Trade-offs

Not designed for complex or performance-sensitive apps

MicroPython & CircuitPython (Raspberry Pi Pico / RP2040)

Why MicroPython/CircuitPython: On the Pico, you’ll often choose MicroPython/CircuitPython for instant sensor tinkering without toolchains. It’s REPL-friendly and ideal for classroom microcontroller work.

Blink (MicroPython):

from machine import Pin
from time import sleep

led = Pin(25, Pin.OUT) # Onboard LED on many RP2040 boards
while True:
led.toggle()
sleep(0.5)

When to use the C SDK on Pico:

Highest performance, tight real-time timing, or when you need precise control and memory efficiency.

Bash & System Tools — The Underrated Superpower

Sometimes you don’t need a full app—just a shell script and cron.

Examples:

Log sensor data every minute and append to CSV

Call gpioset/gpioget (from libgpiod) for simple pin control

Glue scripts that call Python/Node/Rust services and rotate logs

!/usr/bin/env bash

Quick LED toggle using libgpiod tools

gpioset gpiochip0 17=1
sleep 0.5
gpioset gpiochip0 17=0

Pros

Zero extra runtime, perfect for automation glue
Trade-offs

Not ideal for complex logic or long-running network servers

Other Languages You Can Use

PHP — If you’re turning the Pi into a LAMP stack web server

Ruby — Scripting and lightweight web apps (Sinatra/Rails)

C#/.NET — Modern .NET runs on ARM; good for teams in Microsoft stacks

Swift — Community builds exist; handy for cross-training Apple-centric teams

R/Julia — Data analysis and scientific computing demos

Common Project Stacks That Work Well

Python + MQTT + InfluxDB/Grafana: Sensor network with a slick dashboard

Node.js (Express) + React/Vite: All-JavaScript device UI and control

Go service + NATS/MQTT: Lightweight, resilient message processing

Rust daemon + Python notebooks: Safe, fast device core; easy data analysis

Java (Spring Boot) + Pi4J: Enterprise-grade IoT gateway with strong ops

Getting Set Up (Quick Notes That Save Time)

Virtual environments (Python): python3 -m venv .venv && source .venv/bin/activate && pip install ...

Systemd services: Keep your app alive across reboots; add a unit file in /etc/systemd/system/ and systemctl enable --now yourapp.service

GPIO tooling: Prefer modern libgpiod (gpiodetect, gpioset, gpioget) over legacy sysfs paths

Node on ARM: Use nvm to manage Node versions; rebuild native modules on the Pi

Cross-compile (Go/Rust/C): CI can produce ARM binaries; test on device for hardware access

Security basics: Use a non-root user, keep ports closed by default, and rotate logs

FAQs

Q: Can I use C#/.NET on Raspberry Pi?
A: Yes. Modern .NET runs on ARM. You can build console services, web APIs (ASP.NET Core), and access GPIO via .NET IoT libraries. It’s a solid choice for teams in the Microsoft ecosystem.

Q: Is Python too slow for “real” robotics?
A: For many robots, Python is fine—especially when the heavy lifting is delegated to native libraries (OpenCV, NumPy) or a microcontroller that handles the tight loops. For strict real-time control, move critical paths to C/C++ or Rust and call them from Python.

Q: RPi.GPIO vs. gpiozero vs. pigpio?
A: gpiozero is the friendliest high-level API; pigpio (daemon-based) is great for precise timing and works with multiple languages. RPi.GPIO is low-level and simple but less ergonomic for beginners.

Q: Which language is “fastest”?
A: In raw speed, C/C++ and Rust typically lead, then Go/Java/Node, then Python/Scratch. But “fastest to working prototype” is often Python.

Q: What about Raspberry Pi Pico?
A: Use MicroPython/CircuitPython for easy tinkering or the C SDK for maximum control and performance.

Example Mini-Project: Temperature API in 3 Flavors

Python (FastAPI):

pip install fastapi uvicorn smbus2

from fastapi import FastAPI
from smbus2 import SMBus

app = FastAPI()
I2C_ADDR = 0x48

@app.get("/temp")
def read_temp():
with SMBus(1) as bus:
raw = bus.read_byte(I2C_ADDR) # demo: pretend 1-byte temp
return {"celsius": raw}

Run: uvicorn app:app --host 0.0.0.0 --port 8000

Node.js (Express):

// npm i express i2c-bus
const express = require('express');
const i2c = require('i2c-bus');
const app = express();
app.get('/temp', async (_, res) => {
const bus = await i2c.openPromisified(1);
const raw = await bus.readByte(0x48, 0x00); // device/register: demo only
await bus.close();
res.json({ celsius: raw });
});
app.listen(8000);

Go (net/http):

// go get github.com/d2r2/go-i2c
package main
import (
"encoding/json"
"net/http"
"github.com/d2r2/go-i2c"
)

func main() {
http.HandleFunc("/temp", func(w http.ResponseWriter, r *http.Request) {
i, _ := i2c.NewI2C(0x48, 1); defer i.Close()
// demo: single-byte read
b := []byte{0}
i.ReadBytes(b)
json.NewEncoder(w).Encode(map[string]byte{"celsius": b[0]})
})
http.ListenAndServe(":8000", nil)
}

Pick the flavor that matches your team and deploy style; all three get you a simple HTTP endpoint you can chart in a front-end or ship to the cloud.

Key Takeaways

There’s no single Raspberry Pi language—choose by project constraints (performance, timing, web UI, team skills).

Python wins for approachability and peripherals; C/C++/Rust win for tight timing; Node/Go/Java win for services and scale.

For Raspberry Pi Pico, think MicroPython (speed of learning) or C SDK (speed of execution).

A Simple Plan to Start (Today)

Define the goal: sensor → API → dashboard? robot → motor control?

Pick the language using the decision flow.

Run a blink or sensor read in your language within 30 minutes.

Wrap it in a service (systemd), log it, and secure the port.

Iterate: add cloud, dashboards, and alerts as needed.

If you do that, you’ll be productive on Raspberry Pi—no matter which language you start with.

AD-FMCOMMS5-EBZ Evaluation Board Overview

Alex Mo — Fri, 27 Jun 2025 05:55:35 +0000

The AD-FMCOMMS5-EBZ is a high-performance RF transceiver evaluation board developed by Analog Devices. At the heart of the board are two AD9361 chips—highly integrated RF agile transceivers capable of operating from 70 MHz to 6 GHz. Each AD9361 integrates a full RF signal chain including mixers, filters, low-noise amplifiers (LNAs), and digital baseband processing blocks.

This evaluation board is primarily designed to demonstrate and test the capabilities of the AD9361 in MIMO (Multiple Input, Multiple Output) configurations. It supports dual-channel transmission and reception, making it suitable for evaluating complex wireless systems including LTE, WiFi, radar, and software-defined radio (SDR) applications.

Key Features:
Dual AD9361 transceivers for 4x4 MIMO support

SMA connectors for RF input/output signal interfacing

High-precision crystal oscillator providing stable clock signals to ensure accurate RF performance

Matched impedance transmission lines for high-frequency signal integrity

Various passive components (resistors, capacitors, inductors) to support signal conditioning, biasing, and filtering

Compatible with FMC (FPGA Mezzanine Card) interfaces, making it ideal for integration with FPGA development platforms such as Xilinx Zynq UltraScale+ or Intel FPGA boards

Applications:
Wireless Communication Systems Development
SDR (Software-Defined Radio) Prototyping
MIMO System Testing
Radar Signal Processing
5G and LTE Testbeds

This evaluation board provides researchers and engineers with a versatile platform for rapid development and in-depth testing of RF systems.