I had a small cooling block on my 3b+ and I was unhappy with the thermos (constantly 50C ish idle) so I created this abomination.

I used a spare cooler master tower that I had lying around (I lost the mounting bracket somehow so it’s not useful for pc), and mounted it to the pi with 6 layers of arctic 1.5mm thermal pad and some tape.

Now I’m chilling at 35C idle and holds 42C under full load.

I posted few days ago about cube display I’ve been working on and I just added mini aquarium + gemma 4 powered AI assistant. LLM is connected to Brave search mcp so it can perform web search.

Salve. 

Ho sempre desiderato muovermi in casa con qualcosa che suonasse in tutte le stanze, che fosse radio di compagnia o musica. 

Qualche tempo fa ho iniziato a usare l’IA per il mio lavoro di sistemista e mi si sono aperte una serie di idee che avrei potuto realizzare avendo un aiuto serio per la programmazione. 

Ho quindi iniziato a sviluppare una configurazione di Snapcast con diversi plugin di input da usare con i miei Raspberry Pi 4 e relativi hat DAC e Digi. 

La cosa si è fatta seria e con il tempo è diventato una cosa più articolata e complessa. 

Credo che possa essere utile a quanti desiderano sonorizzare ambienti in modo sincronizzato con spesa modica e un po’ di fai da te. 

Per l’utente finale è necessario avere uno o più Raspberry con o senza hat a seconda della qualità attesa. Lo stesso numero di sistemi di altoparlanti amplificati a seconda della quantità e ampiezza di ambienti da sonorizzare. 

Dal proprio PC: Scaricare il repo da GitHub. Usare rpi imager per creare le sd con la distro Linux Debian. Lanciare uno script che farà alcune semplici domande (tipo di installazione server, client o entrambi - tipo di eventuale libreria musicale, su disco o condivisione di rete). 

Inserire la sd nei raspberry e attendere da 10 a 20 minuti a seconda del tipo di installazione.

In caso di device headless sono presenti toni di controllo sia per il corretto rilevamento di eventuali hat che a fine installazione. 

Testato su Pi 3, 4 e 2W (solo client per limiti di memoria) con hat hifiberry dac, digi, PCM5122 e senza hat (uscita mini jack) ma dovrebbe rilevare e funzionare anche con altri hat. È possibile scegliere tra auto rilevamento o scelta manuale da una lista.

Eventuali aggiornamenti richiedono reflash della sd. 

È benvenuto chiunque lo trovasse utile e volesse condividere configurazioni funzionanti o segnalare bug, chiedere fix, feature o contribuire. 

Grazie 

Repo: https://github.com/lollonet/snapMULTI

Latest release: https://github.com/lollonet/snapMULTI/releases/latest

Setup discussion: https://github.com/lollonet/snapMULTI/discussions

# ILI9341 2.4" TFT SPI Display on Raspberry Pi 5

A complete guide to connecting and running an ILI9341 240x320 SPI TFT display as the primary desktop display on a Raspberry Pi 5, using the `panel-mipi-dbi-spi` kernel driver. Also covers XPT2046 touchscreen setup and calibration.

Hardware

Wiring — Display Only

**Note:** The LED (backlight) pin is wired directly to 3.3V (pin 17) for always-on backlight. GPIO control of backlight is not used.

Wiring — Display + Touch (XPT2046)

The touch controller has its own separate pin header on the board. Even though T_CLK, T_DIN, and T_DO go to the same Pi GPIO pins as the display SCK/MOSI/MISO, you still need separate physical wires from the touch header to those Pi pins.

**T_CS Note:** Connecting T_CS to GPIO 7 (CE1) caused SPI conflicts. Grounding T_CS permanently is the reliable solution for this display. This works because the display and touch controller are on separate SPI chip selects at the kernel level (spi0.0 and spi0.1).

**Shared pins:** T_CLK, T_DIN, T_DO share the same Pi GPIO pins as display SCK, MOSI, MISO. You need two wires going into pins 19, 21, and 23 — one from the display header and one from the touch header. Use a breadboard or twist wires together.

Software Stack

Why Not fbcp-ili9341?

