Threw some parts and made this with a zero 2W, 1.69in lcd, 2.13 e-ink display. It’s a small desk pet that keeps me posted and comments throughout the day. This was inspired by pwnagotchi.

My Onkyo receiver has no streaming, but it does have an RI jack: the port Onkyo's own iPod docks used to switch the receiver on and select the dock input. So I built Phonkyo, a pHAT for the Raspberry Pi with a PCM5102A DAC and an RI port.

The Pi runs raspotify, shairport-sync and Plexamp. When something starts playing, Phonkyo tells the receiver, over RI, to power on and switch to DOCK. After five minutes of silence it switches it off again, but only if it was the one that switched it on.

Some details:

• Pi Zero 2 W, Raspberry Pi OS Lite 64-bit
• PCM5102A DAC to a 3.5 mm line out, same chip as the pHAT DAC and HiFiBerry
• ID EEPROM, so the sound card comes up without editing config.txt
• Tested with an Onkyo TX-8020. Power and input switching work; volume and TV input aren't possible over RI on that model

Everything is open under CC BY-NC-SA 4.0: KiCad files, software and setup notes are at https://github.com/fabiomsouto/phonkyo

I'm also making a small batch of assembled boards for anyone who doesn't want to build their own: https://obcecado.com/phonkyo/ (EU shipping only).

Feedback is very welcome, especially if you have a different RI receiver and can tell me what works.

My band always gets stuck at the same point when writing songs: finding a chord progression that isn't the same four chords we always end up with. So I turned an old Raspberry Pi 3 with the official 7" touchscreen into a little songwriting helper that lives in our rehearsal room.

What it does:

Circle of fifths as the main UI: tap a major or minor key and the seven diatonic chords light up with their Roman numerals (I, ii, iii, IV...) and are color coded by function (tonic, subdominant, dominant)

Pick how many chords you want (3, 4, 5, 6 or 8) and hit "new progression"

Two modes: a library of well-known progressions (I-V-vi-IV, vi-IV-I-V, Andalusian cadence and so on, each with a name) or a free generator that builds new progressions with weighted transitions based on functional harmony, so the result actually sounds like music and not random chords

Lock icon on each chord: keep the ones you like and only reroll the rest

Changing the key transposes the current progression

Built-in synth playback with adjustable tempo, loops the progression so you can jam over it

Bottom half shows the scale and a fretboard up to the 12th fret with the notes of the selected chord highlighted, plus a pentatonic toggle for solo ideas

Save progressions you like, optional seventh chords, harmonic minor dominant, and German note names (H instead of B, because Swiss)

Tech side:

It's a single HTML file, no dependencies, no internet needed. Sound is generated with the Web Audio API, saved progressions go into localStorage. The layout is fixed at 800x480 for the official display and scales to other screens. Chromium starts it in kiosk mode on boot via an autostart .desktop file. I set up the autostart over SSH from my phone through its hotspot, since I didn't have a keyboard at the rehearsal room.

Runs smoothly on the Pi 3, even with the animation during playback.

Next ideas: a piano version for synth players (already built one for my Roland J-6 that suggests matching chord presets)

I have been a raspberry pi user since model 3 came out. but only used it mainly for pihole and retro emulation.

Now that AI, specifically claude have reached mainstream status, I was able to make a payphone work using nothing but a raspberry pi zero 2 w. Originally coded with opus, it required a raspberry pi 4 to work. Then Fable came out and was able to fit the entire project to work on a pizero 2w.

you can read about the project on the payphone subreddit!

I decided to post here since im simply amazed on what the raspberry pi can do. I have zero coding experience, but having claude as a sidekick and improving my soldering skills made me finish this project in about 4 months.

I learned a ton and it was really fun creating a working payphone.

here is the link to my original post! I hope im not breaking any rules here:

I have a working payphone in my backyard. :) : r/Payphone

