I've been working a few projects that require controlling a PC 4-wire (PWM) fan from an esp32 running ESPHome.  One of them is an exhaust fan for my Bambu H2C, which I want to automate based on the printer state.  This is all stuff that is working on my Bento style filter (v2 - yet to be released), so I know it can be done.  The exhaust fan is not however an apples to apples design compared to the working Bento style filter v2, since the exhaust fan will use a 4 wire PWM fan, while the Bento style filter uses 2 wire fans (and controls their speed using  MOSFETs).

It turns out, the PWM control of a fan from an ESP32 is a bit more difficult than just turning a 2 wire fan on or off (or even controlling the speed on a 2 wire fan).  PWM fans should be more efficient than switching a MOSFET to control a 2 wire fan though.  What I've run into are several problems related to the PWM and tach for a 4 wire fan, controlled from an ESP32.  These problems (that I know of so far) are the following:

1. Not all PWM fans shut off completely based on the PWM signal alone.

2. The tach readings can be off by quite a bit.

3. On one of my fans, I noticed that there was a small current backfeeding through the tach line, with the fan's ground disconnected.

I am no electronics expert, but here is what I did to work through each of these issues.  For the first problem of the PWM signal not fully shutting down a fan, that seems like a known aspect of how PWM fans operate.  I learned that most fans will not fully turn off based on a zero duty cycle PWM signal, and will continue to run at some very low speed instead.  There is probably a reason why most of the Arduino or ESP32 fan control tutorials use Noctura fans too.  It's because most Noctura fans do actually shut off completely when the PWM goes to a zeroed out duty cycle, so they're almost like a cheat code if using fans with ESP32's or Arduinos.  I think if I were able to use a Noctura fan for this project, I'd just do that and save myself some headaches.  But I need to use an Arctic 8038 12v fan for the exhuast system, and it does not fully shut off when the PWM signal goes to zero.  

I decided to use an n-channel MOSFET board to control the fan's ground (low side switch), and add a control pin to the ESP32 to cut the fan's ground when it was "off" according to the program.  This is not the best fix, since I learned that fans are tricky, and can suck power from other places if they really want to.  While the MOSFET worked on my Arctic 8038 fan to shut it down, it did not work on another 120mm fan I used to bench test the setup.  I use a 120mm fan to test since the 8030 is a scary finger eating monster at 10k, while the 120mm fan is relatively a kitten at full speed.  The 120mm fan however was pulling a small current through the tach line, which was resolved when the tach line was cleaned up a bit in the next part.

​So the fully shutting off problem was mostly fixed, except for the 120mm bench testing fan which I didn't really care to much about, but the tach readings were still off.  My understanding is that the PWM fans use a tach which is an "open collector" so they only pull the line low to signal.  Without adding a pull up resistor to some voltage like 3.3v or 5v, the tach is just waving a white flag to signal, on a snow covered mountain.  The additional voltage gives the background some color, so the ESP32 can read a signal off the fan's tach line.  I was originally using a 10kOhm resistor to 5v (pull up) off the ESP32's GPIO 7 to read the fan's tach line, but that was not working well.  I then found the following helpful post which explained that using a voltage divider network to limit current and drop the tach line to around 3v at the ESP solved some odd tach readings that author was getting:
https://www.paulkeeble.co.uk/posts/tachometer/

I followed that post and added a similar resistor network as follows:
12v ---- 4.7kohm ----- TACH pin from fan ----10Kohm ----- GPIO 7 (tach read pin pn ESP32) ---- 4.7kohm ---- GND

The tach values still bounce a bit, but they are very close to what I expected, and reasonably stable.

Finally, the last issue was the tach line backfeeding on the 120mm bench testing fan, which was also solved by adding the resistor divider network, so two birds with one stone there.  Here is an image of the backfeeding current before the resistor divider network was added.  This is with the fan ground disconnected (via the n-channel mosfet cutting the fan ground), and zero pwm signal being sent to the fan.  The fan in this test should have been off but was spinning slowly.  In this config, the tach line was connected to the ESP32 on GPIO 7, and there was a 10kOhm resistor to 5v as a pull up so the tach signal can be read by the ESP32.  The ESP was registering 0 RPM as displayed on the OLED in the background (it did show an rpm value when it should be on high or low, but not when "off", though the fan did still spin slowly when "off").  The fan was pulling just a tiny current from the ESP32 while spinning slowly, though it did show the max was 27.4mA! (which I didn't actually catch when it happened so I'm not really sure about that value).  In any case not good.  In contrast, the 8038 monster fan which I intend to use for the project was only showing 0.0003mA (so nothing), when I ran this same test.  I think this would have been OK in the specific case of using the 8038 fan, but not so great in the general case of just using any PWM fan.

I didn't re-test this setup after the resistor divider network was added, but the 120mm fan stops when it should be off now (and that is with the MOSFET cutting the fan ground when "off", along with zero PWM signal).

