What changed

• Video channels. Drop video files in a folder and point a channel at it. My folder of 90s commercials is now channel 2, for example.
• A broadcast clock. Channels air whether you’re watching or not. Tune away, tune back, and you land mid-program.
• Scheduled hours. Cartoons can keep Saturday-morning hours. Off the air, the channel shows a test card with the resume time, color bars, or static.
• A tuner. Change channels with arrow keys, a USB gamepad, or an HTTP request. Every change cuts through a moment of tuner static and shows a channel banner.
• A demo channel. node channels/fetch-demo-channel.js downloads eight public-domain films from the Internet Archive’s Prelinger collection. Duck and Cover, Design for Dreaming, One Got Fat. A working channel in one command.
• The control room. A Channels panel with a folder picker, a schedule editor, and a week grid of your on-air windows.

The broadcast clock

A normal media player has a play state: what’s playing, where you paused, what’s next. A cable channel has none of that. Its position is a pure function of the wall clock: given the playlist and the time of day, the channel knows exactly what should be on the air and how far into it we are.

That means there is nothing to save and nothing to resume. Tune to channel 2 at 9:14 and you join a commercial already in progress, like TV that doesn’t wait for you.

I changed channels with an Atari joystick

The tuner reads NES-style D-pad buttons and the analog axis, so when I plugged in a single-button Atari USB stick, up and down worked on the first try. A 1977-style controller changing channels on a 1987 television driven by a modern Raspberry Pi. The input doesn’t care what you use: anything that can press a key, close a GPIO pin, or POST to /api/tune is a remote control.

My CABLE 82 network has a channel dedicated to 80s commercials, 90s commercials, retro movies, Beavis and Butthead, music videos, Transformers, Saturday morning cartoons, and the community bulletin board. I have been busy copying old VHS tapes to MP4.

Thermals

Software video decode is the hardest this Pi has ever worked. The bulletin board alone kept the 3 B+ in the high 50s C; continuous video holds it in the low 60s. That trips the 3 B+’s soft temperature cap at 60 C (vcgencmd get_throttled reports 0x80008), which is the chip protecting itself by design – not a power problem, and the picture doesn’t care.

Passive cooling has been fine, but a network that broadcasts around the clock earns a fan. I’m looking at a Raspberry Pi 3 case with a fan and heatsinks. It also comes with a 3A supply with a power switch, but don’t use the power switch. Send a proper shutdown signal to the Raspberry Pi. Older Pi’s can corrupt the SD card.

Get the latest CABLE 82 release

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

Open the address it prints and you’re on the air with channel 82, the community bulletin board. Run the demo channel fetcher, add it in the control room, and you have a network.

The repo is at github.com/nothans/cable-82. The original build story and the step-by-step tutorial cover the build from a blank SD card to a cable network of your own.

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.

I was standing in the hardware store holding a dead coin cell, squinting at it, trying to remember if the Lutron dimmer in my hallway takes a CR2032 or one of the other fourteen round silver batteries that all look exactly the same. So I guessed. I bought two of the wrong one. Classic.

Here is the thing about a house. You slowly learn a thousand tiny facts about it. The vent sizes. The filter part numbers. The spa was installed in some year you’ll never remember. The good info is scattered across manuals in a junk drawer, an email from the installer, a photo of a model plate you took and never looked at again. By the time you actually need a fact, it’s gone.

I finally fixed it. Not with an app. With a folder.

The idea I borrowed

Earlier this year Andrej Karpathy posted a little pattern he called an “LLM wiki.” Instead of the usual retrieval setup where you chop documents into chunks and stuff them in a vector database, you just keep a folder of Markdown files that the AI itself writes and maintains. The model builds the connections once, when it learns something, instead of re-deriving them every single time you ask. The internet looked at it and went “wait, it’s just a folder? why did we ever do the other thing.”

Then Google Cloud made it official. On June 12 they published the Open Knowledge Format, or OKF. It’s a tiny, vendor-neutral spec: a directory of Markdown files, one concept per file, a bit of YAML at the top, an index, links between them. No database. No SDK. Readable by a human and by any agent. That’s the whole thing.

So I pointed it at my house. The project is called Abode 101.

What I actually built

Abode 101 is an OKF folder about my home. There’s a file for the Lutron dimmer, one for the swim spa, one for the HVAC vents, one for the smoke alarms. There’s an index.md the AI reads first so it knows where to look. To use it, I don’t open an app. I just talk to it in Claude Code.

you ▸ what's the battery for the Lutron dimmer?
abode ▸ Panasonic CR2032, per the install guide (page 10).

That’s the fact I drove to the store without. Now it’s one question away, and it tells me where it got the answer.

But a folder of files just sitting there is a filing cabinet. The magic is in two things the bare spec leaves out.

Thing one: the loop

