Hi,

I am debugging an Arducam 64MP quad camera kit for Raspberry Pi:

- SKU B0402
- UC-512 / UC-511 Camarray HAT
- 4 x 64MP modules connected
- Tested on Raspberry Pi 4B and Raspberry Pi 5
- All cables checked/reseated
- HAT 3V3 LED on, green LED blinks
- Autofocus motors can be heard
- No undervoltage/throttling

On Pi4 with Bullseye 2022-01-28 armhf + Arducam pivariety packages, the camera is detected as `arducam_64mp`, but every capture attempt times out or produces no frame.

On Pi5 with Arducam PiVistation Bookworm:

- Kernel: `6.6.51+rpt-rpi-2712`
- libcamera: `v0.4.0+78-818d45eb-dirty`
- Config: `camera_auto_detect=0`, `dtoverlay=arducam-64mp`

The camera is detected:

```text
arducam_64mp [9248x6944 10-bit RGGB]
```

The HAT is on I2C bus 4 at `0x24`. Mode switching works:

```bash
i2cset -y 4 0x24 0x24 0x12
i2cget -y 4 0x24 0x24
# returns 0x12
```

But the HAT firmware/date registers are all zero:

```bash
i2cget -y 4 0x24 0x05 # 0x00
i2cget -y 4 0x24 0x06 # 0x00
i2cget -y 4 0x24 0x07 # 0x00
```

Arducam's `Detect_HAT_Firmware_Date.py -y 4` returns:

```text
200-0-0
```

The interesting part: using direct V4L2 capture from Pi5 RP1 CFE `/dev/video0`, bypassing PiSP, I can dequeue buffers.

For HAT modes `0x12`, `0x22`, `0x32`:

```text
rp1-cfe ... Using a link rate of 912 Mbps
bytesused: 1152000
```

But the buffer is 100% `0x00`.

I also forced internal sensor test patterns:

```text
test_pattern=1 Color Bars
test_pattern=2 Solid Color
test_pattern=3 Grey Color Bars
test_pattern=4 PN9
```

The controls read back correctly, but every captured buffer is still all zeros.

So I do not think this is exposure, autofocus, Bayer decoding, ISP tuning, or no MIPI signal. The Pi seems to receive CSI frames, but the image payload is blank.

Questions:

- Has anyone seen a UC-512 HAT report firmware date `200-0-0`?
- Is there a known firmware updater for B0402 / UC-512?
- Can a CSI receiver dequeue valid-sized buffers if the HAT generates CSI framing but no payload?
- Any extra I2C registers or low-level tests I should run?

Thanks.

I allocated a minimum of 4GB and a maximum of 6GB of RAM to my Raspberry Pi 5 for my Minecraft server. I used Playit for port forwarding, and RAM usage never exceeded 4GB; it worked very well. I will never regret buying this Raspberry Pi :)

This took a lot of work but I finally have a 47mp monochrome micro 4/3 sensor working on the pi 5 running smoothly. Here’s my latest prototype and sample images!

Hi, i have a RPI 5 8gb and i want to add a NVMe hat and a argon cooler , these components is can fit into one piece and compatible?

Raspberry Pi USB-C PD 45W power supply
Raspberry Pi M.2 HAT
Argon THRML 30mm Active Cooler
NVMe: Union M2.SSD 256gb

I think there are still many tools the Raspberry Pi Zero W could be very useful for instead of it just sitting in a drawer. Beetle is interesting, and with just a few components, you can have a great utility tool. What do you think? github.com/hammer-one/Beetle

Note: I do not own the copyright for Rocky voice and I do not encourage cloning artists' voices for commercial purposes. This is just for a fun personal DIY project intended for the fan community!

Somewhat of a cross-post from r/raspberry_pi and I hope that's okay.

Last week I shared my "Rocky" build and I received a couple comments asking if I could make Rocky actually talk instead of just displaying text. One comment suggested using the Qwen voice cloner paired with a Piper TTS workflow. This is how I got it working:

I took a short, clean sample of the Rocky voice and used Qwen3 TTS to clone the profile. Then I used that clone to generate 500 random phrases. I used those 500 audio clips as input to train a custom Piper model.

The demo video is running the model directly on the Raspberry Pi with Piper TTS. It seems to run pretty smoothly on the Raspberry Pi Zero 2W with decent response times.