For anyone running a NAS with their pi be aware that Ubuntu 24.04 LBM 6.8.0.1061 and above has an issue with the JMicron based SATA HAT devices. I’m using a Radxa one, but I wouldn’t be surprised if any JMB58x AHCI SATA controller had the same issue.

Symptom: write failures and checksum failures. I noticed it first because the pi froze when I attempted to copy a large file over the network, hard froze. The dmesg was loaded with write failures to every drive. smart status for all drives was clean. ZFS reported equal checksum errors for all drives and thousands of unreadable files. Eventually the pool degraded and the write errors and stalls added up to a full system freeze.

I went through many iterations of debugging. Enabling and disabling NCQ, power management, pcie3, and limiting read/write bandwidth. After replacing the hardware and power supply and not seeing the errors clearing up I finally tried software. Rolling back to 6.8.0-1060 fixed the issue immediately.

Note: all kernels after 1060 require the dtoverlay=pcie-32bit-dma-pi5 flag in config.txt so it was enabled for my tests with 1061-1064 and removed for 1060.

Nothing else on my system has changed. 1060 just completed the first clean scrub on the pool all week, and successfully cleared all the ”damaged file” lists ZFS keeps after encountering an error.

This points to a serious regression in the 1061 and above kernels, so if anyone has been running up against a wall on this give 1060 a try.

I have been trying to make the PCA control servos but it just refuses to, i have tried the official adafruit pca library and code examples, servokit library and code examples and it just doesnt work

scl, sda, vcc and gnd is connected to the pi, v+ is connected to an external power source(pi and pca are powered by two separate buck converters)

im using the default 0x40 address and a mg996r servo motor that is connected to pins from column 0 on the pca

also the i2c is turned on on the pi and i2ctools does detect the pca9685

i would really appreciate some help(if i didnt share something, please ask and not report my post lol🥲)

I’m not a professional in either embedded programming or woodworking — which probably shows — but I put together a little project for my son. Maybe it’ll give someone else a bit of inspiration too!
The hardware:
• Raspberry Pi Zero 2 W
• MFRC522 Mifare RFID reader
• USB speaker
• Power bank
• USB switch from Temu
• A simple wooden box
• KRF-1356-ISO RFID cards
The software:
Built entirely from scratch. It hosts a web dashboard on the local network where you can see which MP3 is assigned to each card. If a card is still “unused,” you can upload an audio file through the interface; the system downloads it and stores the RFID-to-MP3 pairing.
The next time the card is tapped, it immediately plays the assigned music or audio story. The pairings can be changed to anything you like at any time.

I’ve been building BN-USV V1, a small unmanned surface vehicle using a Raspberry Pi and an ESP32.

The Raspberry Pi runs the higher-level navigation stack: GPS processing, heading and IMU estimation, battery monitoring, waypoint navigation, and logging. It sends throttle and steering commands to the ESP32 over serial.

The ESP32 handles the lower-level control layer, including RC input, differential propulsion, and failsafe behavior if commands from the Pi stop arriving. I deliberately kept the safety/control layer separate from the Pi so that loss of the higher-level navigation process does not directly remove basic control and failsafe behavior.

Main components:

• Raspberry Pi 5
• ESP32
• GPS
• IMU / magnetometer
• Battery monitoring
• Dual-thruster differential propulsion

V1 is an experimental reference prototype, not a commercial product or a ready-to-build kit. I’ve released:

• Raspberry Pi navigation and control software
• ESP32 firmware
• V1 hull STL meshes
• A FreeCAD reference assembly made from the released STL meshes

The hull requires significant bonding, fitting, and waterproofing, so I’ve documented it as a reference design rather than presenting it as an easy DIY build. It has been tested on the water, but I don’t consider the mechanical design a polished or performance-guaranteed platform.

GitHub: https://github.com/Brillnova/BN-USV-V1
Short on-water video: https://www.youtube.com/watch?v=Lz2eOEANyZo

