Hackaday Podcast Episode 335: Beer, Toast, And Pi

Some podcasts bring you hot takes. Hackaday Podcast Episode 335 brings you hot plates, hot toast, and the kind
of “hot” that arrives via lightning and turns your Raspberry Pi into modern art. If you’ve ever wondered what happens
when hardware hackers review the week’s most interesting builds, repairs, teardowns, and tech policy dramathis is the
episode that answers it with a grin and a soldering iron.

Episode 335 is a wonderfully chaotic sampler platter: automated beer brewing, surge protection tough enough to stare
down Zeus, a tool-battery “firmware curse” that reverse engineering can break, and even a bathroom-themed detour into
how you measure liquids in microgravity. It’s the kind of lineup that sounds like a dareuntil you realize it’s also
a snapshot of what modern hacking looks like: practical, stubbornly curious, and increasingly allergic to cloud
dependency.

What Episode 335 Is (and Why It Works)

The Hackaday podcast format is simple: a fast-moving roundup of standout hacks and stories from the past week, plus
recurring segments that keep things playful. Episode 335 leans into that vibe hard. One moment you’re in the garage
reviving a “dead” battery pack with a debugger; the next you’re in the kitchen softening butter like it’s a
materials-science experiment; and thenbecause of courseyou’re in outer space thinking about fluid sensors.

The connective tissue is the mindset: you don’t accept “that’s just how it is” as an answer. If the power grid is
spicy, you build protection. If the charger depends on a vendor’s servers, you de-cloud it. If a battery is bricked
by firmware, you find the byte and flip it back. And if butter is tearing up your toast, you… okay, you print a tiny
butter hammock and clip it to your coffee mug. That counts.

News Segment: A 220 PeV “Ghost Particle” and the One Hertz Challenge

A neutrino with “are you kidding me?” energy

Episode 335 opens with a piece of science news that feels like it belongs in a comic book: confirmation of an
ultra-high-energy neutrino detection on the order of 220 petaelectronvolts (PeV). Neutrinos already
have a reputation for being maddeningly hard to detect because they barely interact with matterso catching one with
that kind of energy is like spotting a single glitter speck in a stadium while it’s raining confetti. The broader
implication is even cooler: events like this can hint at extreme astrophysical accelerators (or rare “cosmogenic”
processes) that we’re still trying to understand.

The One Hertz Challenge: timing is a design material

On the other end of the spectrumliterallyis the One Hertz challenge energy: making something tick, blink, or behave
with a steady 1 Hz rhythm. It’s deceptively simple: a single beat per second. But it forces you to face the real
world where clocks drift, components vary, and “close enough” becomes a design decision. In other words, it’s a great
reminder that engineering isn’t only about speed or power; it’s also about repeatability.

Interesting Hacks of the Week: Beer, Lightning, Batteries, and a Pi-Sized Dose of Assembly

Automated brewing: letting an ESP32 babysit the boil

Beer brewing can be beautifully hands-onuntil you’re on hour three of watching a pot and wondering if your hobby has
quietly become “standing.” The automated brewing project featured in Episode 335 tackles that problem by automating
the parts that are repetitive (temperature control, stirring, step timing) while leaving the craft choices to the
human (recipe decisions, ingredient additions, and the all-important taste testing).

The setup is delightfully pragmatic: small batches (around eight liters) make automation simpler, and using a hot
plate makes the heating element controllable in a way that’s harder with a gas stove. An ESP32 handles temperature
control, runs a paddle stirrer, and uses a screen to cue the brewer for the next stepessentially turning a brew day
into a guided workflow instead of a marathon of vigilance.

If you’ve ever gone down the homebrew rabbit hole, you’ve seen the same idea show up in fermentation control: steady
temperature is one of the biggest levers for improving flavor consistency. Systems like BrewPi and other controller
builds emphasize how precise temperature profiles can reduce off-flavors, help hit style targets, and make recipes
repeatable. The beer takeaway from Episode 335 is classic hacker wisdom: automate the boring parts so your brain
(and your time) stays available for the fun parts.

How to stop Zeus from toasting your Pi: surge protection with teeth

