The TV is a Magnavox portable from Facebook Marketplace, a Perfect View from August 1987, the kind with a handle on top, a rod antenna, and a 12V jack so you could watch it in the car.

The Pi is a 3 Model B+, the same board the reader had.

The false start: the original 2012 Pi

My first instinct was to do this on the least capable Pi in the house: the original Model B, board marked “(c)2011.12”, with the 4GB “Debian 6 for Linux” card it came with. Raspberry Pi OS still supports it, which is remarkable for a 2012 computer, and Node.js 20 installs from apt. The server half of CABLE 82 would run fine.

The TV half would not. The original Pi’s chip is ARMv6, and no current browser runs on it. Raspberry Pi dropped Chromium for ARMv6 in 2023; on the current OS it prints “This hardware doesn’t support NEON SIMD extensions” and quits. Firefox is built for ARMv7 and dies the same way. The one engine left is WebKit, with no JavaScript JIT, on a 700MHz core. I looked at that path for a while… and decided the tutorial should be about the channel, not about heroics.

What you need

• Raspberry Pi 3 Model B+ (or any Pi 2 or newer; a Pi 4 is a fine choice too).
• 16GB or larger microSD card. Mine is a SanDisk Ultra PLUS 16GB.
• Micro-USB power supply, 5V at 2.5A. The 3 B+ is the last micro-USB Pi.
• A network connection. Ethernet is simplest for the first boot; the 3 B+ also has Wi-Fi.
• 4:3 CRT with a coax antenna input. Almost every tube TV has one, which is why this is the path that works for everybody. Mine has nothing else: one F connector marked EXT ANT and a switch to pick it over the built-in rod antenna.
• HDMI-to-RF modulator, the little box that turns HDMI into channel 3 or 4 on the antenna input, plus a short coax cable. Mine is an “HDM61” unit; the same design is sold under a dozen brand names.
• Another computer to flash the card and to SSH into the Pi (needs to be on the same network as the Raspberry Pi).

Step 1: Put the OS on the card

Which image, and why

Raspberry Pi OS (64-bit), the desktop edition. It is the image Raspberry Pi’s own kiosk tutorial tells you to use, and there are two practical reasons to follow that advice on a 3 B+:

1. Chromium is the browser that will show the channel, and the 64-bit build is the one that has been solid on Pi 3 boards (the 32-bit build had a will-not-start bug on the Pi 3 as recently as this summer).
2. Node.js 22 from NodeSource is 64-bit only now; their installer refuses 32-bit outright.

The image is a 1.3GB download and takes about 6GB on the card, so 16GB leaves plenty of room.

Flash it with Raspberry Pi Imager

Raspberry Pi Imager is the right tool here, and not balenaEtcher or dd, because it can bake the hostname, your user, and SSH into the card before the Pi ever boots. That is what makes the headless setup work. Install it from raspberrypi.com/software, put the card in your computer, and walk the steps down the left side.

Device: Raspberry Pi 3. This filters the OS list to images that run on the 3 family (A+, B, B+, and Compute Module 3).

OS: Raspberry Pi OS (64-bit). The top entry, marked Recommended. Not the 32-bit one and not the “Legacy” one; Legacy is the older Bookworm release.

Storage: the SD card. Imager hides your system drives by default, so the only thing in the list should be the card. Mine shows up as a 14.8GB “Generic MassStorageClass USB Device” because it is in a USB reader; a 16GB card really is about 14.8GB once you count the way computers count.

Customisation. This is the part Etcher cannot do, and the reason the Pi will come up on the network with no screen attached.

• Hostname: cable82. That gives you cable82.local later, so you never have to go looking for an IP address.
• Localisation: your time zone and keyboard layout. The clock on the channel runs off the Pi’s time zone, so get this right.
• User: a username and password you will remember. You will type them into SSH in a few minutes.
• Wi-Fi: your network name and password. I set it even though the Pi would be on Ethernet for the build; it means the finished TV can live anywhere in the house.
• Remote access: enable SSH, password authentication. I also left Raspberry Pi Connect on, which gives you a browser-based remote shell to the Pi from anywhere, handy for a TV that lives in a corner.

Then Write. Imager asks once more whether it can erase the card, downloads the image, writes it, and verifies it. The write was the slow part: this card takes data at about 10MB/s, so the 6GB image plus verification took about fifteen minutes.

First boot

Imager ejects the card when it is done. Card into the Pi, Ethernet in, power in. The green light flickers for a while: the first boot resizes the filesystem to fill the card, generates SSH keys, and runs a one-time setup pass. Mine answered on the network in well under two minutes. Then from your computer:

ssh yourname@cable82.local

(If .local does not resolve on your machine, your router’s device list will show a cable82 with an IP address; SSH to that instead.)

Three things to check while you are in:

head -2 /etc/os-release
free -m
df -h /