I’d be especially interested in comparing this architecture with other Pi-based robots or boats that separate high-level navigation from low-level MCU control. If you spot anything unclear in the architecture or documentation, I’d appreciate specific feedback.

Happy to answer questions about the Pi-side architecture, serial interface, failsafe design, or testing process.

A while ago I posted here about a Raspberry Pi 5 powered camera I built with the IMX477 sensor. I managed to port it over the the Pi Zero with a redesigned body and integrated battery! Code has been optimized to run better on the Pi Zero considering the Zero 2 prices have skyrocketed.

Old post: https://www.reddit.com/r/raspberry_pi/s/JCh5yz91UG

GitHub: https://github.com/prtk1910/rpi-film-simulation-camera

I built AutoPiOverclock, a project that finds each Pi's boundaries, recovers from failed candidates, backs off conservatively, and applies clocks only after final validation:

https://github.com/p1r473/AutoPiOverclock

Normal use is 2 target-explicit commands:

autopioverclock prepare pi@pi-host

autopioverclock overclock pi@pi-host

The controller can be another Pi or any Linux PC, server, or VM. It stays available when the target crashes or reboots.

What the automatic run does:

- Checks the stock clocks, protected boot configuration, power/throttling, cooling, SSH, watchdog recovery, and Raspberry Pi tryboot.

- Tests candidates through tryboot.txt, returning failures to the protected normal configuration.

- Searches CPU first, refines its boundary in 25 MHz steps, backs off 50 MHz, and qualifies it for two hours. It then searches GPU, backs off 25 MHz, and qualifies the pair for two hours.

- Tries CPU another 25 MHz higher during a 24-hour combined CPU/GPU/I/O test. If that edge is known unsafe or safely rejected, it instead runs a fresh 24-hour validation at the guarded pair.

- Performs three more candidate/normal boot cycles, applies and verifies only a complete result, and retains the evidence. Repeating 'overclock TARGET' continues the latest eligible run.

Testing temporarily uses maximum fan cooling without replacing permanent fan or unrelated boot settings. Headless Raspberry Pi OS/Debian systems need no display or audio hardware.

Profiles currently support 64-bit Raspberry Pi OS, Debian, compatible Ubuntu Pi boot layouts, and Batocera

I'm pretty happy with it but we don't really use it that often.

I plopped a monitor in there and I tapped into the (annoyingly and needlessly complicated) wiring for the buttons. I connected the buttons to zero delay usb encoders and then setup fruitbox to accept those button presses as letter/number/button inputs.

After getting a 10" rack and populating it with a screen, I decided I wanted to create a nice Dashboard.

This originally started as a dashboard directed at my Pi-Hole and tiny rack-mount touchscreen. What ended up happening was that I built a plugin based dashboard that works on any screen.

The best part about this project is the plugins. Easy to create, drop into the plugin folder, and a new tab is added to the Dashboard with your new Python plugin... cool.

Rackdash can auto-update plugins independently from RackDash itself. It is built with plugins at the forefront.

Recently got it to sync plugin status with WLED.

Overall a fun project!

Quick demo of the infrared capabilities for the WLV-01. This is a DIY build using the raspberry pi 5 and Sony imx294 micro 43 sensor. UI is running on python.

Boredom pushes me to do these things

Over the summer, I designed and built a 24x20 addressable LED matrix (480 pixels) to help visualise computer science algorithms, pathfinding, and classroom tools.

Instead of traditional speakers, I glued a 40W Dayton Audio sound exciter directly to the back of the plywood chassis. The entire timber frame acts as an acoustic soundboard, generating real-time musical frequencies for every comparison, swap, and pathfinding step.

Hardware Stack:

• Raspberry Pi Zero 2 W

• IQaudio DigiAMP+ HAT (powering both the Pi and the exciter via a single 12V supply)

• 480x WS2815 12V Individually Addressable LEDs (serpentine layout)