The “Pi” in the episode title isn’t a math punit’s survival advice. One featured build comes from the reality of
rural power: storms, lightning-induced surges, and grid switching transients that can shrug off the kind of consumer
surge strips most of us buy at the hardware store. After repeated damageincluding a dead Raspberry Pithis project
responds with a serious line-voltage filter design meant to take hits without immediately turning into smoke.

The approach stacks multiple layers of defense: a fuse for catastrophic faults, an inrush-limiting thermistor to
tame startup surges, a gas discharge tube to shunt big lightning-class events, MOVs for clamping mid-sized spikes, a
common-mode choke to calm ugly EMI, and safety-rated capacitors (plus bleed resistors) to filter what’s left.
It’s not “magic,” it’s engineering: each component handles a different slice of the surge problem, and together they
reduce the odds that your downstream power supply or SBC becomes collateral damage.

Important note: this is not a cute weekend breadboard project. Mains voltage can injure or kill you. The real lesson
for most readers is the design pattern: don’t rely on a single protective part. Build defense in depth, ground
properly, and respect the fact that “weather” is an electrical system you don’t get to negotiate with.

Battery repair by reverse engineering: when firmware bricks your tool pack

Now for the kind of hack that makes you feel both triumphant and slightly annoyed at the universe: fixing a cordless
tool battery pack that “randomly stopped working,” not because the cells failed, but because the pack’s electronics
entered a firmware lockout state.

The reverse-engineering work highlighted in Episode 335 focuses on a specific Ryobi 18V pack model and documents
common failure modes with unusually concrete detail. The headline: a “permanent firmware lockout” showing a
characteristic LED flash pattern was, in many cases, recoverable by dumping the microcontroller firmware, locating a
single-byte difference associated with the lock state, and clearing iteffectively un-bricking the pack. That’s a
big deal, because it reframes the failure from “trash it” to “debug it.”

It also raises a bigger question: how much functionality should a product be allowed to withhold from you after you
own it? The right-to-repair movement often talks about screws and spare parts, but modern repair increasingly means
protocols, diagnostics, and firmware states. Episode 335 doesn’t preachit just shows the reality: a determined
tinkerer can sometimes rescue a product from a lockout that looks indistinguishable from hardware death.

Wire photo fax teardown: the analog ancestor of “send pic?”

Episode 335 also takes a detour into communications history with a teardown of a “wire photo” fax machineequipment
that predates the office fax era and was used for transmitting images over networks long before “attach image” was a
button. The teardown highlights a wonderfully transitional design language: rugged, serviceable, and unapologetically
industrial. When your phone line connection is literally a pair of banana jacks, you know you’re not dealing with a
consumer gadget.

The bigger point isn’t nostalgia. It’s continuity. A lot of what hackers do todayencoding, decoding, signal
conditioning, mechanical scanning, data transportis the same set of ideas wearing different connectors. Seeing the
older machine makes modern gear feel less like magic and more like a long-running engineering conversation.

JuiceBox rescue: de-clouding an EV charger

If there’s a single modern theme Episode 335 nails, it’s this: “cloud-tethered” hardware becomes your problem the
moment a business model changes. The JuiceBox story is about EV chargers whose smart features depended on a remote
serviceuntil corporate upheaval and shutdown plans put owners at risk of losing key functionality.

The response described in the episode is the kind of community-driven engineering that restores your faith in the
internet (briefly, before you read the comments on anything else). Owners and developers pursued two tracks:
software that emulates the cloud service locally so the charger keeps behaving, and hardware “brain transplant”
options that replace the charger’s control board entirely. The practical upside is huge: you keep the expensive,
perfectly fine high-current hardware (cables, enclosure, relays) while swapping only the intelligence layer.
Less waste, less expense, and far less anxiety about a vendor flipping a switch.

It’s also part of a larger consumer issue: software support and disclosure. Regulators and consumer advocates have
increasingly pointed out that connected products can lose featuresor even stop workingwhen software updates end,
and that buyers often aren’t told how long support will last. Episode 335 doesn’t turn into a policy lecture, but the
JuiceBox story makes the stakes clear: when “smart” becomes “tethered,” reliability becomes political.

