I’m beautiful and tough like a diamond…or beef jerky in a ball gown.

– Titus Andromedon

  • 2 posts
  • 42 comments
Joined 11 months ago
Cake day: July 15th, 2025

I came across some articles about how people are upcycling a specific cryptocurrency mining single-board computer and decided to pick one up myself and put together a rig. The board is the AMD BC-250 which is similar to the APU in the PS5.

I’ve been out of the gaming scene since the Xbox 360 and never could justify the expense of building a gaming rig, but I couldn’t pass up the opportunity to build something decent for under $200. This thing rocks and can play my entire catalog of Steam games, many of which I bought on sale and worried later about having a PC that could actually run them.

Specs

  • CPU: 6x AMD Zen 2 cores @ ~3.5GHz (actually has 8 cores/16 threads, but I haven’t yet unlocked the other 2)
  • GPU: 24 RDNA2 Compute Units with 1536 shaders. Actually has 40 compute units, and you can unlock the remaining ones pretty easily. The PS5 has, I believe, 36 CUs active.
  • Memory: 16GB GDDR6 shared memory
  • TDP: 220W (50W idle - 235W max load)
  • OS Support: Linux only (no Windows GPU drivers)

I/O

  • 2x USB 3.0 (A only)
  • 2x USB 2.0
  • 1x RJ-45 gigabit ethernet
  • 1x DisplayPort output
  • 2x buttons. One is power and the other seems to be reset

Cost and Parts

  • BC-250 APU - $125 (sadly they’ve jumped in price again and are now $165)
  • 300W 12v PSU - $35
  • 500 GB NVMe SSD - $0 since I already had a few spare ones on hand
  • 120mm Fan - $17 for a 3-pack
  • 8-pin PCIe power cable - $3 (to connect from the PSU to the APU)

Total cost: $180 though would have been closer to $250 if didn’t already have an SSD on hand. Price also doesn’t include the filament I used to print the case as I already had that as well. I didn’t check the exact usage, but expect to use the better part of a 1 kg roll on the print. It used about half a roll of red and half a roll of black in my case.

A few optional components added to the build that I already had in my parts bin:

  • Game controller (you can use a Xbox or PS4 controller if you add a USB bluetooth adapter)
  • USB Hub
  • USB Wifi adapter (it’s only got wired ethernet onboard)
  • Passive DP to HDMI cable (to connect to my HDMI-only TV)

Depending on the parts you have on hand, you could still potentially build this for $200 or less even after the price hike of the boards.

I’m running Bazzite on it and booting directly into Steam Big Picture. Works great!

Resources

View of the Guts

Note: These aren’t mine and are from the Printables model page as I neglected to take photos as I went, and it’s kind of a pain to disassemble this because of the way it goes together. I also modded the heatsink and cut off the little ridges since it was originally made for rack cooling and didn’t cool well with just a fan on top.

  • I was surprised by that, too. When I went looking for a way to decode them with RTL-SDR, I assumed it wouldn’t be parsing the audio but a narrowband data stream. TIL also.

    Edit: It does kind of make sense with it being AFSK encoded in-band, though, or maybe I’m just so used to it being that way. I always thought the screeches were there to demand attention (and also be something that headend equipment can pick up and respond to). So it’s interesting they’re doing double duty as both an unmistakable audio cue to pay attention as well as containing the actual alert data.

    Plus there are NOAA stations all over the country rather than centralized like the time signal transmitters. It was probably cheaper to do it in band at that scale.

EAS (emergency alert system) alerts are issued for various local and/or national emergencies, and are frequently issued for severe weather events. As we enter tornado season in the US, I wanted to be able to receive and relay those over Meshtastic, specifically severe weather alerts, as an extra precaution since cell service often goes out after big storms.

I first setup a prototype setup on my laptop, but am planning to move the setup to a PiZeroW2 or a Banana Pi if the Raspi isn’t up to the task. In addition to monitoring/relaying EAS alerts, I’m also going to pipe the audio to an Icecast source and then to an Icecast server so anyone on the local network can listen to it.

