Project Logs

Collapse

• Final Log — Completed

  Markus Hüttner • 04/18/2026 at 23:47 • 0 comments

  The build is complete.

  The system runs stable, all components are in place, and the device behaves as intended.

  There are still ideas for future extensions.

  Different CRT color profiles.
  Streaming audio via SSH.
  External modules, possibly even a Geiger counter.

  All of that is possible.
  None of it is necessary.

  For now, the device does exactly what it was built.

  Thats enough.

  ***

  Thanks to my family ❤️ who gave up many hours while I was down in the basement working on this. 

  Thanks to AkselK. for printing the custom power supply enclosure.

  Thanks to RF-Elektronik in Augsburg for supplying all the small parts — one of the few remaining local electronics shops where you can still buy solderable USB connectors, waterproof switches, and countless other essentials at fair prices.

  Thanks to Enzo for lending me the multitool. It didn’t survive — but don’t worry, what you get back is brand new.

  Thanks to the developers of cool-retro-term — a great window into another time.

  Thanks to ChatGPT — without it, I wouldn’t have been able to write a single script.
  

  And thanks to all friends who patiently listened to my long explanations about this project. ;-)

• Final Assembly — Internal Layout

  Markus Hüttner • 04/17/2026 at 20:37 • 0 comments

  This stage was mostly about fitting everything into place.

  Wiring, routing cables, and making sure each component had a defined position inside the enclosure.

  The internal structure is kept simple.

  No shared ground bus.
  All connections are point-to-point.

  Two separate power domains:

  5V for Raspberry Pi and display
  12V for the amplifier

  Both switched independently.

  The display module is mounted as a sealed unit behind the front window.
  All other electronics are contained in separate compartments.

  The goal wasn’t visual perfection, but clarity and accessibility.
  Every connection can be followed, and components can be accessed if needed.

  Once everything was in place, the enclosure was closed and the system tested as a whole.

  From that point on, there were no further changes to the internal layout.

• Designing the CRT Interface and Boot Sequence

  Markus Hüttner • 04/09/2026 at 20:27 • 0 comments

  While the hardware side of the project is still in its final integration phase, a lot of time went into something less visible — the user interface.

  From the beginning, the goal was not just to display information, but to create something that feels like a real system.

  The CRT-style terminal interface is not meant as decoration.
  It’s an integral part of how the device communicates its state.

  Instead of hiding everything behind a graphical UI, the system exposes what it is doing:

  • startup sequence
  • service initialization
  • connection status
  • playback activity

  The boot process became an important part of that experience.

  Rather than jumping straight into a finished interface, the system goes through a staged startup sequence that resembles older terminal-based systems.

  This includes:

  • simulated system messages
  • delayed output to create readable progression
  • visual feedback during service startup

  It doesn’t make the system faster.
  But it makes it understandable.

  The idea is simple:

  A device should not feel like a black box.

  It should show what it is doing.

  Technically, the interface runs in a minimal X session with a lightweight window manager, launching a CRT-style terminal environment.

  A custom script controls the startup sequence and hands over to a live system log view once the system is fully operational.

  The result is something between a diagnostic terminal and a user interface.

  Not designed to be efficient —
  but to be readable, transparent and alive.