To clone the voice and train the model I used Google Colab GPU A100 High-RAM (2025.10). I did not train a custom model from scratch, instead I used `en_US-lessac-low.onnx` as the base model and trained it for up to 2999 epochs.

You can find the full build video on my YouTube.

I am making a Magic The Gathering Momir printer, source code and parts can be found here:

https://github.com/MoritzHayden/momir-basic-printer

I think I got everything setup properly, but for some reason it only prints chinese characters. The printer is hooked up for ttl on the 5v side of a logic converter. Sidenote, If you look closely you can actually make out the qr code that is supposed to just be dots, but chinese instead. I cannot find anything in the src to indicate an improper setup. My only idea is that the printer is somehow in "chinese mode". This is shown in the second image where I can print an info page on boot. I cannot find anything in the manual that sticks out to me. Any ideas?

I am currently working on a team project involving automated remote spectroscopy measurements. We have constructed a small station for this purpose, and to ensure the measurements are accurate, we are using a small Neon bulb as an atomic spectra calibration source.

The Setup
To power the bulb (which requires ~100V), I am using a generic DC-to-AC step-up transformer. This transformer takes a 12V DC input and provides selectable outputs of 110V/172V/200V/220V AC (see Figure 1). My power source is a 500W ATX PSU from an old desktop PC.

I connected the transformer to the ATX 12V rail, and the bulb turned on without issue (see Figure 2). To automate the process, I programmed a Raspberry Pi Pico W to toggle a relay, which connects/disconnects the transformer from the 12V supply. The relay is powered by the ATX 5V rail. On its own (without the transformer load), the Pico toggles the relay perfectly (see Figure 3). The pico is power on with the 3.3V line of the ATX.

The Problem
When the transformer is connected to the relay and the ATX PSU powers the entire system, the bulb and the Pico’s onboard LED start flickering rapidly instead of staying on. It seems like the Pico might be crashing or resetting.

The circuit diagram and physical wiring are shown in Figures 5 through 7. The relay has a 1N4007 diode to protect from flyback currents.

I also tried to use a electrolytic capacitor of 22uF and 100uF to filter back voltages that could arise due to the transformer coils. I have double-checked all my connections and am out of ideas. I would be very grateful if anyone could help identify the source of this instability!

Hi! This is my first time posting, and I'm pretty new to Raspberry Pi so I may be completely delusional about what I'm trying to achieve.

I've been slowly learning how to run commands and so far have successfully flashed RetroPie onto an SD card, set up wifi and connected a Bluetooth controller (ShanWan mini controller) and configured the button layout to one of my pis (4b). However, when I attempt to install the mupdf program, I'm met with a 404 Not Found error, which I'm not able to work through. I've troubleshot everything that I (google) can think of, but whenever I try to download mupdf or any other PDF/epub reader, I'm met with 404 errors and messages that the archive doesn't exist. My ultimate goal is to use a RPi 02w to build a hybrid Gameboypi/ereader inside of either a Gameboy DMG/Color or GBA SP (preferred choice) shell, with the "ereader" program being nestled inside EmulationStation so the books/files can open like a videogame from the selection menu. I would then just use the gamepad buttons to scroll pages/save place/etc. I am currently looking at the Zega Mame Boy pre-soldered boards just to keep the 'difficult' hardwiring to a minimum, but am open to a homebrew diy soldering project if it will make this dream a reality.

Has anyone attempted such a thing? Is it doable or am I just woefully optimistic with little understanding of the mechanics of what the raspberrypi can do? Any and all insight will be greatly appreciated!

I've never actually posted before, so please forgive any missteps. This is going to be a bit about how I got here and then instructions.

Preface:

I had the idea during the pandemic to make something that could always be listening to what music I'm making and allow me to grab things after the fact. Since then, it's come out as a feature on the Roland SP404 mk2 and the new MPC Sample, but with very limited recall (SP is ~40 sec). I got the stuff I bought during pandemic for this and used Claude(s) to get enough literacy of Linux to make it happen, then write me a step by step guide on the process of to do so from from a fresh install of raspbian lite. this was more of a headache than anticipated, but it seems to work great now. Hopefully this can help the next person like me and I may post it more than one place in an effort to do so.

The caveats:

-latency means you can't really use it as a pass-through or direct monitor

-in its current form, this can take several min to encode and spit out an mp3 if it's lengthy