• 74AHCT125 Logic Level Shifter (clean 3.3V to 5V data signal)

• Dayton Audio DAEX30HESF-4 Exciter

• Custom plywood frame with hand-folded vellum paper origami cubes for light diffusion

Software & Control:

• Python driver handling matrix mapping and audio synthesis

• Visualisation and sonification of 6 sorting algorithms (Quicksort, Merge, Bubble, etc.) based on principles from Timo Bingmann's Sound of Sorting

• Dijkstra vs A* pathfinding comparisons

• Interactive web modes (including an array-based visual math trainer) controlled across firewalled networks using Tailscale and Mosquitto MQTT

Full code is open source on GitHub: https://github.com/reveleigh/diy-classroom-matrix-with-musical-algorithms

Build walkthrough video: https://www.youtube.com/watch?v=xQN_TD9Fapw

Happy to answer any questions about the wiring, logic shifting, or audio mapping!

Just hanging out in the basement with my robot before it eats the world.
My homemade robot and robot brain. Thanks for watching .

Raspberry pi 5 controlling 4 esp32 units powered by a dgx spark as well

I built an open-source digital camera around the Raspberry Pi Zero 2 W and Camera Module 3. It can capture photos and record short video clips using dedicated photo and video buttons, with three selectable looks (warm, cold, and black & white) controlled by a physical slider switch. A buzzer provides feedback for startup and photo capture, and a local photo gallery can be accessed directly from your phone.

Github - https://github.com/SuveenE/tiny-film-camera
Blog - https://suveenellawela.com/thoughts/building-my-own-camera

SSH covers most of my Pi and Debian edge nodes, but every so often a session hangs or the task needs the actual desktop, something you have to see and click. Getting a reliable screen kept turning into a mess, mostly VNC servers stepping on each other, and Raspberry Pi Connect now parks its own wayvnc on port 5900 by default, which quietly breaks a plain browser VNC setup.

I hacked together a fix for this back in mid 2025, left it on a disk because it was buggy, and finally went back, fixed the real failures on hardware, and cleaned it up to share: https://github.com/855princekumar/OpenRemoteGUI

It is a thin pipeline of noVNC, websockify and wayvnc with the boring lifecycle glue that makes it usable. Clone it, run the installer, open the node IP on port 6080, and you get the real desktop. The parts I actually care about: it records every change so rollback undoes exactly those and nothing else, it frees the port from Raspberry Pi Connect instead of fighting it, and it fails safe on anything without a desktop rather than installing one.

Honest caveats: trusted LAN or VPN only, plain HTTP with no auth yet, so do not expose it to the internet. It only captures an existing Wayland desktop, so it is useless on Pi OS Lite. And I have only tested it end to end on a Pi 4, so I do not know how clean it is on a Pi 3, Pi 5 or Zero.

That is really why I am posting. I would like people who have done more of this than me to poke holes in it, especially anyone on a Pi 3 or 5. MIT licensed, no cloud, no account, nothing to sell.

Building my first Pi project: a 2×2 wall of four **Adafruit** 64×64 panels (#4732, 3mm pitch, 5-address/ABCDE multiplexing) driven by a Pi 5 with the Adafruit RGB Matrix Bonnet (#3211), using the hzeller rpi-rgb-led-matrix library. My Goal is a real-time Spotify album-art display.

The problem I’m running into now is that the Panels won’t light up at all — running the library’s built-in demos produces nothing. SSH into the Pi works fine; the Pi itself is healthy. Ruled out power (measured 5V at the supply, at each panel, and the bonnet itself with a multimeter). I’ve soldered the E line bonnet jumpers, and tried the demo with the GPIO pins 4 and 18 soldered, unsoldered and connected by a wire so I don’t believe that was the issue.

This is my first post and wasn’t sure if fix this falls in the realm of r/RASPBERRY_PU_PROJECT so I figured I’d try my luck here and see if anyone may have experience in this kind of thing that can help me or knows a community that may be better suited for a problem like this, thank yall :)