Mine came back Debian 13 (trixie), 905MB of memory with about 570MB available, and a 15GB root partition with 8.4GB free after the 6GB image. The Pi had been up eight minutes by the time I got around to asking. Then bring the image current:

sudo apt update && sudo apt full-upgrade -y

(sudo asks for your password; recent Raspberry Pi OS releases turned off passwordless sudo by default.)

The Pi is on the network, current, and answering SSH.

Step 2: Node.js

CABLE 82 is a Node.js app with no dependencies, so Node is the only thing to install. It needs Node 18 or newer, and a fresh Raspberry Pi OS has none at all:

$ node -v
bash: node: command not found

That line, by the way, is almost certainly what was behind the reader’s “localhost refused to connect.” No Node, no server, nothing listening, and the browser reports it as a refused connection.

Two ways to get Node on a 64-bit Pi. The quick one is the distro’s own package, sudo apt install nodejs, which gives you Node 20. I went with NodeSource for Node 22, the current long-term-support line, and it is two commands:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
node -v

Mine printed v22.23.2. (NodeSource only builds for 64-bit now; if you flashed the 32-bit image, use the apt route.)

Step 3: CABLE 82 on the air

With Node in place, the channel itself is next. Clone it and start it:

cd ~
git clone https://github.com/nothans/cable-82
cd cable-82
node server.js

It prints every address it answers on:

CABLE 82 broadcasting
  http://localhost:1982   (a browser on this machine)
  http://192.168.68.93:1982   (a browser on another device on your network)
Control room: http://localhost:1982/config

Read that second line carefully, because it is the other half of the reader’s problem. localhost means “this machine.” Typed into a browser on your laptop, it asks the laptop for a channel it does not have. The 192.168.x.x address is the Pi as seen from everywhere else on your network, and that is the one to open from the laptop. I did, and the channel was there: blue screen, the clock, the crawl.

The first run also writes a config.json next to the server, which is where everything you change in the control room ends up. Open http://192.168.68.93:1982/config from the laptop and make it yours: channel name, your messages, your feeds, your town for the weather. Save, and the channel picks it up within about twenty seconds.

Make it a service

Ctrl-C the server and hand it to systemd so it runs at boot and restarts if it ever dies. Create /etc/systemd/system/cable82.service:

[Unit]
Description=CABLE 82
After=network-online.target

[Service]
ExecStart=/usr/bin/node /home/cable82/cable-82/server.js
Restart=always
User=cable82

[Install]
WantedBy=multi-user.target

Both cable82s are my username; use yours (whoami tells you, and which node confirms the path on the ExecStart line). Then:

sudo systemctl enable --now cable82
systemctl status cable82

active (running) with the broadcasting lines in its log, and sudo journalctl -u cable82 -f is where to look if anything is ever wrong. The server sits at about 46MB of memory.

Step 4: Chromium in kiosk mode

The desktop image already logs in automatically and starts a Wayland session (the compositor is called labwc; the old LXDE desktop from earlier Pi OS releases is gone). Chromium 151 is preinstalled. All we have to do is tell the session to open Chromium full screen on the channel at login.

The file for that is ~/.config/labwc/autostart. Create it with these lines:

# CABLE 82 kiosk: wait for the channel server, then put Chromium on it full screen.
until curl -s -o /dev/null http://localhost:1982; do sleep 1; done
/usr/bin/lwrespawn /usr/bin/chromium http://localhost:1982   --kiosk --noerrdialogs --disable-infobars --no-first-run --no-memcheck   --disable-lcd-text --autoplay-policy=no-user-gesture-required   --enable-features=OverlayScrollbar --password-store=basic --start-maximized &

A few of those deserve a word:

• The until curl loop waits for the server to answer before launching the browser. Without it, Chromium can win the race at boot and show “localhost refused to connect” on the TV, and nothing ever tells it to try again.
• lwrespawn is a Raspberry Pi helper that restarts a program if it dies, so a crash brings the channel back instead of leaving a blank desktop.
• --no-memcheck stops Chromium from popping a low-memory warning over the channel on a 1GB board.
• --autoplay-policy=no-user-gesture-required lets the background music start without anyone clicking.
• --disable-lcd-text turns off subpixel font smoothing so the chunky text stays crisp white instead of going pink at the edges.
• --password-store=basic keeps the desktop keyring from asking for a password at login.

Then turn off screen blanking, or the TV goes dark after ten minutes:

sudo raspi-config nonint do_blanking 1

(Or interactively: sudo raspi-config > Display Options > Screen Blanking > No.)

If you are here from the original post: the chromium-browser --kiosk line and the /etc/xdg/lxsession/LXDE-pi/autostart file in that post were for the previous Pi OS release. On Trixie the binary is chromium and the file is the labwc one above.

Reboot. About a minute later Chromium was running full screen on the channel. I could tell from the laptop before the TV was even connected:

$ pgrep -a chromium | head -1
1407 /usr/lib/chromium/chromium ... --kiosk ... http://localhost:1982