OKF standardizes the files. It says nothing about keeping them fresh. Karpathy’s original idea had the AI do the maintaining, and that’s the part I cared about most, so I built it back in as a set of playbooks.

I capture a thing by telling it “I bought X,” or by dropping a manual, a receipt, or a photo of a label into an inbox folder. It reads whatever I throw at it, pulls out the real specs, and files them. Then overnight it does the boring homework I never do. It looks up the filter I just bought, finds the replacement part, figures out how often it needs changing, and adds a reminder. I wake up and my house knows more than it did when I went to bed.

Thing two: it refuses to guess

This is the part I’m proud of. Every exact fact carries its source and a confidence level. A battery type from the manufacturer’s manual is “verified” and it gets cited. A spec from a random Amazon listing is “reported” and ranked lower. And when I ask something it doesn’t actually know, it says so.

you ▸ what size is the kitchen toe-kick vent?
abode ▸ Not recorded. It's marked TODO, needs measuring. I won't guess.

An AI that says “I don’t know” instead of inventing a confident wrong number. For house facts, where the wrong answer means a second trip to the store or a part that doesn’t fit, that refusal is the feature.

I ran a little eval suite over it to make sure. Twenty-one questions, answered cold. It got the exact facts right, with sources, and on the three questions it shouldn’t know, it refused all three. That’s the behavior I want from something I’m going to trust with my house.

Why a folder beats an app

I could have built a slick app with a database. I’m glad I didn’t. The folder is portable, it diffs in version control, it works with any model, and I own it. There’s no service to shut down, no export button I’ll go hunting for in five years. When the next better model comes out, I point it at the same folder and it just works. Try that with your smart-home app from 2014.

Get it

I open-sourced the framework. The structure, the agent instructions, the playbooks, even the eval harness are all in the repo. My actual house data stays on my machine, gitignored, because you do not need to know my spa’s gallon count. You fork it and fill it with your own home.

→ github.com/nothans/abode101

Go give your house a memory. And maybe check what battery your dimmer takes before you drive to the store. Just a thought…

Here are some tips that I have learned after a few seasons in New England with an Ariens 1128 Sno-Thro snowblower.

RTFM. The manual contains a lot of clues. Ariens.com has manuals for all of its models archived. Actually, I find that the manual gets more helpful over time. Initially, you don’t know anything about this machine that you just bought. How hard could it be, you may think? The machine typically works pretty well when you first get it. Once you get a little time under your belt, read the manual. You will find little details that help you understand what’s going on.

Take notes. When you learn something, write it down. Your future self will thank you. Write down the socket sizes, threads, part numbers for replacement parts, and any tips that you discover.

Watch videos on YouTube. When you encounter a problem or a developing issue, find appropriate videos on YouTube. You will have to make sure that you watch a video on your specific model, as sometimes you might be watching a video on a different model. I tend to act like a detective and seek out the information from the videos. Not all of the videos, or every video you are going to find, are going to apply. This is a good skill to develop to speed up the learning process with anything that you may want to learn.

Grease the shear bolts. Your snowblower is designed to fail-safe when you run over a dog toy, a tree branch, or a rock. A shear bolt is designed to break in case of a jam instead of putting the forces back on the belt, drive, and motor. When you replace your shear bolt, grease it up. It will be easier to remove and replace when you inevitably hit something.

Keep a stock of shear bolts. Use the manual to find the type of shear bolt you need. Write down the part number. Buy a bunch of shear bolts. Try them out as soon as you get them. Make sure they fit and last with normal wear. On Amazon, there is a variety of quality that you will find. So, find ones that work and return the ones that don’t. You will be thankful when you need them. In New England, they tend to be out of stock in the winter since everyone is breaking their shear bolts and going out to buy them. Mine uses a 1/2″ socket to install. Yes, I wrote that down in my notes.

Grease the auger when you replace the shear bolts. A good time to grease the auger shaft is when you replace the shear bolts. I like to take the shear bolts off and apply grease via the Zerk fittings and then spin the auger to spread out the grease. I squeeze grease in there until it comes out the sides of the auger. This was something I had to watch a YouTube video on. I never used my grease gun before and didn’t even know how to attach it to the grease fitting.

Maintain the correct tire pressure. My Ariens 1128 tires require 14 psi to function properly. I bought a battery-powered air compressor to make it easy to fill the tires. I also like that it tells me the pressure in the tire with a digital readout. Make sure that both tires are set to the same air pressure. This will help the snowblower travel in a straight line. If you don’t know your target PSI, check the sides of the tires. It is usually written on the walls of the tire.

Take advantage of the calm before the storm. It’s freezing in the winter, and it’s not convenient to perform maintenance. In the spring or fall, you can take advantage of warmer weather and lower stakes. Grease the auger, buy some shear bolts from Amazon, clean the gas, add oil, tighten the chute, and set the right air pressure in your tires.