Got lucky in that today was the day they did the weekly EAS alert test and that I happened to have this running during the test. Everything surprisingly worked, which was nice. However, I wanted to tweak some things and needed a way to run my own tests. So I grabbed the audio sample from the Wikipedia page for SAME and piped that in which worked beautifully.

Requirements

  • A Pi or other computer than can run rtl_fm
  • A RTL-SDR dongle and antenna that can receive in the ~160-170 MHZ range (i.e. pretty much any FM radio antenna)
  • A Meshtastic node connected over USB or TCP

Sending Test Alerts

If you want to test the setup without having to wait for a weekly test, you can download a sample SAME audio clip from Wikipedia (https://en.wikipedia.org/wiki/File:Same.wav). You’ll need to convert the sample rate before you can use it, though.

$ ffmpeg -i Same.wav -ar 48000 same48.wav
$ cat same48.wav | Meshtastic-SAME-EAS-Alerter --test-channel 0
2026-04-02T15:32:31.172Z INFO  [Meshtastic_SAME_EAS_Alerter] Successfully connected to the node.
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Loaded locations CSV
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Monitoring for alerts
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Alerts will be sent to channel: 0
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Test alerts will be sent to channel: 0
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] Begin SAME voice message: MessageHeader { message: "ZCZC-EAS-RWT-012057-012081-012101-012103-012115+0030-2780415-WTSP/TV-", offset_time: 47, parity_error_count: 0, voting_byte_count: 69 }
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] No location filter applied (locations empty) or no locations in alert
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] Attempting to send message over the mesh: 📖Received Required Weekly Test from WTSP/TV, Issued By: Broadcast station or cable system, Locations: Hillsborough, Manatee, Pasco, Pinellas, Sarasota
Connected to radio
Sending text message 📖Received Required Weekly Test from WTSP/TV, Issued By: Broadcast to ^all on channelIndex:0 
Waiting for an acknowledgment from remote node (this could take a while)
Received an implicit ACK. Packet will likely arrive, but cannot be guaranteed.
Connected to radio
Sending text message  station or cable system, Locations: Hillsborough, Manatee, Pasco, to ^all on channelIndex:0 
Waiting for an acknowledgment from remote node (this could take a while)
Received an implicit ACK. Packet will likely arrive, but cannot be guaranteed.
2026-04-02T15:33:11.227Z INFO  [Meshtastic_SAME_EAS_Alerter] End SAME voice message
2026-04-02T15:33:11.251Z WARN  [Meshtastic_SAME_EAS_Alerter] Program stopped, no longer monitoring

Working Prototype

This is the bash one-liner to start rtl_fm, tune it to the local NOAA frequency, and set the rate. That gets piped to tee which does 2 things currently:

  1. The audio is piped to play so that I can listen to the broadcast on the laptop’s speakers. This will eventually be piped to an Icecast source
  2. Pipes the audio to the Meshtastic SAME EAS Alerter program (the project linked in this post) and configures its settings

When a SANE message is detected, the program decodes it and broadcasts it to the configured channel. Fun fact: the Screech. Screech. Screech you hear before a severe weather alert is actually the encoded version of the emergency alert and what this program decodes.

When I move this all to whatever flavor of Pi I end up using, that’ll be wrapped in a systemd unit file so it can run headless and unattended.

$ rtl_fm -f 162.400M -s 48000 -r 48000 | tee >(play -q -r 48000 -t raw -e s -b 16 -c 1 -V1 -v 4 - sinc 125-3.2k) >(Meshtastic-SAME-EAS-Alerter --host 192.168.1.236 --test-channel 0) > /dev/null

Found 1 device(s):
  0:  Realtek, RTL2838UHIDIR, SN: 00000001