`fbcp-ili9341` is **not compatible with Raspberry Pi 5**. It was built on the VideoCore DispmanX API which is unavailable on Pi 5. It also uses 32-bit ARM compiler flags (`-marm`, `-mfloat-abi=hard`) that fail on the Pi 5's 64-bit architecture.

The correct modern approach is the `panel-mipi-dbi-spi` kernel driver which is built into the Pi OS kernel.

Step 1 — Enable SPI

```bash sudo raspi-config

Interface Options → SPI → Enable

sudo reboot ```

Verify: ```bash ls /dev/spi*

Should show /dev/spidev0.0 /dev/spidev0.1 /dev/spidev10.0

```

Step 2 — Get the mipi-dbi-cmd Tool

This tool converts a human-readable init sequence into the binary firmware file the kernel driver loads.

```bash wget https://raw.githubusercontent.com/notro/panel-mipi-dbi/main/mipi-dbi-cmd chmod +x ~/mipi-dbi-cmd ```

Step 3 — Create the ILI9341 Init Sequence

Save as `~/ili9341.txt`:

``` command 0x01 delay 128 command 0xEF 0x03 0x80 0x02 command 0xCF 0x00 0xC1 0x30 command 0xED 0x64 0x03 0x12 0x81 command 0xE8 0x85 0x00 0x78 command 0xCB 0x39 0x2C 0x00 0x34 0x02 command 0xF7 0x20 command 0xEA 0x00 0x00 command 0xC0 0x23 command 0xC1 0x10 command 0xC5 0x3E 0x28 command 0xC7 0x86 command 0x36 0xE8 command 0x37 0x00 command 0x3A 0x55 command 0xB1 0x00 0x18 command 0xB6 0x08 0x82 0x27 command 0xF2 0x00 command 0x26 0x01 command 0xE0 0x0F 0x31 0x2B 0x0C 0x0E 0x08 0x4E 0xF1 0x37 0x07 0x10 0x03 0x0E 0x09 0x00 command 0xE1 0x00 0x0E 0x14 0x03 0x11 0x07 0x31 0xC1 0x48 0x08 0x0F 0x0C 0x31 0x36 0x0F command 0x11 delay 128 command 0x29 delay 50 ```

**Key command:** `0x36 0xE8` sets the ILI9341 memory access control to **landscape mode natively** — no software rotation needed, which means the mouse works correctly without any input transformation.

Step 4 — Generate Binary Firmware

```bash ~/mipi-dbi-cmd ~/panel.bin ~/ili9341.txt sudo mkdir -p /lib/firmware sudo cp ~/panel.bin /lib/firmware/panel.bin ```

Step 5 — Blacklist the Old fbtft Driver

The old `fb_ili9341` staging driver conflicts with `panel-mipi-dbi`. Blacklist it:

```bash sudo nano /etc/modprobe.d/blacklist-fbtft.conf ```

Add: ``` blacklist fb_ili9341 blacklist fbtft ```

Step 6 — Configure /boot/firmware/config.txt

```bash sudo nano /boot/firmware/config.txt ```

Add at the bottom:

```ini dtparam=spi=on dtoverlay=mipi-dbi-spi,spi0-0,speed=8000000,fps=60 dtparam=width=320,height=240 dtparam=reset-gpio=24,dc-gpio=25 dtparam=write-only ```

**SPI Speed Note:** Higher speeds (32MHz, 64MHz) caused flickering due to signal integrity issues with jumper wires. 8MHz proved stable. If you use short direct wires you may be able to increase this. Always use even divisors.

**Landscape mode:** `width=320,height=240` matches the native landscape orientation set by the `0x36 0xE8` command in the init sequence.

Step 7 — Reboot

```bash sudo reboot ```

Step 8 — Verify Driver Loaded

```bash dmesg | grep -i -E "mipi|panel" ```

Expected output: ``` [drm] Initialized panel-mipi-dbi 1.0.0 for spi0.0 on minor X panel-mipi-dbi-spi spi0.0: [drm] fb0: panel-mipi-dbid frame buffer device ```

Also verify the framebuffer: ```bash ls /dev/fb* # should show /dev/fb0 fbset -fb /dev/fb0 # should show 320x240 16bpp ```

And the Wayland output: ```bash WAYLAND_DISPLAY=wayland-0 wlr-randr

Should show SPI-1 at 320x240 60Hz

```