Godspeed.

CheerLights is a fun way to get started with IoT, microcontrollers, and LED lights. If you know how to make CheerLights work, you can build some other awesome IoT projects. CheerLights is a great project to get people interested in IoT. It’s often used as an “Hello, World” project for the Internet of Things, and what you learn can be applied to other project ideas.

To make a Halloween-inspired project, you can take the CheerLights color and illuminate a pumpkin or even a… skull from Pimoroni.

Check out other Halloween CheerLights projects over at the CheerLights blog. Have fun with the idea, build something spooky, and help spread the… fear.

ThingSpeak is an Internet of Things (IoT) platform that allows you to collect, analyze, and act on data from sensors and other IoT devices. The platform provides a web-based interface for users to create and manage channels, which are virtual locations where data from sensors and other devices can be collected and analyzed using the built-in MATLAB analytics app.

With ThingSpeak, you can visualize your data in real-time, generate alerts and notifications based on pre-defined thresholds, and even automate actions based on specific conditions. The platform also includes built-in integrations with popular IoT hardware platforms, such as Arduino and Raspberry Pi, making it easy to connect your devices to the internet and start collecting data.

Top 10 IoT Project Ideas for ThingSpeak

1. Weather Station: Build a weather station using a microcontroller such as Arduino or Raspberry Pi that collects data on temperature, humidity, and air pressure, and sends it to ThingSpeak for real-time monitoring and analysis.
2. Home Automation: Use ThingSpeak to automate your home by controlling lights, fans, and other appliances based on sensor data, such as motion, temperature, or light levels.
3. Smart Agriculture: Monitor soil moisture, temperature, and other environmental variables to optimize crop growth and water usage, using ThingSpeak to collect and analyze the data.
4. Water Quality Monitoring: Monitor water quality in lakes, rivers, and other bodies of water using sensors to collect data on pH, temperature, and other parameters, and then use ThingSpeak to analyze the data and generate alerts for unsafe conditions.
5. Smart Parking: Use ThingSpeak to monitor parking spots and guide drivers to available spots using sensors and real-time data analysis.
6. Industrial Automation: Monitor machine data in a factory or other industrial setting to detect anomalies and predict equipment failures, using ThingSpeak to collect and analyze the data.
7. Healthcare Monitoring: Use ThingSpeak to monitor patients’ health data, such as heart rate, blood pressure, and oxygen levels, in real-time and alert healthcare professionals of any critical changes.
8. Air Quality Monitoring: Use ThingSpeak to collect data on air quality, including particulate matter and pollutants, and generate alerts and visualizations for high-risk areas.
9. Smart Energy: Monitor energy usage in homes or businesses and automatically adjust consumption based on sensor data, such as occupancy or sunlight levels.
10. Smart City: Use ThingSpeak to monitor and optimize traffic flow, waste management, and other city services based on sensor data from a network of IoT devices.

Subscribe to the About Things blog for more IoT news, tips, and projects. If you need help or want to share ideas, connect with me and the community on our Quandary Discord Server.

This version of the On Air Light is cheaper and easier to build than my previous versions.

The Idea

I want a light that turns on when my webcam turns on. I want the light to turn off when my camera turns off. The idea is that my camera is on when I am in an online meeting. The light is a good indicator to everyone, including myself, that I am in a meeting.

The System

In order to turn a light on and off, I need a script that monitors my webcam for activity. This script will then send the status of my webcam to ThingSpeak, a cloud IoT platform that allows you to save and retrieve sensor data. Then, the on-air light controller will read the data from ThingSpeak and turn the light on if my camera is on.

The Parts

I was able to find everything you need on Amazon to build this project.

• On Air sign
• ESP32 board
• ESP32 screw terminal board
• LED light strip

Here are some notes about these parts.

• You can use any sign that you want to light up. I chose this one since it was $15 US and looks great. It also includes a Micro USB cable that you can use for the ESP32 device.
• Screw terminals make this project a solder-free project. Some people who wrote me said that soldering was a barrier to getting started. I want this to be accessible to as many makers as possible. Screw terminals offer a quick way to break out the pins of the ESP32 board and easily connect wires.
• Only certain styles of the ESP32 board work with the screw terminals. The terminals are for the 38-pin version of the HiLetgo ESP-WROOM-32 ESP32 dev board. The two parts that I linked to on Amazon will fit together perfectly. Other ESP32 boards might not work with the screw terminal expansion board.

ThingSpeak Setup

ThingSpeak is an IoT service hosted by MathWorks. It is focused on being easy to collect data and then retrieve that data. We are going to leverage that core functionality for this project. ThingSpeak stores data in a channel and each channel has eight fields.

