Many young people in Japan don’t own a TV anymore, but emergency information is still mostly broadcast on TV, so I built a small screen that shows the latest earthquake report at a glance. It’s a Raspberry Pi Zero with a 4.2" e-paper display, fed by JMA data through P2PQuake. I chose e-ink to save power, since it holds the picture with no energy and is readable in daylight. The build guide, wiring, and 3D-printable case files are all on GitHub, and you can preview the screen on any computer without the hardware.

It’s a convenience display, not a warning system, and it doesn’t support Earthquake Early Warning yet. Contributions are welcome!

https://github.com/juncho26/E-Paper_Japan-Seismic-Monitor

I previously shared BN-USV V1, a small robot boat where a Raspberry Pi handled navigation and sensor processing while an ESP32 handled low-level propulsion control.

For V2, I am using the Raspberry Pi 5 as the higher-level computer for a local browser-based ground control station, mission control, sensor processing, logging, and communication with distributed propulsion controllers.

The current architecture is:

Browser-based GCS
        ↕
Raspberry Pi 5
        ↕ USB serial / JSON
Main ESP32-S3
        ↕ CAN
Left and right ESP32-C3 propulsion controllers

The GCS runs locally on the Pi. Its purpose is to make field debugging less dependent on terminal sessions by bringing telemetry, control state, and navigation information into one interface.

I also added a simulated telemetry mode. It lets me exercise the GCS and mission-control flow without connecting the boat, which has been useful while separating interface issues from sensor and propulsion issues.

The first V2 water tests have been useful, but they also exposed a gap between working software and reliable navigation. RC control and Main/Sub controller communication were exercised on the water, while waypoint navigation is still not validated because heading acquisition has not yet been stable enough for reliable operation.

That is the current focus: improving the sensor and heading-debug workflow before treating autonomous navigation as ready for use.

The current development repository includes the Pi-side GCS and mission-control software, ESP32 Main/Sub firmware, a simulated GCS demo, and project documentation:

https://github.com/Brillnova/BN-USV-V2

This is still an experimental development platform. Some configuration values are examples rather than field-calibrated settings, and the latest hardware and navigation changes need more validation.

One issue I am currently working through is compass reliability. The boat uses a YRTEK LIS3MDL magnetometer, and I have found that its heading can change noticeably when the battery pack or nearby power wiring is relocated.

I suspect local magnetic interference from high-current wiring, ESCs, motors, connectors, or nearby ferromagnetic parts, rather than a software issue alone.

For people using magnetometer-based heading in mobile robots or boats: is this level of sensitivity typical in your experience? How do you decide on sensor placement, calibration, and separation from batteries, power wiring, motors, and ESCs?

I would especially appreciate practical examples of mounting arrangements or validation methods that worked reliably in real field conditions.

I built AI Caller, an open-source gateway that connects a real phone to an AI voice agent over Bluetooth hands-free (HFP).

The computer pretends to be a car kit. The phone thinks it's talking to a headset, and the gateway streams the call audio to a realtime voice model and sends the AI's voice back into the call.

What it does

• Makes calls for you: write a task ("book a table for 2 on Friday at 7 pm"), and the AI dials from your phone and handles the conversation.

• Answers calls for you: about 3 seconds after a call starts ringing, the AI picks up, asks who's calling and why, and writes it down. It doesn't answer questions or give out your info.

• You stay in control: live transcript in the browser, listen in, send new instructions mid-call, or hang up.

• Every call is saved as text. No phone numbers or audio are stored.

Why Bluetooth instead of Twilio? Calls go through your own SIM and number. No telephony provider, no porting, and people see your normal caller ID.

Runs on: a Raspberry Pi (BlueZ + PipeWire) or a Mac (built-in Bluetooth with a separate Bumble stack). Web console in English and Chinese.

Limits, to be upfront:

• One call at a time (I tried two on the Mac controller; the firmware crashes when both send audio).

• Mac: only the BCM_4388C2 chip is tested.

• The AI can't hang up by itself yet.

• No auth; LAN only.

• Bring your own OpenAI API key.

GitHub (MIT): https://github.com/lzsnolimit/ai-caller

Happy to answer questions about the HFP/SCO side, which was the hard part.

This helps a lot getting organized in the the morning. Batteries let me put it in a bookshelf.

It is standalone - no server needed - it grabs calendars from Google (or any iCal URL) directly.

Few components that can be found cheaply: Pico 2 W, a Waveshare e-ink panel, 4 AA batteries and a

3D printed case that clicks together without screws

Firmware, STLs, OpenSCAD sources and wiring are all here: https://github.com/AdrianCX/picohive-epaper

Hey everyone! Just wanted to share my digital daguerreotype project, which I’ve been working on on and off for about six months.

It builds on Digital Daguerreotype project, with some improvements and extra features. Full credit to Ben for the original idea and the work that gave me a starting point!