RP2040 assembly mix-and-match: when C needs a tiny bit of spice

The “Pi” thread continues with a project using an RP2040 (the microcontroller behind the Raspberry Pi Pico family)
where most of the work is done in Cbut a small, targeted piece is easier in assembly. The example is almost
perfectly educational: memory alignment constraints make a straightforward byte access tricky, and a single byte-load
instruction in inline assembly becomes the cleanest fix.

This is the anti-dogma argument for learning low-level concepts. You don’t need to write entire programs in assembly
to benefit from understanding what the CPU actually does. Sometimes one instruction is the difference between “why
is this behaving weirdly?” and “oh, right, alignment.” Episode 335 treats it the right way: as a practical tool, not
a personality trait.

Quick Hacks: Everyday Annoyances, Solved the Hacker Way

A homebrew TPMS you can build (and actually understand)

Modern cars hide a lot of useful telemetry behind vendor-specific systems. One quick hack flips that script with a
homebrew tire pressure monitoring system using off-the-shelf valve stem pressure caps that broadcast over Bluetooth
Low Energy. The fun detail: the sensors don’t transmit unless they detect pressuresmart for battery life, confusing
for debugging. Once pressurized, they show up, and the project decodes their advertisement data and displays pressure
readings on an ESP32 with an OLED.

The “USB and MORE” tester: a sanity tool for cable chaos

If you’ve ever tested a flaky USB cable with multimeter probes the size of small screwdrivers, you already
understand why a purpose-built tester board is appealing. The featured tool breaks out a pile of common connectors
(multiple USB variants and more) to labeled test points so you can quickly check continuity, spot shorts, and verify
whether D+ and D- are behaving or pretending to be ground today.

It’s not automatedyet. But as a diagnostic accelerator, it’s exactly the kind of “buy or build once, save an hour
every month forever” tool that quietly becomes invaluable.

Butta Melta: the most charming “thermal interface” you’ll ever print

Not every hack needs an oscilloscope. Butta Melta is a 3D-printed clip that holds a single butter pat against a warm
mug so it softens evenly and spreads without destroying your toast’s structural integrity. It’s silly in the best way:
the solution is tiny, printable, and proves the point that “engineering” is sometimes just paying attention to what
annoys you every morning.

Can’t-Miss: Google, Sideloading, and Who Gets to Install Your Apps

Episode 335’s “can’t-miss” section zooms out from hardware to the rules that shape software freedom. The spark:
Google’s plan to expand developer identity verification to apps installed outside the Play Store on certified Android
devices. The stated goal is to reduce malware and scams by removing anonymity for repeat bad actorsmore like an ID
check than an app content review.

The controversy is predictable and understandable. Android’s openness has long included the ability to sideload apps
and use alternative stores. Adding verification requirements may improve accountability, but it also moves the center
of gravity toward gatekeepingeven if the gate is “who are you?” rather than “what is your app?” Episode 335 captures
that tension: security matters, but so does the ability to run the software you choose on the hardware you own.

The practical takeaway: if you rely on niche tools, alternative app stores, hobbyist builds, or privacy-focused
distributions, policy changes like this can have real ripple effects. Keep an eye on timelines, regional rollouts,
and whether exceptions for students and hobbyists remain reasonable in practice.

Bonus Curiosity: Measuring Liquid Levels in Space (Yes, Even That Tank)

Episode 335’s funniest thread is also one of the most technically interesting: liquid level measurement in
microgravity. On Earth, you can often “just use a float.” In orbit, liquids don’t reliably settle, droplets wander,
and sensors can behave like they’re being haunted.

One playful project in the episode taps into public ISS telemetry to display the urine tank level. That joke has a
serious engineering backbone: the International Space Station has systems that track fluids, and public-facing
telemetry streams have been used for education and outreach for years. The “how” of level measurement gets subtle.
Space systems can use bookkeeping (tracking inflow/outflow), sensors that infer volume via capacitance behavior, and
other methods designed for environments where “up” is not a dependable concept. Even then, microgravity can cause
erratic readingsfor example, droplets splashing onto sensors during transitionsrequiring design tweaks like shields
to protect sensing elements.

