Wow, what a project this has been! I knew from the start that it would be a big one, but it exceeded my expectations in every way: Complexity, cost, time investment, and, most importantly, the quality of the final result.
Electronically, its features are relatively modest, even if quite nice: Automatic control of the cooling system with many configuration options, addressable RGB LED control with optional full control over USB (at high refresh rates), external pump power for maintenance, and various safety features.
However, electronics weren’t the focus of this project – the main goal of the case was to look amazing while cooling the computer effectively. In my opinion, it absolutely excels at both.
Of course, this project wasn’t perfect – the cost of the case build (even without counting my time) exceeded the cost of the PC components inside of it, building the PC in the case was not easy due to some non-ideal design choices I made, and of course, the coolant channels ended up being a failure. If I were to build another case like this, I would make it more maintainable (using less glue), design some things differently, and either abandon the coolant channel idea or redesign it significantly for reliable sealing.
Despite these shortcomings, however, I think the project was a huge success. The result looks great in my opinion, I use it on a daily basis, it’s easy and fun to show to people, and it taught me a lot about designing and making things, both mechanically and electronically.
Very soon after the completion of the initial build, I noticed one problem with it that I hadn’t considered before. Due to the lack of air flow in the case, the motherboard’s voltage regulator modules (VRMs) around the CPU weren’t getting enough cooling. Reaching up to 80-90°C, they were technically still within the acceptable temperature range, but not by a large margin, so I wanted to improve the situation.
For this purpose, I decided to buy some miniature all-purpose liquid cooling blocks from Alphacool, along with some matching 5mm soft tubes and an adapter to incorporate them into the existing cooling loop. These small cooling blocks were attached to the VRM heat sinks using thermal pads (and some wire to hold them in place better later), and the loop was partially drained to allow me to install them safely.
Next, I attached the adapter before the CPU cooling block inlet, where it would act as a splitter: Most of the coolant would continue directly to the CPU block, while some of it flow through the small tubes and VRM cooling blocks first.
This was a relatively simple addition, but after testing and refilling the loop, it reduced the VRM temperatures significantly, down to a very comfortable 40-50°C under full load. Also, in my opinion, the extra liquid cooling components look great too.
Coolant Channel Failure
After the new case had already been in use and working nicely for multiple months, on one night in August 2022, I noticed that the LED edge lighting of the front and left acrylic panels started to misbehave, flickering seemingly at random.
I thought it might have been a bad connection, but once I reached down and touched the shelf below the case, I realised that it was the nightmare of every liquid cooled PC builder: The cooling loop had leaked, spilling coolant into the bottom of the case and onto the LEDs, causing their erratic behaviour. Of course, I immediately shut the system down and disconnected it from power, before starting to clean it up and investigate where this leak had come from.
I was quickly able to identify the source of the leak – it was a small pinhole in the front coolant channel, at one of the DCM-fused joints between acrylic layers. I wasn’t sure what to do about it at the moment, so I covered the area in lots of transparent epoxy, hoping it would be a one-time thing.
Well, it wasn’t. The patched loop did hold quite well for a few more months, but over time, more pinhole leaks started forming in both coolant channels, at an increasing rate too. Therefore, as much as I hated to admit it, I knew that the integrated coolant channels could no longer be trusted.
I implemented a temporary solution using a soft tube to bypass the coolant channels, while considering what to do as a permanent fix. In the end, I decided to try my luck at bending a long hard tube to replace the channels. Therefore, I bought a heat gun, a bending helper tool, and a silicone insert (to prevent the tube from buckling during bending), and after a little bit of practice on scrap pieces, I was able to bend a long acrylic tube into the shape I wanted!
I bought some multi-port fittings to mount the tube and incorporate it into the system, using rotatable fittings plugged with rubber to hold the new tube assembly in place on the coolant channels’ threaded holes.
After a partial loop drain, I mounted the new tube in the case and refilled the loop. While it didn’t look perfect, due to the now empty and useless coolant channels, I think it still looked quite good given the circumstances, and I’m glad I chose that solution.
Gradual Upgrades
A few months after all the leak trouble, the system was working nicely, but I could feel the CPU becoming a bit weak for some intense workloads. The old hard drive I was using also showed some signs of ageing. Aside from that, I wasn’t a big fan of the pump I bought – it wasn’t as quiet as I had hoped, and it struggled with the relatively large flow resistance of my loop (likely caused by its size and large number of fittings).
Therefore, I decided to upgrade the system in two ways – upgrading the PC itself, with a new motherboard, processor (i5 13600K), memory (32GB of DDR5), and storage (NVMe SSDs); as well as buying a new pump, a Laing DDC 4.2 PWM.
The new pump was certainly powerful!
I drained the loop completely and removed the old motherboard, before transferring the CPU and VRM cooling blocks to the new board. Afterwards, I installed it back into the case, replaced the pump with the new one (which was quite simple), tested the loop, and filled it again.
Annoyingly, the new motherboard I bought had some issues, so I had to replace it with a different model after a few weeks – requiring me to repeat a lot of this work. However, even after that, one problem remained: The CPU cooling block didn’t perform well on the new CPU. It seemed that the shape of its cold plate just didn’t fit the processor’s shape very well, leading to bad thermal contact – which was annoying, but not critically bad.
Another year and a half passed with the system working fine, until mid 2024, when I noticed the new pump having some trouble starting up. After draining the system and checking it out, I found the cause to be a deposit of small particles that settled out of the semi-opaque coolant.
Therefore, I decided that it was time for one more upgrade: I emptied the loop and cleaned the entire system thoroughly (disassembling everything I could), got the pump cleaned and running nicely again, and bought a new CPU cooling block (Alphacool’s Core 1 LT).
The reassembly and testing process was similar to before – I just added some more quick-disconnects for easier pump maintenance in the future, put everything back together, tested it for leaks, and refilled it with coolant. However, this time, I decided that I had had enough of the Mystic Fog coolant, and didn’t want a repeat of the pump getting clogged. Also, due to EKWB’s corporate trouble around that time, I really didn’t want to buy more of it. So I opted for pure distilled water this time, with some anti-corrosion and biocide additives to keep the loop safe and clean.
This is the current state of the project, at the time of writing. Let’s look back at it!
As the case was now ready for the computer to be installed in it, I excitedly pulled my existing system out of its (air cooled) case. I had been running a Ryzen 5 2600X processor, 32GB of DDR4 memory, an AMD Radeon RX 5700 XT graphics card, along with a hard drive and SSD, five case fans, and a sound card, all powered by a 600W modular supply.
None of these components were anywhere near the “high end”, and they definitely didn’t need liquid cooling to perform well – but that wasn’t really the point of this project anyway, and I was still happy with them, so I decided to keep using them for now.
The first step was to convert the processor to liquid cooling, by installing the CPU water block (Alphacool’s XPX Aurora Edge) on the motherboard.
Next, I had to do the same thing for the graphics card – however, this would be more complicated, as I had to carefully disassemble its stock cooler, apply new thermal paste and pads, before attaching the GPU water block (also from Alphacool, for my specific graphics card model).
With that, I could start building the computer back up, starting with the power supply. It was a relatively tight fit to get it under the shelf, but it matched up with the mounting holes nicely. Afterwards, I could install the HDD cage into its designated spot.
After screwing some threaded spacers onto the inner wall, I mounted the motherboard in the case – relieved to see it line up with the mounting holes and I/O panel perfectly.
I inserted the sound card back into the board, confirming that PCIe card mounting worked as expected too, and installed the PCIe riser cable for the GPU onto the shelf. With some motherboard cables connected, and the GPU inserted and screwed into place, the build started to come together nicely.
What didn’t look quite as nice was the cable mess in the back, especially after installing and connecting the HDD and SSD and routing all power and RGB connections. This could have been improved, by using custom-length cables and/or putting lots of effort into cable management – but considering how much time I had already put into this project, I honestly couldn’t be bothered. After all, I designed this cable routing area to be opaque and hidden for a reason.
From the visible side, however, I really liked the look of the build, especially with the addition of the remaining coolant tubes.
The only parts of the original build that I hadn’t reinstalled were the CPU air cooler and the case fans, for obvious reasons. However, since I already had those case fans available, I could use four of them for cooling the radiator – after adding some mesh under them to prevent dust from blocking up the radiator fins.
For the coolant, I thought about different options for a while – I could use colourless clear coolant, as recommended by most liquid cooling enthusiasts, but that felt a little too boring for the start. Colouring the liquid was also not great, since it would favour a certain colour scheme, which I didn’t want to do. Therefore, I decided to get something more fancy – EKWB’s Mystic Fog, a semi-opaque white coolant.
After another check for potential leaks, I filled the loop with the new coolant, using the external power supply to run the pump.
With that, I could move the PC setup to its designated spot and connect all the peripherals and other cables to the back I/O panel.
And finally, it was time to power the computer up! I was so excited to see it start up nicely and light up in pretty RGB colours immediately.
That concluded the initial build of this project, and I was incredibly happy with how it turned out. However, this wasn’t be the end yet – over the following months and years, there would be more improvements and fixes to come.
Once I had the finished design, I ordered all of the parts for the case and cooling system. After spending a painful amount of money (for a student), and a bit of waiting, I had everything I needed.
The acrylic panels arrived covered in protective foil. I would have loved to leave that foil on them as much as possible, until the very end, but unfortunately, they had a very intense unpleasant smell from the factory – so I unwrapped them all and washed them thoroughly.
One of the first things I could do was to test fit the translucent logo in the inner wall – which worked perfectly, making me feel quite hopeful about the rest of the build.
After performing more test fits, I could practice my DCM gluing/welding method a little more, by assembling some more of the small pieces I would use later.
Cover panel with LED hexagonFront panel shelvesReservoir LED bar
The next task was to begin the main case assembly. Due to the size and flexibility of the large acrylic panels, it was a bit annoying to get them all into place – at least I added some engraved guiding lines on the inside, to help me line up the panels exactly in the right places.
Once I had three perpendicular walls tacked into place using DCM (bottom, back, and inner wall), the structure became relatively stable – allowing me to easily add the inner front wall, shelf side wall, and inner top wall as seen in the right picture, reinforcing the structure quite a lot, enough to no longer worry about it breaking or bending.
Having gained a bit more experience with the DCM method, it was time to work on the transparent walls, starting with the integrated coolant channels.
Once they were assembled, I tested them for airtightness, before placing and tacking the front and top walls onto the case structure, along with the front panel (connecting top wall and top inner wall).
To reinforce the structure even more, I decided to add some acrylic epoxy glue, to not just rely on the DCM bonds/welds.
Most of it was in the cable management area, as it’s hidden from sight there, and holding the large inner wall, which would be the most load-bearing wall of the structure. I also used the same glue to attach some threaded posts for holding the controller and logo LED PCBs. The same glue was also applied (wherever possible) at the box joints between the four fixed outer walls.
With the fixed case structure complete, I moved on to the electronics assembly.
The front panel PCBs were rather quick and easy to solder, including all necessary connectors, buttons, and some screw terminals to hold the PCB in place later.
Raw PCBs: First revision, Assembled PCB: Second revision with some fixes
The front panel also needed some cables: One to the controller and two that go to the motherboard (general front panel connectors and front panel audio). Since the motherboard cables would be partially visible later, I went with only black wires for them (and some black shielded speaker cable for the audio signals) – so I needed some labels to keep track of the wires during assembly.
For the addressable LED lighting, there was of course the dedicated logo LED board, as well as the small LED bars. Assembling them took some effort, since I needed a total of 17 such LED bars plus the logo, so over 150 individual LEDs in total.
Some of the bars were connected into straight sections as shown (three for the reservoir, four for the front wall, and 3+1 for the left wall), and the remaining six were arranged into a hexagon for the shelf accent light.
For the acrylic panel edge lighting, the corresponding LED bars were mounted on the decorative corner profiles, where I had left some space for them in the design.
In order to test and confirm that all of my LEDs work, I used an independent addressable LED controller. I particularly loved the edge-lit engraved design immediately – that was a really good design choice.
Finally, it was time for the controller PCB. I checked out the original version I ordered, which looked great… until I noticed a big mistake: I had accidentally used the wrong footprint version for the main microcontroller. Another order and some waiting later, I got the corrected version, allowing me to start assembling it.
Original versionMistake fixed…
The assembly process was essentially the same as in my past projects (starting with “difficult” fine-pitch parts, working my way up to bigger/easier ones, while keeping track of which parts may block soldering access to others). Therefore, I won’t show it in detail here. The finished board looked quite nice though.
With part of the front panel, LEDs, and corner profiles installed, the case was starting to look more and more complete.
Around this time, I also received the sheet metal parts for the back I/O panels. They looked quite nice from the start, but were made of bare steel – which didn’t fit the case visually, and of course would be quite susceptible to corrosion.
Therefore, I spray painted them black to protect them and match the rest of the case, before installing them onto the back wall.
Next, I decided to construct some cables that I would need for the build. To begin with, I needed a large compound cable to connect the case controller to the cooling system components outside of the case (pump, fans, flow meter, temperature sensor, and external power supply).
I started by choosing and cutting all of the necessary wires, and feeding the signal-related wires through some shielding (which may be unnecessary, but won’t hurt to have). Then I put a nice-looking braided sheath around it, fixing it in place using heat shrink, before finally stripping the wire ends and attaching all the necessary connectors.
Aside from that, I needed a short internal USB cable to connect the controller to the motherboard, as well as a better-looking PCIe power cable for my graphics card.
The former was easy to make, similarly to the previous one. For the latter, I wanted it to match the look of the braided cables I’d be using for the rest of the PC – so I had to cut individual wires, crimp and braid them, and join them together at the power supply connector (made for the specific modular power supply I was going to use).
With a USB connection to the controller PCB, it was time to program the case controller firmware. For one, this included various safety and cooling control features, configuration and status reporting over USB, and so on. Aside from that, of course, it featured the RGB LED control – here you can see me testing various LED lighting patterns, as well as a “full USB control” mode, which would allow each LED’s colour to be set individually by software running on the PC, more than 30 times per second.
Full LED control through USB – tested with a binary counter and random colours here.
Up next were the fixed parts of the coolant loop: A hard tube (acrylic tube) from the case inlet to the front coolant channel, a small soft tube between the front and top coolant channels, the reservoir, as well as another hard tube from the reservoir outlet to the case outlet.
I decided to use hard tubes where possible here, as they definitely look nicer than soft tubes, in my opinion – but I’d still opt for soft tubes for tight spots (like between the integrated channels) or variable off-angle runs (i.e., for the PC components). Theoretically, hard tubes can be bent into almost any angles and shapes using heat, but I decided to not deal with that here, just using straight and pre-bent hard tubes that I cut to length.
With these cooling components and the remaining PCBs in place, the base structure of the case was complete! I was really happy with how it looked already.
Now I could turn my attention to the hidden parts of the cooling system. First, I built a little box out of plywood (glued to the inside of the shelf) to house the pump. For noise reduction/damping, I stuffed it with plastic wool (left over from the BlockBox v2 project), and added a similarly damped removable lid.
Next, I mounted the radiator to the back of the shelf using some angle brackets. This ensured a firm mount and easy access for cool air to be drawn through the fins.
I attached the external power supply to the pump box lid and connected an outlet tube to the pump, threading the lid onto it for easy mounting. After inserting the pump and closing the lid, I could attach the secondary reservoir and drainage port near the pump inlet, as well as the flow rate and temperature sensor between the pump outlet and the radiator.
With just a few more long soft tubes and quick connect fittings, the bottom part of the cooling system was complete as well. This meant that I could finally place the case on top of the shelves and connect it (both the coolant inlet/outlet and the electrical cable).
Finally, I completed the coolant loop by attaching the CPU and GPU cooling blocks with some more soft tubes. Of course, they were not attached to any PC components yet, but this allowed me to close the loop, test it for any potential leaks, and even fill it with some liquid (pure distilled water) for the first time, thanks to the external power supply!
Throughout the case design process, I figured out quite quickly that I would need four different circuit board designs for this project: A front panel board, two kinds of LED boards (straight LED bars and a special board for the logo LEDs), and a central controller board for the case.
The front panel board’s job was to house the reset button, front panel audio connectors (with plug-in detection capabilities), drive activity LED, and power LED control. The front panel USB connectors and power button would be mounted separately. The reset button was trivial – literally just a tactile button (with high actuation force, to prevent accidental presses), and a header for connecting it to the motherboard.
Front panel audio was quite simple in itself too, as the audio signals were just routed from the internal HD Audio connector to the 3.5mm jacks. However, plug-in detection was more complicated, as the HD Audio standard assumes isolated switches (separate from audio pins) for plug-in detection, which I couldn’t find fitting 3.5mm audio jacks for. Therefore, I added some solid-state relays to “translate” between these two detection methods.
As I wanted the drive activity and power LEDs to be colourful (RGB) too, just like all other case lights, I added a connector for receiving the colour PWM control signals, some buffers (inverters) for them, as well as solid state relays to allow the motherboard to control the on/off state of these LEDs.
The PCB was designed in tandem with the physical case design, resulting in a slim rectangular board.
As for the LED boards, they’re functionally quite simple, so the schematics are barely worth mentioning – they’re just strings of addressable RGB LEDs (Adafruit NeoPixel Mini Black), with input and output connectors (or solder pads) for easy chaining. Due to their simplicity, I decided to design these in Fusion 360’s built-in PCB design tools, instead of using EAGLE.
Straight LED bars (50 x 5 mm) for most of the case’s lightingSpecial board to perfectly light the translucent logo
Finally, the controller would be the most complex PCB of this project. It had multiple tasks: Controlling and monitoring the coolant pump, radiator fans, and coolant flow rate and temperature, controlling all RGB lighting in the case, communicating with the PC over USB, and some safety features.
As its centrepiece, I decided to use a PIC32MZ EF microcontroller, as it was a relatively powerful option that I was already familiar with from the BlockBox v2 design.
This central controller would interface with pump, fan, and flow rate tachometers and PWM signals using some transistors, provide addressable RGB control outputs for up to three separate LED chains (using a level shifter), and measure the temperature using the controller’s analog-to-digital converter. Configuration of all features would be done using USB, from the PC itself.
If any of the measured values (pump/fan speed, flow rate, temperature) exceeded certain safety margins, the user could first be warned using a buzzer, and in extreme cases, a solid state relay would be actuated to force-shutdown the PC, to prevent overheating.
Finally, I added another feature: The ability to power the coolant pump without turning on the PC, using a separate external 12V power supply. This would be extremely useful for filling and maintaining the cooling system. To enable this, the pump’s power source would be selected using a relay on the controller board.
Making a circuit board out of this was relatively simple, as I didn’t have any strict size or layout constraints. For additional power handling capability (for pump, fans, and LEDs), I added a SATA power connector, along with some pin headers to distribute power (for example, to LEDs).
For anyone interested, the design files are available on GitHub here. Note that, as usual, they’re not necessarily great for direct re-use.
For the case design, I started with the basic wall structure, consisting of four fixed walls (top, bottom, front, back) and two removable side panels (left and right), as is typical for PC cases, as well as a central dividing wall, which would hold the motherboard later. As planned, the top, front, and left sides would be made of clear acrylic, with black acrylic used for the others.
I chose a case size of 50 x 50 x 27 cm, which was quite large for a PC case, but I had the space for it and really didn’t want it to end up cramped. The width was mostly dictated by wanting to have enough cable management space in the back, as well as comfortably fitting a vertically mounted GPU on the left side.
The edges between walls were covered with corner profiles (made of plastic and aluminium), which also served as the “rails” holding the side panels. The placement of the power supply and HDD cage were easy too, so I placed them down right away.
The power supply got a corresponding cutout in the back, with mounting holes allowing it to be placed with the fan facing up or down. For downwards fan placement, I also added a matching cutout in the bottom panel. You can also see here how I added a kind of box joint at the intersections between fixed walls, allowing for a stronger bond between them later.
With the mock-ups for the motherboard and vertical GPU added, I now had a baseline for designing the rear I/O panels, which would be sheet metal parts designed according to the ATX and PCIe standard requirements, as discussed in the previous chapter. The empty space on the main I/O panel was filled with a hexagon hole pattern, to allow at least a little bit of airflow into and out of the case.
Additionally, I added the lower “shelf” you can see inside the case – this would serve as a mount for the vertical GPU, but also as an aesthetic cover for the HDD cage, power supply, and corresponding cables.
Looking at the empty space on the bottom of the front panel gave me my first idea for an aesthetic lighting feature: An engraved design and logo in the transparent panel, with LED edge lighting from below.
The positions of all the main PC components were fixed at this point, so I could start designing the cooling loop. As stated in the introduction post, I wanted an external radiator, placed out of sight – same for the coolant pump. Therefore, the case itself would only contain the CPU and GPU cooling blocks, a reservoir, and coolant tubing (some of which would be replaced by channels integrated into the front and top walls). To connect it to the external components, I added two quick-disconnect fittings on the back.
Next, it was time for some more aesthetic LED features – a hexagon accent and logo made of translucent acrylic, an LED bar behind the reservoir, as well as a few more engraved edge-lit features in the left wall. Also, you can see that I added some cutouts in the dividing wall around the motherboard, for routing cables.
Another important part of any PC case is the front panel, which provides the power and reset buttons, the disk activity indicator, and connectors for USB and audio. Here’s the design I came up with, on the top right of the case.
Behind the right panel, the design looked like this. Lots of cutouts and space for cable routing, access to the HDD cage, some 2.5″ SSD mounting spots, small acrylic “shelves” for the front panel electronics, and three circuit boards (logo LEDs, front panel, and case controller), which I will go into in the next chapter.
At this point, there were just a few details left to add – for example, rubber feet to support the case (while leaving an air gap for the power supply), as well as small rotatable pieces on the back side to lock the side panels into place.
With that, the basic physical design of the case was complete, and I loved how it turned out.
For the external cooling components, I found some simple square shelves, into which I could integrate a large square radiator (an Alphacool 480/560mm unit), a small additional reservoir, a drain port for emptying the loop, a flow and temperature sensor (Aquacomputer high flow 2), as well as a sound-dampened box for the coolant pump (initially designed for the Jingway DP1200PWM).
Placing the case on top of the shelf and connecting the external components resulted in a nice-looking overall system, with most of the “visually unpleasant” components hidden away.
As the main goal of this project was to house PC components and be a functional case for them, the design process was a little different from my usual project designs: Here, I had to follow certain standards (mainly the ATX and PCIe standards) in order to make standard PC components fit inside and have their connectors be accessible on the outside.
Therefore, I’d have to start with a significant amount of planning in CAD – starting with the central PC component, the motherboard. I created a Fusion 360 mock-up of a simplified motherboard, with its mounting holes, I/O shield, and PCIe expansion cards based on the standard specifications. This would allow me to easily transfer sizes and positions from this mock-up to my case design, ensuring the case fits all standard specifications.
I made similar mock-up designs of a standard ATX power supply, a stand-alone PCIe card, and an HDD cage (which I salvaged from an old PC case).
Because of the design of the motherboard and expansion card I/O panels, I knew that the corresponding case wall would likely have to be made of sheet metal, as is typical in most PC cases: It needs to be quite strong (as it holds the cards, for example) and thin (to not get in the way of connectors).
My first idea was to build a majority of the case out of sheet metal, with some other material for the transparent walls – however, I quickly discovered that single-quantity custom sheet metal parts are quite expensive, so using them for most of the case would blow up the project cost beyond any reasonable budget.
Therefore, I decided to keep the sheet metal parts to a minimum (rear I/O only) and switch to a different material for the rest of the case: Laser-cut acrylic plastic. While plastic isn’t perfect for PC cases (no EMI shielding, not fire/heat resistant, thermally insulating), it allows the project to be much more affordable, while being visually pleasing and solving the question about transparent wall materials.
I had two more ideas that would be fun with acrylic plastic, but they would need to be tested first: Laser engravings (for lighting and visuals), as well as building coolant channels into the transparent side walls of the case. So before continuing my design, I ordered some test pieces to be laser cut out of transparent acrylic.
The first thing I wanted to see was the quality of the engraving, as well as what different engraving options (offered by Sculpteo, the laser cutting company I chose) would look like in real life.
For testing the idea of integrated coolant channels, I had to test two things: Whether I could glue acrylic layers together sufficiently well for that, and whether I could tap threads for fittings into the acrylic pieces. Threads turned out to be quite easy using a corresponding tap, assuming the hole size was chosen well.
Gluing acrylic layers together was much more difficult. I tried a special glue called Acrifix, but I didn’t like how it behaved for small parts (especially hollow ones), and also it had an extremely unpleasant smell, making it very annoying to work with. Another method I found online was solvent bonding using DCM (dichloromethane), basically dissolving a bit of the plastic at the boundary between two pieces, welding them together – so that’s what I tried next.
Initial attempts to make some small test “cups” looked promising – the layers stuck together quite well, though sharp corners were prone to cracking.
They seemed to be watertight as well, having no obvious leaks. To make sure, I filled them with ink, which revealed that one of my test pieces was not watertight on the inside edges – but it did still seem to hold on the outside.
While this “partial” seal didn’t instil much confidence, I decided to carry on with my other test: Making some actual test channels and checking them for airtightness.
I ordered a leak testing tool from Alphacool, designed for PC liquid cooling. Using it on the channels (with one end plugged) showed that they seemed to be perfectly airtight, which was good enough for me, so I decided to carry on with that idea.
In hindsight, I should have been more suspicious of the “partial seal” I noticed earlier – but at this point, I was blissfully unaware of that. Therefore, satisfied with the test results, I started designing the case itself.
Following the successful completion of the CO2 Station project in late 2021, I felt quite eager to start the next thing right away, so I started looking for ideas. With how practically useful the CO2 Station ended up being, I wanted something similarly useful to me.
One thing, which had been on my mind for years, was to make something nice for my main daily tool and workplace – my PC. Namely, I always dreamed of building a liquid cooled PC, but it just never felt worth it by itself. But what if making it a project could change that?
Anyone who knows me wouldn’t be surprised by where this was going: I wanted to take the “liquid cooled PC” idea to another level. Namely, I was going to build my own custom PC case, designed entirely for liquid cooling and a unique look. In short, I decided on the following basic ideas:
Full custom liquid cooling (CPU and GPU)
External radiator, hidden out of sight
Main case with three transparent walls (left, front, top)
Fully addressable custom RGB lighting
Custom RGB/Fan/Pump controller with USB configuration
And so, the Liquid Cooled PC Case project was born. While my previous projects had been mostly electronics-based, with electrical engineering being the main discipline and complexity of their designs, this one would be quite different – I’d need to dig my heels in and get much better at mechanical design and building things like this.
To summarise this project, let’s make a list of features, as I did with my previous projects:
High-accuracy CO2, temperature, and relative humidity sensors
High-resolution, low-power 3.7″ E-Paper display
Built-in clock and calendar
Configuration and charging over USB
Two user buttons and status LED for easy interaction and self-calibration
Configurable timed standby mode
Very long battery runtime between charges (up to multiple weeks)
In short, I achieved or exceeded all of the goals I set for this project – it was a complete success. And in addition to that, it taught me a lot about low-power designs, EPD technology, sensor technology, and building smaller devices.
I’ve been using the CO2 station ever since, having a dedicated spot for it under one of my monitors, so that it’s always in view. I especially love how it ended up being a “set and forget” device most of the time – all it needs is an occasional charge and clock adjustment (about once every 3-4 weeks, with my settings and 8 hours of standby per day), as well as a quick calibration in outside air once every 3 weeks.
What doesn’t feel great is having to continuously increase the calibration reference value over time, as the atmosphere’s CO2 concentration rises…
So in conclusion, I am extremely happy with this project. This was the first time I completed a project and didn’t have the feeling that it was lacking something (compared to my initial imagination of it). Even multiple years later, at the time of writing, I feel like there aren’t too many things I’d change if I were to design another CO2 Station now.
As mentioned, I designed the enclosure for this project to be CNC machined out of plywood – I won’t show the process of that here, since it’s essentially the same as I showed for the BlockBox v2. After some basic post-processing, I was left with six beautiful enclosure walls – only blemished by some delamination of the plywood near the top and bottom side countersinks, but that’s easy to fix with some small wooden chips (or just ignore where it’s not visible).
Five of the walls (all except the back) were glued together using wood glue, forming a strong box, which fit the electronics assembly very nicely. Some matching screw holes in the side walls hold the PCB in place using its soldered screw terminals. For an easy USB connection, a USB Micro-B jack was glued into the the side and wired to the board, and the SCD30 module was installed on a long pin header.
The back side of the enclosure received four small wooden blocks with threaded inserts, allowing it to be screwed in securely, while still being easily removable.
And with that, the CO2 Station was fully assembled, and looking great, in my opinion!
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.