Check the power supply while you are here

This section wasn’t what I expected. My first run was off a phone charger…

$ vcgencmd get_throttled
throttled=0xd0005
$ vcgencmd measure_clock arm
frequency(48)=600064000

Any bit set in get_throttled is a complaint; 0x5 means under-voltage and throttling right now, and the clock line shows a 1.4GHz Pi running at 600MHz. It worked, in the sense that the channel was on, but at less than half speed. With a proper 5V 2.5A supply the under-voltage bits cleared and the clock came back up. If you only run one check from this whole post on an existing Pi, run that one.

(On a 3 B+ you may still see 0x80008 with a 1.2GHz clock: that is the board’s own soft temperature limit at 60C, normal with Chromium running, and nothing to do with power.)

Step 5: The CRT

Note on photos of the TV… it turns out to be surprisingly hard to get a good photo of the screen. My phone didn’t capture it well. Also, the screen had a giant smudge backed into the acrylic covering the TV. I had to use Novus 2 polish to clean up the smudge and scratches. I assure you that it looks better in person…

The Magnavox has exactly one way in: an F connector marked EXT ANT.

So the path is HDMI out of the Pi into a small HDMI-to-RF modulator, coax from the modulator into the TV, and the TV tuned to channel 3. The box is the size of a cassette tape, takes USB power, has a CH3/CH4 switch, and its spec sheet says everything you need to know: NTSC out, 480p to 1080p in, sound on the 4.5MHz carrier (that means mono, the way 1982 did it).

Plug it all in and the channel was on the tube.

Send it a 4:3 picture

The box scales whatever it gets to fill the 4:3 tube. CABLE 82 draws a 4:3 stage, so if the Pi sends a widescreen mode, the stage gets squashed. The Pi has to output 640×480. On current Raspberry Pi OS the old hdmi_group and hdmi_mode lines in config.txt are dead; the kernel takes its orders from cmdline.txt, and the desktop then picks its own mode on top of that. So it takes two small files.

Append to the end of the single long line in /boot/firmware/cmdline.txt:

video=HDMI-A-1:640x480@60D vc4.force_hotplug=1

The D forces the output on even when nothing answers, and force_hotplug keeps it on if the modulator never raises the hotplug pin (mine does not). Then pin the desktop to the same mode in ~/.config/kanshi/config:

profile crt {
  output HDMI-A-1 mode 640x480 position 0,0
}

Without that second file, the desktop on my Pi happily chose 1024×768 on top of the kernel’s 640×480.

Give it an EDID, so there is sound

The first picture had no audio, and the reason is a good one: cheap modulators send no EDID, the little data block a screen uses to introduce itself. No EDID means the Pi does not know the “screen” can hear, and it refuses to send HDMI audio at all. So I made it one. The CABLE 82 repo now ships a 256-byte EDID that describes a 640×480 4:3 screen with stereo audio (edid/cable82-640x480-audio.bin, with the script that generates it). Hand it to the kernel:

sudo mkdir -p /lib/firmware/edid
sudo cp ~/cable-82/edid/cable82-640x480-audio.bin /lib/firmware/edid/cable82.bin

and add one more parameter to that same cmdline.txt line:

drm.edid_firmware=HDMI-A-1:edid/cable82.bin

Reboot. wpctl status now lists an HDMI sink next to the headphone jack; make it the default and give it some level (WirePlumber remembers):

wpctl status                       # find the "(HDMI)" sink's number
wpctl set-default <number>
wpctl set-volume <number> 0.8

The channel’s music came out of the Magnavox’s speaker on the next page turn.

Hide the cursor

A mouse pointer sat in the middle of the picture with no mouse attached. The HDMI CEC input counts as a pointer device, so the desktop draws one. The fix is a labwc keybinding that hides it, pressed automatically after boot. Copy /etc/xdg/labwc/rc.xml to ~/.config/labwc/rc.xml, add inside <keyboard>:

<keybind key="A-W-h"><action name="HideCursor"/></keybind>

then sudo apt install wtype and add to the end of ~/.config/labwc/autostart:

(sleep 10; wtype -M alt -M logo -P h -p h -m logo -m alt) &

The detour: composite

Before the HDMI modulator arrived I tried the other way in: the Pi’s 3.5mm AV jack, a 4-pole cable to yellow/red/white, and an old composite-to-RF adapter. On a Pi 3 that means sudo raspi-config nonint do_composite 0, which turns HDMI off; on every Pi before the 5 it is one or the other. The Wayland desktop also does not trust the composite connector until it is told the mode, so video=Composite-1:720x480@60ie,tv_mode=NTSC goes on the cmdline.txt line too.

Step 6: Make it readable

With everything working, the verdict on a 9-inch 1987 tube over RF: the big clock and the crawl read fine, the small text was marginal, and the red and blue pages were worse than the cyan one. That is NTSC. It smears saturated color, it clips pure white (broadcast engineers kept white at 90% for a reason), and the hard drop shadow under every character turned into ringing.