That's all I have right now for this project, but the fan control is working much better after the changes mentioned here.  I'm adding this here as much for myself to review, in case I hit this problem again.  A big thanks goes out to https://www.paulkeeble.co.uk/ for sharing the tip on tweaking the tach line for better values.  

Again though, I'm no electronics expert, I'm just working my way though the problems as I see them with this project, and thought I'd share what I've done so far.  Do your own research, and use your best judgement if you try anything similar.

Update 8/3/2026:  After further pondering, I think I need to drop the low side switching and instead switch the 12v for the fan. Switching the ground may work for my particular fan, but it could be problematic in a more general case.  I decided to try a relay instead of the MOSFET, which I settled on due to the complete lack of good P-channel MOSFET modules for the ESP32.  I have several of these 3.3-6v relay boards ordered from AliExpress, which will take a week or so to arrive, and then I can get testing again.  I've already designed a rough footprint of that relay board, and it should fit inside the existing in-line exhaust fan housing, which is a plus.  Using a relay over a MOSFET is kind'a a bummer, but I don't really see a better choice unless I want to roll my own board (which I don't).  The relay should be OK though for this project, since it only needs to switch on and off few times to disconnect the fan after a print, or turn it back on before one.  The PWM will be handled separately using the fan's own internals.  

I needed a small 12V fan to cool an network device which has to live outside (in the heat of summer), and found a neat little controller on AliExpress (also on Amazon), which can operate a PWM (4-wire) PC fan based on temp set points.  It is pretty simple to program, but I found the default settings work pretty well.  The one I bought has a small temp probe which can be mounted using a screw, though for my application I just taped it to the device that was being cooled.

I made a simple 3D printed stand to hold the fan, a DC connector and the controller, which assembles with four M4x40mm FHCS and M4 locknuts.  I added a pair of 2 port WAGO's to keep the wiring simple (no soldering).  I haven't posted it yet, but when it is, I will update this post with a link.

7/31/2026:  I decided to add a dual fan version of this, which should work for larger routers.  I still need to get these uploaded though.

8/6/2026: I had to shrink the dual fan version by 2mm to fit it on an X1/P1 size printer bed, but there is plenty of room so nothing was given up to do that.  The current version is now uploaded to MakerWorld:

https://makerworld.com/en/models/3142511-temperature-controlled-12v-pc-cooling-stand#profileId-3548341

https://www.printables.com/model/1802241-temperature-controlled-12v-pc-cooling-stand

I've been testing a prototype (update) of my "Bento Box" style filter, which uses a neat ESP32 dev board that integrates a couple MOSFETs (perfect for fan control), and a nice 5v buck and 3.3v regulator.  Overall the board has been working well, but I really hated soldering the thin wires I was using to it.  I really suck at soldering, so I thought I'd try building a breakout board to slap on the dev board and make the connections somewhat simpler.  It still requires soldering, but soldering headers is much simpler than dealing with the thin wires I was using (due to an I2C hub that used JST-SH (1.0mm pitch) connectors.  Anyway, the last time I designed a PCB was when Eagle was the tool to use, and it seems that the baton has been passed to KiCad.  I'm sure Eagle was just as frustrating to get started with as KiCad has been, but if you ever use it, I have one suggestion - get the "Freerouting" plugin.  I thought it would have an autorouter integrated, so I was puzzling over where it was, until I asked AI and discovered it's a plugin.  That was an hour I won't get back, but so you won't also spend an hour messing around trying to find it, here is how to install the "Freerouting" autorouter plugin:

1. From the Main Screen for KiCAD, go to "Tools" > "Plugin and Content Manager":

2. Search for "Freerouting" and install it.  But make sure to install the Java JRE first, since I found the install hung until the JRE was installed. 

3.  To run the autorouter, it can be found under "Tools" > "External Plugins" > "Freerouting" from the PCB editor in KiCAD:

That is just the autorouter though, don't get me started on all the BS Design Rule Checker (DRC) rule violations I had to fix.  The DRC is handy and there was a similar tool in Eagle, it basically checks the PCB to make sure the manufacturer won't reject it for some design issue.  It does all the basics like checks if a pin is not connected or if some silksceen text is off by half a damn mm, but also some very esoteric (and annoying) stuff.  I spent the better part of the evening chasing down DRC errors until I finally slayed the last one.  All that said, KiCAD does work well (a bit buggy with a few things), but it is a nice package and pretty well polished.  If you want to build a PCB though, it pays to expect problems and schedule accordingly, since the learning curve is always a bit steep (and frustrating) with software like this.

But with all that wasted time, I now have a neat breakout board design that can act as an I2C hub (for three devices), breaks out all the worthy GPIO pins, has some cool LEDs (purely optional), and an optional power load switch IC, which I put on it at the suggestion of my AI buddy who said why not?  Aparently it can be handy if I2C devices lock up or get confused (they can be power reset through a GPIO from the ESP32 when it detects no data is flowing).  I tried to keep everything that was required for the basics to work as through hole components, while the optional bits are SMT (but aside from the SOT-23 package for the IC, they are all 1206 SMD parts).  KiCAD was able to export the board as a STEP so I could verify it would fit with my other models too, which was pretty cool.

I expect to have a few projects coming down the pike using this ESP32 dev board, related to 3D printer air quality monitoring, printer exhaust filtering or ducting, which will have integration with Home Assistant (for automation).

​I haven't priced out what this will cost to make, but I'm gonna give it another once over this week to make sure I didn't mess up some pinout or something stupid.  Then I'll probably order a small batch to test out.  I need to look up who the best companies are to order from.  I see a lot of ads for JLPCB and PCBWay, so I will check them first.  The breakout board will require some JST-PH connectors and some pin headers, along with a couple small though hole ceramic capacitors, which I will also need to order now that the bill of materials is set. 

All this begs the question though, why make a breakout board (which requires soldering to assemble) if you suck at soldering?  For me at least, there is a big difference between trying to solder tiny wires that really shouldn't be going into a board (aside from a prototype), and soldering pin headers which are much simpler to deal with.  Even though I suck at soldering, I can make a reasonable effort at soldering a pin header.  To help with my technique, I also decided to pick up some real flux to help me with this project, since I typically use flux core solder, and some decade old flux paste, which is not ideal.  One tool I have that absolutly rocks though is my Alientek T80P USB-C soldering iron.  It gets to 350°C in seconds.  Before I can get my bearings on what I'm soldering, it's ready to go.  It does require a beefy USB-C PD supply though (I use a 100w battery power bank since I like to work outside when possible).

7/16/2026:  I decided to rework this board with SMD resistors and caps, since that offers a bit more legroom.  I needed that extra space because I forgot to add some optional pullup resistors for the I2C bus, however I expect that that may not really be needed with the modules I'm using (it's been working OK without them in my current setup).  Even the Adafruit I2C hub doesn't have them (and it has also been working fine).  Since I was reworking things, I also went through the design and fixed some of the component "footprints" and values so this design could be produced as a complete board (if it works out).  That process was a whole nother story, and I think I learned more about KiCAD during the updates than I did with the first version.  I think right now though, I just need to make sure the board works as intended, and that it fits as I expect into the Bento style filter update (v2). 