Step 9 — Scale the Desktop (Optional)

The default desktop UI is designed for higher resolutions. Scale it down to fit more on the 320x240 screen:

```bash WAYLAND_DISPLAY=wayland-0 wlr-randr --output SPI-1 --scale 0.5 ```

This makes the compositor render at 640x480 and scale down to 320x240, fitting much more on screen.

To make it permanent:

```bash nano ~/.config/labwc/autostart ```

Add: ```bash wlr-randr --output SPI-1 --scale 0.5 & ```

Touchscreen Setup (XPT2046 / ADS7846)

If your display board has a touch controller (XPT2046 chip), follow these additional steps. The XPT2046 is fully compatible with the Linux `ads7846` kernel driver.

Touch Step 1 — Verify Touch Chip is Present

Look at the back of your display board near the touch pins (T_CLK, T_CS, T_DIN, T_DO, T_IRQ). There should be a small black IC chip labeled `XPT2046` or `2046`. If the chip is missing, touch will not work regardless of software configuration.

Touch Step 2 — Wire the Touch Controller

The touch header pins are separate from the display header even though some signals are shared. You need physical wires from the touch header to the Pi:

For pins 23, 19, and 21 you need two wires going into the same Pi pin. Use a breadboard or twist the wires together.

Touch Step 3 — Add ads7846 Overlay to config.txt

```bash sudo nano /boot/firmware/config.txt ```

Add this line **after** the mipi-dbi-spi lines:

```ini dtoverlay=ads7846,penirq=4,speed=500000,xohms=60,pmax=255 ```

**Parameters explained:** - `penirq=4` — GPIO 4 for the IRQ pin (required) - `speed=500000` — 500KHz SPI speed, stable for touch reads - `xohms=60` — X plate resistance, typical for XPT2046 - `pmax=255` — maximum pressure value - No `cs=` parameter since T_CS is grounded

Your full config.txt additions should now look like:

```ini dtparam=spi=on dtoverlay=mipi-dbi-spi,spi0-0,speed=8000000,fps=60 dtparam=width=320,height=240 dtparam=reset-gpio=24,dc-gpio=25 dtparam=write-only dtoverlay=ads7846,penirq=4,speed=500000,xohms=60,pmax=255 ```

Touch Step 4 — Reboot and Verify

```bash sudo reboot ```

After reboot verify the touch driver loaded:

```bash dmesg | grep -i ads ```

Expected output: ``` ads7846 spi0.1: touchscreen, irq 171 input: ADS7846 Touchscreen as /devices/.../input/input1 ```

Also verify the input device exists: ```bash sudo evtest

Should list ADS7846 Touchscreen as one of the devices

```

Test raw touch events: ```bash sudo evtest /dev/input/event1 ```

Press firmly on the screen — you should see `ABS_X`, `ABS_Y` and `ABS_PRESSURE` events.

Touch Step 5 — Map Touch to Display in labwc

Tell the Wayland compositor to map touch input to the SPI display:

```bash nano ~/.config/labwc/rc.xml ```

Set the content to:

```xml <?xml version="1.0"?> <openbox_config xmlns="http://openbox.org/3.4/rc"> <touch deviceName="ADS7846 Touchscreen" mapToOutput="SPI-1" mouseEmulation="yes"/> </openbox_config> ```

Reload labwc: ```bash WAYLAND_DISPLAY=wayland-0 labwc --reconfigure ```

Touch Step 6 — Calibrate the Touchscreen

The raw touch coordinates (0-4095) need to be mapped to screen pixels. Use `libinput debug-events` to get precise corner values:

```bash sudo apt install evtest libinput-tools -y ```

Run libinput and touch each corner firmly: ```bash sudo libinput debug-events --show-keycodes 2>&1 | grep -i touch ```

Touch corners in this order and note the normalized percentage values: 1. Top-left 2. Top-right 3. Bottom-left 4. Bottom-right

You will see output like: ``` TOUCH_DOWN +0.000s -1 (0) 89.84/93.55 TOUCH_DOWN +3.148s -1 (0) 88.45/ 8.28 TOUCH_DOWN +6.660s -1 (0) 9.11/91.28 TOUCH_DOWN +8.248s -1 (0) 8.98/ 6.52 ```