So I added a CRT set of settings in the control room for much older TVs…

• CRT mode swaps in a softer palette (less saturated backgrounds, 90% white) and drops the drop shadow.
• Text size enlarges the body text, kicker, crawl, and the small header lines, from 1 to 1.5x. I run 1.25 on this set; the big clock stays as it is.
• Overscan safe margin was already there; raise it if the TV crops the edges.

Turning text size up found one more thing: at 640×480 the weather card no longer fit and its HI/LO line slid under the crawl.

So pages now fit themselves: if the content would overflow, the weather card gives up its sunrise/sunset line first, then shrinks just enough, and a long fact does the same.

All of that is in the repo as of this post.

What changed because of this build

Three things fed straight back into the project:

• The original post now carries a dated update: the kiosk command is chromium in ~/.config/labwc/autostart on current Raspberry Pi OS, and the power supply got the mention it earned.
• The repo README was rewritten from this build, step by step as tested, with a Troubleshooting section keyed to the exact errors from the comment thread.
• CABLE 82 itself gained CRT mode, the text size setting, the fit-to-page behavior, and the shipped EDID, because a real 1987 tube demanded all four.

That is the part I did not expect when a reader said “localhost refused to connect”: the failure report turned into the best test pass the project ever had!

A channel of your own

The Magnavox sits there now, tuned to channel 3, being a channel. The clock, the bake-sale energy, the crawl, the beautiful-music bed coming out of a mono speaker that was built when the music was new. It is a thirty-nine-year-old TV showing a channel that stopped existing before the TV was built, fed by a computer the size of a deck of cards, and the whole thing works because somebody left a comment saying it did not.

So: if you build one and it refuses to connect, say so. That is how this channel gets better, and it is very 1982 of you. Thanks.

You might know the one if you watched MTV when it first came on cable. A flat blue screen, chunky white text, the time and the temperature in the corner. The Lions Club pancake breakfast. A birthday wish for someone named STEVE. Little League signups at the rec center. Headlines crawling along the bottom while a Muzak version of a song you almost recognized played underneath. I remember watching it for long stretches, waiting for the flea market notice to come back around. Our Sears CRT had the blue bars burnt in.

At some point, the Cable Bulletin Board Channel disappeared from all of our lives. NOBODY IS TALKING ABOUT IT.

Recently, I have been spending evenings learning about retro gaming and reading posts on Reddit saying that you have to game on a CRT for the proper gaming experience. This led me to Facebook Marketplace. After a few weeks of looking at photos of TVs this got me remembering the big honker in our living room… then, I uncovered a repressed memory. I had to have it back in my life.

Meet CABLE 82

CABLE 82 is a tiny web app that turns any screen into your own 1982 community bulletin board channel. Ideally that screen is an old 4:3 CRT fed by a Raspberry Pi, sitting in the corner of a room, being ambient.

It scrolls the date and time, your community messages, fun facts, dad jokes, live weather, and headlines from whatever RSS feeds you point it at. There is a crawl along the bottom, a red LATEST flag, and a little station bug in the corner, because of course there is.

You make it yours in a control room in the browser, or by editing one plain config file. It is free and open source and it runs on a Raspberry Pi.

The rest of this post is how to get it going on a Raspberry Pi and a CRT.

Step 1: Get it on the air

SSH into the Pi, or just open a terminal on it, and run:

git clone https://github.com/nothans/cable-82
cd cable-82
node server.js

Open http://localhost:1982 in a browser on the Pi. You’re on the air.

Out of the box it already looks right: the blue screens, the clock, a couple of example bake-sale messages, and real headlines pulled from a few default feeds.

Step 2: Make it your channel

Everything about the channel lives in one place. Open the control room at http://localhost:1982/config and you get the whole thing on one screen: the name, your community messages, which RSS feeds to pull, your town’s weather, the colors, the page lineup. Change something, hit Save, and the channel updates itself within about twenty seconds. Nobody has to touch the TV.

If you would rather edit a file, it all lives in config.json, and you can hand-edit that just as happily. Put your own town in the weather. Drop in the feeds you actually read. Write the messages your household needs to see, which in my house is mostly reminders that trash day is tomorrow.

Step 3: Run it on boot

You do not want to SSH in and start a server every time the power blips. Make it a service so the Pi just comes up broadcasting.

Create /etc/systemd/system/cable82.service:

[Unit]
Description=CABLE 82
After=network-online.target

[Service]
ExecStart=/usr/bin/node /home/pi/cable-82/server.js
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

Then turn it on:

sudo systemctl enable --now cable82

Now the channel is always running in the background, whether anything is looking at it or not.

Step 4: Point a browser at it, full screen

Have the Pi launch Chromium in kiosk mode, pointed at the channel:

chromium-browser --kiosk --noerrdialogs --disable-infobars \
  --disable-lcd-text \
  --autoplay-policy=no-user-gesture-required \
  http://localhost:1982