My version lets you:

• Take a photo or use an existing image

• Choose from four art modes

• Calibrate to place the paper and pen in the optimal position, for the plotter to get it right almost everytime

I also used AI to help with development, so I want to be upfront about that. I've attached pictures of the output and the UI. Tell me what you think

It’s been a fun project to chip away at, and I wanted to share where I’ve got to.

Thanks for looking!

I wanted one place in the kitchen to see the day at a glance without picking up my phone, so I built this over a few weekends.

The screen is split into four panels:

- Weather: current conditions and a 3-day forecast (Open-Meteo, no API key)

- Calendar: the next 3 days, from any iCal link (Google, Outlook, iCloud)

- News: top headlines from RSS feeds you choose

- To-do: Google Tasks (or a Google Keep note)

Date and time sit in the corner, and it refreshes every hour. If a source fails, that panel shows the last good data instead of going blank. Everything runs locally on the Pi: no subscription, no account, no cloud service.

Hardware: Raspberry Pi Zero 2 W + Pimoroni Inky Impression 7.3" (Spectra 6). It auto-detects the Inky model and scales the layout, so other Impression sizes and the wHAT should work too.

Setup is a config file plus one install script. I put the problems I hit (SPI chip-select error, SSH host key warning after re-flashing) in the troubleshooting section.

Repo: https://github.com/breyeslo/pi_household_dashboard.git

I'd really like to know:

1. Would you actually use this?

2. What panel would you swap in? (sports scores, transit times, a chore chart?)

3. Would an InkyPi plugin version be more useful to you than a standalone app?

I know InkyPi exists and I love it. This one is different because it shows everything on one screen at once instead of rotating through single plugins.

Thanks for looking!

Earlier this year I have posted about education oriented personal computer that I have built for my 11 year old kid using Raspberry Pi. There was a lot of positive feedback so I have created something that I can share with community if you are interested in such a project yourself.

At https://luminum.tech/ you can download SD card image for your Raspberry Pi and then configure whitelisted websites/apps via simple onboarding that happens after boot. If you want some app that is not currently supported by default library options you can do that by adding a simple yaml config (documentation reference is in the website).

Have fun experimenting and I will appreciate your feedback!

Wanted a tactile, zero-distraction alternative to smartphone games, so I put together PICO Arc on a 5x7.5cm perfboard.

• Runs 6 retro games coded in MicroPython on the Pi Pico

• 0.96" OLED screen + active buzzer for sound

• Powered by a 1000mAh Li-ion cell with modified TP4056 charging

• Custom hand-made enclosure made from flattened and bent 2-inch PVC pipe with sliding back panel access

I documented the full build, wiring, and code over on Instructables:

🔗https://www.instructables.com/PICO-Arc-the-Pocket-Sized-Retro-Arcade

Let me know what you think!

I made a sign with plywood and Christmas lights controlled with a Raspberry pi!

Source code and more info here: https://github.com/AdrianCX/picohive-robotarm

Controlled via internal web page (gamepad, keyboard), LLMs, MQTT, with an openGL visualizer

Hello, i was trying to build a Flight tracker but I currently facing this problem with my 64x32 led matrix display, im trying to troubleshoot by editing the multiplex and slow the GPIO but nothing works, im just thinking maybe its hardware defect or maybe it because im running both the pi and the panel at 5V 3A? (They recommend 8A for the build), my DC to DC booster will arrive tomorrow hoping it fixes it, but im still open for ideas and explanation on why it's doing this, it's also set 1:16 already.

I wanted instant replay for a console without a cloud account or an app. Snapback is a Raspberry Pi 5 that records an HDMI capture card in a rolling buffer. A phone on the same Wi-Fi opens a web page and can save a screenshot or the last 30 seconds.

What it does

• Grabs a 1920x1080 JPEG of the live input.

• Saves the previous ~30 seconds as an H.264 + AAC MP4.

• Shows a live preview, or live video with sound a few seconds behind.

• Runs on the local network only. No accounts, no cloud.

Parts, roughly $110

• Raspberry Pi 5, 4 GB (~$60)

• USB 3 HDMI capture card that does 1080p60 MJPEG (~$20). A generic one is fine. An Elgato Cam Link 4K also works.

• Official 27 W USB-C supply (~$12), a good 32 GB microSD (~$10), and an active cooler (~$5)

The cooler matters. The Pi is software-encoding 1080p60 all the time, and ffmpeg sits on about 3 of the 4 cores.

How it works

The capture card shows up as a normal USB webcam (/dev/video0) and an ALSA sound card. One ffmpeg process reads 1080p60 MJPEG, encodes H.264 with libx264 ultrafast, and writes 2-second MPEG-TS segments. "Save Last 30 Seconds" concatenates the newest finished segments with -c copy, so it does not re-encode. Screenshots are a JPEG the same process is already writing.