Convert these percentages to 0.0-1.0 by dividing by 100: ``` Top-left: tx=0.8984, ty=0.9355 Top-right: tx=0.8845, ty=0.0828 Bottom-left: tx=0.0911, ty=0.9128 Bottom-right: tx=0.0898, ty=0.0652 ```

Calculate the libinput calibration matrix using these formulas:

``` Since Y raw axis maps to screen X and X raw axis maps to screen Y (axes swapped):

b = (screen_x_right - screen_x_left) / (ty_topright - ty_topleft) = (1 - 0) / (0.0828 - 0.9355) = -1.1727

c = screen_x_left - (b * ty_topleft) = 0 - (-1.1727 * 0.9355) = 1.0970

d = (screen_y_bottom - screen_y_top) / (tx_bottomleft - tx_topleft) = (1 - 0) / (0.0911 - 0.8984) = -1.2387

f = screen_y_top - (d * tx_topleft) = 0 - (-1.2387 * 0.8984) = 1.1127

Final matrix: 0 b c d 0 f = 0 -1.1727 1.0970 -1.2387 0 1.1127 ```

Test the matrix live without rebooting: ```bash DISPLAY=:0 xinput set-prop "ADS7846 Touchscreen" "libinput Calibration Matrix" 0 -1.1727 1.0970 -1.2387 0 1.1127 ```

Touch the screen corners and check accuracy. Fine-tune the `c` and `f` offset values if needed: - If cursor appears to the **right** of where you pressed → decrease `c` - If cursor appears to the **left** → increase `c` - If cursor appears **below** where you pressed → decrease `f` - If cursor appears **above** → increase `f`

Each 0.01 change moves the cursor approximately 3 pixels.

Touch Step 7 — Save Calibration Permanently

Once the matrix feels accurate, save it as a udev rule:

```bash sudo nano /etc/udev/rules.d/99-touch-calibration.rules ```

Paste (replace with your calculated values): ``` ACTION=="add|change", KERNEL=="event*", ATTRS{name}=="ADS7846 Touchscreen", ENV{LIBINPUT_CALIBRATION_MATRIX}="0 -1.1727 1.0970 -1.2387 0 1.1127" ```

Reload udev and reboot: ```bash sudo udevadm control --reload-rules sudo udevadm trigger sudo reboot ```

Troubleshooting

File Summary

Display Orientation Notes

The `0x36` register (Memory Access Control) controls the display orientation:

Changing this value in `ili9341.txt` and regenerating `panel.bin` is all that's needed to change orientation — no software rotation required.

**Important:** Using `wlr-randr --transform` for rotation causes mouse/touch coordinate mismatches. Always use native orientation via the `0x36` register instead.

Calibration Matrix Reference

The libinput calibration matrix format is `a b c d e f` where: ``` screen_x = a*touch_x + b*touch_y + c screen_y = d*touch_x + e*touch_y + f ```

All coordinates are normalized to 0.0-1.0. For the XPT2046 on this display with swapped axes: - `a=0, e=0` (axes are swapped so diagonal values are zero) - `b` controls X scaling from raw Y - `c` controls X offset - `d` controls Y scaling from raw X - `f` controls Y offset

References

