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.

Five months later, I owe that post an update. The stack evolved.

The Agent Engineer

Seth DeLand has been at MathWorks for fifteen years. He started in mechanical engineering, building mathematical models for diesel combustion and NOx emissions. Control strategies, optimization, statistics. The kind of work where getting the math wrong means the engine doesn’t meet spec. Now he’s a Product Manager focused on generative AI, and he recently sat down with Jousef Murad on the Engineered-Mind Podcast to talk about what agentic AI means for engineers.

He’s not selling hype. He’s describing what he sees happening in real engineering workflows.

On what makes agentic AI different from chatting with an LLM:

“Rather than it just generating a bunch of text, it’s actually going to generate calls to APIs… now they’re not limited just to generate text as an output, they can actually start to work on the same artifacts that we humans are working on.”

Seth DeLand

That distinction matters. An LLM gives you text. An agent gives you results. It runs your code, checks your tests, detects your toolboxes, and iterates on errors. No copying and pasting between windows. The agent works on your project, not a hypothetical version of it.

Seth didn’t frame this as tools replacing engineers. He framed it as engineers leveling up.

“It’s more that we are working at a higher level now. We are thinking much more in terms of what are the problems, what are the constraints, how do I shape the solution space so that I can turn my AI loose in that solution space and have it go work… and then come back to me.”

Seth DeLand

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. That’s not a demotion. That’s what senior engineers have always done, except now the junior engineer on your team is an agent that never sleeps and never complains about the build system.

Seth also nailed something I’ve been feeling since I started using agents for prototyping:

“Why not have it implement four prototypes of all of those different options and see which one I like the best… it allows me to shorten that cycle to get from kind of an idea to some type of proof of concept.”

Seth DeLand

Four prototypes. Not four design docs. Four working implementations. You compare running code instead of arguing about architecture diagrams. I wrote a whole post about this idea (Twenty Prototypes), and hearing a MathWorks PM describe the same workflow independently tells me this isn’t a niche trick. It’s becoming the default.

What Changed Since November

When I wrote the original super stack post, the MATLAB MCP Core Server was at version 0.1. First release. Five tools. It worked, but everything is moving fast.

Here’s where things stand now:

The MCP server is at v0.6.1. MathWorks shipped cross-platform MCP Bundles for one-click installs, added headless mode so MATLAB can run without the desktop GUI, and introduced MCP Resources that feed coding guidelines directly to your AI agent. Nine releases in five months.

MATLAB Copilot launched with R2025a in May 2025. It’s a purpose-built AI assistant inside the MATLAB desktop with chat, code generation, autocomplete, and error explanations. They even upgraded the underlying model to GPT-5 mini a month after launch.

Simulink Copilot entered beta. You can chat with your Simulink models, search and trace features with natural language, and troubleshoot errors through a dedicated panel on the canvas. If you do model-based design, this is worth watching.

And the MCP ecosystem around it exploded. MCP now has 97 million monthly SDK downloads and over 10,000 active servers. Anthropic donated it to the Linux Foundation. OpenAI, Google, Microsoft, and Amazon all support it. MathWorks calls MCP “USB-C for AI,” and that metaphor has held up.

The super stack isn’t experimental anymore. It’s infrastructure.

The Setup: MATLAB MCP + VS Code + GitHub Copilot

The original post showed the stack with Claude Code. This time I’ll set it up with GitHub Copilot in VS Code. Same MCP server, different AI client. That’s the whole point of an open protocol.

What you need:

• MATLAB R2020b or later, installed and on your system PATH
• Visual Studio Code with the GitHub Copilot Chat extension
• The MATLAB Extension for VS Code (optional but recommended)
• A GitHub Copilot subscription (the free tier works)

Step 1: Download the MCP server

Go to the MATLAB MCP Core Server releases page on GitHub and download the binary for your platform:

• Windows: matlab-mcp-core-server-win64.exe
• macOS Apple Silicon: matlab-mcp-core-server-maca64
• macOS Intel: matlab-mcp-core-server-maci64
• Linux: matlab-mcp-core-server-glnxa64

On macOS or Linux, make it executable: chmod +x matlab-mcp-core-server-*

Step 2: Configure VS Code

Create a .vscode folder in your project root (if it doesn’t exist), then add an mcp.json file:

{
    "servers": {
        "matlab": {
            "type": "stdio",
            "command": "C:\\path\\to\\matlab-mcp-core-server-win64.exe",
            "args": [
                "--matlab-root=C:\\Program Files\\MATLAB\\R2025a",
                "--initial-working-folder=C:\\Users\\you\\YourProject"
            ]
        }
    }
}

Replace the paths with your actual MATLAB installation and project directory. On macOS or Linux, use forward slashes.

Step 3: Validate

Open GitHub Copilot Chat in VS Code and ask: “Which MATLAB toolboxes are available?”

If everything is wired up, the MCP server launches MATLAB in the background and Copilot responds with your installed toolboxes. The first call takes a few seconds while MATLAB starts. After that, it’s fast.

What you get:

Five tools, available to any MCP-compatible AI client:

• detect_matlab_toolboxes: Lists your installed MATLAB version and toolboxes
• check_matlab_code: Runs static analysis on a .m file (style issues, errors, deprecated functions)
• evaluate_matlab_code: Executes a MATLAB code string and returns the output
• run_matlab_file: Runs a .m script file
• run_matlab_test_file: Runs MATLAB unit tests

Plus two MCP Resources (added in v0.3) that feed your AI agent the official MATLAB coding guidelines. The agent doesn’t just write MATLAB code. It writes MATLAB code that follows MathWorks conventions. 1i instead of i for imaginary numbers. k for loop variables. Error handling the way the documentation says to.

“I think one of the impressive things about a lot of these AI models is that if you can teach it about the system that it’s working on… they can build on top of existing things that you have.”

Seth DeLand

That’s exactly what the MCP server does. It teaches the AI about your MATLAB installation, your toolboxes, your project. The agent isn’t guessing. It’s building on what you already have.

You Are the Engineer

The tools got better. The MCP server matured. The ecosystem grew. But the most important upgrade in the super stack isn’t software.

It’s you.

You decide what problem to solve. You set the constraints. You shape the solution space and turn the agent loose inside it. When it comes back with four prototypes, you’re the one with the engineering judgment to pick the one that actually works for your system.

The agent writes code, runs tests, checks for deprecated functions. It can’t decide what matters. That’s your job.

Seth put it well: engineers are working at a higher level now. Not because the tools forced them to, but because the tools finally caught up to where the interesting problems live. The math. The constraints. The design decisions that determine whether the system works when it meets the real world.

The super stack is MATLAB, VS Code, and an AI agent connected through MCP. The stack doesn’t work without the engineer at the top of it.

Choose a Brisket

I used to buy my briskets at a mass-market store and hope for the best. This still works, but there are some fantastic Brazilian butcher shops all around me. I have learned that I am looking for a carne de peito. If you have a few options, be picky. Pick a brisket with purpose. I tend to look for how much fat there is, the overall shape, and how thin the flat side is. I am thinking about how much I am not going to be able to use. I tend to trim aggressively, so I don’t want to pay for what I am going to throw away. Get the brisket home safely and put it in the refrigerator. Keep it cold until you are ready to trim.

Make a Brisket Rub

While your brisket is getting cold, prepare a fresh brisket rub. This is where your personality and preferences can shine through. Don’t worry too much about being traditional or what others like; try out different rubs, spices, and flavors. Over time, you will figure out what you like and what others tend to like. To me, a brisket rub is basically salt and pepper. This is because I have had many briskets in Texas, and they tend to be heavy on the black pepper. The trick is to use coarse grinds on the spices that you want to use. You want the smoke to make it the meat; fine powders tend to block the smoke from getting in. If you want to experiment, try coarse-ground spices instead of powders. I recommend Penzeys Spices Tellicherry Black Pepper and grinding it when you need it.

