ATX PSU controller for Framework Mainboard in traditional case

I wanted to share some progress on a project I just prototyped: an adapter board to control an ATX power supply and run some case fans in a standard PC case while powering a Framework laptop via a DC-to-USB-PD charger.

Background: My home server/NAS is getting way too old and creaky, and since I did the 12th gen board upgrade, I wanted to re-use my 11th gen Framework board as my new server. But for Wife Approval, I wanted it all in one case, and I wanted just one power plug. I also wanted to do this without any physical modification to the Framework board itself, no matter how minor.

One problem I had to solve was powering both the NAS hard drives and the Framework board from a single wall socket. USB-PD at 100W is not quite enough to do that safely for more than one or two drives, and hooking USB-PD logic and voltage converters to a fixed-voltage power supply is complicated. While two smaller hard drives or two SATA SSDs might be enough for some people, I wanted flexibility and the option to use more.

Here’s my solution:

This is a prototype board that takes the motherboard ATX and EPS12V connectors from a standard PC PSU and breaks out standard interfaces for case fans, Intel-standard front panel headers, and routes that juicy +12V power into an automotive accessory socket for a 100W USB-PD adapter. The controller is a standard Raspberry Pi Pico, which can run standalone or be plugged into the mainboard by USB for control via serial port commands (stuff like fan speed, using the case switches to initiate macros for a soft shut down, etc.).

For my particular use, I’ll be matching this up with a PCIe-slot-mounted mainboard holder in a Fractal Design Node 304. I picked a pretty high end 550W SIlverstone 80+ Platinum PSU, specifically because it didn’t have any required minimum loading requirements and I didn’t need to worry about putting power resistors on things.

The firmware is written in MicroPython and is currently pretty basic, but it’s built on a state machine architecture that’s very extensible and customizable. In its current state, it can do fan speed control and RPM reading via serial or toggled by the Reset button, verify the PSU’s “Power Good” signal, and toggle the PSU on and off. In the future, I’d like to have a little PC-side helper app to enable proper soft power-off.

Standby may or may not happen - every way I can think of requires leaving the PSU on, since the mainboard was designed around an always-present battery voltage rather than an ATX standby power rail. Most PC power supplies are extremely inefficient at low loading.

To-do list:

  1. Minor fixes on the board: Add on-board voltage divider for the ATX POWER_GOOD signal rather than my bodged resistors. Correct the 12V output hookup and strain relief (it was way smaller than I thought - probably will change to a solid 2- or 4-pin Molex-style connector).

  2. Look for a good way to trigger the Framework mainboard’s power switch without modifying the board. The open-source resources suggest the input cover has a power switch signal pin, some USB signals, and some LED outputs I could break out with a small and inexpensive flat-flex PCB. I also looked at pressing the tiny power button with a servo(!) but the input cover connector looks a bit easier. :smile:

  3. Experiment with direct feed of 12V through the battery connector, skipping USB-PD and freeing up a USB port*. I am way too nervous to just YOLO this and risk destroying the board or messing up the battery logic, since the stock battery should never give less than like 14V through there. I am in no way EE trained, so while I think the buck-boost system should be able to handle it, I have no idea if it would handle it well or if the system firmware would object to not having the other expected battery signals attached.

  • It’s not a huge deal to “lose” a USB port to USB-PD, since you can get USB hubs with 100W PD passthrough, so the port will still give you e.g. three Type A ports and an HDMI or whatever.
  1. Get the cost down. The board and parts cost about $35 each for a quantity-three run. Changing the board layout should let me use thinner copper, which should open up cheaper PCB fab options. Getting all those Molex plugs from US suppliers is expensive, too - the 24-pin, 8-pin, and three fan connectors together are probably like $15 with shipping from Digikey. Even just buying cheapies from AliExpress would let me cut that to 1/5th. I could nickel-and-dime by using a bare RP2040, but honestly a Pi Pico costs $4 and offers so much for the price. Maybe I can get away with just a transistor to toggle the PSU rather than using a relay…

  2. Put all this stuff on Github when I feel it’s reasonably usable.


Wow, another piece of the puzzle for me to convert my old FreeNAS to use a Framework mainboard. Thanks!

One of the main issues I had would be that I would not be able to reuse the wonderful SeaSonic SS-660XP2 Platinum power supply I have in it. It still has lots of life left and was probably the best 660W power supply ever made at the time. 10 year warranty, so it’s still under warranty.

I have a 12th gen mainboard on order and was going to sell my 11th gen mainboard, but this may make me think twice. Like you, I have an array of hard drives to power which would need an ATX power supply anyway.

Don’t mind me, just bookmarking this for later…


This is a damn cool project! I have been looking at how to make a mini PC Framework with an AliExpress TB PCIe adapter w a GPU. I was hoping to run both off a PSU rather than having 2 adapters.