Visit ThingSpeak.com and Sign Up for an account. This will just take a minute and user accounts are free. Once you have a user account, you need to create a channel. ThingSpeak channels are where data gets stored. Create a new channel by selecting Channels, My Channels, and then New Channel. Name the channel, “On Air Light” and name Field 1, “Webcam State”. Click “Save Channel” at the bottom to finish the process.

Click API Keys and note your write API key and read API key. The write API key will be used by the code to track your webcam state. The read API key will be used to turn on or off the light based on the webcam state.

Track Webcam State

I wrote a Python script that uses OpenCV to detect if the camera is in use or not. It sends a “1” to field1 of the ThingSpeak Channel if the camera is in use. It sends a 0 if the camera is not in use. Just run this code on a periodic basis to track the state of your webcam.

The code to track my webcam state and upload the state to ThingSpeak is available on GitHub. Update the code with your ThingSpeak Channel’s write API key.

Most of the magic is here:

def returnWebcamStatus(webcamIndex):

    webcam = cv2.VideoCapture(webcamIndex, cv2.CAP_DSHOW)

    if webcam.isOpened():
        webcam.release()
        return True #Webcam not in use
    else:
        return False #Webcam in use

Assembly

Get your parts together and get ready to put everything together. Take your time and step through. There is no soldering, just some connections to be made on a set of screw terminals. You will need cutters, a small screwdriver, and some tape to complete the assembly.

Connect the ESP32 board to the SCrew Terminal Board

Make sure to get the right orientation of the boards together. The 5V pins should line up and the USB part should be pointing down.

Cut Off the Out Connector from the LED Strip

We can use the connector on the out side of the LED strip. Cut this off and strip back some of the insulation. We will use this connector for the screw terminals.

Connect the Connector to the Screw Terminal Board

Connect the red wire to the 5v terminal. Connect the green wire to P13. Connect the white wire to GND.

Connect the LED Strip to the Connector

Program the ESP32

Using the Micro USB cable that comes with the On Air Light, connect the ESP32 to your computer.

The code that the Arduino IDE uses is called a “sketch” – this is just a short program that the device runs over and over. In this project, we are going to have the code that checks the ThingSpeak channel for the webcam status and sets the LED strip to either on or off. Copy the example code to your Arduino IDE and change some of the defaults to match your Wi-Fi network and ThingSpeak settings.

Once everything is set, click Sketch and then Upload. This will take the code and program the ESP32 with it. It takes a minute, so be patient. If anything goes wrong, make sure that you have the right board settings and that your “Port” matches what your laptop thinks the port is.

Open the On Air Light

The housing of the On Air light is held together by several tabs. Take your screwdriver and gently twist in each opening. It will come apart without damage. Just take your time and open each tab.

Remove the Existing LED Board

Remove the existing board on the inside of the light. Trim the wires off close to the circuit board so you have some length to work with.

Connect the USB Wires to the Board

Connect the red wire to the 5v screw terminal. Connect the black wire to the GND screw terminal. You will have two wires in each. I used some tape to make sure that the screw terminal board doesn’t move around.

Snap It All Back Together

Carefully snap the two halves back together.

Profit.

Enjoy your On Air light. Maybe this will remind you or someone in your family that you actually work when you are home.

My goal was to show you the steps as clearly as possible and share the code. I hope that you can reproduce this as easily as possible. If you need help leave a comment or join me on my new Discord server.

Most people experienced MATLAB on their PC, but you can also access MATLAB in your browser with MATLAB Online. MATLAB Online is a web-based version of MATLAB that allows users to access the software and its features through a web browser. It eliminates the need to install and configure the software on a local computer, making it accessible from anywhere with an internet connection.

In this project, I will be using MATLAB Online to take a picture with a webcam, classify the image using a pre-trained deep learning model, and display the results.

I selected the ResNet-50 model, which is a deep convolutional neural network (CNN) trained on the ImageNet dataset. ResNet-50 stands for “Residual Network with 50 layers” and was developed by Microsoft Research in 2015. The architecture is known for its ability to train very deep neural networks without the problem of vanishing gradients, which allows for improved performance on image classification tasks. The model is capable of identifying objects in images and classifying them into one of 1000 different categories.

% Connect to webcam
cam = webcam;

% Take a picture
img = snapshot(cam);

% Resize image to [224 224 3]
img = imresize(img, [224 224]);

% Display the picture
imshow(img);

% Load pretrained model
net = resnet50;

% Classify image
label = classify(net, img);

% Display label
disp(label);

% Release webcam
clear cam;

What’s really neat is that MATLAB Online can use your webcam. This code takes a photo, resizes it for ResNet-50, shows the output, and classifies the photo.

Check out MATLAB Online and run the very latest version of MATLAB and select toolboxes. Everyone should be able to try this project out and get started with image classification.