Two of those flags earn their keep. --disable-lcd-text turns off subpixel font smoothing, which otherwise tints the chunky white text a faint pink on some screens. --autoplay-policy=no-user-gesture-required lets the background music start on its own at boot, so nobody has to click anything to get the beautiful-music bed going.

While you are in there, turn off screen blanking so the picture never sleeps: sudo raspi-config > Display Options > Screen Blanking > No.

Step 5: Get it onto a real CRT

The easiest and most reliable hookup works on any Pi and any TV with a coax (antenna) input. Run HDMI from the Pi into an HDMI-to-coax RF modulator, then run coax from the modulator into the TV, and tune the TV to channel 3 or 4. Your Pi is now a broadcast channel and the TV is receiving it over the air the way God and 1982 intended.

If the TV crops the edges of the picture, bump up the overscan margin in the control room until nothing important gets cut off. There are no fake scanline filters in CABLE 82, on purpose. The CRT is the filter.

Step 6: Give it a soundtrack

Drop a few audio files into the music/ folder and CABLE 82 plays them as a continuous background bed behind the pages, looping the set, shuffling if you like. Two tracks ship with it to get you started. Aim for the sound the old channels actually used: beautiful music, easy listening, and eventually the famous smooth jazz.

A channel of your own

A Pi, an old TV, a coax cable, and a folder of files, and now there is a corner of your house that runs its own quiet little channel: your messages, your weather, your headlines, your dad jokes, scrolling by all day.

It’s not useful, exactly. It’s better than useful.

CABLE 82 is open source and lives at github.com/nothans/cable-82.

Project Demo Video

Watch 6 minutes of glorious community news like it is 1982. Enjoy.

Update July 27, 2026: CheerLights Support

I can’t believe that it took me a few days to do this… CheerLights. A perfect feed (for me) is to see the latest CheerLights color scroll by every once in a while. Okay, so now you can add CheerLights feed support with a custom message if needed.

Update August 22, 2026: Updated GitHub README and better CRT support

Based on some user feedback, I built a version of the project on an older Raspberry Pi and used a much older CRT TV. This helped me find some areas for improvement.

I updated the kiosk command to use chromium (not chromium-browser), and it goes in ~/.config/labwc/autostart.

Old TVs do not have as much contrast as newer ones, so I added a CRT mode to help. This is in the “control room” or in the config.

And, a user reported “throttling” of the CPU. This happens when the Raspberry Pi is underpowered. This usually happens when you use a phone USB charger instead of a Raspberry Pi power supply.

From what I learned during the first month of the project, I added a troubleshooting section to the GitHub README for the CABLE 82 project.

I will publish an end-to-end tutorial for a Raspberry Pi 3 B+ soon to help smooth out the installation steps.

Thanks for sharing your feedback and trying the project. It helps all of us.

Fine for a side-project web app. Does not work for an inverted pendulum spinning on your desk.

The Pit and the Pendulum

MathWorks just published a Tech Talk by Brian Douglas. It is worth watching if you build hardware.

The setup is a Quanser cube servo with an inverted pendulum, a Raspberry Pi running the controller, and a coding agent wired into Simulink through the Simulink Agentic Toolkit. The agent’s job is to swing the pendulum up and balance it.

Balancing an inverted pendulum is a classic control problem because it’s unstable by nature. Get the math wrong and the pendulum falls. Get the code wrong and a 12V motor jerks the cube into something it shouldn’t.

What Happens If You Just Prompt It

The tempting move is the one most of us have done with web apps. Open a chat, describe the system, ask for the code. One prompt, big blob, ship it.

The MathWorks engineers walk through why that falls apart for hardware:

“If you rely on AI to generate code directly, that process is much less structured… it’s often unclear exactly how or why a particular implementation was created, making it harder to trust and verify.”

Brian Douglas

Hardware is unforgiving. You can’t roll back a destroyed motor with a git revert. When a physical system fails, you need to know which assumption broke, which equation got the wrong constant, which sample rate the controller is actually running at. A black box of generated C code doesn’t tell you any of that.

“You don’t want to let your AI agent skip parts of your engineering workflow. That’s how you can get yourself into trouble with a final product that doesn’t meet your objective or worse, is just purely unsafe.”

Brian Douglas

The Workflow Is the Script

The answer is to keep the AI inside the workflow engineers already trust: Model-Based Design. The agent doesn’t replace the workflow. It runs each step inside it, faster.

Define quantifiable requirements. Before any code, the human and the AI agree on what success looks like. Spin-up speed. Wobble limits. The 12V motor constraint. These targets become the benchmarks for verification later.

Use a trusted model. Instead of letting the AI invent a custom physics engine, the workflow points it at an existing Simulink model. The agent runs linearization through the Simulink Agentic Toolkit and reports the system’s poles back to the human. The math comes from validated tools, not from a language model freestyling differential equations.