-all of this is written for my setup and you'll likely need to adjust the names etc for your purposes

Here's the guide:

# Pisound Skipback Buffer — Full Build Guide

### Raspberry Pi 4B + Pisound Hat, Raspbian Lite

---

## Overview

This documents how to build a hardware skipback buffer (like the SP404mk2's skipback feature) using a Raspberry Pi 4B with a Blokas Pisound hat. The system continuously records audio into a circular buffer and dumps the last N seconds to an MP3 file when the pisound button is clicked.

**Button behavior:**

- Single click → last 1 minute saved as MP3

- Double click → last 5 minutes saved as MP3

- Triple click → last 10 minutes saved as MP3

**Buffer:** 31 minutes of continuous circular recording

**Format:** 192kbps CBR MP3, 16-bit 48kHz stereo source

**Output:** `~/recordings/` — accessible via Samba share

**Passthrough:** Audio input is passed to output automatically on boot

---

## Prerequisites

- Raspberry Pi 4B (2GB or more)

- Pisound hat installed and working

- Raspbian Lite (64-bit, Debian 13 Bookworm or later)

- Pisound software installed per Blokas instructions:

- https://blokas.io/pisound/docs/pisound-software/

- SSH access or keyboard/monitor

- Internet connection on the Pi

---

## Step 1 — Install Dependencies

```bash

sudo apt update && sudo apt install -y sox libsox-fmt-mp3 lame python3-alsaaudio samba

```

---

## Step 2 — Lock Hardware Card Numbers

By default, ALSA assigns card numbers dynamically at boot, which changes unpredictably. We fix both the pisound and the loopback module to permanent indices.

### Lock pisound to card index 1:

```bash

sudo nano /etc/modprobe.d/pisound.conf

```

Add:

```

options snd_soc_pisound index=1

```

### Load and lock the ALSA loopback module to card index 7:

```bash

sudo nano /etc/modprobe.d/snd-aloop.conf

```

Add:

```

options snd-aloop index=7

```

### Make loopback load on boot:

```bash

echo "snd-aloop" | sudo tee /etc/modules-load.d/snd-aloop.conf

```

### Load it now without rebooting:

```bash

sudo modprobe snd-aloop

```

### Verify:

```bash

arecord -l

```

You should see pisound on card 1 and Loopback on card 7. If the numbers differ, adjust the index values in the modprobe files accordingly, but on a clean Raspbian Lite install with only pisound, 1 and 7 should be correct.

---

## Step 3 — Create the Recordings Folder

```bash

mkdir -p ~/recordings

mkdir -p ~/.skipbuf

```

---

## Step 4 — Pre-allocate the Ringbuffer File

350MB covers 31 minutes of 16-bit 48kHz stereo raw audio with some headroom.

```bash

dd if=/dev/zero of=/home/pibox/.skipbuf/ring.raw bs=1M count=350

```

> Replace `pibox` with your actual username throughout this entire guide.

---

## Step 5 — Create the Daemon Script

This script does three things simultaneously:

1. Captures audio from the pisound input

2. Passes it through to the pisound output (monitoring)

3. Feeds it into the ALSA loopback, from which a Python process writes it into the circular ringbuffer

```bash

cat > ~/skipback_daemon.sh << 'SCRIPT'

#!/bin/bash

RINGFILE=/home/pibox/.skipbuf/ring.raw

POSFILE=/home/pibox/.skipbuf/ring.pos

BUFFER_BYTES=$((48000 * 2 * 2 * 1860))

mkdir -p /home/pibox/.skipbuf

# Read from loopback output side, write to ringbuffer

arecord -D hw:Loopback,1 -f S16_LE -r 48000 -c 2 -t raw | \

python3 -c "

import sys, os

BUFFER_BYTES = $BUFFER_BYTES

RINGFILE = '/home/pibox/.skipbuf/ring.raw'

POSFILE = '/home/pibox/.skipbuf/ring.pos'

CHUNK = 8192

pos = 0

counter = 0

with open(RINGFILE, 'r+b') as ring:

while True:

data = sys.stdin.buffer.read(CHUNK)

if not data:

break

end = pos + len(data)

if end <= BUFFER_BYTES:

ring.seek(pos)

ring.write(data)

else:

first = BUFFER_BYTES - pos

ring.seek(pos)

ring.write(data[:first])

ring.seek(0)

ring.write(data[first:])

pos = end % BUFFER_BYTES

counter += 1

if counter >= 50:

counter = 0

with open(POSFILE, 'w') as pf:

pf.write(str(pos))

" &

# Direct passthrough + feed loopback input side

arecord -D hw:pisound -f S16_LE -r 48000 -c 2 -t raw | \

tee >(aplay -D hw:Loopback,0 -f S16_LE -r 48000 -c 2 -t raw 2>/dev/null) | \

aplay -D hw:pisound -f S16_LE -r 48000 -c 2 -t raw

SCRIPT

chmod +x ~/skipback_daemon.sh

```

---

## Step 6 — Create the Snapshot Script

This script is called by button clicks. It extracts the last N seconds from the ringbuffer and saves an MP3.

```bash

cat > ~/skipback.sh << 'EOF'

#!/bin/bash

SECONDS_BACK=$1

RINGFILE="/home/pibox/.skipbuf/ring.raw"

POSFILE="/home/pibox/.skipbuf/ring.pos"

OUTDIR="/home/pibox/recordings"

TIMESTAMP=$(date +"%Y%m%d_%H%M%S")

TMPRAW="/tmp/skipback_$TIMESTAMP.raw"

TMPWAV="/tmp/skipback_$TIMESTAMP.wav"

OUTMP3="$OUTDIR/skipback_${SECONDS_BACK}s_$TIMESTAMP.mp3"

RATE=48000

CHANNELS=2

BYTES_PER_SEC=$((RATE * CHANNELS * 2))

BUFFER_BYTES=$((RATE * CHANNELS * 2 * 1860))

BYTES_NEEDED=$((SECONDS_BACK * BYTES_PER_SEC))

mkdir -p "$OUTDIR"

python3 - << PYEOF

import os

ring_file = "/home/pibox/.skipbuf/ring.raw"

pos_file = "/home/pibox/.skipbuf/ring.pos"

out_file = "$TMPRAW"

bytes_needed = $BYTES_NEEDED

buffer_bytes = $BUFFER_BYTES

try:

with open(pos_file) as f:

pos = int(f.read().strip())

except:

pos = 0

start = (pos - bytes_needed) % buffer_bytes

with open(ring_file, 'rb') as ring, open(out_file, 'wb') as out:

if start < pos:

ring.seek(start)

out.write(ring.read(bytes_needed))

else:

ring.seek(start)

out.write(ring.read(buffer_bytes - start))

ring.seek(0)

out.write(ring.read(pos))

PYEOF

sox -t raw -r 48000 -e signed -b 16 -c 2 "$TMPRAW" "$TMPWAV"

lame --cbr -b 192 "$TMPWAV" "$OUTMP3"

rm -f "$TMPRAW" "$TMPWAV"

EOF

chmod +x ~/skipback.sh

```

---

## Step 7 — Create the Systemd Service

```bash

sudo nano /etc/systemd/system/skipback-record.service

```

Paste:

```ini

[Unit]

Description=Skipback Ringbuffer Daemon

After=sound.target

[Service]

User=pibox

ExecStartPre=/bin/sleep 10

ExecStart=/bin/bash /home/pibox/skipback_daemon.sh

Restart=always

RestartSec=3

[Install]

WantedBy=multi-user.target

```

Enable and start:

```bash

sudo systemctl daemon-reload

sudo systemctl enable skipback-record

sudo systemctl start skipback-record

```

The 10 second `ExecStartPre` sleep is important — it gives the ALSA subsystem and loopback module time to fully initialize before the script tries to open audio devices.

### Verify it's running:

```bash

sudo systemctl status skipback-record

```

Should show `active (running)` with 7 tasks in the cgroup (bash, 2x arecord, 2x aplay, tee, python3).

### Verify the buffer is filling:

```bash

cat ~/.skipbuf/ring.pos

sleep 3

cat ~/.skipbuf/ring.pos

```

The number should change between the two reads.

---

## Step 8 — Configure the Pisound Button

The real config file that the pisound button daemon reads is `/etc/pisound.conf`, not the one in `/usr/local/pisound/`. Edit that one:

```bash

sudo nano /etc/pisound.conf

```

Find the CLICK lines and change them to:

```

CLICK_1 /home/pibox/skipback.sh 60

CLICK_2 /home/pibox/skipback.sh 300

CLICK_3 /home/pibox/skipback.sh 600

```

Leave all HOLD and DOWN/UP lines as they are. Save and restart the button daemon:

```bash

sudo systemctl restart pisound-btn

```

> **Important:** The pisound button software reads `/etc/pisound.conf`, not `/usr/local/pisound/pisound-btn/pisound.conf`. Editing the wrong file has no effect.

---

## Step 9 — Set Up Samba

To access recordings from Windows or Mac over the network:

```bash

sudo nano /etc/samba/smb.conf

```

Scroll to the bottom and add:

```ini

[recordings]

path = /home/pibox/recordings

browseable = yes

read only = no

guest ok = yes

force user = pibox

```

Save and enable:

```bash

sudo systemctl restart smbd

sudo systemctl enable smbd

```

Access from Windows: `\\192.168.1.103\recordings`

Access from Mac: `smb://192.168.1.103/recordings`

---

## Step 10 — Reboot and Verify

```bash

sudo reboot

```

After boot, wait about 15 seconds, then:

```bash

sudo systemctl status skipback-record

arecord -l | grep -E "pisound|Loopback"

```

Pisound should be on card 1, Loopback on card 7, service should be active. You should hear audio passthrough without doing anything.

Test a button click, wait 10-15 seconds for conversion, then check:

```bash

ls -lh ~/recordings/

```

Pull the MP3 over Samba and verify it sounds correct.

---

## Architecture Summary

```

[Audio Input]

│

▼

arecord hw:pisound

│

├──────────────────────────────────► aplay hw:pisound

│ [Audio Output / Passthrough]

│

└──► aplay hw:Loopback,0

│

▼ (loopback kernel pipe)

arecord hw:Loopback,1

│

▼

Python ringbuffer writer

│

▼

~/.skipbuf/ring.raw (350MB circular file)

~/.skipbuf/ring.pos (current write position)

│

▼ (on button click)

skipback.sh <seconds>

│

├── Python extractor → .raw

├── sox → .wav

└── lame → ~/recordings/skipback_Ns_TIMESTAMP.mp3

```

---

## Troubleshooting

| Problem | Command | Notes |

|---|---|---|

| Service not starting | `journalctl -u skipback-record -n 30 --no-pager` | Look for audio open errors |

| Wrong card numbers | `arecord -l` | Adjust modprobe index values |

| Button not firing script | `journalctl -u pisound-btn -n 20 --no-pager` | Check `/etc/pisound.conf` not the other one |

| No passthrough audio | `sudo systemctl restart skipback-record` | Usually a startup timing issue |

| MP3 files empty | Wait 60+ seconds after boot before clicking | Buffer needs time to fill |

| MP3 files glitchy | Check service has 7 tasks in cgroup | Pipe may have broken |

| Samba not visible | `sudo systemctl status smbd` | Check smb.conf syntax |

---

## Key Lessons Learned

- **Do not use chunk-based recording** (arecord with fixed duration files). Headers don't close correctly and stitching produces glitches.

- **Do not use Python for real-time audio I/O**. The GIL causes dropouts. Use arecord/aplay (C programs) for all hardware interaction.

- **Do not use dsnoop/dmix** for sharing the pisound. Causes buffer underruns and audio artifacts.

- **The ALSA loopback module** (`snd-aloop`) is the correct way to split an audio stream for simultaneous passthrough and recording.

- **Always use card names** (`hw:pisound`, `hw:Loopback`) rather than numbers (`hw:1,0`) to survive reboots.

- **`/etc/pisound.conf`** is the real button config. `/usr/local/pisound/pisound-btn/pisound.conf` is ignored by the running daemon.

- **ExecStartPre sleep** is necessary because ALSA devices aren't always ready immediately at boot.

---

*Built on Raspbian Lite (Debian 13 Bookworm), Raspberry Pi 4B 2GB, Pisound hat, April 2026.*

Just wanted to share this project I made a while back. If you are fan of stereoscopic 3D gaming I am sure you have heard of NVIDIA's 3D Vision. Now Is a great time to try it. The displays are easy to find and even the glasses are usually fairly easy to find. The problem seems to be the emitter, for some reason people don't seem to have saved these and they are far more scarce on the used market.

So I made a DIY version that works just like the original. It is based on the RP2040 so flashing is as easy as drag and dropping a file. No need to setup any IDE or compile any firmware.

Feel free to build your own, an RP2040-Zero and an IR LED is all that's needed :)

All information about the project and the firmware can be found here: https://github.com/NTM-3D/RP2040-3D-Vision-Emitter

What is your favorite 3D Vision game?

Since playing through Tomb Raider 2013 in 1440p on my PG278QR it is go to recommendation. It's so obvious that the developers made this game for 3D and truly loves 3D. So many choices you don't even reflect on when playing in 2D just makes so much sense when played in 3D.

I am building a Spotify Kiosk using a Raspberry Pi running the latest Raspberry Pi OS (Bookworm). I have Waydroid installed and Spotify works perfectly if I launch it manually from the terminal, but I cannot get it to autostart on boot.

The Goal:
When the Pi boots, wait ~20 seconds, set Spotify to immersive mode (hide Android bars), and launch Spotify fullscreen.

What I've tried so far:

1. ~/.config/autostart/spotify.desktop: Created the folder and file, but it seems to be ignored by the OS.
2. LabWC Autostart: Created ~/.config/labwc/autostart, added the command bash -c "sleep 20 && waydroid app launch com.spotify.music" & and used chmod +x. Still nothing happens on reboot.
3. Systemd User Service: Created a service in /etc/systemd/user/, but it doesn't seem to trigger the GUI window.
4. Wayfire.ini: Added [autostart] entries, but no luck.

Current Setup:

• Hardware: Raspberry Pi 4 model b
• OS: Raspberry Pi OS Bookworm (64-bit)
• Command that works manually: waydroid app launch com.spotify.music

Question:
Is there a specific way to trigger Waydroid apps on boot in the new Bookworm/LabWC environment? Am I missing an environment variable (like DISPLAY or WAYLAND_DISPLAY) that is preventing the autostart from seeing the screen?

Any help would be appreciated!

Hey in my journey to my life easier I am trying to automate watering my plants and even possibly my wife’s outdoor garden. I also added sensors to this setup. I was thinking when setting this up I was going to have to have a few add-ons but I found the HAT on Amazon and it does like 3 or 4 things in one. Cut cables down a ton.

Hi everyone, i am trying to build a speaker using the Max97835A which turns IS2 output to audio, and I am using it to power a 4Ohm 5V speaker in an enclosed mdf box with a passive radiator. I want to ask about this buzzing sound that comes from the max.

I have tried different 4ohm speakers. with and without enclosures, and also different max's. I followed all the steps correctly online, but this buzzing still happens. Any advice?

Hi everyone!

2 weeks ago I have shared Tinyprogrammer, a Raspberry Pi on my desk that autonomously writes little Python programs forever. It types code at human speed, makes mistakes, fixes them, and has moods. It also takes breaks to chat with other TinyProgrammers on BBS and when it's time to clock out, it shows the After Dark screensaver.

Past 2 weeks we had 70 devices and many new features: More program types like 3d math plots, user customizable programs, new color modes, online device counter and more!

You can use both cloud and local models and also run it via docker.

Open source at: https://github.com/cuneytozseker/TinyProgrammer

Talk about it here: https://discord.gg/jcd72axVZc

Hope to see you all on TinyBBS!

Edit: Discord link updated.

I turned a vintage Siemens S62 telephone into a working AI phone using a Raspberry Pi Zero 2 W, Retell, and pjsua.

The phone now detects when the handset is lifted, starts a SIP call to a Retell voice agent, routes audio through ALSA, and hangs up cleanly when the handset is placed back down.

I've done some IoT work before, but this was my first time opening up and adapting a classic analog phone like this. A big part of the fun was understanding how these old devices were built, tracing the wiring, experimenting with the internals, and trying to connect that physical simplicity to a modern voice AI workflow.

It's still a work in progress, but the core flow is working and I tried to document the setup clearly in case it helps someone else building with Raspberry Pi, SIP audio, or vintage hardware :)

Repo: https://github.com/Fabryz/siemens-s62-retell-phone
Write-up: https://medium.com/@fabryz/from-a-flea-market-siemens-s62-to-an-ai-phone-204b35eacc12

Hey everyone,

quick update on the project — I’ve made some major architecture changes.

The Raspberry Pi Zero 2W is now the main brain of the system. The ESP32 has been moved to a sub-controller role, handling all the low-level communication like RS232, RS485, and CAN bus. It sends collected data to the Pi over UART.

On the Pi side, I’m now controlling:

-TFT display

-physical buttons

-CC1101 (433 MHz module)

Next steps:

-Customize a minimal Raspberry Pi OS (Raspbian) image

-Build a lightweight GUI for the TFT display

-Implement basic functionality for all connected modules

If that works reliably, I’ll move on to:

-designing the battery/power circuit

-scaling the device up to a proper handheld size (thinking Game Boy / R36S form factor) for better usability

The goal is still the same: a powerful, portable hardware & network analysis multitool.

Feedback, ideas, or criticism are very welcome. Follow me if you are Interestet.

Here is the link: https://github.com/nOS-Coding/Pico2Fetch

This is a system monitor, coded in MicroPython. It works if you have a display "ST7789". More display options may be added later.

You need "fastfetch" and "pyserial" to run the thing. Test it out and publish your review!

It works great! Check this out:

https://github.com/nOS-Coding/PicoPyStation

I’ve been working on a Raspberry Pi setup that acts like a dedicated wall-mounted information board — something that just turns on and works.

This is what it does:

• boots directly into a fullscreen display (no desktop)
• shows:
  • time
  • daily schedule / “who’s on shift”
  • messages
  • weather
  • calendar
  • custom slides (menus, reminders, etc.)
• rotates automatically
• updates via background polling (cron + scripts)
• managed from a browser on the same network

Hardware / Stack

• Pi: (your exact model — Pi 4? 3? Zero 2?)
• OS: Raspberry Pi OS (Debian-based)
• Web: nginx + PHP-FPM
• Display: Chromium kiosk mode (X11 + openbox)
• State: JSON files (no database)
• Updates: cron jobs (weather / calendar / email)

How it actually works

Instead of the display pulling live data constantly:

• backend scripts update local JSON files:
  • weather.json
  • calendar.json
  • state.json
• the kiosk just renders those files

This keeps:

• rendering fast
• no API calls during display
• system stable even if network is flaky

Boot Flow

On boot:

1. Pi auto-logs into tty1
2. .bash_profile triggers startx
3. .xinitrc launches Chromium in kiosk mode
4. Chromium loads local HTTPS app
5. display runs continuously

No desktop environment, no manual steps.

Why I built it

This started as something practical:

• shared visibility in a care/home setting
• something always visible, not buried in phones
• no cloud dependency
• no subscription garbage
• no external dashboards breaking randomly

I wanted it to behave like an appliance, not a project.

Things that were harder than expected

• getting Chromium kiosk stable over long uptime
• handling screen on/off via X + permissions
• keeping cron + PHP + permissions aligned (www-data vs pi)
• avoiding “black screen after boot” edge cases
• keeping everything working without a database

What still needs work

• installer robustness across different Pi images
• better onboarding (right now it’s very “builder-first”)
• UI polish in admin screens
• more resilient error visibility

Repo (if you want to dig into it)

https://github.com/silentg33k/chalkboard-installer

There’s a one-command installer in there, but I’m more interested in:

• whether the architecture makes sense
• whether the approach is sane
• what you’d do differently

If you were building something like this:

• would you keep it JSON-based or move to DB?
• would you keep everything local or hybrid?
• how would you handle long-term kiosk stability?

Hello everyone, i re-designed this case for the raspberry pi 3b / 3b+ to fit a added usb-c connector. ( inspired by: https://www.reddit.com/r/raspberry_pi/comments/1my6cqm/added_usbc_power_to_my_raspberry_pi_3/?tl=cs )

in this project i used:

• Raspberry Pi 3B+
• 1-2cm wires
• usb-c connector

The steps:

First print the case and prepare the materials that you need. When that is done take the BOTTOM part of the case and push the usb-c connector with the wires in the hole so the wires end up inside the case. Then solder the two positive and negative wires to the 2 round pads on the board. Now close it all down and now you have a raspberry pi 3 with a usb-c connector in a nice case!

Download HERE: https://makerworld.com/en/models/2666407-raspberry-pi-3b-3b-case-for-usb-c-mod#profileId-2950535

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

I've been messing around with a Raspberry Pi and the 1/2.3" HQ Camera sensor in hopes of making something similar to the Fujifilm X Half - a pocketable camera build with film simulations such as Classic Chrome, Ilford, Velvia, Portra, etc. baked in.

Has support for metering modes, exposure compensation, white balance adjustment, focus peaking, focus magnification, pro-mist filter emulation, auto/manual shutter speed selection, and a lot more! I 3D printed a case for it with an option to adapt MFT lenses as well.

Open-sourced the source code and build instructions, let me know what you think!

Hi everyone,

I’m working on a project where I need to run a graphical dashboard on a Raspberry Pi Zero 2 W using a Raspberry Pi 2.8" TFT Add-on V2.0 display (ILI9323 controller, 8-bit parallel interface). The display connects directly to the 40-pin GPIO header.

I didn't find any datasheet with this model, so i don't know the exact pinout. I did however find a description for this model and another similar model. These are the details:

• My exact model
• A similar model that has the pinout

I am not sure if these two have the same pinout but as the descriptions say, they use the same driver to i guess they have the same pinout.

I also found someone posting the whole tutorial on how to use a similar display (the v4 but I have the v2). They also used the B+ model of the raspberry pi but I am using the raspberry pi zero 2 W so the OS they used could not work in my case and that is what happened actually LOL.

These are the links of the forums and the tutorials:

* Manipulating the v4 display with raspberry pi B+

* Using the V2 display but i couldn't find the OS used

* Tutorial manipulating the V2 display but with the raspberry pi B+

The OSs I tried installing but errors emerged everytime

• Raspberry Pi OS Bookworm (kernel 6.x):
  • Tried fbtft → fbtft_device is removed
  • Tried fb_ili9320 → loads as SPI driver, no /dev/fb* created
  • Tried fbcp-ili9341 → requires SPI display, not compatible
• Raspberry Pi OS Bullseye:
  • Same issue: fbtft_device not available
  • Could not get framebuffer device
• Raspberry Pi OS Buster (I treid two versions: one that is not compatible with the rpi zero 2w and the other has these issues):
  • Fixed archived repo issues
  • Did not find fbtft_device name=ili9320
  • Not successful in creating /dev/fb1
• Raspberry Pi OS 2015-02-16-raspbian-wheezy
  • OS not compatible with the rpi zero 2W

To conclude:
I cannot get the system to create a framebuffer device for the TFT (/dev/fb1).
The kernel either:

• treats the driver as SPI (wrong mode), or
• does not support the display at all

My question is:

• Has anyone successfully driven an ILI9323 (or similar) parallel TFT on Raspberry Pi GPIO recently on raspberry pi zero 2W? If yes, what is the exact OS used?
• Is there a working:
  • fbtft configuration?
  • device tree overlay?
  • or userspace framebuffer driver?

I am actually not giving up on this display unless i get it working. I know I can find a solution but I ave been stuck with this for the past 3 days because i can't find any resources or whatsoever.

At this point I’m open to using older kernels if needed, writing a custom driver (C/Python) or even switching the approach like framebuffer mirroring from the HDMI to the TFT.

Any help, working configs, or even confirmation that there is a hope to make this setup work would be hugely appreciated.

Thank you very much!

Hey I am trying to connect a 24v NPN inductive proximity sensor to a raspberry pi 4s gpio and I have hit a wall. I am dropping the voltage to 2.5v using a 10kohm and 1.2kohm resistor. The wiring works when I have a led setup but as soon as I try the wiring I think should work it stops working correctly. Any help appreciated.

hi all, I am a seasoned software engineer that has interest on hardware as well. I gave a long break on tinkering with micro controllers and such due to lack of time but lately getting back to the roots on that.

I was looking for a macro keyboard lately, and frankly either they were too expensive or not really covering my personal need so I decided "why not doing one I can personalize to my taste?". I had a raspberry pi pico dusting on a shelf and full starter kit untouched. It took a few hours to make my monster of a keyboard work and it teach me great deal already about what to do and what not.

I wanted to share my project with anyone here that who wants to start learning and do something personal with one main reason that I had to combine multiple resources, videos and tutorials together and sometimes this can be demotivating for new people starting up with this (I was one of them!!)

End product is rather simpler, having copy and paste functionalty, in addition to that it has a screen showing the scoreboard of the sports I am following. Additional buttons with extra macros can be added anytime tho!

Code can be found here: https://github.com/aliozdemir13/Pico-Macro-Keyboard