• Building a Sealed Speaker System

  Markus Hüttner • 03/27/2026 at 15:11 • 0 comments

  After abandoning the idea of using a commercial speaker, the project took a more complicated turn: building a custom audio system.

  There was one immediate constraint:

  Space.

  The enclosure had originally been designed around the very compact form factor of the JBL Flip 4.
  Replacing it with something custom meant working within dimensions that were never intended for a proper speaker system.

  On top of that, this was my first time building a speaker enclosure:

  And it wasn’t just about sound.

  The system had to survive in a sealed, weather-resistant unit.

  Which raises an obvious problem:

  Speakers don’t like water.

  One of the first questions was how to protect the speaker membranes from moisture without completely killing the sound.

  After some research, I found that there are dedicated outdoor speaker fabrics designed to be water-repellent while still allowing sound to pass through.

  I ordered samples — four different shades of grey.

  Conveniently, they turned out to be large enough to actually use in the build.

  That solved one problem, but introduced another:

  Which one should I use?

  The next issue was even more fundamental.

  The control electronics sit directly behind the front panel — exactly where water exposure is most likely.

  And right in the middle of that panel is a critical component: The volume potentiometer.

  
  It has to remain accessible and mechanically usable.

  But at the same time, the enclosure needs to resist rain and splashes.

  Sealing a fixed surface is easy.

  Sealing a moving shaft is not.

  At this point, the project became less about assembling components and more about solving small, very practical problems.

  How to protect moving parts.
  How to keep water out without trapping moisture inside.
  How to make something robust without overcomplicating it.

  
  The speaker system ended up being a balance between acoustic performance, space constraints and environmental protection — with no prior experience to rely on.

  Which, in hindsight, was probably the most interesting part of the build.

• From JBL Flip 4 to Custom Audio System

  Markus Hüttner • 03/27/2026 at 14:30 • 0 comments

  The goal for the audio system was simple:
  it had to be compact, reasonably good sounding and — most importantly — robust enough for a sealed, weather-resistant enclosure.

  At first, a commercial solution seemed like the perfect shortcut.

  A used JBL Flip 4 checked all the boxes:

  • acceptable sound quality
  • inexpensive and easy to source
  • built-in battery
  • and a 3.5 mm input that could be connected directly to the Raspberry Pi

  On paper, it looked like the ideal solution.

  It wasn’t.

  The moment I opened the enclosure, things started to go wrong.

  The battery was completely worn out and had to be replaced.
  That wasn’t unexpected — so I ordered a replacement and started disassembling the unit.

  That’s when I discovered the real problem:

  The original battery had expanded to the point where it was mechanically locked inside the housing.
  It couldn’t be removed by normal means.

  There was no safe way to pull it out.

  In the end, the only option was to remove it piece by piece — essentially drilling it out until nothing remained but black, unpleasant-smelling residue.

  Not exactly the kind of procedure you want to perform on a lithium battery.

  Still, I went ahead and installed the new battery.

  And that’s where the real failure happened.

  The device was completely dead.
  No power, no response, no charging — nothing.

  That was the end of the Flip 4.

  At this point, the idea of reusing a commercial speaker had clearly failed.
  Between the degraded battery, the tight integration and the lack of serviceability, it simply wasn’t a viable solution.

  So the project took a different direction.

  The question became: what is cheap, available and actually designed to produce sound?

  The answer was obvious — old PC speakers.

  I found a used set from Yamaha.

  And Yamaha, at least, knows something about audio equipment...

• Concept & Design Philosophy

  Markus Hüttner • 03/26/2026 at 20:53 • 0 comments

  The original idea was simple: build a radio.

  But I didn’t want another Bluetooth speaker or app-controlled device.

  I wanted something that feels like a real piece of equipment — something with weight, purpose and physical interaction.

  No touchscreen. No menus. No abstraction.

  Just switches, indicators and direct control.

  The design evolved into a sealed field unit with an industrial look.
  Something that could plausibly exist in a lab, a bunker or a remote installation.

  Interestingly, when I showed it to someone for the first time, the reaction was: “This doesn’t look like a radio. It looks like you’re controlling a nuclear facility.”

  That wasn’t the goal — but it turned out to be a pretty accurate description.

  From a technical perspective, the device is based on a Raspberry Pi running a streaming client, combined with a custom-built audio system and a CRT-style terminal interface.

  Every interaction is handled through physical controls.
  The system gives immediate feedback — visually and physically — without relying on modern UI concepts.

  The result is something between a radio, a terminal and an unknown industrial device.

View all 6 project logs