Use a trusted controller. Same logic. The agent is told to use the MPC Toolbox. Model Predictive Control has decades of theory behind it and a deterministic implementation. If something looks wrong, you can tune it manually. You’re not debugging an optimizer the AI invented on the fly.

Verify in layers. Three stages before the code touches hardware:

• MIL (Model-in-the-Loop): the controller runs against the theoretical model
• SIL (Software-in-the-Loop): the generated embedded C code runs on a computer, behaving exactly like the simulation
• PIL (Processor-in-the-Loop): the C code runs on the actual target Raspberry Pi

Each layer catches different bugs. Skip one and you’ll catch that bug on hardware instead.

Deploy and iterate. Only after layered verification does the code go on the real pendulum.

“Instead of asking an agent to solve your problem however it wants, you tell it to follow an engineering workflow that you understand.”

Brian Douglas

The AI executes. The human directs.

The Hardware Truth

Here’s the part of the video I liked best. They ran the verified controller on the real pendulum and it didn’t quite work. The physical hardware behaved differently from the model.

This is what the vibe-coding fantasy ignores. Reality disagrees with simulation, especially the first time. You will need to iterate. The thing that matters is whether you can.

Because the team followed the workflow, they could. The model was traceable. The requirements were quantifiable. The controller was inspectable. They used the AI to update the physics model, ran it back through MIL, SIL, and PIL, and tried again. No starting over.

The workflow doesn’t promise perfect code on the first pass. It promises code you can fix.

The Director Pattern

A few months ago, I wrote about Seth DeLand’s framing of agentic AI for engineers. The headline idea: you’re not being replaced, you’re being promoted. The engineer becomes the one who defines the problem, sets the constraints, and shapes the space where the AI works.

The MathWorks Tech Talk is what that looks like in hardware. The AI isn’t the engineer. It’s the agent. You’re the director.

“Agentic AI is powerful, but for engineering, the value comes from how you use it. You get the speed and productivity benefits of AI without sacrificing trust, safety, or understanding.”

Brian Douglas

You don’t get speed and safety together by handing the AI a prompt and crossing your fingers. You get there by keeping the workflow you trust and letting the agent move faster inside it.

Speed without losing safety. Productivity without losing traceability.

For software, vibe coding is mostly fine. The blast radius is a wasted afternoon.

For hardware, the blast radius is a sparking motor and a pendulum on the floor.

Borrowing ideas from my Lofi Girl CheerLights Shadowbox project, George and I made a CheerLights Gift for under our Christmas tree. This gift changes color based on the latest CheerLights color and anyone on Twitter or Discord can change its color and the color of all of the other CheerLights projects.

The CheerLights Gift project is based on the Pimoroni Plasma Stick 2040 W and NeoPixel string lights for illumination. The Plasma Stick ships with CheerLights code main MicroPython file, so all you have to do is change the Wi-Fi network name and password. The microcontroller makes a request to the ThingSpeak API to get the latest CheerLights color, sets the color of the NeoPixel LED lights, waits 10 seconds, and repeats. This is about the fastest way to build your own CheerLights display.

I used a metal gift box that I found in a craft store to house the lights and controller. All we needed to do was stuff the LEDs inside and glue them in place. I only burned my fingers twice.

The project turned out well and kept my five-year-old’s interest for the duration of the build. I was happy that the Plasma Stick 2040 W made it really easy to get the project going.

Join the CheerLights IoT community at CheerLights.com.

The Lofi Girl Shadowbox is backlit with the latest color of CheerLights. It’s always changing based on what people set the color to on Twitter and Discord.

Parts

• Lofi Girl poster – I am a 1 A.M person
• Shadowbox
• Black foam board
• Foam block
• Pimoroni Plasma Stick 2040 W (based on the Raspberry Pi Pico W)
• LED string lights
• Micro USB cord and power supply
• Other things: utility knife, straightedge, hot glue gun, and repositionable glue squares

Assembly

The poster that I got from the Lofi Girl shop was 30cm x 45cm and on really thin paper. I used the repositionable glue squares to stick the poster on the black foam board. This gives the poster some structure. I cut a hole in the back of the shadowbox and feed the USB cable through. I cut out a rough shape of the Pimoroni Plasma Stick 2040 W and wrapped the string lights around the foam block.

Programming

The best part of the whole project is that CheerLights is baked into the Pimoroni Plasma Stick 2040 W. All you need to do is program the device with your Wi-Fi settings. Open Thonny and open the WIFI_CONFIG.py file. Change SSID to your wireless network name, PSK to your password, and COUNTRY to your country code like US or GB. Click Save.

Pimoroni has an excellent tutorial on getting Thonny installed and an explanation of the Pimoroni Plasma Stick 2040 W kit. I have also written a tutorial on the CheerLights blog.

Chill