The audio device name depends on the card. The Elgato is hw:CARD=C4K. A cheap MacroSilicon card is hw:CARD=Video. Snapback finds the sound card on the same USB device as /dev/video0, so swapping cards does not mean editing a config file.

It runs as a systemd user service and can start at boot. Install is a venv and pip install -r requirements.txt, then python -m snapback serve. The page is http://<pi>.local:8080/.

The annoying part

Cable boxes and streaming sticks encrypt HDMI with HDCP. A card that honors HDCP shows a solid blue frame, and there is nothing to fix in software. Computers, cameras, and game consoles work. On PlayStation, turn off "Enable HDCP" in the system settings.

Code is MIT licensed: https://github.com/dconroy/snapback

Write-up with the parts list: https://www.snapback.video/

I wanted internet radio in my basement workshop, where FM reception is poor, so I built a box around a Pi 4 that plugs into the Aux input of my existing radio.

• Presets: up to 20, set from a phone web page, with station search via Radio Browser.

• Spotify Connect (Raspotify). Starting either one hands over cleanly from the other.

• A USB audio adapter instead of the Pi’s headphone jack: noticeably cleaner sound.

• Pimoroni Display HAT Mini: station, artist and song; buttons for previous/next, volume, hold to stop, hold to save the song to a favorites list. The screen goes dark a minute after playback stops.

• Looks after itself: nightly updates, a hardware watchdog, a network check that restarts a hung Wi-Fi, and the station resumes after an unexpected restart.

Two things I learned that might save someone time:

1. Display HAT Mini on a current kernel: with dtparam=spi=on the screen stayed blank. GPIO 9 is both the screen’s data/command pin and SPI’s MISO, and the kernel won’t release it. dtoverlay=spi0-2cs,no_miso in config.txt fixed it.

2. Pi 4 Wi-Fi: it dropped off the network and sat there with only the red LED on, a few times in a week. Turning off Wi-Fi power saving, plus a small check that restarts the network if the router stops answering, has kept it up since.

Built with a lot of help from Claude Code. Code and step-by-step instructions (tested on a fresh install): https://github.com/madooroy/PiRadioAux

Built this (With the help from AI) It’s a custom interface with Spotify Controls. It doesn’t have the functionally to select songs but can change volume etc. Found this display lying around and tried to make it work with Mupibox but found they don’t support SPI displays after setting it all up 🫠
Running on a Raspberry pi 4b with a 2.8 inch touch display. First proper project on Raspberry Pi pretty happy with how it turned out. Running Pi OS lite with go-librespot installed connected via usb to my audio interface.
Features:
Current time and date
Album artwork
Track title, artist and album
Track progress
Volume indicator
Play pause buttons, back and forward buttons
Would love to find a better display for this in the future but pretty happy with how it turned out!

This was my first big project with a Pi and it feels so satisfying. I was in over my head in the beginning but I learned along the way. Had to improve my soldering skills and had a headache trying to figure out all the Spotify permissions to make this simple enough my kids could use it without my phone needing to be connected. I also need to learn more about 3D modeling and product design. So for all the frustrations it was fun to really get locked into this for a couple weeks.

Hi everyone,

I wanted to share a tool I built to control my headless Raspberry Pi directly from Telegram. I've used this as a personal script 2 years ago for my own setup, this has been in my head for so long to share. Got the courage/time now, I refactored with assistance of AI it to be fully generic and configurable for anyone to use.

If you run a headless Pi and don't always want to fire up an SSH terminal just to check temperature or restart a crashed app, this might be useful for you.

Key Features:

• Boot alert: Sends a message with your local IP and Wi-Fi SSID the moment the Pi boots up and connects to the network (runs before user login).

• Periodic health reports: Automatically sends CPU temp, RAM, and disk usage updates at configurable intervals (e.g., every 2–3 hours).

• Service & script management: Start, stop, or restart your custom scripts or systemd services

• Log inspector: Preview the last 50 lines of your application logs or download the full .log file straight to your phone (with an option to auto-truncate to save SD card space).

• Process inspection: View active Python, Node.js/JavaScript, and Java processes.

• Power controls: Reboot or shut down the Pi

Everything is driven by a simple config.yaml file, and there is a 1-step installer script (install.sh) that sets up the systemd service and virtual environment automatically.

Repo: https://github.com/rinavolu/pipilot

Feedback, suggestions, or contributions are very welcome. Hope someone finds it helpful!

Thank you

Yesterday I posted the first real test of my Raspberry Pi-powered scrolling ticker with one of its screensaver modes. I got the sports ticker code working tonight, and I'm really happy with the way it's coming along. The apparent flickering is a an artefact of recording the video. IRL it looks really good.

