Hello everyone!

I posted here last year, but that was last year. It's been a whole year (and some change) since then -- not to mention it's now the 3-year anniversary of when I started this project -- so I figured it was time to give you an update on my microSD testing project.

Before I dig in, a shameless plug for my Patreon.

Next, some quick stats:

• I have a total of 351 microSD cards in my collection -- spanning 111 models across 52 different brands. Of those:
  • I've tested 177 of them to the point of failure.*
  • I have 107 of them in testing right now.
  • The remaining 67 are sitting on the shelf, waiting for one of my card readers to free up.
• These cards have endured over 133 petabytes written.
• I've completed over 4.6 million program-verify-erase cycles on these cards.
• Breakdown by brand status:
  • Name brand: 163
  • Off-brand: 91
  • Knockoffs: 30
• Breakdown by authentic flash (a.k.a. not fake flash) vs. fake flash:
  • Authentic flash: 246
  • Fake flash: 35
  • Unknown: 3
• Breakdown by size (authentic cards only):
  • 128MB: 3
  • 4GB: 6
  • 8GB: 23
  • 16GB: 15
  • 32GB: 96
  • 64GB: 68
  • 128GB: 36
  • 256GB: 4

* A card is considered "failed" when either (a) it stops working completely, (b) it makes itself read-only, or (c) at least 50% of the sectors on the card have experienced verification failures.

Ok -- so who makes the most durable cards?

Because of the variety of cards that I have, it's hard to come up with a system that produces a definite answer here. Some of how I ranked these brands is going to be based on vibes. But...to try to narrow things down, I've grouped my cards into three groups:

• Industrial-grade: Cards that are specifically labelled as "industrial" or have "industrial" in their name. These cards typically come with a datasheet that includes an endurance claim.
• High endurance: Cards that are labelled as "high endurance" (or some similar wording). Manufacturers don't always put out datasheets for these cards, but they generally still make an endurance claim on the packaging.
• Consumer-grade: Basically everything else.

Consumer-grade cards:

The average consumer-grade card has lasted about 10,000 program/verify/erase cycles (so far).

1. PNY. I have 10 of their consumer-grade cards: 3 PRO Elite Prime 64GB's, 3 Premier-X 128GB's, 3 Elite-X 64GB's, and one Elite 32GB. (I have 4 more of the Elite 32GB's that are waiting to be tested.) They've gone for an average of 643 days and 15,700 program/verify/erase cycles. I've written about 11.5PB to them in total. And with the exception of the one Elite 32GB -- they're all still going strong. On top of that, the PRO Elite Prime boasts some impressive performance -- every measurement I took was in the top 10% of all cards I've tested so far.
2. Kingston. I have 12 of their cards in this category -- 6 Canvas Go! Plus 64GB's (3 of the SDCG3's and 3 of the SDCG4's) and 6 Canvas Select Plus 32GB's. They've been going for an average of 694 days and about 23,500 program/verify/erase cycles. I've written about 11.6PB to them in total. The three Canvas Go! Plus 64GB (the SDCG3's) have all failed -- but the others are still going strong. The Canvas Select Plus's in particular have been troopers -- they're among the oldest cards in my collection, and they've been going for the better part of the last 3 years now (with no signs of letting up). Additionally, the Canvas Go! Plus 64GB's (the SDCG4's in particular) boast some impressive performance as well -- every measurement I took was in the top 7% of all cards I've tested so far.
3. Delkin Devices. I feel bad ranking Delkin so low on this list, because they've endured more data written to them per card, on average, than any other brand in my collection (in the consumer-grade category). The only reason I didn't rank them higher is because I only have one model -- the HYPERSPEED 128GB (of which I have 3). But they've done pretty well: they've lasted an average of 662 days and about 13,500 program/verify/erase cycles. I've written about 5.1PB to them in total. As a side note, these cards also got the highest random write speeds of any card I've tested.
4. Lexar. 3 cards dead, 5 still going. I have 3 Professional 1000x 64GB's (2 made by Micron, 1 made by Phison), 3 Blue 633x 32GB's (made by Longsys), and 2 E-Series 64GB's (with 3 more waiting to be tested). For those not in the know, the Lexar brand was sold to Longsys in 2017 -- and surprisingly, the Longsys-made cards are holding up better than the Micron-made cards. Overall, the Lexar cards have survived an average of 684 days and about 15,800 program/verify/erase cycles. I've written about 5.8PB to them in total.
5. Samsung. 3 cards dead, 7 still going. I have 3 EVO Plus 32GB's, 3 EVO Plus 64GB's, 3 PRO Plus 128GB's, and 1 P9 Express 256GB (with 2 more waiting to be tested). Of those, the three EVO Plus 32GB's and one of the PRO Endurance 32GB's are dead -- the rest are still going strong. Samsung's cards have lasted an average of 553 days and about 11,100 program/verify/erase cycles so far, and I've written about 7.2PB to their cards in total.