​The images below show the updated (all SMD) board design (center) and to the left and right are some pics of the current setup.  The board will replace the Adafruit I2C hub (which has tiny 1.0mm pitch JST-SH connectors), and will make the overall soldering job much easier.  And since I'm gonna be doing a bit of soldering, I am working on something cool to help with that too.

7/26/2026:  The first batch of boards arrived (I ordered a second set after changing the components to 1206 SMD resistors and capacitors).  1206 is large enough that they can be hand soldered, but much more compact than the through hole stuff.  I also added the the optional pullup resistors for the I2C bus, though as I mentioned in the prior post, those are probably not needed for this design.  I've been quite busy with another semi-related project though, so assembling the board may take a week.  Although PCBWay kindly offered to collaborate on the boards for this project (in the comments), I had already ordered them from JLPCB when I saw their offer.

Over the past couple months, I've been working with MadMopar over on MakerWorld to bring a few designs to life.  These were all his suggestions, and he did the testing, while I did the CAD design work.  It's been a great collaboration and now all the designs which we have worked on are available.

The first design, which started it all, was a P2S low profile exhaust fan.  This uses the same parts as the Bambu P2S Chamber Exhaust Kit ($20), but is lower profile, is scooted over to the left by a few mm (which resolves an issue of compatibility with some poop chute designs), and it has a magnetically attached duct design.  There is currently a tested 2" duct included with the models, and a 2.5" (untested) duct that is available separately.  This design does not allow for adding a HEPA filter though, since it's intended to be an exhaust only fan, which is lower profile for tight spaces.

You can find the P2S Low Profile Exhaust Fan over on Printables and MakerWorld:

https://makerworld.com/en/models/2970122-low-profile-p2s-chamber-exhaust-fan-kit-ver1-0#profileId-3330760

https://www.printables.com/model/1676858-low-profile-p2s-chamber-exhaust-fan-kit-ver10

The next design is a P1S exhaust adapater, which uses the same magnetically attached ducts as the P2S design above, and the Core 200S design below.  This is a very simple adapter plate and optional TPU gasket, which attaches to the back of the P1S, where the exhaust exits the printer.  

You can find the P1S 2" exhaust adapter over on Printables and MakerWorld here:

https://makerworld.com/en/models/2945719-bambu-p1s-2-magnetic-duct-adapters#profileId-3299690

 https://www.printables.com/model/1751316-bambu-p1s-2-magnetic-duct-adapters 