I just ordered 10 copies of version 1.1 of the board. The layout changed a fair bit to make it a bit more compact, but I only took a few mm off one side - the rest of the savings went to a header to make it easier to use the outside row of pins of the Pi Pico.

I also made some significant progress on converting the RPM calculation from a bodge to a more organized structure that can do tricks like rolling averages. Turns out serial communication over USB in MicroPython is a bit of a bodge itself, though, so that will take some effort.

Should be a few weeks before the new boards are in and I can build one up, but I’m pretty confident in them.

I’m less certain about how to approach the input cover slot. I saw Arya’s input connector shim project (Input connector shim - for power switch, USB 2.0 and LEDs) and that would work, but it’s very minimalist and not quite suited for what I want to do. I think a rigid board might be the way to go, but rather than have it quite so compact, have it extend off the side for some different options in connector plugs and orientation. It would still be a small board overall.

The local library is printing my PCIe slot adapter. Could probably make it easier to print on a home printer with some redesign (it’s really long, especially because I wanted to keep the modular slots on one side and needed room for those) but I am not much of a mechanical guy, so electrical side first.


Haha, hey, it sure helps your fan control logic if you don’t mix up the tachometer pin and the speed control pin!


The library finished printing this one. Now, I worked right from the CAD drawing. I just slapped together parts of the VESA mount template and did the CAD equivalent of a jigsaw and hot glue. I made some silly errors, like how the heck do I expect to screw this down to the motherboard mounts? But I am just thrilled with how the board fits, the expansion cards fit, and it’s plenty sturdy for the job.

Expansion cards need to be levered out with a flat-head screwdriver or suchlike, except maybe the ethernet card, but shazaam.

Idea is to screw down to two of the motherboard mounting lugs and to the expansion slot cover. Printing it all as one piece was mostly impatience, ideal would be to put a finger on the mount that can actually fit in a PCIe slot like a card edge, then print a separate “board blank” with a slot (or a spot to glue in a real PCIe slot with the mounting hook and all).

I ended up using self-tapping M3 screws to secure the board, since I didn’t know what print quality was going to be like on the finished part (and it wasn’t great). I also just filled in the “slot cover” with plans to drill a hole for the screw after fitting. So this is still a beta, but… Honestly, it’s good enough that I’m going to use this in my actual server! Mistakes and all.

Other to-dos: Adjust the VESA mount screw holes to match the final spacing of the ATX adapter bit, so it can be mounted on the opposite side. Might have enough stiffness to hollow out the WiFi card holder again… maybe. Split up the case into 2-3 parts to make it easier to print without your public library’s extra large Makerbot.

Also, engineer question: I oriented the board this way because the “getting started with a bare mainboard” guide emphasized using the left-side USB-Cs for power delivery, hence flipping the board to put them on the inside. Am I worrying too much and it doesn’t matter after initial setup?

E: Oh, the guide has been updated. It seems that this is an unnecessary change, as both sides’ PD controllers need updating and you need to swap between sides during the update process, but then they work identically?


Perhaps this is a bit late, but there is a very nice ATX case adapter for the mainboard:

Sorry (if this turns out to be useful in your case) - I guess after I read about the PSU controller I glossed the fact that you needed to mount this in a case.

1 Like

I’m aware, it’s not what I need. I wanted a small form-factor case. Believe me, I considered a lot of options, but ultimately I figured “Well it’s about the size of a high-end GPU” and things went on from there.

Side benefit: Can adapt a drive cage to sit in the rest of the ITX board spot, fit more drives.


A little late, but how about a 3D printed case to mount the mainboard as a GPU?

Could mount an eGPU on one of the rack

Replace the Wifi module with an ethernet port and we kinda have a pseudo desktop?

That’s an interesting device! It wouldn’t fit in a standard case unless you went for a very big case, though. The expansion slots assume the motherboard is about 3/4 of an inch off the bottom of the case, only.

I was also reminded of the Intel NUC Extreme while planning this. That’s a system that uses a case with just a simple PCIe backplane, then the CPU, RAM, etc. is on a board with a PCIe connector and card-style cooler.

GPU in front, Compute Element in back, power supply on the right. It’s an expensive-as-heck kit, though. The compute elements alone make Framework mainboards look like a bargain.

I tried a test fit of the PCIe mount in the case, and I made a major error somewhere in measurement. It’s survivable, because hacksaws and plywood exist, but I’ll need to do some adjustments. Fixing this error also helps with the screws.

The errors give me good ideas for version 2. Let me doodle to illustrate:

A 3/4 border ITX mainboard dummy, with a slot to hold a PCIe card in place and an I/O panel blank-filler with keystone jacks, or figure out some way to strap most USB-C hubs there with zip ties or something. ITX boards are 170mm square, so it should fit fine on a typical 3D printer.

The PCIe mount itself still needs some thought. Mashing the VESA mount and the standalone case together will totally work, but it’s clunky and needs a huge printer. A perfect final version would be printable on a home printer, allow multiple orientations of the board, allow you to use a real metal slot cover.