Using device 0: Generic RTL2832U OEM
Found Rafael Micro R820T tuner
Tuner gain set to automatic.
Tuned to 162652000 Hz.
Oversampling input by: 21x.
Oversampling output by: 1x.
Buffer size: 8.13ms
Exact sample rate is: 1008000.009613 Hz
Sampling at 1008000 S/s.
Output at 48000 Hz.
2026-04-02T14:20:49.702Z INFO  [Meshtastic_SAME_EAS_Alerter] Successfully connected to the node.
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Loaded locations CSV
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Monitoring for alerts
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Alerts will be sent to channel: 0
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Test alerts will be sent to channel: 0

  • That’s what I’ve done for years. Makes managing things much easier, and I run multiple APs (all with the same SSID/PSK) and you can just roam to the best one. One upstairs, one downstairs, one in the weird dead zone in my office, and one on the back patio (it’s not hardwired and uses the mesh connection for uplink).

    These are all old Aruba APs running OpenWRT but that’s the plan for this Cudy Model. I may pick up a few more and just replace all of my trusty but very old Arubas.

  • Nedry was literally a computer scientist and systems designer / programmer from Cambridge. Arnold was a theme park engineer (designing rides and control systems; some programming involved but a whole different paradigm than developing large systems).

    Source: Have read the novel 50+ times.

  • Maybe one of those HDMI “stick” PCs you can get? There’s x86 Android builds you can run or you can do like I did with my media PCs and boot into Openbox and just launch a fullscreen browser right to Jellyfin and control it from your phone. (My main setup uses Emby but should be able to do the same with JF).

    I’ve actually got a portable Jellyfin server I take with me. Built on the OrangePi Zero 2W with a USB->NVMe acting as media storage (as well as the Jellyfin DB). It’s got several other services running as well as a second Wifi adapter so it can also act as a travel router.

    For playback, I pretty much just use my laptop or phone but have thought about adding one of the “stick” PCs as a client for it.

  • The only reason I gave up on Docker Swarm was that it seemed pretty dead-end as far as being useful outside the homelab. At the time, it was still competing with Kubernetes, but Kube seems to have won out. I’m not even sure Docker CE even still has Swarm. It’s been a good while since I messed with it. It might be a “pro” feature nowadays.

    Edit: Docker 28.5.2 still has Swarm.

    Still, it was nice and a lot easier to use than Kubernetes once you wrapped your head around swarm networking.

  • I had 15 of the 2013-era 5010 thin clients. Most of them have had their SSDs and RAM upgraded.

    They’ve worn many hats since I’ve had them, but some of their uses and proposed uses were:

    1. I did a 15 node Docker Swarm setup and used that to both run some of my applications as well as learn how to do horizontal scaling.
    2. After I tore down the Docker Swarm cluster, I set them up as diskless workstations to both learn how to do that and used them at a local event as web kiosks (basically just to have a bunch of stations people could use to fill out web based forms).
    3. One of them was my router for a good while. Only replaced it in that role when I got symmetric gigabit fiber. Before that, I used VLANs to to run LAN and WAN over its single ethernet port since I had asymmetric 500 Mbps and never saturated the port.
    4. Run small/lightweight applications in highly-available pairs/clusters
    5. Use them to practice clustered services (Multi-master Galera/MariaDB, multi-master LDAP, CouchDB, etc)
    6. Use them as Snapcast clients in each room
    7. Add wireless cards, install OpenWRT, and make powerful access points for each room (can combine with the above and also be a Snapcast client)
    8. Set them up as VPN tunnel endpoints, give them out to friends, and have a private network

    Of the 15, I think I’m only actively using 4 nowadays. One is my MPD+Snapcast server, one is running HomeAssistant, ,the third is my backup LDAP server, and one runs my email server (really). The rest I just spin up as needed for various projects; I downsized my homelab and don’t have a lot of spare capacity for dev/test VMs these days, so these work great in place of that.

  • A database can be used to plug into any number of applications that run on top of it as well as be easily shared by multiple people and centrally backed up. Auditing, logging, and row and table level access controls, and other measures can be easily added.

    Excel files (or even MS Access files) as “databases” are often just people emailing around a file or accessing it from a shared drive. You end up with a split-brain situation at best and at worst you’re dealing with constant file corruption from multiple people thinking they can access it from a shared drive at the same time.

    Then you get vendor lock in and are forced to keep MS Office professional licenses because Shawn created some stupid Access “app” 10 years ago which is “THE DATABASE” and no one understands how it works.