The third (and largest) project that we collaborated on is a Levoit Core 200S based filter adapter for 3D printers.  I posted about this project below, where there is more info on the development.  This was a design that was inspired by  the "Perfect Poor Man's Filter" by MrFunctionalPrint, but can be printed on a P1/P2/X1/X2 without splitting the model.  It requires the full build area though, so certain conditions need to be set up on the P1 and X1 in order to print the largest parts of the design.  That additional setup is only required on the X1 and P1 though, since they have the cutter exclusion area on the front left of the build plate.  This design took a lot of prototyping to get to the point where it could be released, so it's nice to see it complete.   There are a few things which are extras that have not been released yet (such as carbon filter inserts), but those can be added later.  The license allows for remixing so hopefully the community will also add some ducts or other parts to expand the system.

You can find the design at the link below:

https://makerworld.com/en/models/2920723-levoit-core-200s-3d-printer-filter-adapter#profileId-3268061


All of these designs only come with 2" ducts, since that is the size that has been tested.  However there is also a 2.5" duct which is untested (though I have tested the screw on couplers elements in my system, which is otherwise different).  The 2.5" ducts are available over on Printables, for anyone willing to give them a test (but feedback is requested).

https://www.printables.com/model/1754424-25-ducts-for-bambu-p2s-and-p1-exhaust-see-descript

I've mentioned this in previous posts, but I thought I should start a new thread, since those posts were older and not always for this same project (but related ones).  Anyway, I've been working on a V2 of my "Marvin the MircoParticle Machine (Bento) Filter V1" which is a bento box type filter that gets placed inside a 3D printer to help reduce fumes and microparticles.  I used the original V1 design for well over a year, and it worked well, but I gave it away to a relative along with one of my printers, and have been missing it.  The V2 update has been long planned, but the problem was that the 4 wire (PWM) 5020 blower fans I planned to use have become really hard to find (and expensive).  Fortunately the basic 2 wire (dumb) 5020 blower fans are still available and relatively cheap.  The reason this mattered was that I wanted to have some form of smart control over the fans and 4-wire PWM fans make that much simpler from the hardware side of things.  It's still possible to smartly control a 2-wire fan, but it requires adding some additional MOSFETs to actually control the fans (since the fans draw more current than can be switched from a microcontroller).  This is pretty standard stuff for anyone who makes stuff with micros, and I could have just bolted a mosfet board to an ESP32 and gone on my merry way.  But recently I found a ESP32-32E board which covers all the bases, except that it lacks almost any documentation lol.

This is an ESP32-32E based board, with an onboard buck controller which will take 5-60 volts input, has an onboard 3.3v linear regulator (to give all the 3.3v sensors and the ESP32 a stable voltage source), USB-C power input (5V only) which is really only useful for programming, and most importantly, two MOSFETs which are controlled by GPIO pins (via some transistors).  They also have a four MOSFET version, but two is enough for this project.

The pinouts, which I discovered based on tracing things on my board are:

CHANNEL 2 = G17
Channel 1 = G16
Status LED = G23
Switch = G0

Those pin mappings should be considered a starting point, since I don't know if all these boards are the same (they may look similar but they could be wired differently).  I took a close look at mine (and from what I can make out), it uses a NCE6020AK MOSFET (60V/20A n-channel), with a small "J3Y" transistor (40V/0.5A NPN) which drives it.  There is also a AMS117 3.3V/1A linear regulator for supplying the ESP32 and sensors.

The design goals of the project to update the filter are:

• Use cheap 2 wire 12v 5020 blower fans
• Local fan control with high, low and off speeds
• Optional automatic control of the fans using ESPHome and Home Assistant, but only when enabled
• Optional OLED display with 4 buttons to navigate and change settings
• Optional TVOC, Temperature and Humidity sensors
• Optionally the filter can be made with just 2 fans and a switch (full manual control, without any smart features)

So far all these goals have been met, or are in progress and almost completed.  The fans are working very well at a low (70%) and high (100%) speed.  I'm testing the automation using ESPHome and Home Assistant currently, and the major functions are working OK.  The sensors are working as well as can be expected.  The  ENS160+AHT21 TVOC sensor  is pretty cheap, and combines an ENS160 TVOC sensor with a AHT21 temperature and humidity sensor in one board.  The downside is that the temperature and humidity sensor (AHT21) is used to calibrate the ENS160 TVOC sensor, but the ENS160 has a small heater which it needs to work, and that can affect the temperature sensor... which is used to calibrate the ENS160.  That said I don't think it will be a big deal, since the board will be getting airflow, and really the TVOC value is just gonna be a relative thing, so the value doesn't have to be 100% accurate.  I could add a 2nd temperature sensor, but that seems like it's just more complication and expense.

The OLED screen is small at 0.96", but it is readable.  I may update the design to add the possiblity of using a larger 1.3" OLED, but those seem to be harder to find.

The switch is the one component I am a bit concerned about, since I had to order it from AliExpress.  I didn't see any momentary RGB button switches that were reasonably priced on Amazon.  However an RGB switch is not a requirement, and a non-RGB momentary (16mm) switch could be used instead.  The RBG LED will be used to indicate fan or operational states, but other than that it just looks cool.  