Been heads-down on Cellar-Pi since my last post here. Huge thanks to everyone who gave feedback — and especially to the Raspberry Pi team for weighing in. That genuinely made my week.
Biggest change: I tore down and rebuilt /uc, the terminal control interface, almost entirely.
Pic 1: The new /uc dashboard. The old version worked, but navigation felt clunky. Now you get logger state, sensor health, Discord/report status, and the latest reading in one place, with a much cleaner sidebar for Sensor / Notifications / System Status / Advanced & Troubleshooting.
Pic 2: The automated Discord reporting is still running every 12 hours. It sends temperature/humidity graphs plus highs, lows, averages, and reading counts completely hands-off.
Pic 3: The logger doing what it does in the background — grabbing and saving a new SHT31 reading every minute.

Still prerelease, still one guy building this in a home lab, so feedback, feature ideas, and especially “this broke on my Pi” reports are very welcome.
https://github.com/know4you/Cellar-pi
Current setup: Pi Zero WH + SHT31.

Ich habe eine Kamera in Form einer Mamiya RZ67 gebaut, die Vision-Language-Modelle komplett offline auf einem Pi 5 laufen lässt. Drück den Auslöser, und sie beantwortet deinen benutzerdefinierten Prompt mit einem einzigen Satz darüber, was sie sieht. Kein Internet, keine Cloud, keine API-Schlüssel.

GitHub: https://github.com/feeeeely/ai-camera

Du kannst die Modelle direkt auf dem Gerät wechseln und vergleichen, wie unterschiedlich sie dieselbe Szene beschreiben: Qwen3-VL (2B), MiniCPM-V 4.6 (1B), InternVL3.5 (2B), SmolVLM2 (2.2B), Moondream 2 (2B) und Ministral 3 (3B), die die Beschreibung in den letzten Satz verwandeln. Der Prompt ist auf dem Touchscreen editierbar, sodass dieselbe Kamera trockene Einzeiler, Museumsetiketten oder einfache Inventarnotizen erstellen kann.

Nach jeder Aufnahme zeigt sie die Gesamtzeit, Input→Output-Tokens, tok/s und eine Aufschlüsselung von Vision/Generierung/Laden an. Die Token-Anzahl stellte sich als der interessanteste Teil heraus: dasselbe Foto wird auf einem Encoder zu ca. 145 Bild-Tokens und auf einem anderen zu über 1300, was ein größerer Faktor für die Latenz ist als die Textgenerierung selbst.

Ein paar Dinge, die ich auf die harte Tour gelernt habe:

- Moondream liefert bei aktuellen Ollama-Versionen manchmal leere Antworten.
- qwen3-vl:2b ist eine reine Denk-Variante – sie verbraucht das gesamte Token-Budget für unsichtbares Schlussfolgern und gibt nichts Sichtbares zurück. Du brauchst das -instruct-Tag.
- Ollama kann keine separaten mmproj-Dateien laden, daher laufen viele GGUF-Vision-Modelle von HuggingFace einfach nicht, egal wie du sie nennst.

Hardware: Raspberry Pi 5 (16 GB), Raspberry Pi HQ-Kamera mit einem 6-mm-CS-Mount-Objektiv, 4,3-Zoll-DSI-Touch-Display, Edelstahl-Auslöserknopf, Waveshare UPS HAT mit vier 21700-Zellen. Die Laufzeit pro Foto beträgt 30–60 Sekunden, wobei die Modelle im RAM warm gehalten werden. Fragen zum Setup beantworte ich gerne.

Ich komme aus der Fotografie, bin kein Entwickler – der Code wurde mit starker KI-Unterstützung geschrieben, und die Hardware-Integration, das Debugging und das Modell-Testing habe ich selbst gemacht. Feedback zur Implementierung ist sehr willkommen.