My Secret Texas Brisket Rub Recipe

• 1/2 cup of Lawry’s Seasoned Salt
• 1/2 cup of kosher salt
• 1 cup of tellicherry black pepper (coarse ground)

Add all of the ingredients to a container, seal it, and shake it to mix thoroughly.

Trim the Brisket

YouTube is your friend here. If you have never trimmed a brisket, watch a few hours of video to see different techniques and to get comfortable with what you are trying to accomplish. I will list some of my tips, but trimming a brisket takes some practice. It is also nerve-wracking, as you don’t want to mess up a very expensive cut of beef. Trim right out of the refrigerator—the colder, the better. I recommend a cheap deboning knife to trim a brisket.

At the end of the trimming process, you want a piece of meat that will be easy to smoke and yield eatable pieces. “Don’t be a hero” is what I say to the people who I teach. I aggressively trim and cut away pieces that are just not going to cook well or be tasty. Save the trimmings to make tallow.

At the end of the process, you want a brisket with an aerodynamic shape. This means no sharp corners and a rounded, domed shape. Trim down the flat side so it is at least an inch thick; any thinner, you run the risk of burning it up and drying it out. Trim the fat cap to around a quarter of an inch. Remove the silver skin and fat pockets from the bottom side. Take your time.

Apply the Rub

Put the brisket on a large cutting board. Apply your brisket rub to the brisket by shaking the container of rub from about 12 inches away. I start with the bottom side, go around the edges, flip, and cover the top of the brisket. I only lightly press the rub down. I don’t use any binders, and I don’t rub them into the meat. And make sure to get all of the sides. I tend to miss the side facing away from me.

Smoke the Brisket to 170°F

I use vertical smokers and charcoal and wood chunks for smoking meat. You can do this with a pellet smoker or an offset smoker. Use what you know and what you are comfortable with. I smoke at 225°F, and I am looking for an internal temperature of 170°F and a defined bark. Before I move to the next step, I like to have good color and have the bark in place.

Make Tallow

While your brisket is smoking, make some tallow. We are going to use the scraps from trimming and render them into tallow. I put some of my scraps in a pot and heated it up slowly for a couple of hours. I am not worried about getting all of the fat to render. I just want to make a cup for when I wrap the brisket and smoke it the rest of the way. I pour the rendered fat through a strainer and then a coffee filter. I am only trying to get a cup to use in the next step. You can also buy Wagyu Tallow, smoke it, and use it without all of the mess of making your own.

Wrap the Brisket

Take two large sheets of pink butcher paper and place them on top of a cooking sheet. Pour the tallow onto the paper, and put the bottom of the brisket down on the pool of beef tallow. Fold the paper around the sides, flip, and tuck. I like to make sure that there are no air pockets in the paper. It might take a few tries to wrap it, but I haven’t noticed too much of a difference in the output. Tallow helps with moisture, texture, and mouthfeel.

Smoke the Brisket to 203°F

Take your wrapped brisket in pink butcher paper and place it back on the smoker. I am looking for an internal temperature of 203°F and a certain feel of the temperature problem. I use an instant-read temperature probe with a pointy end. I want the probe to punch through the paper and have little resistance going into the brisket. It takes some experience to get the feel for this.

Rest the Brisket

Once the brisket is at the desired temperature and has the right texture, I let it cool down to around 180°F. I keep it wrapped the whole time. Then, I place it in a cooler until the brisket is ready to serve. I give it at least 4 hours and have gone as long as 8 hours. The resting part is really important for moisture. A good cooler will hold the internal temperature around 160°F. I used some extra butcher paper to fill up the space in the cooler. I am not sure if this helps, but it is something that I do every time.