I still have to make some cosmetic adjustments to the UI, but all the functionality seems to be working well.  I'm waiting on a momentary button switch with an RBG LED, but once I have that, the rest should come together, since the CAD design is over 95% complete.

Ultimately, when this project is done, I will be able to use this same controller (with some software tweaks) to control the window vent fan and booster fan which have been sitting at an almost done state for quite a while.  A variation of this may even end up in the next version of the StoopidAire CR-Filter.

6/13/2026:  The ESP Home side of things seems to be working well, but I need to tweak the screens since some of the text should look better if it's centered.  I discovered that a simple thing like centering text in ESPHome can be a bit of a pain though, since every change means a re-compile, so I'm trying to find a better way to do it.  It's not a big deal though, since it's only cosmetic, though I still want it to look decent.

I've been working on the Home Assistant side today with Perplexity, and I have to say our new AI overlords are pretty good at this stuff.  They can sometimes forget where they were, but when they get their bearings they can really put some cool stuff together code-wise.  I've tested the automation of the printer filter with my X1C, found a few bugs, optimized things and then retested, and now it's finally banging on all cylinders.  The only downside is that putting the Home Assistant part together requires two "automations" and a "timer" (which is a "helper" in Home Assistant-speak).  That is something I will need to write up, since before last week, I'd never set any of that stuff up in Home Assistant.  Really though, it's not too difficult once the basics of Home Assistant are understood (or at least grasped).  I think I'm getting there thanks to this project.  

Below is a simple dashboard I set up in Home Assistant, which tracks some parameters on my X1C, and the "Printer Filter" (which is actually sitting on my desk).  The dashboard has "sections" which are filled with "cards" that show all the interesting stuff.  The cards look like they must be hard to set up, but really it's just a couple clicks and they work, since most are pre-templated and already have the parameters set up so they are ready to go.

On the left is the X1C related stuff, including a "tile" with a "Bambu Lab Print Status Card" which is something I found in the "community cards section when I went to set up the dashboard.  Below that is an "Entity Card" with three "Entities" which are just parameters which Home Assistant (via the BambuLab-HA integration) is pulling from my X1C.  These include the "Print Status" (running, failed, idle, etc), the "Aux Fan Speed" (this is the fan on the side of the printer), and "Print Error" which is just an error status (normally OK).  One thing I didn't find was anything for the AMS filament loadout, however I need to look into that a bit more.

On the right side is where the fun begins for me.  That's the section with some of the parameters that are available from the "Printer Filter" (which runs ESPHome on an ESP32-32E).  The TVOC data is pulled from the ENS160+AHT21 module attached to the ESP32-32E, and the temp and humidity data are also pulled from that same module.  All that stuff is sitting on my desk and barely held together with some jumper wires, worn out Dupont connectors and a splash of hope (and a breadboard).  The cards on top show the "Printer Filter Mode" which is "High (100%)" currently, since a print is "running".  The card next to that is "Printer Filter Auto Mode" which is "On".  The ESPHome config is set up so the filter can be in "auto" or "manual" mode, where auto mode is required for Home Assistant to control it.  The other cards are pretty self explanatory, but I thought the graphs for the Temp, Humidity and TVOC data were really cool.  They are easy to set up in the dashboard too, since it's pretty much a few clicks and bam, there they are (no special config or coding required).  Not shown (they are below where I screen grabbed the image), are cards showing the "Printer Filter IP Address", "Printer Filter SSID", "Printer Filter Uptime" and "Printer Filter RSSI" (which is measure of the WiFi signal strength).

Now that the Home Assistant and ESPHome configs are mostly done, I'm getting back to polishing up the CAD design of the V2 filter, with a few more optimizations and goodies (all internal changes, but may be appreciated during the build).  And as I mentioned earlier, I still need to tweak the screens a bit on the filter, but that will just take some time and banging away at it till it looks better.