I wish I had a laser so I could do this in plywood…

Overall, this project is surprisingly tough because the Framework mainboard was designed to be a laptop mainboard first. And that’s totally appropriate! It’s just tough, even though it’s a thousand times easier than trying to do this with any other laptop mainboard.

I’ll do some revisions and get some new prints this weekend.

The idea wasn’t for it to be an in case, kinda more like a mining rig, with the mainboard as one of the “GPU” I guess.

Kinda something closer to the Elite Mini with the GPU, except because the mainboard is more like a rectangle than a square, probably a 3D printed GPU like enclosure might work.

Version 1.1 boards came in, I’ll build one up soon.

Working on the input port breakout. I don’t want to strain the board connector, so the switch is directly on top, and I spent a lot of time looking for a zero insertion force USB plug. But except for a USB-C test jig that costs $150 per connector, I couldn’t find one.

Flat flex USB widgets exist and might be an option, but it’s got a few cost and assembly problems for home gamers - not everyone is comfortable or able doing SMD connector soldering. The premade ones on eBay and AliExpress aren’t super clear about how they’re wired and the listings can be a bit obtuse.

For now, I ordered a very simple, form-over-function board that’s just a power button (aligned right over the connector so you can press it without putting torque on it), an RGB LED (there weren’t any RGW surface mount packages on DigiKey), and a spot for a standard USB-A 2.0 socket that you could also just solder wires to. I’ll see how that works on my board.

I just realized, I might have screwed up this revision. I tied the keyboard scan inputs low so the connector would have more mechanical strength, but I have no idea whether the EC treats keys as active low or active high. This will either be fine or it’s going to always mash every key at once. A little searching the Chromium OS EC github suggests active high, so maybe I’ve lucked out.

Future possibilities on the input board:

  1. add a baby micro like an ATTiny10 to read what the Framework LEDs are doing and translate that to a Neopixel output.
  2. Multiple pad options for multiple USB sockets.
  3. Secondary board attached at right angle to stabilize the whole thing against the board’s case/mount.
  4. Other breakouts? I really thought about it and I can’t see much use for exposing the keyboard backlight/capslock light, the i2c bus, or any power rails besides 5VALW for USB, not for use in a case anyway.

Paging @DHowett! :grin:

1 Like

PCB development is a huge pain.

Molex Mini-Fit Jr. plugs and work-alikes like Amphenol Val-U-Lok connect to the same mating connectors. If you’re using wires, you can mix and match, no problem, it’s all good. But the PCB sockets… They have slightly different pin spacing.

The pins in the sockets are a standard 4.2 mm apart, and on Val-U-Lok, they’re arranged in a perfect grid. The Molex parts have kinked pins, and so while within each row, pins are 4.2 mm apart, the rows are 5 mm apart. You need a different pin layout.

So, long story short, I have a bunch of boards that take expensive Molex connectors and a bunch of inexpensive Val-U-Lok connectors, and these very much don’t work together.

Also, just a general rant, it’s super frustrating prototyping and designing during the component shortage. This board is simple and isn’t heavily affected, but I was accepted into the expansion card dev program for a headphone amp expansion module. Thing is, the time between picking the chips and finishing the board layout was long enough that one of the chips went on backorder.

Now, I ordered it anyway, since the estimated lead time was about a month off. But that date kept getting pushed back. And pushed back. And pushed… baaaaaaaaack.

It has come to the point where a bunch of chips I wanted to use the first time, which weren’t in stock, have come back in stock. And I finally got a completely different design worked up, all parts in hand, just waiting on the boards. But that ONE CHIP from the first version that I ordered in March? Maybe I’ll get it by the end of this month! Maybe!

Late edit: For the moment, I found some cheap knock-offs with the Molex pin layout, so I’ll make these 10, then respin the boards if I need more later.


I haven’t forgotten about this. I’m just stuck in Integration Hell as the mounting bracket doesn’t quite work, the sockets keep giving me problems, and I’m getting distracted by the sudden availability of parts to integrate a USB-PD regulator to the board, rather than relying on a car plug.

This week my wife and I are going to fabricate a new mounting whatsit, just take a saw to some wood and some shears to some chipboard. After that, once my server is up and running, I’ll at least release schematics/BOM/gerbers for the ATX power board before I make a version 3.

Version 3 may or may not have a web-based basic management interface, since the Raspberry Pi Pico W exists and is awesome.

Oh! Also my little power button/USB/LED board passed the first test of “not blowing up the board when I plug it in.” It also passed the second test of “the fan spins when I hit the power button.” But the LEDs didn’t turn on so I need to test it again, with a boot drive and a screen attached or maybe in my assembled laptop, to see what’s happening there.


Well. I tried it in my assembled laptop, and all I can say is: Don’t ground the keyboard input pins. It locks up the EC and I had to remove all power, including battery, to get the system to turn on again.

Time for version 1.1!