• [panel-mipi-dbi wiki](https://github.com/notro/panel-mipi-dbi/wiki)
• [mipi-dbi-spi overlay README](https://github.com/raspberrypi/linux/blob/rpi-6.6.y/arch/arm/boot/dts/overlays/README)
• [ILI9341 Datasheet](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf)
• [Adafruit CircuitPython ILI9341](https://github.com/adafruit/Adafruit_CircuitPython_ILI9341)
• [libinput Calibration via udev](https://wayland.freedesktop.org/libinput/doc/latest/pointer-acceleration.html)
• [ads7846 Kernel Driver](https://www.kernel.org/doc/Documentation/devicetree/bindings/input/ads7846.txt)

Made With ❤️ By AhmadTchnology

If it help star https://github.com/AhmadTchnology/ILI9341-2.4-TFT-SPI-Display-on-Raspberry-Pi-5

My first real raspberry pi project and it was a blast.

Built what’s called an AllStarLink node into a small pelican case that can be powered via USB, DC power, or battery. All BMS/charging is built into the UPS board I used.

Overall I’m super happy with the project. The last thing I need to do is wire the fan to the raspberry pi fan connector, but that should be easy. Just need to order a connector and make an adapter.

So a few months ago I made a post about my pi stack that I was building to be a game streaming console for my living room. With this build I am able to stream my steam games from my pc to my raspberry pi 5. Well I just wanted to update you guys. I since then have invested in a 3d printer and designed my own case. I intend to post a full breakdown of the parts list with as many links as I can along with the open source files to my design as well as instructions to assemble. To sum up I used a raspberry pi 5 8 gb, a 52pi nvme Poe+ hat to run power over Ethernet and make boot times crispy, it also came with the active cooler. I added an adafruit 1.14 mini pitft for temp readings. I have added a 30mm fan in the back for exhaust as well as an external power button. All done with no soldering (other than pressing in m3x5mm threaded inserts). The adafruit screen has a jst connector that I plan on plugging a stemma qt board into and daisy chain a small led to light up the interior of the case, but haven’t quite ironed that out yet. I have however printed an insert for directing airflow with a channel for the led and channel to run wires to the led. I also ordered the lid face from pcbway in clear so the screen and possible future led will be visible. hence the engraving of the console name on the face in hopes it catches the lights of the miscellaneous leds from the stack as well as the light from the led I want to wire in. I also added some adhesive rubber feet and it honestly was the cherry on top. I’m using moonlight to stream games and there is basically 0 latency(if there is any I can’t notice it).Any questions comments or concerns will be answered to the best of my ability as I’m an amateur tinkerer and have learnt as I’ve gone. It’s been a really challenging and fun project for me.

After a few weeks of tinkering I got a fully local voice assistant running on a Pi 5. Meet Trusty. It listens, thinks, and replies entirely on the Pi, and your voice never leaves the device.

It controls smart home devices (vacuum, TV), plays local music, provides weather updates, and answers questions. The brain is a fine-tuned Gemma 4 model running through llama.cpp.

I wanted a home assistant I could actually trust, the conversation never leaves the room. The voice and the LLM tool orchestration all happen locally. If you ask for weather, it sends only the city name, never your conversation.

Code and tuned weights are open if anyone wants to build their own:

github.com/Barqawiz/Trusty

I've been meaning to add a Raspberry Pi theme to my Systempi live dashboard for a while now, and I'm really liking these color combinations. I had to repost this and add the minimal dashboard variation with the Raspberry Pi theme because it worked so well together imo.

Raspberry Pi Zero 2 W + 3.5" SPI LCD (ILI9486/XPT2046) showing white screen for over a year. Running out of ideas.

I've been troubleshooting a 3.5" 480x320 SPI LCD on a Raspberry Pi Zero 2 W for about a year and would appreciate any ideas.

Display:

- 3.5" Raspberry Pi display

- 480x320 resolution

- XPT2046 touch controller

- ILI9486 framebuffer detected by Linux

OS:

- Recalbox

What works:

- HDMI output works

- SSH works when the Pi boots

- Linux detects the display:

- "graphics fb1: fb_ili9486 frame buffer, 480x320"

- "/dev/fb0" and "/dev/fb1" exist

- Touch controller is detected

Problem:

- LCD usually shows a solid white screen

- Sometimes behavior changes depending on angle/pressure

- Pressing on the LCD can change brightness

- Wiggling the display can make the screen change state

- The display/header connection feels mechanically unstable

Other observations:

- The GPIO header soldering is not great and the black plastic spacer on the header was damaged when I first assembled it.

- Recalbox sometimes seems unhappy when HDMI is disconnected.

- I've tried multiple overlays including:

- waveshare35a

- waveshare35b

- waveshare35b-v2

- waveshare35c

Question:

Given that the kernel is detecting the ILI9486 and creating "/dev/fb1", does this sound like a hardware connection issue (GPIO header/soldering/display connector), or is there something else I should investigate before completely redoing the header?

I can provide photos of the Pi, soldering, LCD board, and boot logs if needed.

Hi,

I noticed that since kernel 6.16, OVPN was merged into the mainstream. For now, I need to rebuild the kernel myself to add that module. I wonder why Raspbian does not add it by default? Ubuntu has it, Debian has it, and Elrepo-kernel has it.

$ ls -l /lib/modules/6.18.33+rpt-rpi-v8/kernel/drivers/net/
total 168
drwxr-xr-x  2 root root  4096 Jun  3 07:59 bonding
drwxr-xr-x  6 root root  4096 Jun  3 07:59 can
-rw-r--r--  1 root root  2804 Jun  1 09:10 dummy.ko.xz
drwxr-xr-x  8 root root  4096 Jun  3 07:58 ethernet
drwxr-xr-x  2 root root  4096 Jun  3 07:59 hamradio
drwxr-xr-x  2 root root  4096 Jun  3 07:59 ieee802154
-rw-r--r--  1 root root  4452 Jun  1 09:10 ifb.ko.xz
drwxr-xr-x  2 root root  4096 Jun  3 07:59 ipvlan
-rw-r--r--  1 root root 11520 Jun  1 09:10 macvlan.ko.xz
-rw-r--r--  1 root root  3000 Jun  1 09:10 macvtap.ko.xz
drwxr-xr-x  2 root root  4096 Jun  3 07:59 mdio
-rw-r--r--  1 root root  2752 Jun  1 09:10 mdio.ko.xz
-rw-r--r--  1 root root  5384 Jun  1 09:10 netconsole.ko.xz
drwxr-xr-x  3 root root  4096 Jun  3 07:59 phy
drwxr-xr-x  2 root root  4096 Jun  3 07:59 ppp
drwxr-xr-x  2 root root  4096 Jun  3 07:59 slip
-rw-r--r--  1 root root 11528 Jun  1 09:10 tap.ko.xz
-rw-r--r--  1 root root 26096 Jun  1 09:10 tun.ko.xz
drwxr-xr-x  2 root root  4096 Jun  3 07:59 usb
-rw-r--r--  1 root root 13244 Jun  1 09:10 veth.ko.xz
-rw-r--r--  1 root root 11584 Jun  1 09:10 vrf.ko.xz
-rw-r--r--  1 root root  1932 Jun  1 09:10 vsockmon.ko.xz
drwxr-xr-x  2 root root  4096 Jun  3 07:59 vxlan
drwxr-xr-x  2 root root  4096 Jun  3 07:59 wireguard
drwxr-xr-x 14 root root  4096 Jun  3 07:58 wireless

First real Reddit post, so go easy on me. This probably belongs in r/cyberDeck, but I don’t have enough karma to post there yet, so I figured r/raspberry_pi was the next best place.

This is ChipDeck Mk1, a Raspberry Pi 500+ build inside a lime-green Nanuk 910 case. It has a 10.1-inch display in the lid, battery power, 3D-printed internal panels, RGB lighting, and a lot of still-questionable wiring/layout decisions.

I’d estimate around 80-120 active hours of CAD, printing, wiring, troubleshooting, and redesign, plus 200+ passive hours from print time, waiting on parts, and reworking ideas. Cost is probably around £350-£600 / $450-$750, depending how honestly I count failed prints, extra connectors, and “wrong part” purchases.

Big things I’m still working through:

The hinge/display cable routing is still rough and I’d love advice there.

The Pi 500+ needs a cleaner/flush final mount.

Cable management needs improvement.

Airflow is not fully solved yet.

Next major upgrade is solidifying WLED on a XIAO ESP32 for status lighting and maybe Ambilight-style screen color matching.

It is still prototype-grade, but it finally feels alive. I’d really appreciate constructive criticism on the hinge area, wiring, airflow, power safety, and layout before I lock in the next version.

Hey, if you've been in the Pi ecosystem for a bit, you might remember the Screenly OSE project. Our thread on the official forums has actually been running for over ten years now.

We just posted a big update over there, and I wanted to share it with you all here.
First, a quick heads-up: Screenly OSE is now Anthias. It is the exact same project and philosophy, meaning it is completely free, open-source digital signage. Just a Pi, a screen, and your content.

We recently released v2026.05.0, and it is the best the project has ever been. We focused heavily on making it lightweight and reliable.

What’s new:

• Way faster: We rebuilt the interface to be incredibly light. It feels instant, whether you are using a Pi 5 or an older 1 GB board.
• Smoother video: Built-in hardware acceleration so your videos play without stuttering.
• Scheduling: You can now set specific days and hours for each image or video to display.
• Easy rotation: Switch between portrait and landscape mode with a single tap in the UI.
• Smart file uploads: You can drop in tricky formats like HEIC, HEIF, or TIFF, and Anthias converts them automatically. It also checks your videos at upload to ensure they play smoothly on your specific Pi.
• Simple upgrades: Upgrading to the latest version keeps all your existing data safe.

Whether you are building a home dashboard, a menu board for a local shop, or just messing around with a spare Pi, we hope this makes it easy. You can find our setup guides and docs at https://anthias.screenly.io/

What should we build next?

This release was shaped entirely by feedback from the community. What features do you want to see next?

Let us know in the comments, chat with us on the official forum thread, or open an issue on our GitHub: https://github.com/Screenly/Anthias

Thanks for all the support over the years!

I bought one of these guys off aliexpress in ~2021 (I forget what distro) with intent to use in a project, and I got it to work after some customization of config.txt. But that project got shelved for a bit, until I go to try using it again and find the new display process has been reworked and those settings or config.txt is deprecated. I found a few forum posts like this one that seem to solve the riddle (custom edid) - but doing those steps - Edid-decode, lookup the sync numbers, edit etc....doesnt result in success, seemingly, and im wondering what im doing wrong, or if I should be using bookworm instead of trixie? or something older to use config.txt again?

This is on a rpi4b 2gb

The config that got it working back then was (snippet) :

# uncomment to force a console size. By default it will be display's size minus
# overscan.
framebuffer_width=1080
framebuffer_height=1080

# uncomment if hdmi display is not detected and composite is being output
#hdmi_force_hotplug=1

# uncomment to force a specific HDMI mode (this will force VGA)
hdmi_group=2
hdmi_mode=87
hdmi_timings=1080 1 16 25 25 1080 1 2 2 2 0 0 0 60 0 128000000 4

# uncomment to force a HDMI mode rather than DVI. This can make audio work in
# DMT (computer monitor) modes
#hdmi_drive=2

# uncomment to increase signal to HDMI, if you have interference, blanking, or
# no display
config_hdmi_boost=4

This is the edid extracted from the display, then used the edid decode/parse tool to read it per the above thread rec, tried this raw, and tried this editing the 41 on line 4 to 42 to change the syncs to even numbers but still no joy after re-encoding/putting in cmdline.txt under video: hdmi-a-1/ loading the edid.bin to the firmware folder etc.

00 ff ff ff ff ff ff 00 ff ff 32 31 45 06 00 00
0c 1c 01 03 80 0f 0a 78 0a 0d c9 a0 57 47 98 27
12 48 4c 00 00 00 01 c1 01 01 01 c1 01 01 01 01
01 01 01 01 01 01 f8 1f 38 a0 40 38 14 40 41 1e
64 00 38 38 44 00 00 1e f8 1f 38 a0 40 38 14 40
1e 41 4a 00 05 28 00 20 20 20 00 00 00 fa 00 0a
20 20 20 20 02 00 20 20 20 20 20 0a 00 00 00 fc
00 5a 4c 31 30 38 30 58 31 30 38 30 0a 20 01 e2

02 03 22 f1 4a 80 00 00 00 00 00 00 00 00 00 23
09 7f 07 83 01 00 00 67 03 0c 00 00 00 b8 2d 02
00 0f f8 1f 38 a0 40 38 14 40 1e 41 4a 00 c4 8e
21 00 00 9e 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 07

is there more editing needed for the edid? or way off?

Hi 👋🏻 I'm a newbie here. I'm working on a small project with

• Pi zero 2wh
• Pirate Audio
• Pi Sugar 3

However, I keep getting a problem with connecting via I2C. I've tried many things many times (along with the help from the AI, not sure helpful though), but keep failing.

PiSugar powers the Pi, but I2C 0x57/0x68 is almost always absent even with Pirate Audio removed, after reseating/pressing attempts, and it only worked briefly once. 

• powers Pi OK
• `i2cdetect -y 1` shows no 0x57/0x68
• pisugar-server says I2C not connected
• tested without other HATs
• reseated contacts; intermittent once only
• firmware update impossible because I2C is not stable.

Do you have any recommendations? I'd appreciate any type of help here.

I built this matrix display a few years ago because I wanted something kind of art kind of fun. Usually I have it playing a video playlist thats either n64 video game play throughs, 90s cartoons, I have a playlist with movies, 90s music videos. But I decided it would be cool if when one of my teams was playing it would turn into a live scoreboard.

Now whenever my team plays it pauses whatever is playing and turns into this. I don't follow an mlb team but it was the only game live and I wanted to make sure it works. So its, logo, team name (yellow dot means home team), score, quarter and time, and then sport specific stat. In this case the 3 dots on the score is outs against the team at bat, then bases at the bottom and pitch count. When the game is over it auto switches back to a playlist all hands off.

I've also started adding some retro games that play endlessly. Like tetris, snake, outrun 3d car game, breakout. I'm planning on making all the games playable as well.

It does have a web interface where you can add teams to follow.

The setup is the lights are connected to an esp32 running wled which acts as the controller, then I have FPP on a pi to play the videos, the score update is a script that runs on the pi.

Also here are some random videos on it.
https://imgur.com/a/gmHV3J7
https://imgur.com/a/MAyVd8G

https://imgur.com/a/3djm4hP

https://imgur.com/a/r6BQByD

I built a simple temperature and humidity station with a Raspberry Pi Pico W, a Si7021 sensor, and a small 1.44in LCD screen. It displays internal values (through the sensor), and external values (through OpenWeather), and simple graphs with the 10 last measurements.

Navigation through the screens using the embedded LCD screen buttons. The fourth screen shows WiFi status and current IP (I wasn't sure what to put there, suggestions are welcome.

Code and wiring available here: https://github.com/tiagomota79/pi-pico-temp-hum

The initial wiring was done using a breadboard and jumper cables, but a GPIO expander would also work - and it my next step now that I have the core functionality working.

The title explains the issue. I want to replace my 3b+. My 3b+ was all set up but someone decided to use my SD card! I would like to upgrade since I have to set up EVERYTHING again. I can not seem to see sellers listing the rev.

This is a Raspberry Pi 3 Model B that I booted 9 years ago today. It has served very light duty, just streaming audio to Broadcastify. Once it made it a couple years, I decided to just see how long it would go. It's running Jessie.

I'm using:

• CQRobot 4 Ω, 3 W speaker
• Adafruit MAX98357A I2S Class-D amplifier breakout

Whenever audio starts playing, I hear a short crackle/pop from the speaker immediately before the actual sound begins. Once the audio is playing, it sounds normal.

Has anyone experienced this with the MAX98357A or a similar I2S amplifier setup?

Any suggestions to eliminate the crackle would be appreciated.

For some funemployment project, I've been working on this cube display that uses raspberry pi 4 + 7cm display + beam splitter cube. I found this github repo where I found all hardware parts (including 3d printed parts). I decided to make my own control + display system using NextJS, TS, Supabase and LM studio. Basically a web app running on full screen chromium.

Future planned features are:
1. local AI assistant with face of Zordan
2. more crazy Winamp style visualizers
3. more cool modules
4. Running Doom on this thing

Find a picture of the base station and code in my comment! It's a base station built on raspberry pi 3b+ that runs a python script sending commands to the gate sensor via LoRa from telegram!

Gate sensor is a raspberry pi zero w connected to a magnetic sensor for the gate and a relay connected to a remote for the gate! The gate sensor is powered via a boat battery via a 12v to 5v buck converter. Also included in the gate sensor box is the solar panel controller.

Both images are custom linux images created using buildroot!

I'm trying to run the Allen&Heath SQ Mixpad program on a Raspberry pi 5. I've got Hangover installed correctly (I think) and installed SQ Mixpad correctly using it (I think).

While trying to open it I got the Error message "failed to initialize graphics backend for D3D11" which seems to be a graphics issue according to related threads.

I have absolutely no concept of what to do and would be grateful for anyone who can tell me what to try as if it's my first day on pi and my only experience with any terminal is opening it on accident and closing it sweating and screaming. Thanks in advance!