6/28/2026:  Since the Home Assistant and ESPHome code seems to be done, aside from some possible cosmetic tweaks to the text, I've been working on a few optimizations to the CAD design.  I also added some parts to accomodate the four types of OLED display boards with buttons that I've acquired over the course of this project.  There will now be options to use a 0.96" or a 1.3" OLED display (of which there are three types).  The 0.96" OLED board seems to be very common and consistent as far as the design, but the1.3" OLED displays seem to be more difficult to source with several variants (unless of course they are bought from AliExpress, and then it's no problem to find them).  I've found that there are two sizes of the 1.3" OLEDs with the buttons to the side (which look very similar, see pics 2 and 3 below), so I designed parts for each type to avoid problems with sourcing parts.  I also made the buttons larger and better to read.

Although I expect that people would power the filter with a DC power supply, I've made a USB-C PD trigger option as a power input.  Unfortunately, 24V fans are not really supported by the common USB PD modes, so 12V fans are the only real option for using the PD trigger.  I've also been testing some 6000rpm 12V 5020 blowers, and have found they are a nice upgrade over the somewhat generic "GDSTime" 5020 fans I've been using.  Both will however work, and I think the PWM fans I was using in the V1 of this design (which I gave away so cannot check), were not high power fans either, and they worked fine.  

Since this design is meant to be flexible, one of the goals was to make it work with a number of different budgets.  The high end design could cost $40-50 for the parts (or more depending on sourcing and shipping costs), while the low end design could be built for as little as $10.  So I've also been working to make sure the simplest builds will also have some options to use different parts.  The most basic configuration would be the fans, a power switch and a DC jack.  Some WAGO blocks will simplify wiring (but are optional), and the design will accomodate 12 or 16mm switches, with or without a wiring clip.  The switches I'm designing around are about 3 bucks on AliExpress, though any switch that fits a 12mm or 16mm diameter panel mounting hole should work.  Those switches (which were linked) are only for the basic configuration though, since the configuration with all the Home Assistant stuff will require a lower profile 16mm momentary switch, due to the limited space inside the electronics compartment.

Right now I'm waiting on one more batch of parts from Adafruit.  They have a neat I2C hub board, which will really help to clean up the wiring on the "smart" version of this fan.  I should be getting those parts this next week, and can then do some final test builds to check everything out.

7/7/2026:  Few things ever works out as planned seems to be a rule I keep hitting in projects like this.  I thought I had the design finalized, so printed some parts only to find that there was an interference problem I had missed.  At least it wasn't an obvious problem, but it required some major reworking of some parts which will take hours more to re-print.  I have a growing collection of parts that were almost (but not quite) there, sitting around my desk.  Fortunately I have enough filament (I hope) to complete this project in the colors I would like to use for it.

Building the prototype also informed me on how much I hate soldering tiny wires to boards.  These are wires which are 28ga or smaller, so they really are not meant to be soldered into through holes on boards like the dev board I'm testing.  But for a prototype it's fine.  Soldering pin headers designed for through hole soldering is much easier, so I decided to see if there was room for a breakout board on top of the ESP32, and it appears there is (though it has limitations in this design).  There is no breakout board for this dev board though, so I knew it would mean trying to remember how to design one from scratch.  I've used Eagle many years ago for a few projects, and though it was difficult it still worked out, so decided to go for it.  I posted a bit about the breakout board above, which took much longer than expected, but I'm happy (so far) with the result.  I haven't ordered them yet, but plan to do that later this week, once I've given the board another fresh look to make sure I didn't screw something up.

The user interface is however done, or at least enough that I'm happy with it.  I made some tweaks to it to clean up the text formatting and used Figma to help with the layout of the OLED screen.  There is no tool I found that would help to design the layout, so Figma was useful to position text and other elements (MDI Icons), on a 128x64px field.  From there I was able to use the pixel positions for the elements and bring those values into the ESPHome YAML by hand.  It saved time but is not a perfect process, which took several iterations to get things just right.  The images below show some of the screens and how the final design should operate based on the program.  The electronics side in the final design will be similar, just with another option of using a breakout board to simplify the wiring.   The rats nest of wiring in the images is actually not that bad once the wire management is taken advantage of, but since the wire manager sits where the breakout will go, I will need to design another option for wire management with the breakout. 

The last image shows a 470μF electrolytic capacitor on the power input of the board, which was put there due to the board controlling fan motors (inductive loads).  I wasn't having any problems with the prototype during testing without that capacitor, but it's one of those things which is just nice to have.  I've said this before, but I'm no expert with electronics, and have not tested with my cheap scope multimeter, but usually with motors there can be an initial spike when they start up, which can cause some instability of the power flow to the more sensitive componenets like the ESP32 or the I2C sensors.  The capacitor may help clean that up a bit, which may help in the long run.  I could also put capacitors on the fans leads, but I think that may be unnecessary since they are so small and don't pull much power.  Something to note about electrolytic capacitors is that they are polarized, so they must be installed with the stripe (with a small "-" sign) on the ground side, or they can get really unhappy and pop.  My understanding is that it's also a really good idea to use a capacitor that has about twice the voltage rating of the voltage being used.  I'm running the board at 12v, so that capacitor has a 25v rating.  I think of it like a cup, if I need to fill it up with 12 oz of water, I don't want a cup that holds only 12oz of water, a 24oz cup would be much better.  The capacitor rating of 470μF was just a guess, and was chosen since I had one handy and it should be more than enough for the job.

7/16/2026:  I've gotten the filter assembled with a shorter version of the carbon box, and have been doing some testing.  So far it works as expected, but I found that I had to redesign the USB-C connection and also use a flat USB-C cable in order to fit it into the X1C.  The filter is placed near the back left corner and there is not enough room for a standard USB-C cable there when plugging into the left side of the filter (where the USB-C connector is located).  I unfortunately cannot use this filter in the H2C (no room).  I also found that my USB-C PD power supply seems a bit flaky.  I've tried different cables and different power supplies, and isolated an intermittent issue of having no power to the supply, so I will need to get another one.  In the meantime I've been running this off a USB-C PD power bank. 

The only glaring issue I've noted during testing so far is related to the ENS160 TVOC sensor + AHT21 temperature and humidity sensor.  The temperature sensor reads a bit high, which is a known issue with that sensor combo.  The ENS160 heats the board up (it needs to heat to function), and that skews the temperature readings... which are used to calibrate the ENS160.  It's not really a big deal though, since for this application the TVOC data is most important, and as long as it can show a relative trend, that is what matters.  I still may add a separate AHT40 temp sensor, and use that to calibrate the ENS160 TVOC sensor.  Though things are quite crowded already inside the electronics compartment of the filter.  I have half an idea to integrate the temp sensor into the breakout board, which would solve the issue more elegantly, though I also like having the breakout as a generic I2C hub.  I really don't think the skewed temp reading is a big deal though, since when this is integrated with the printer using Home Assistant, the printer temp can be displayed on the dashboard, and the TVOC can be used as a relative measure of VOC's.

7/29/2026:  I've been testing this with my X1C and found a couple issues related to the software, which I need to dig into.  The first is that my X1C is far from the wifi router, so it loses signal often.  This is not a big deal when the printer is running, since there are some hold downs in the software which maintain the state for a while when connection is lost.  But during cooldown, it has been causing the filter to stop prematurely (it's set to run 10m after a print is finished).