Show Off the Brisket

I am a ham. I love to share my work. I usually gather everyone around for the big reveal. This step is optional.

Slice the Brisket

I use a sharp brisket knife while wearing gloves to slice to order. My first cut is around the middle to separate the flat from the point muscles. I pose for the moisture shot and then continue slicing. I have watched a lot of videos on slicing a brisket properly, and I learn something new every time I do it. My flat cuts are around a quarter of an inch, and my point cuts are a little wider. Over time, you will learn where the burnt ends are. I usually cube up four pieces from the flap on the point to make some really tasty burnt-end pieces.

Rest Yourself

I never sleep so well after a day or so of smoking and eating. It is exhausting to keep up with the fire, checking things, overthinking things, and striving for your best. Get some rest, reflect, and be ready for the next battle.

What tips do you have? Please share and help build up our community. I am always learning. And the more I share, the better I get. I love talking about BBQ, so connect with me here or on Instagram. Godspeed.

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.

Parts

First, you need to go buy a thing on Amazon. I recommend an ESP8266-compatible device like the NodeMCU for this project. Don’t be scared. Add it to your Amazon shopping list or ask Alexa to buy you one. It’s $8.

Other parts that you will need:

• Laptop
• Micro USB cable

ThingSpeak

While you are waiting for your Amazon stuff to arrive, you can learn about ThingSpeak.

ThingSpeak is where we are going to store the data collected by our thing and where we can see the data that we collected. Visit ThingSpeak.com and Sign Up for an account. This will just take a minute, and the 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 “ESP8266 Signal Strength” and name Field 1 “RSSI”. Click “Save Channel” at the bottom to finish the process.

Arduino Setup

Once the ESP8266 comes in the mail in a couple of days, you need to gather a few more things to be able to program this thing. You will need a laptop and a micro USB cable (like the one that you charge a phone with). On the laptop, we need to install some software to be able to program the ESP8266. Visit Arduino.cc and install the Arduino IDE.

Once the Arduino IDE is installed, open the program so we can do a couple of setup steps to get it ready to program ESP8266 devices. Under File, Preferences, and Additional Boards Manager URLs, add this link: http://arduino.esp8266.com/stable/package_esp8266com_index.json – this will allow the Arduino IDE to manage ESP8266-compatible boards.

Close and reopen Arduino. Click on Tools, Board, and Boards Manager…. to open the board manager. The Arduino IDE will load the Additional Boards URL that you entered in the preferences.

ThingSpeak Library

Arduino needs to have a library installed in order for your thing to know how to send data to ThingSpeak. In the Arduino IDE, choose Sketch, Include Library, and Manage Libraries. Search for “thingspeak” and click Install.

The thing that you bought from Amazon uses the CP2102 USB driver. You might have to install a USB driver from Silicon Labs for this to work with your computer. Connect the ESP8266 to your laptop with the micro USB cable.

Back on the Arduino IDE, under tools, configure the following settings:

Whew. We got through the setup. Now we can program this device or any ESP8266-compatible device and shouldn’t have to do that again.

Programming

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 our project, we are going to have the code measure the signal strength of the Wi-Fi connection and upload the data to ThingSpeak, wait, and repeat. Over time, we can see the signal strength of our Wi-Fi connection. 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 ESP8266 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.

Back on ThingSpeak, you should see data start to come in. You are looking for the Private View of your channel and a chart that is updating. As new data comes in, the chart shows the latest value. If you carry the ESP8266 around the house, you might notice the signal strength changing.

Next Steps

To take the project further, you can use MATLAB on ThingSpeak to do some data analysis using the MATLAB function thingSpeakRead and passing in your channel number. I will post about IoT data analytics on another day. The ESP8266 source code for sending data to ThingSpeak is available on GitHub.

Welcome to the Internet of Things. Let me know if you try this out, and let me know if you take this project further and build something cool.