Now that you’ve done all of the hard work, it’s time to chill and enjoy the Lo-Fi vibes tuned to CheerLights. While I was making this project today, I had Lofi Girl on YouTube, and the lights were just bright enough to see what I was doing without cutting myself. I am looking for a wall to permanently install my Lofi Girl Shadowbox. I am seriously thinking of drilling a hole in the wall to hide the USB power adapter.

I have been exploring MicroPython ever since I got a Raspberry Pi Pico W. The community is moving fast and making more and more examples and libraries for MicroPython. Having the Arduino team lean into making the Arduino Lab IDE for MicroPython is a good indicator where things are headed. I was able to build an awesome CheerLights display using MicroPython running on a Raspberry Pi Pico W connected to a Pimoroni Galactic Unicorn PED panel.

Consider Arduino Labs for MicroPython as pre-release, experimental software. Things are moving fast and the project will stabilize. Follow the project on GitHub and file any problems that you come across on GitHub Issues.

Recently, my college at MathWorks, Christopher Stapels, introduced me to the Raspberry Shake. The”shake” is a personal seismograph that laterally allows you to watch the Earth move and the things that cause the earth to move.

Christopher went on to collaborate with Alan Kafka at Weston Observatory, Boston College, and Jay Pulli at Raytheon to explore traffic data analysis using seismic data collected by the Raspberry Shake and sent to ThingSpeak.

The team explored the data using MATLAB and tried to establish some correlation between vibration and traffic density. Check out the project on the MathWorks IoT Blog. Whole Lotta Shakin’ Goin’ On.

For this season, I wanted to try out the Blinkt! kit from Pimoroni. I really what I am seeing from Pimoroni. Their starter kits and accessories for the Raspberry Pi are really well designed, colorful, and useful. If you are in the US, some of the Pimoroni kits are on Amazon.

I do recommend the Pimoroni Raspberry Pi Zero W Starter Kit if you are using the Raspberry Pi Zero W for the first time. The main reason for using a starter kit is that the ports on the Raspberry Pi Zero W need some adapters. You need to get a mini to full-size HDMI adaptor and a Micro-USB adapter to be able to connect a monitor, keyboard, and mouse to the Raspberry Pi Zero W. The kit also includes a 16GB micro-SD card with an operating system pre-loaded.

Connect a monitor, keyboard, and mouse to the Raspberry Pi Zero W and connect the USB cable to a reliable 5V USB power supply and you are ready to start programming.

I followed Pimoroni’s getting started tutorial to install the Blinkt! python library. The Blinkt! board is a strip of LEDs that sit on top of the Raspberry Pi’s GPIO pins. Blinkt! is a cool way to get started with controlling things with the Raspberry Pi. Consider turning on the LEDs for the first time using code as your “Hello World” program for physical computing.

After connecting your Raspberry Pi Zero W to your Wi-Fi network, open a terminal window and enter the following comment to install the Blinkt!~ libraries (type ‘y’ or ‘n’ when prompted).

curl https://get.pimoroni.com/blinkt | bash

Create a new file in your home directory called “cheerlights.py”. This file will contain the code that gets the latest CheerLights color on ThingSpeak and sets the color of the Blinkt! LEDs. Copy this code into the “cheerlights.py” file and save it.

python cheerlights.py

After a few seconds, you should see the latest CheerLights color on the Blinkt!

To keep the “cheerlights.py” running all of the time, you need to add the script to crontab. This will make the script stays running in case of an error or reboot of the device.

sudo crontab -e

Then, add this line to the end of the crontab file and save the file.

@reboot sleep 60 && sudo python /home/pi/cheerlights.py

A couple of years ago, I noticed that a maker space along with Qwirkshop created a desktop light kit for the Raspberry Pi Zero W and Blinkt! board. The kit was sold for a brief time on Etsy and I picked up a few kits. Well, I just found them in my storage closet! The kit is a bunch of laser cut pieces that you assemble together. It is an ingenious kit in that it was designed in layers and holds together with no glue. The results were beautiful.

Let me know if you build something to display the latest CheerLights color. I am always looking for new ideas for the CheerLights blog.

Let’s stay connected!

I recently was looking around my game room for some inspiration for a quick project. I have a custom arcade cabinet based on RetroPie running on a Raspberry Pi attached to a smart TV. It has been a lot of fun playing my video games from 30+ years ago. My project this time was to add a custom acrylic sign with an RGB backlight. I wanted the cabinet to look more like an actual arcade cabinet.

My go-to site for graphic printing is Signs.com. I have used it many times for upgrading Arkham Horror: The Card Game and for other projects around the house. I designed a sign using Adobe Illustrator and got it made out of acrylic. I cobbled together vector logos of many of my favorite systems plus the RetroPie logo and named the arcade cabinet, “The Scharcade”. See what I did there? Do you see it?

I used an RGB Led Strip with IR Remote Control as a backlight for the sign and to edge light the TV screen. The IR remote is handy to change the color of the lights. Just make sure that you expose the IR receiver on the power supply so you can change the color from the front of the cabinet.