I'm also suspecting that the esp32 may be glitching or resetting somehow, since sometimes the histograms for the TVOC, temp and humidity have lost data.  None of these issues are a deal-breaker, but I would like to figure them out.

I'm also planning to make a "dumb" version prototype and test it as well.  It will be a minimal config with just a button to turn it on and off, and no smart features.  The idea there is to make something cheaper to build and easier to assemble for folks who may not want or need automation (or may want to control it with a smart outlet).

8/3/2026:  The testing with the X1C has been productive, with some improvements to the stability of the UI and also some "nice to have" features added.  I'm still investigating the occasional glitching, but at least the problem no longer affects the functionality.  Not much more than that to report right now on this project.  I still need to make another one (a "dumb" version) to test that design out, and I have an breakout board for the  ESP32 dev board  I'm using, which I need to assemble and test as well (though that is more of an addition to this project, than a deal stopper).  

I haven't posted this previously, but since late March I've been working on a new design based on a suggestion from a really cool guy over on MakerWorld who needed a filter for his 3D printers.  He wanted to use the "Perfect Poor Man's Printer VOC/Fume Extractor" by MrFunctionalPrint over on Makerworld, but that design would not fit on his P1 or P2 without splitting it up.  He agreed to test the design and provide feedback, since I don't own the Levoit C200 filter (which the design is based around), so I agreed to design it.  I think he burned through several rolls of material and many hours of printing to help bring the design to the point where it's ready to share.  The upside was that he got a filter that was pretty tailored to his requirements, though it was modular enough that it should be adaptable to many different configurations. 

​I think I spent well over 50 hours on the design in total, possibly more, (the devil is always in the details).  The deisgn also evolved quite a bit from the inital idea, and was expanded into a more modular configuration (which lead to designing some additional related parts).  Probably it would be easier to tweak a design if I were using a true parametric CAD program, but mine is not that.  This is my hobby though, and I enjoy designing cool stuff, especially when it's stuff that could be useful to the 3D printing community. 