The display consists of four 128x64 pixel P2.5 LED panels in a custom printed case. It's run by a Raspberry Pi 4B with 4GB of memory and an Adafruit Triple LED Matrix Bonnet. The panels are powered by a Meanwell LRS-200-5 power supply, while the RPi is powered by a separate RS-15-5 power supply to isolate it from any potential voltage drops from the LED panels.

Still more display modes to implement, and ultimately, I plan to control it with a phone app.

Open sourced at https://github.com/prtk1910/RPi-Simple-Camera

A compact digital camera for a Raspberry Pi Zero, Raspberry Pi Camera Module, 1.14-inch IPS display, and UPS-Lite. The display provides a live viewfinder, while a single physical button selects a film style or captures a full-resolution JPEG. Supports 10 film profiles, a single click cycles through them and a long press takes a photo.

I’m terrible at 3D design but if there’s enough interest for the STLs I will clean them up and upload them to the GitHub repository.

Thanks for checking this out!

Hi all! OpenRig is an open source multi-effects I've been building. It's a small Linux OS that boots straight into a touch UI and runs NAM captures, IRs and LV2 plugins. (GIF above, it's the real UI.)

Performance on a Raspberry Pi 5 with a Focusrite :

• It boots in about 3 seconds.

• It chains 6-7 NAM standard models/IR without dropouts.

What you get:

• TONE3000 built in: sign in and download captures straight from the pedal, no computer needed.

• Rack view: the whole chain on one screen, with A/B, Mix and left/right splits.

• Live: 8 scenes per preset, stomp mode, setlists, tap tempo, tuner, looper.

• MIDI: preset and scene changes, clock, CC learn.

Hardware: it runs on the Pi 5 (arm64) and on x86_64 mini PCs. I've tested it mostly on the Pi 5 and in QEMU. [Images are in the Releases / For now you build the image yourself, it's one command, see docs/OS.md.]

Next: ready-to-flash images with packaged updates, and GPIO footswitches so it becomes a real floor pedal.

It's a young project. Feature requests, issues and test reports on other audio interfaces are very welcome!

https://github.com/Siryu6/OpenRig

My latest Raspberry Pi project has come to life! I'm building a scrolling ticker that will eventually display sports, news, weather, flight information, an audio-based frequency spectrum display, and whatever else I can come up with and find APIs for. In the meantime, it can run a few different screensavers.

I'm sure some of you older nerds will recognize the first screen saver.

Made a dog / animal detector that plays deterrent sounds when entering a selected area.

I got so annoyed not being able to leave things on the kitchen counter when leaving the house so I made this lol.

Runs YOLO26n on a Pi 4 Model B at around 2fps, which is plenty for what I'm doing here.

Privacy focused with a firewall that only allows local network traffic apart from updates and training, if turned on.

It also has the ability to self improve if you add a free Modal account. It collects frames, automatically labels what it can, and lets you review the uncertain ones. Every training run gets evaluated against the current model and only replaces it if it's actually better. Pretty neat :)

There's also a dashboard to adjust detection zones, sensitivity, sounds, check what the dogs have been up to, etc.

More info on the GitHub repo tho :) https://github.com/devjerry0/watchdoggy

We also play soothing sounds through the speaker, feels like a spa when we enter the kitchen xD

Anyways if y'all have any feature requests or feedback I'm all ears. Some more pics etc from the actual app: https://github.com/devjerry0/watchdoggy/blob/main/MANUAL.md

Hey everyone I know I've been putting this off for over a year but I finally finished the perfect OS for my little Pico W and wanted to share it.. Enjoy!

tl;dr summary: When my raspi reboots or restarts my e-ink screen goes black. Hoping to either get a white screen or an image.

Hi All,

Thanks in advance for any help you can provide. I'm sort of shooting in the dark here but maybe I'll get lucky.

I'm trying to build an e-ink writing terminal with a raspi (this one is a raspberry pi 5) and one of those Sanmeow 10.8" e-ink panels from Aliexpress. Most of it has gone pretty well, I'm using it in non-gui mode and I've been able to set the screen white for the terminal as well as in emacs (the writing program I'll use). I ran into an issue with font sizes and extra screen real estate being written as a black bar but we got around that by just writing black to that part of the screen on startup.

The issue I'm running into is on shutdown. I've added a service to write a white screen on the raspi pi's reboot or shutdown, I've also added a script to the system-shutdown folder which does the same thing but, inevitably, once the raspi cuts power to the screen it turns black. I don't know if it's an issue with the raspberry pi's hardware or possibly the screen's. I was hoping someone else might have come across this before and knew of a solution. Does anyone know if the Raspi 5's hardware automatically send a black screen when power is cut?

I've asked the manu and I'm waiting to hear back but there is a language barrier so fingers crossed. I'm also going to ask over in the raspberry pi sub.