This is why hackers love space hardware: it turns ordinary assumptions into failure modes. And it turns “basic”
measurement into real research.

What Episode 335 Says About Modern Hacking

• Automation is about reclaiming attention. From brewing to diagnostics, the goal isn’t lazinessit’s
  freeing your brain for decisions that matter.
• Resilience beats convenience. Surge protection, de-clouding hardware, and repairability all trade a
  little simplicity up front for dramatically better long-term reliability.
• Low-level knowledge still pays. Whether it’s decoding BLE packets, using a debugger on a battery
  pack, or dropping one assembly instruction into C, fundamentals are leverage.
• Policy is now part of the stack. What you can install, repair, or self-host increasingly depends on
  rules written far from your workbench.

Hands-On Experiences: My “Beer, Toast, and Pi” Weekend (Extra 500-ish Words)

The funniest thing about Episode 335 is how easy it is to accidentally recreate it in real life. You start with good
intentionsmaybe you’ll just listen while you tidy the benchand suddenly you’re living in a montage of small
problems that all feel strangely hackable.

For me, it begins in the kitchen. Brewing isn’t just “boil stuff and wait,” it’s a long chain of tiny checks:
temperature, timing, stirring, and the constant suspicion that you’ve forgotten something important. The automated
brewing segment made me think about the difference between craft and babysitting. I don’t need a robot
to choose my hops, but I would love one to watch the temperature while I clean up, label bottles, orlet’s be
honestsit down for five minutes without feeling guilty. The real win isn’t that the ESP32 is smarter than me. It’s
that it’s happier doing the boring part, and it never gets distracted by the smell of snacks.

Speaking of snacks: toast. The Butta Melta bit sounds like a joke until you’ve experienced the heartbreak of ripping
a beautiful slice of toasted bread because your butter is colder than your social life in February. I tried the “warm
mug” trick years ago, but the clip-on holder idea is better because it makes the system predictable. You’re not
improvising; you’re building a tiny thermal process. If that sounds ridiculous, congratulationsyou’ve understood
why hackers are fun at parties (and why we sometimes don’t get invited twice).

Then comes the “Pi” portion of the weekend: the moment you realize your little single-board computer is only as
reliable as the power feeding it. I’ve lost devices to sketchy adapters and mysterious brownouts, so the ZeusFilter
story hit close to home. Even if you never design mains hardware yourself, the concept of layered protection changes
how you build everything else. Better grounding, better power supplies, better separation between “dirty” and “clean”
power railsit’s not glamorous, but it’s the difference between a project that runs for a year and one that dies the
first time the weather decides to have opinions.

The battery reverse-engineering story is the one that lingers, though. I’ve thrown out electronics before because the
failure looked final. Episode 335 is a reminder that “dead” sometimes means “locked,” “confused,” or “waiting for the
right reset ritual.” That doesn’t mean you should poke lithium packs with a screwdriver like you’re defusing a movie
bomb. It means the best tool you can own is curiosity paired with caution: read, measure, document, and don’t accept
mystery as a permanent condition.

By Sunday night, I’m not building an EV charger transplant or decoding TPMS packetsyet. But I’m looking at my own
devices differently. Which ones are tethered to someone else’s server? Which ones can be repaired? Which ones need
better power hygiene? Episode 335 doesn’t just entertain; it quietly upgrades your instincts. And if it also makes
your breakfast more butter-friendly, that’s what we call a high-value engineering outcome.

Conclusion

“Beer, Toast, and Pi” sounds like the world’s nerdiest brunch menu, but Episode 335 is more than a pun: it’s a tour
of the modern hacker’s reality. We automate what we can, we harden what we must, we repair what manufacturers never
expected us to touch, and we keep one eye on the policies that shape what our devices are allowed to do.

If you like practical builds, real troubleshooting, and the occasional reminder that space engineering includes
bathroom telemetry, Episode 335 delivers. Just don’t be surprised if you finish the episode and immediately start
reorganizing your toolbox… or redesigning breakfast.

SEO Tags