Since the design is finished now, and we know it's functional, I plan to post it soon.  What we haven't done (and don't have the means to do), is to test how well it works at cleaning the air, or any long term testing of the design.  The design is pretty similar to the Perfect Poor Man's filter though, so I expect it to be similar in how it works.

I have a few more additions I'm working on for the design, including a couple aux carbon inserts.  The design will release with 2" and 2.5" hose adapters, but I pan to release some more adapters in larger hose sizes later.  I may also open the license up to remixing, once I have some of the other associated designs uploaded, and feedback on them.  Since I don't own the Levoit C200 filter, it makes it difficult to support the models, so I think a license which lets other folks remix it is the best way to go (but again, that will be opened up a bit later).

Below are some images of the design, including some of the assembly process.  It looks a bit complicated, but it only requires 16x M3x16mm FHCS and 16x M3 locknuts, along with some 5/16" weatherstripping and superglue to assemble.  There are some TPU parts, but with some compromises, it may be possible to build it without the TPU parts.

Update 6/9/2026:  I goofed up on the icons for the lid, and put them on backwards from the way they actually work.  That is now fixed and I also fixed the images for the instructions, which relate to those parts. So now I'm just polishing up the profiles to get everything ready to post (which will be this week).  

6/16/2026:  This design is now posted over on MakerWorld:

https://makerworld.com/en/models/2920723-levoit-core-200s-3d-printer-filter-adapter#profileId-3268061​

I've been working on an update to the 20 Bin Gridfinity Cases as a side project.  The primary purpose of the update is to add snap in latch parts (which removes the need for several screws on every case).  The update will be incremental to v3.2, and I will leave an option to add screws in case somebody wants them.  Though the snap in latches have been working well in my H2/P2/X2 Spares Cases, without complaints.  

I'm also planning to add a couple design options for the top and base, with one being a hexagonal pattern which I used on my Generic Printer Spares Case, and another being just a plain full field contrasting color.  Like the v3.1 cases, these will be available in 6U, 9U, 12U and 15U sizes, with or without a TPU gasket.

Putting all the options together is gonna be a lot of work though.  I tackled the hardest ones first and am printing the hex patterned case now to test it.  The final design will have three separate profiles (one for each pattern option).  That's gonna be 27 different lids and bases which I need to set up in profiles, to cover all the options.  This should be fun.

Update 6/6/2026:  The profiles are mostly done now, but they have been a real pain due to various issues and a very slow PC that bogs down hard when I work with very large profiles and models in Bambu Studio.  I have to assemble my 2nd prototype and print a TPU gasket, to validate things one last time before I feel OK to post it.  It's getting close.

Since the X2D was announced, I've been planning to get my H2 and P2S Spares Case updated to suppot it as well.  I finally had the time to test print another case, and it looks good.  I don't own the X2D, however most of it's spares, aside from the cutters, are the same as the P2S so adapting things was easy.  Aside from a label, the only change from the P2S spares case parts, was to swap the small module for the base with one that has a compartment for holding the cutters (which are unique for the X2D).  So the X2D version will not have a specific location for storing cutters, but they will fit in any of the compartments. 

I also added a couple small lidded bins with latches, which were designed to hold spare snap in hotend labels for the cases.  They could be used for other small parts as well.  

You can find the updated spares case for the H2 Series, P2S and now X2D at the link below:

https://makerworld.com/en/models/2435448-bambu-h2-series-x2d-and-p2s-accessory-case-v2-0#profileId-2671977 

This was sort'a side quest which was suggested by somebody over on Makerworld.  They had noted that it would be cool to have some dividers in the larger Gridfinity bins, and I thought it was such a cool idea, I decided to test it out. Something which I've never liked about bin dividers however, is that they tend to be loose and never really solidly held in place.  I'm hoping that the design I've come up with address that issue.  But because there are a ton of different sizes of the bins, I decided to take it slow (until I get some feedback on the design).  Right now, I plan to release a 2x2 and a 3x3 sized bins in 6U, 9U and 12U heights.  If they work well, I may add a divider option to other sizes of the bins (currently I have 1xn, 2xn, 3xn and 4xn sizes in the "standard" bins without dividers posted).  Unfortunately the existing "standard" bins will not be compatible with the divider system, since the bin bases and lids will be different.  I plan to keep the original bins up (without dividers), and make the bins with dividers a separate (but similar) project, since the dividers come with a cost.  The lids on the divider bins is several mm thicker, which will reduce the volume a bit.  I'm running a test print of the 3x3 prototype now, and then will try one of the 2x2 bins to see how it works.

I have several other large and interesting projects going as well, with three of them being tested currently by very helpful user on MakerWorld. That user suggested the ideas for a 3D printer filtering system, and has contributed time and material to help me test them.  Normally I print and test everything myself, but those projects involved printers (a P2S and P1S) and a filter which I do not own.  Those projects will not be posted until they are ready though, since the filtering system was just recently brought up, and it will take some time to get an idea how it works.  I'm also going to be restarting work on the Bento clone V2 update, now that I have found an ESP32 board which I think can handle non-pwm fans.  I'm waiting on the parts though, so hopefully there will be more on that later.

5/26/2026:  The 2x2 version of these bins with dividers has been posted to MakerWorld here:

https://makerworld.com/en/models/2839972-2x2-gridfinity-bins-with-latching-lids-dividers#profileId-3165833

I'm planning on releasing another version (which will be a 3x3) soon.  

I recently stumbled on the "SIG SAUER K320 Inspired Folding Utility Knife" by Trent Studio over on MakerWorld.  It looks like Trent Studio has a bunch of really cool box cutter designs, but this one stood out to me.  The remix by MarkAdams is also really worth checking out (it has thinner scales and a clip), but is designed for some Coast blades which are non-standard.  I didn't want to pay for the Coast blades, but really liked the thinner profile of MarkAdams's remix, so I used his remixed parts with the blade holder from the original design, and it worked well together (shown in the 2nd pic).  

I then made a few smalll mods to the original design to tighten up the action, and add some pre-load to the spring.  This makes it a bit more difficult to open, but that is my preference.  While I was at it, I copied the MarkAdams mod with thinner scales and then added a similar belt clip with the post integrated, so the clip is held in by one of the screws.  There were several other small changes, but overall I feel they add very little to a great design (and a really nice remix).