My upgrade to the upgrade was to frost the arcade cabinet sign to make it look better. The original sign was completely transparent and you could see the lights shining through from each one of the LEDs. LEDs love diffusers. To fix this issue, I used Rust-Oleum Frosted Glass Spray Paint on the backside of the sign. I tested out the spray paint on a scrap piece of acrylic. I was really worried about ruining the custom sign. Once I was confident with the results, I went ahead and sprayed one even coat of the paint on the backside of the sign. It takes about 20-30 minutes in order for the paint to activate. I wanted in anticipation for 20 minutes and I gradually saw the clear acrylic turn frosted. I was really happy with the results. The 20 minutes felt light an eternity.

MQTT operates under a publish/subscribe model in which clients connect to the MQTT broker and either publish data or subscribe to topics to receive data from other clients.  MQTT messages can be sent using unsecured TCP, which is the easiest and has the lower RAM, CPU, and bandwidth requirements.  MQTT messages can also be sent using WebSockets.  This may be needed for situations when the standard port for MQTT, 1883, is blocked on the network.  When using MQTT over WebSockets, it is possible to encrypt the communication with SSL.  If your hardware is capable of using SSL over a WebSocket, that is the recommended method.

On the Raspberry Pi, an MQTT client library is required to send data to ThingSpeak.  Paho is an open-source MQTT client library that will be used for this example.  It has been adapted to many languages, including Python.

This example will demonstrate how to publish data to a ThingSpeak channel using the Paho library.  The CPU and RAM usage of the Raspberry Pi will be measured and published to ThingSpeak every 20 seconds.

Setup

1) Create a new channel as shown in Collect Data in a New Channel with two fields named “CPU (%)” and “RAM (%)”.

2) Create an MQTT device by clicking Devices > MQTT at the top of the ThingSpeak page, then Add Device. When setting up the device and adding the new channel to its authorized list, click Download Credentials > Plain Text. For details, see Create a ThingSpeak MQTT Device. Use the saved credentials in the Code section below.

3) Download the Paho MQTT client library for Python. You can use the command line to install the libraries. If you are using Python 2, use this code:

sudo pip install paho-mqtt
sudo pip install psutil

If you use Python 3, use this code:

sudo pip3 install paho-mqtt
sudo pip3 install psutil

Publishing to ThingSpeak Example

This example shows how simple it can be to send data to ThingSpeak using MQTT.

Three MQTT connection methods are demonstrated in this example: TCP, WebSockets, and SSL. To use a conventional TCP socket on port 1883, set useUnsecuredTCP=True.  This connection method is the simplest and requires the least system resources.  To use WebSockets on port 80, set useUnsecuredWebsockets=True.  Websockets are helpful when the default MQTT port is blocked on the local network.  Finally, if encryption is required, set useSSLWebsockets=True.   Be sure only to set one of the connection method variables to True and leave the other two False.

Also, be sure to change the channel ID and API key to your channel’s settings.

# Publich to a ThingSpeak Channel Using MQTT
# 
# This is an example of publishing to multiple fields simultaneously.
# Connections over standard TCP, websocket or SSL are possible by setting
# the parameters below.
#
# CPU and RAM usage is collected every 20 seconds and published to a
# ThingSpeak channel using an MQTT Publish
#
# This example requires the Paho MQTT client package which
# is available at: http://eclipse.org/paho/clients/python
import paho.mqtt.publish as publish
import psutil
import string

# The ThingSpeak Channel ID.
# Replace <YOUR-CHANNEL-ID> with your channel ID.
channel_ID = "<YOUR-CHANNEL-ID>"

# The hostname of the ThingSpeak MQTT broker.
mqtt_host = "mqtt3.thingspeak.com"

# Your MQTT credentials for the device
mqtt_client_ID = "<YOUR-CLIENT-ID>"
mqtt_username  = "<YOUR-USERNAME>"
mqtt_password  = "<YOUR-MQTT-PASSWORD>"

t_transport = "websockets"
t_port = 80

# Create the topic string.
topic = "channels/" + channel_ID + "/publish"

while (True):

    # get the system performance data over 20 seconds.
    cpu_percent = psutil.cpu_percent(interval=20)
    ram_percent = psutil.virtual_memory().percent

    # build the payload string.
    payload = "field1=" + str(cpu_percent) + "&field2=" + str(ram_percent)

    # attempt to publish this data to the topic.
    try:
        print ("Writing Payload = ", payload," to host: ", mqtt_host, " clientID= ", mqtt_client_ID, " User ", mqtt_username, " PWD ", mqtt_password)
        publish.single(topic, payload, hostname=mqtt_host, transport=t_transport, port=t_port, client_id=mqtt_client_ID, auth={'username':mqtt_username,'password':mqtt_password})
    except (keyboardInterrupt)
        break
    except Exception as e:
        print (e) 

This site uses Akismet to reduce spam. Learn how your comment data is processed.