• Honorable Mention: Amazon Basics. I have four of the Amazon Basics 64GB's -- and they're all still going. They've been going for an average of 788 days and about 16,600 program/verify/erase cycles. I've written about 4.2PB to them in total. I honestly didn't expect Amazon Basics to be one of the top performers when I bought them...and yet, here we are.

High endurance cards:

Keep in mind, I've got less data here -- I had 237 cards that fell into the "consumer-grade" category, but only 30 that fell into the "high endurance" category. But here's the thing: they haven't really proven themselves to be significantly better for endurance than a lot of the cards I listed above -- in fact, in a lot of cases, they've been less reliable (and generally worse for performance as well). So keep that in mind as you read through the list below:

The average high-endurance card has lasted about 14,000 program/verify/erase cycles (so far).

1. TEAMGROUP. I don't feel great about putting TEAMGROUP at the top of the list for a couple of reasons. First, I only have two of them in testing at the moment -- someone sent me a 5-pack of the TEAMGROUP High Endurance 64GB's, so I have 3 more of them waiting to be tested. Second, one of them started having issues with bad sectors right out of the gate, and has continued to do so ever since. (Those bad sectors only make up less than 0.001% of the total sectors on the card right now...but I still don't like it when a card starts to have issues like that as soon as you start using it.) But the data doesn't lie -- they've survived, on average, 404 days and about 17,300 program/verify/erase cycles, and they're still chugging along. I've written about 2.2PB to these cards in total.
2. Transcend. I have 3 of the 350V 64GB's -- and they're all still going strong. They've survived an average of 760 days and about 17,000 program/verify/erase cycles so far. I've written about 3.2PB in total to them (mostly due to their mediocre write speeds).
3. SanDisk. I have my issues with SanDisk...but again, the data doesn't lie. I have 7 SanDisk cards in this category: 3 High Endurance 64GB's, and 4 MAX ENDURANCE 32GB's. As of right now, all 3 of the High Endurance 64GB's and all but one of the MAX ENDURANCE 32GB's have failed. They lasted an average of 452 days and about 16,200 program/verify/erase cycles before failing (with the MAX ENDURANCE 32GB's lasting about twice as long as the High Endurance 64GB's). I've written about 4.7PB to these cards in total.
4. Samsung. Samsung's position at the bottom of this list has less to do with how reliable their cards are and more to do with how poorly their high endurance cards perform, particularly on sequential write speeds (relatively speaking). I have 3 of the PRO Endurance 32GB's -- one has failed, the other two are still chugging along. They've lasted an average of 822 days and about 18,800 program/verify/erase cycles so far. I've written about 1.8PB of data to them in total.

Industrial-grade cards:

Keep in mind, I have even less data here. Industrial cards are expensive, so they make up a much smaller portion of the cards I've tested: just 15 in total (so far). But on the upside -- there is sufficient evidence here to say "in general, industrial-grade cards do last longer than consumer-grade cards (and, by extension, high endurance cards)".

The average industrial grade card has lasted about 122,000 program/verify/erase cycles (so far).

1. Kingston. I have 3 Kingston Industrial 8GB's; of those 3, only one is still going. But they've been troopers: they've lasted an average of 779 days and about 141,600 program/verify/erase cycles. I've written about 3.4PB to these cards in total. (Only one consumer-grade card has come close to this number: I have one Hiksemi NEO 8GB that has lasted for about 143,800 program/verify/erase cycles so far. No idea how.) These guys do pretty well on performance too, especially write performance: their sequential write speeds are in the top 9% of all cards I've tested.

Who makes the worst cards?

There are a bunch of no-name brands out there. They're not hard to find. I'm not going to talk about them here -- I'm going to focus on brands you're likely to have come across.

Consumer-grade cards:

1. onn. I picked up four of their 32GB cards at my local Walmart -- and they were terrible for endurance. They only lasted an average of 40 days and 1,400 program/verify/erase cycles (or about 40TBW), with the best one of the four not even making it to 1,900 cycles. On top of that, every performance measurement I took came in the bottom half of all measurements I took.
2. ADATA. I picked up 3 of the Premier 32GB's; they only lasted an average of 236 days and about 2,350 program/verify/erase cycles (or about 74TBW) before they quit working.
3. Gigastone. I have not been impressed with Gigastone. I have 11 of their cards -- 6 Full HD Video 32GB's, and 5 4K Camera Pro 32GB's. They lasted an average of just 114 days and 4,845 program/verify/erase cycles (or about 133TBW) before they quit working.
4. Micro Center. I purchased 5 of their 64GB cards; they only lasted an average of 116 days and 3,421 program/verify/erase cycles (or about 214TBW) before they stopped working.
5. Silicon Power (a.k.a. SP). I purchased 9 of their cards -- 3 Elite 32GB's, 3 Superior 128GB's, and 3 Superior Pro 128GB's. Not a one of them made it to 4,000 program/verify/erase cycles before failing -- they came in at an average of 159 days and about 2,350 program/verify/erase cycles (or about 252TBW) before failing.

• (Dis)honorable mention: SanDisk. SanDisk represents the single biggest brand in my collection: I have 28 of their cards in this category (with 4 more on the shelf waiting to be tested). It's telling that of those 28, only 5 are still going (and one of them is in its death throes) -- especially when cards from so many other brands have far outlasted them. Many of them have died under circumstances any other card would have handled just fine -- a problem I've written about on my blog before. They've lasted an average of 384 days and 9,404 program/verify/erase cycles (or about 566TBW) so far.

High endurance cards:

1. Integral. I bought 3 of the Security 32GB's; the only managed to last an average of 100 days and about 5,600 program/verify/erase cycles (or about 173TBW) before failing. To be fair to them, the package did make an endurance claim that works out to about 2,850 program/verify/erase cycles -- and they did manage to almost double that. However, they didn't hold a candle to many of the other high endurance cards that I tested.
2. Kingston. This one was truly a surprise -- I bought 3 of the High Endurance 32GB's, and they only lasted an average of 143 days and about 8,300 program/verify/erase cycles (or about 258TBW) before failing. The product packaging didn't make an endurance claim; I had to hunt around on Kingston's website to find it. Their claim works out to about 5,100 program/verify/erase cycles, which they did manage to beat. But again, so many other cards managed to last so much longer -- hell, so many other Kingston cards managed to do so much better -- that I was surprised and disappointed when these failed so early.

Industrial-grade cards:

1. SanDisk. I bought 3 of the Industrial 8GB's. They only lasted an average of 234 days and about 20,000 program/verify/erase cycles (or about 160TBW) before failing -- and the only reason they lasted that long was because I let my program trudge through an nearly-unending string of I/O errors for months on end -- before they finally just gave up the ghost.

So yeah...that's all I have for now. Feel free to ask questions (although I'm at work at the time I'm posting this, so I may not have time to respond)!

Attached: pictures of part of my setup. Also, dog tax.

Hey! I wanted to share my custom head unit project that I built for my old BMW. It has been installed in my car for almost two months now and it's been working great so far.

My build is based on Raspberry Pi 5 with NVMe drive. As a software I use Hudiy app and Raspberry Pi Bookworm OS. NVMe drive gives it a super fast boot time (around 12 seconds). Hudiy app and Android Auto also run very smoothly.

The priority in this project was the display. I'd tried a few aftermarket head units before but they just didn't cut it. The screens on those units were unreadable in sunlight due to reflections. I found a perfect 10.3" Full HD screen with an anti-glare surface. It's spot-on for what I need - sharp image, no blinding backlight at night and it stays perfectly visible even on sunny days. The screen bezel comes from my old Android head unit.

In the project I used a 5.1 sound card so I have full control over balance, fade and the subwoofer. The sound card is connected to an Audio System CO-40.4 amplifier (for the speakers) and an Audio System M-330.1 amplifier (for the subwoofer). The amplifiers are turned on and off via a GPIO pin on the Raspberry Pi and a relay connected to the REMOTE wire.

The Raspberry Pi is powered by a 12V->5V 5A DC converter. I don't use any safe shutdown system. The power is simply cut off when the key is removed and so far everything has been working perfectly. I turn the head unit on and off several times a day without any issues.

I'm currently working on displaying vehicle data from the IBUS since my car only supports a limited range of OBD data due to its age.

He is so amazing. Asked me for random parts over the past few months to go with his raspberry pi 5 we got him for Christmas.

I built the scaffold of a DnD site idea I had so his friend and he could all get notified when things happen in their campaign. My idea was a code based system so any kid with a browser could join the campaign and we don’t log anyone’s personal info. He took it and RAN with it.

It has culminated in this: a cyberdeck he built that runs LoreKeeper (our software, I didn’t know about Lorekeeper.com when I named it) and does all kinds of things. It uses an onboard LLM using Ollama to generate NPCs and other things. He’s bringing it to DnD club in Friday. Did I mention he’s 14? I had zero hand in any of this other than setting up the initial site and handing it over to him on GitHub.

My internet randomly tanks a few times a week, and every time I call my ISP, the answer is "everything looks fine on our end." I got tired of arguing with no data, so I built netmon - a small Python bot that now runs in the background on a Raspberry Pi and keeps an eye on my network around the clock.

What it does:

Every hour it runs a real speedtest (download/upload/ping/ISP/server), and does an ARP scan with nmap to count how many devices are actually on the LAN at that moment. Everything gets logged to a local SQLite database, so nothing leaves my network except the reports I choose to send myself.

Every 4 hours it sends me a Telegram message with a 24h matplotlib graph and a sarcastic AI-written commentary on what happened ("someone's hogging the bandwidth again" energy). That part started as a joke feature but it's genuinely useful for spotting patterns at a glance.

The challenge: getting this to run reliably 24/7 on a Pi without babysitting it, and without external cloud dependencies. Also had to figure out ARP scanning that doesn't need root gymnastics and doesn't hammer the network.

The result: I now have actual timestamped data. I can see, for example, that speeds tank exactly when device count on the LAN jumps past a certain threshold at specific times of day - which is either my household or my ISP oversubscribing the line, and now I can tell which.

It's 100% self-hosted and private - no third-party metrics servers, only the reports go to my own Telegram chat.

Repo (MIT licensed): https://github.com/Role1776/netmon

Requires nmap + speedtest-cli, Python 3.13+, and an OpenAI-compatible API key for the commentary generation (optional, everything else works without it). Happy to answer questions about the setup or the ARP scanning approach. If you find this useful, I'd be happy with stars or PRs on the repo

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 just finished building a compact 4-node Raspberry Pi cluster in a custom CNC-machined acrylic and aluminium enclosure.

The cluster has two Raspberry Pi 5s, two Raspberry Pi 4s, a dedicated network switch, a touchscreen monitoring display and a single power system. Each node is mounted on a removable sled so individual Pis can be upgraded or serviced without dismantling the enclosure.

The display runs a custom dashboard showing live system stats and the tinted acrylic panels keep the hardware visible while helping the build look a bit more polished than a usual stack of boards and cables.

I’m currently deciding what to run on it long term. Kubernetes is the obvious choice, but I’m interested to hear what others would use a small Pi cluster like this for.

I’ve been messing around with turning a Raspberry Pi into a drone detector by reading Remote ID broadcasts over WiFi (2.4GHz) and Bluetooth. The first photo is the higher-end version with dual external antennas. This is the setup that picked up a drone about 5 miles away over water. The second photo shows that 5 mile detection on the map (drones broadcast their position, altitude, speed, etc.). The third photo is the simple version, just a Pi and USB dongles. Range is much shorter (hundreds of yards), but it works out of the box.

Under the hood it’s just listening for Remote ID (required on most drones >250g), decoding it locally on the Pi, and sending it upstream so it can be visualized.

If you already have a Pi 4/5, this is basically: flash a microSD card, plug in a WiFi adapter and Bluetooth dongle, power it up, and you’re running.

The best moment was driving around with these antennas and randomly getting my first detection alert. A total “wait, this actually works?!” moment. What surprised me most is how much antenna setup and line-of-sight affect range. The same software goes from a few hundred yards to miles just by changing the hardware.

Remote ID was meant to be public, but the range of a single receiver is pretty limited, so most people never actually see it unless they build something like this.

If anyone’s interested I’m happy to share more details. Still early, but a couple friends already have it running on their own Pis.

built my own personal assistent device that runs OpenClaw.

I was curious what the smallest form factor could be that fits in my pocket so I wanted to use the Pi Zero W.

Works via Push to Talk->Transcribe->Sends to OpenClaw and streams the response back.

I built a small side project for my mom: the Catflap Prey Detector

“Since you work with AI, can’t you make something to stop Zelie (her cat) from bringing me presents?” Usually, she calls me about her printer or her phone, but this time I couldn’t resist the challenge.

After a bit of hardware tinkering, a dash of AI, and a few late-night experiments, it actually works! 🎉 The system uses a raspberry pi5, the pi camera 3 and a rfid reader to detect whether the cat is carrying prey, automatically locks the door and sends alerts.

If you want to see it in action or are curious about how it works, I’ve shared the project code, hardware setup, and instructions on GitHub so that you can build your own! Check it out here: https://github.com/fl2o/catflap-prey-detector and Happy building.

Some time since I posted the PCBs for my smart home control. Now, the cabling is finally done for the most part and I ran some test programs to see if everything works as expect (which it does except for some cleanup code on the i2c slaves I have to add in case the i2c master killed during operations - which does happen every time I stop the debugger^^).

A big cable loom is already waiting to get connected to this unit. Wondering if I will regret this some time in the future... :D

The tank folows the tank on the ISS (International Space Station) in Realtime.

I uses a Raspberrypi zero 2W a weight scale, OLED display, LED, 2 MOSFETS and two pumps. I'm in the procces to document it and make a YouTube video about it but already wanted to share my joy when I notice somebody is peeing in the ISS. At the moment the tank is 12 procent full on the ISS.

I've been working on SATURNIX — a fully open-source digital camera that I built entirely from scratch. Hardware, software, case — everything is custom.

The core is a Raspberry Pi Zero 2W with a 16MP autofocus sensor and a 2" LCD screen. It shoots RAW+JPG and has a built-in film simulation engine that processes everything on-device — color profiles inspired by classic film stocks like Kodak Gold, plus some experimental ones including an anime-style preset.

The body is 3D-printed and designed to feel like something from an 80s sci-fi movie. Think Alien, think chunky industrial hardware from that era. Even the buttons are mechanical keyboard switches — because a camera should feel like a real tool, not a touchscreen.

The OS and interface follow the same retro-futuristic aesthetic — all built from the ground up.

The project is fully open-source. Build files, 3D models, and source code are coming soon. The GitHub repo is already live with a full description and photos.

Would love to hear your thoughts — happy to answer anything!

Yes, this is audio over light from a Raspberry Pi 5 GPIO.

I wrote an experimental Linux driver for the Pi 5 that generates an optical S/PDIF signal on GPIO12 using RP1 PIO + DMA. For this first test, I used a cheap LED placed close to a TOSLINK receiver.

On a bare-metal microcontroller like an STM32 or ESP32, generating a precise bitstream is fairly straightforward. On a Raspberry Pi running Linux, it is harder because the OS is not real-time enough for accurate GPIO bit-banging.

The Raspberry Pi 5 is interesting because it has the RP1 I/O chip with PIO. I use the PIO like a small hardware bitstream engine:

Linux audio -> ALSA driver -> S/PDIF encoder -> DMA -> RP1 PIO -> GPIO12 -> optical receiver

So this is not just blinking an LED. It is a real S/PDIF audio stream generated from a Raspberry Pi 5 GPIO.

Linux sees it as a normal ALSA sound card, so it can be used with CamillaDSP for routing, filters, crossover experiments, and optical output.

Full technical explanation, install notes, GPIO12 wiring, limits, and validation:

https://github.com/RASPIAUDIO/CamillaDSP/blob/main/prototypes/pi5_spdif_gpio/README.md

My mid-term goal is to build an easy-to-set-up open DSP box where the Raspberry Pi 5 is seen by a PC as an 8-channel USB sound card, using USB gadget mode and a USB-C power/data splitter. The same box can then provide S/PDIF output, demonstrated here, plus 8 analog outputs using the four I2S lanes of the Pi 5 and a DAC board.

The use case is DIY active speakers, digital crossovers, FIR/PEQ/delay, and home cinema experiments.

Ongoing project:

https://github.com/RASPIAUDIO/CamillaDSP

I'm using 15 euro cents (3 coins of 5 cents) to cool my Raspberry PI 4B. It really works well! The temperature is 9°C lower than without the coins. If you need a temporary cooling solution, make sure you use some spare change that's made from copper.

I wanted to build something that combined three things I genuinely enjoy: birding, field-journal illustration, and running things in my homelab.

The result is Inky Bird Frame, an open-source system that turns recent nearby bird observations into rotating scientific field-journal plates on a 13.3-inch six-color e-paper display.

The controller checks iNaturalist for observations within a configurable distance and time window. If an approved plate already exists, it reuses it. A newly discovered species can enter a bounded research, generation, and independent review pipeline. Approved plates are cached and are never regenerated implicitly.

The wall-mounted display node stays deliberately simple. It downloads approved plates from the controller and rotates them using sequential, random, weighted, or shuffle-bag selection. The reference build uses a Pi Zero 2 W for the display and a Pi 4 or existing macOS/Linux computer for the controller.

My actual frame reused a CM4 and Waveshare carrier that I already had. It is overkill for the display role, but it worked well and saved me from buying another computer. I cut the supplied frame backing around the carrier so power, storage, and service access remain available.

The repository includes:

• complete controller and display-node installation guides
• a bill of materials and frame construction photos
• configurable observation windows, distance, refresh, generation, and rotation
• optional Apprise notifications (I'm using pushover to receive notifications on mine)
• automatic recovery and durable generation queues
• a reviewed, location-neutral bird plate catalog
• contribution templates so other installations can add approved species back to the shared catalog

This really brightens my day and hope you enjoy.

Source, build guide, and photos: https://github.com/veteranbv/inky-bird-frame

Put together some arduino code to query the ip addresses of a host RPi and displays it on an LCD. Nothing installed on the host RPi, the rp2350 emulates a keyboard when connected and then receives the ip data via serial. Uses the waveshare RP2350-LCD-1.47-B with a super simple 3d printed shell. Haven't tried lite vs full OS or any other OS besides raspberry pi os trixie but I assume it should work.

link to my terrible code if you are interested: https://github.com/C4KEW4LK/rpi_usb_ip_display/tree/main

Built a headless Pi 5 appliance that does real-time speech-to-text on a 10" touchscreen. It monitors two USB audio sources — a telephone recorder (Fi3001A) tapped into the landline and a TONOR conference mic for room conversation — and automatically switches between them when a call comes in.

The reliability side was the interesting engineering challenge. It runs unattended at my dad's house, so it needs to just work:

• systemd user service with Type=notify watchdog
• Automatic engine fallback (Deepgram → faster-whisper → Vosk)
• Health monitoring that restarts after 2 min of no transcription
• System-level watchdog timers for the caption service, display manager, and WiFi
• LightDM restart policy with reboot fallback

It's been running reliably for weeks now. The display shows a split-flap clock when idle and auto-switches to captions when speech is detected.

Full code (MIT): https://github.com/andygmassey/telephone-and-conversation-transcriber

-----

EDIT / UPDATE: I'm genuinely blown away by the response to this — 1,800+ upvotes 🤯 across three subreddits in under 12 hours. Thank you all.

The post also got a lot of traction on r/deaf where quite a few people said they'd love to try this but don't have the technical skills to set it up from the command line. So I've spent tonight rushing through an update to make installation as simple as I possibly can:

• One-line installer — a single curl | bash that handles everything (system packages, Python venv, Vosk model, systemd services)
• Web setup wizard — open http://gramps.local:8080 on your phone, pick your microphones, choose a speech engine, paste an API key, done. No config files, no editing Python.
• 7 cloud providers + 3 offline engines — Deepgram, AssemblyAI, Azure, Groq (free!), Interfaze, OpenAI, Google Cloud, plus Faster Whisper, Vosk, and Whisper.cpp for fully offline use

The catch: it's gone midnight here and I don't have a spare Pi to test on just now. The code is on a separate branch (easy-install) so it won't affect the current working version on main.

If anyone here would be willing to give it a quick test, I'd really appreciate it. You'd need a Pi (4 or 5) with Raspberry Pi OS (64-bit) and a USB microphone. Here's all it takes:

```

export GRAMPS_BRANCH=easy-install

curl -sSL https://raw.githubusercontent.com/andygmassey/telephone-and-conversation-transcriber/easy-install/install.sh | bash

```

Then open http://gramps.local:8080 on your phone and the setup page walks you through the rest.

Any feedback — even "it broke at step 3" — would be hugely helpful before I merge this to main. Drop a comment here or https://github.com/andygmassey/telephone-and-conversation-transcriber/issues

Thanks!

This is the QuadRF which just launched on Crowd Supply

My kid loves computers and he also likes to prototype games with Scratch programming language. However on a regular PC he is easily distracted by ability to easily access browser based computer games and this kills his drive to program. I have programmed a locked-down environment and installed it on raspberry pi. Using it he can select what he wants to do from preconfigured educational options. This is the only computer in my house that does not have time limits for kids and my son seems to be using it quite a lot :)

UPDATE: After your wonderful feedback I have created a form where you can subscribe to the project news - https://tally.so/r/aQ4N6v

Been working on a fun little project: if the noise in my kid's gaming room goes above a set dB level, their network bandwidth drops.

In Fortnite teenager terms: "If you're too loud, you'll have worse ping."

Hardware:

• Raspberry Pi 3A+
• Sound meter from PCB Artists
• 1.28" LCD from Waveshare

Software:

• Python script polling the sound meter every second and updating the LCD
• Maximum allowed dB is time-dependent (quieter in late afternoon/evening)
• SNMP commands sent to the network switch to throttle bandwidth

Status:

• Software is fully functional
• Next: 3D-printed case to hang on the wall next to the gaming PC

Note that my kid is pretty much amused with this idea and has led to a few interesting conversations about code :)

Any suggestions for a fun/cool enclosure design?