Palit Geforce RTX 3060 Dual 12 GB with the OG GA106-300 die. @AluminiumTech has bought this Card for me and in total I paid 520 £ Shipping included.
The Box has a minor rip in the bottom left but other than that no Shipping Damage.
Yes it's an all plastic shroud, at least it's very light so hopefully no GPU sag.
uwu Honeycomb shaped flow through design, me likey.
Glad that the AIBs are using the normal 8 Pin Connector instead of the stupid 12 Pin.
We both actually managed to defeat the scalpers and bots since he also got his hands onto a RX 6700 XT and thus now both have rare to obtain Cards. He tested the Card before sending it to me and it worked and performed as promised. I won't be able to use or even test the Card until I've bought the rest of the parts for my new Rig so into Storage it goes. I'm now gonna save up and buy the rest of parts for the System and then start mining to afford to upgrade the 3060 because my end goal is to have something like a 3080 or Higher.
I don’t see a difference in refresh rates/high FPS. I went from a $60 60hz 1080p monitor to a 32” 1440p 144hz monitor and the only change I’ve noticed is the insanely better image quality. I also have a 300hz screen on my laptop. I can tell no difference between them in terms of refresh rates and smoothness.
Even using my old 60hz one again, the refresh rate is completely normal looking to me. Though I do notice tearing and stuttering on any of the screens.
Table of contents (be sure to use Ctrl+F to navigate through the thread):
 Introduction to this project and topic
You can see keyboards as a commodity and nothing other than a tool, but to many others keyboards - especially mechanical keyboards - have become closer to a hobby.
In 2016 I bought a mechanical keyboard and have been happy with it, but seeing the plethora of options in boards, switches, etc. got me interested in more.
Eventually that led me down the path of custom keyboards and got me interested in making my own PCB. I knew I’d start with a simple keypad though.
First I found the guide by ruiqimao and later the updated spiritual successor by ai03 (all links will be at the bottom of the post). ai03’s guide was easy to follow and taught me what I needed to know about the design decisions and tools.
After leaving the project sitting for a bit, I picked it up again, made a few changes and dubbed this changed board the mini_cardboard.
After ordering the board and components, assembling it and designing a custom little enclosure I had my own 4% keyboard!
This thread will cover the steps I took in making this keypad, but also the theory of how a keyboard works. This thread will cover how a keyboard works on a high level, decisions during the design phase, issues that came up and how I fixed them and in general what to do after following ai03’ tutorial.
Hopefully this will give me the motivation to work on my next project and you the motivation to work on a project outside of your comfort box!
[0.1] Topic Information
If you have any questions about this project, keyboard technology, etc. Do not hesitate to ask.
Be sure to check out the FAQ below too, as that might hold the answer to your question right away!
Links to additional (re)sources, programs, etc. will be linked below in section 
Any feedback, criticism, etc. is also highly appreciated.
This thread is quite large, be sure to use the table of contents and Ctrl+F to find the different sections.
While this thread contains quite a few images, I tried to make sure they aren't too large. All images together are less than 4MB.
[0.2] Why the name ‘mini_cardboard’?
Once in a video I heard it’s customary in the custom keyboard community, to name your keyboard PCB after your name and the amount of keys it has.
That should already explain the first part of the name, as ‘mini’ is the name I use online.
The ‘cardboard’ comes from the fact that the keypad is roughly the size of a (credit)card* and it’s a keyboard. Card and board. Cardboard.
It did have another meaning earlier in development, as at first I had planned to use cardboard as a case, but that was not something I ended up doing (didn’t look pretty, wouldn’t be very protective etc.).
*mini_cardboard = 88 x 38mm
creditcard = 85.6 x 53.98mm
 How does a keyboard work?
On the surface, how a keyboard works is quite simple. This explanation will go as far as needed, as context for the schematic and PCB later. Feel free to dive in further into the parts that interest you.
The three most important components to know about:
The Microcontroller (MCU): which has input/output lines for the keys and it can interface to a computer via USB
Keyswitches: when pressing these down, two pieces of metal in the switch make contact and allow for power to run through the switch
The PCB (printed circuit board): a board which holds the components and connects them together with traces, which act like wires.
Mechanical keyboards work with individual keyswitches. There are different types of keyswitches, with the most popular ones being the Cherry MX-like switches (including Chery MX, Kailh, Gateron, etc.). Other keyswitch options exist too, such as optical switches (which track how far you have pressed down the key), but for the purposes of this explanation I will only cover the Cherry MX-like switches.
These switches have two states:
An open state: when they are not pressed down (their neutral position)
A closed state: which is when you have pushed the switched down (past its actuation point)
(A Cherry MX Red switch, for illustration, Similar concept on all other MX-like switches):
Pressing down the switch makes the stem (red part) move down, so the two metal contacts (silver leaves, on the left) can make contact with each other.
When these two metal pieces contact, electricity can flow through the switch, to make a closed state. This closed state is what the MCU has to use to see the switch is pressed.
There are dozens of different keyswitches, generally falling in the clicky, tactile or linear categories. These switches work with the same principle of closing a circuit when pressed down.
If you want to learn more about these different switches, check out section 5.0 of the “Introduction to Custom Mechanical Keyboards”: https://linustechtips.com/topic/1214368-an-introduction-to-custom-mechanical-keyboards/
The MCU, or Microcontroller Unit is the brains of a keyboard. To know what to interpret as input and what to send out as output, the MCU needs to read its input/ouput pins for switch activity and the firmware on the board will come up with the right output. The MCU scans these I/O lines in very rapid succession, to check for any keypress.
The mini_cardboard is based on the tutorial by ai03, which is inspired by the Teensy 2.0 microcontroller board, which uses the ATmega32u4 MCU. This MCU is also used in the Arduino Pro Micro and Leonardo, two well-known MCU boards too.
The ATmega32u4 is well-supported in the open-source firmware used in this project, QMK.
[1.3] The MCU’s input/output lines and why we use a matrix
To detect if a key is pressed, the MCU needs to somehow know a keyswitch’s state.
There are multiple ways to achieve this, by far the most popular and practical method is using a matrix.
[1.3.1] The alternatives
To quickly cover the alternatives and their disadvantages:
Option #1: Connect each key between two I/O pins and check if there is a connection between these two pins.
Disadvantage: Needs two I/O pins per switch, potentially messy wiring.
Option: Connect the keyswitch between power and ground with a resistor and measure the voltage (5V = not pressed, 0V = pressed)
Advantage: ‘only’ needs one I/O pin per key, because all keys share a single ground plane
Disadvantage: one I/O pin is still a lot, messy wiring, needs a resistor per switch
When MCU’s only have 25 - 40 I/O pins, you can see how the above options are not viable for anything over the size of a numpad.
The limitations and disadvantages of the alternatives is what leads us to the use of a matrix.
[1.4] The Keyboard Matrix
A matrix has horizontal lines; rows and vertical lines; columns.
The mini_cardboard used a 2x2 matrix, so the following schematics will show that too. While a matrix wouldn’t be necessary, this project has always been intended as a starting point to a larger project, so I wanted to get the needed experience with the concept of a matrix.
The 2x2 size also makes the explanations much easier, but these explanations are relevant to larger matrices too.
Matrices are particularly more relevant to larger keyboards, as with a 2x2 keypad you aren’t saving any I/O pins with a matrix.
When thinking about the amount of I/O pins for your keys/matrix, just think about this
rows * columns = amount of keys supported by your matrix
rows + columns = amount of I/O pins needed by your matrix
With a 2x2 matrix, it’s:
2 * 2 = 4 keys supported
2 + 2 = 4 I/O pins needed
With a 65% keyboard, the equations would look like this:
5 rows, 15 columns:
5 * 15 = 75 keys supported
5 + 15 = 20 I/O pins needed
That’s a much larger difference, when without a matrix you’d need 75-150 I/O pins for this amount of keys.
[1.4.1] How a matrix works and the issue with the simple approach
With our 2x2 keypad, we get a schematic like this:
This works great, because the MCU can scan the columns in very quick succession, to see if they connect to any of the row pins.
Here is an example of COL0 and ROW0 connecting together, through MX1, which tells the MCU MX1 is pressed down:
The rows and columns are connected together through the switches, which are normally open. When a MX1 is pressed, there exists a path between a COL0 and ROW0, which the MCU interprets as a keypress.
The issue with a simple matrix like this, is that ‘ghosting’ can appear. Ghosting is when the MCU thinks a key is pressed down, but it’s not.
Take this scenario as an example:
In this 2x2 matrix, I have pressed down three keys (MX1, MX2, MX4) and the MCU is currently scanning the COL1 I/O line.
MX2 is selected, so COL1 and ROW0 are making contact. MX4 is also selected, so there is a connection between COL1 and ROW1. These two are expected to be seen.
MX1 is also selected though, so the energy from COL1 can flow through MX1 into COL0. Because ROW1 is connected through MX4 and COL0 is reached through MX1, the MCU will think MX3 is also pressed down, when in fact it is not.
The issue in this example is that power can flow from one column to another, through a switch. This can be fixed with a simple add-on, the diode.
[1.4.2] A Matrix Addition: The Diode
By placing a diode between a switch and its row connection, the issue described above can be solved.
This is how we would add the diode to the existing schematic:
A diode is an electrical component that lets electricity through one way, but not the other. See it as a “one way street” sign for electricity, with the arrow shape showing what direction the energy can flow.
By placing a diode between the switch and row connection, it can be ensured the power can never flow from one column to another column pin, which is what we want to avoid.
Now I’ll show the same example from before, with three switches pressed down, which now looks like this:
COL1 is being scanned, but because of the diode after MX1, the power cannot flow through switch MX1 into COL0, which means MX3 is not seen as being pressed down.
These diodes solved the issue of ghosting, because the diodes prevent columns from being connected together, which would've caused keys to be seen as pressed down.
Understanding the keyboard matrix took me quite some time, but getting to a point where I could explain it was another step further.
If my explanation was not clear, please do let me know and feel free to consult the resources linked below. I had read three different explanations before fully understanding the concept. Different explanations work better for different people.
[1.4.3] Physical vs. Logical/Electrical matrix
When working with a matrix, it's important to think about the physical, but most importantly the electrical matrix.
Let's say I wanted to make a keypad with this layout:
I could follow the physical matrix (grid) of these keys and make an electrical matrix like this:
This matrix has two 'dead spots' though, next to keys 1 and 2.
It would be more effective to make a matrix like this instead:
Which maximizes the use you get out of your input/output pins, by only using four, instead of five.
This is of course a very small scale example. Once you start working with larger keyboards and different compatibility options (like an ANSI or ISO enter key), you can start to see examples where some thinking about the physical vs. electrical matrix can save you some input/output lines.
 The PCB
The guide by ai03 walked through the steps of making the schematic - including the matrix - before going through the steps of making a PCB.
The PCB in context to a keyboard has two roles:
- Holding the components in place
- Connecting them together, through its traces.
The guide does a great job at showing where to place components and how to run the traces - a PCB’s wires - to these components.
[2.1] Doubts and planned changes
After following the tutorial I had a board as seen above, but I felt like I was missing some knowledge and portions of a final design.
What I specifically lacked in knowledge was how to put a bootloader/firmware on the MCU and what lacked in the design was a way to use screws to fasten this board to a case.
The screw holes were easy. I just added them around the corners and next to the switches.
One thing I did not do was connect these screw holes to ground. In short, ground is the place ‘excess’ power (such as from ESD) can go, instead of going through the components.
This is something I also should've done with the four through-hole legs of the USB connector, so the shield of the USB connector was grounded too.
The bootloader/firmware issue was another thing, as to install firmware to an ATmega32u4, you need a bootloader (kind of like a BIOS for an MCU).
I wasn’t sure if that came pre-loaded on it or not. Some people on Reddit told me it did come with a bootloader, but with the power of hindsight I can tell you it doesn’t (from the vendor I bought it from).
You can get a programmer that holds the MCU itself, but I chose to include an ICSP header on the PCB, which allows you to connect another device (like an Arduino UNO) to it, to burn the bootloader on the MCU.
Once you have a bootloader, you can simply use USB to flash a firmware on it.
More on this in section .
[2.2] Small Alterations and Additions
The tutorial had set up the PCB a certain way, but through adding these screw holes and ICSP header, I had to do some alterations to make everything fit.
At some point - for aesthetics - I decided I wanted the components on the front side of the board too, instead of the back, so I edited the majority of the board at this point, by moving the components to the desired locations and running the needed traces.
Of course I am glossing over details here, but once you get the hang of it, routing PCB traces in KiCAD is a lot of fun!
Once the components were in the right places, with all the traces connected, I had a PCB ready for production!
Of course no PCB is complete without a silly logo and some text on the board:
And a definitely not arbitrary version number is a necessity too, of course!
 The Build
After ordering the PCB, the components and the needed tools I was ready to go ahead and assemble it all together!
[3.1] Components and Tools
To assemble the mini_cardboard I needed quite a few components and tools I didn’t have already.
The full component rundown is at the end of this topic in [6.1] and of course the guide of ai03 also shows the needed components in step 15.
The components list contained multiple different types of parts, including the MCU, resistors, capacitors, the USB connector, keyswitches and more.
The alterations I made to the board only influenced the component selection a little bit, as I needed some header pins for the ICSP header, I got THT instead of SMD diodes (more on this in [3.3]) and I needed some nuts/bolts too, to affix the case to the board (which I just grabbed those from a bin I have).
[3.1.2] Tools and supplies
These are the tools and supplies I used to assemble the mini_cardboard::
Solder tin (0.5mm for SMD and 0.7mm for THT)
Multimeter (at least needs to have continuity mode)
99% alcohol and cotton buds
Small screwdriver (to put together the nuts/bolts on the case)
Goggles (solder/flux can splatter)
Other safety precautions (i.e. fan, well ventilated room, washing your hands after soldering, etc. Please do your research to ensure proper safety while soldering)
3D printer (optional: see section Case)
There may be more tools you wish to use, but this is what I would consider the minimum needed (except the optional 3D printer).
I intentionally didn’t mention the specific components I used. I am still a novice in all of this, so I highly suggest consulting some soldering guides from more professional people (links down below) for actual recommendations.
Just as when building a PC, it’s important to know if it’ll work before assembling it fully.
In the case of a PCB, that comes down to cleaning the board and inspecting it thoroughly by eye and more importantly with a multimeter.
Setting the multimeter to continuity mode allows you to check if everything connects to where it should and to make sure no wrong connections are made.
After confirming it was all fine, it’s time to assemble. Because the last time I soldered was some time ago, I decided to first practice on some scrap boards, before doing the real work.
After getting confident with the equipment, it was time to assemble.
[3.3] The First Attempt for a Board
Now it’s time to work on the first board, but before I get into that I’ll provide some context.
Keep in mind this won’t be a comprehensive “how to solder” guide, but rather an explanation of what I did. If you want a better guide, feel free to consult the links below!
[3.3.1] Component types
There are two sorts of soldering used in this project (and these are the two most common types of soldering):
THT: Through Hole Technology components have long legs that stick through the board and get soldered to these holes. This will be the switches, ICSP header, legs for the USB connector and the diodes (the latter of which could be done SMD too)
SMT: Surface Mount Technology uses pads on a board, where SMD (Surface Mount Device) components are soldered onto. These are all the other components on this board.
The legs of the THT components stick out on the other side of the board, so I started with all the SMD components so the board could lay flat while doing those.
The SMD components could’ve been soldered in place in any order, but I chose to start with the smallest components first.
[3.3.2] Two or four leg SMD components
The resistors, capacitors and fuse is what I started with and these are all SMD components with two pads, like this:
The way I soldered them in place:
Place a small blob of solder on one of the pads on the board
Hold the components with tweezers, heat up the blob of solder and place the component in that blob
Heat up the blob of solder again and push down the components so its flat on the board
Heat up the other side and apply solder
Clean up both sides with some IPA
After soldering the components with two legs in place, I moved over to the reset switch which has 4 pins. Soldering this switch in place was much of the same, just repeating step 4 for the other three legs.
[3.3.3] Other SMD components
The other 4 pad component was the crystal was a bit more difficult, because the pads for this component are on the bottom of it.
This makes it more difficult, because with soldering you want the iron to touch the pad on the board and component at the same time, so the tin flows on both pads. With the crystal’s pad on the bottom, this is a lot more difficult.
In the end I just placed 4 blobs of solder on the board, and heated them up while pushing down the crystal.. Definitely not the best way to go about this (the proper way would be with a hot air station, which blasts hot air from a nozzle).
The next component to solder in place was the MCU, which has 11 pins on all of its 4 sides, for a total of 44 pins in total. Soldering these in place one by one is generally considered a nightmare, so I chose to utilize the popular drag solder method.
In short, you first get the MCU in the right place, place some solder on a corner to hold it in place and then add a whole bunch of solder on all sides.
Then with the solder wick and some additional flux you go over these legs to wick away all the excess solder to be left with just the legs soldered onto the pads on the board!
[3.3.4] The THT components
After all the SMD components were done, I moved over to the THT components - the switches and diodes - which were significantly easier to solder in place.
It's all about heating up the pin and through-hole, add some solder and that's it. Repeat this for all the through-hole components - including the legs for the USB port and that’s it.
The USB connector also has some SMD legs that go on the other side of the board, but that proved little trouble.
For now I skipped the keyswitches, as the board was ready for testing!
Some more advanced users probably know an important step I had missed at this point.
[3.4] The troubles
My memory is somewhat fuzzy on what I did next. I think I measured some of the connections, to make sure there weren’t any connections there shouldn’t be.
+5V and GROUND had a short between them, which - in simple terms - is no good.
+5V and GROUND are used in various places together, including four points on the MCU, the USB port, the ICSP header and various capacitors.
This taught me a good lesson: check continuity between various points throughout assembling the PCB; not just at the end.
The short could’ve been in various places, at least eight different places.
Again, I don’t remember the steps I took exactly, but at some point I plugged in the board and didn't hear a Windows “ding!” for a new USB device (which I didn’t know if I should or not at this point).
I could feel the MCU heat up quite a bit. With my unfamiliarity with the MCU I didn’t know if that was normal or not.
With hindsight, I can tell you it’s not. It kept being hot. Using a USB voltage/amp reader I could see the device was pulling 5v (normal) and 200mA (definitely not normal. Normal is 2mA), but at some point it stopped doing that.
What I think happened is that I didn’t measure it all very well and the MCU basically fried itself.
I tried troubleshooting the board a bit more, but at some point I basically wrote this board off as a casualty of my stupidity and just moved onto a new board (as I had five PCB’s and enough parts for a couple boards).
[3.5] The Redemption Arc
With the second board I followed the same steps as above, but was sure to test between each step.
There were no shorts, up until I installed the MCU, which is when the +5V and GROUND shorted, just like last time.
Because of the intermittent measuring, I knew the issue was in the MCU. Check the possibly offending places and soldering/wicking fixed that right up.
With a bit more hindsight, I can tell you I definitely should’ve:
Solder one of the four sides of the MCU
Repeat step 1 and 2 until all four sides were soldered
That way I would’ve at least known which side of the part I should inspect with any issues.
Of course I double- triple- quadruple- checked all the connections before proceeding further.
 Flashing the bootloader and firmware
Connecting the board to my PC with a USB cable, no Windows “ding!” was heard, so I knew the board didn’t have a bootloader after all.
A bootloader is used to be able to install firmware on the board, which would make it functioning.
[4.1] Hardware required
To flash the mini_cardboard I used its ICSP header, some jumper wires and an Arduino UNO. The Arduino UNO is an inexpensive microcontroller (officially €20,-, but clones are available from €3,- and up). It is also one of the most used hobbyist boards, so you might just have one laying around or know someone who you can borrow it from.
To connect them together and install the bootloader, I used the steps here: https://www.arduino.cc/en/Tutorial/BuiltInExamples/ArduinoISP
[4.2] Setting up QMK
By flashing a bootloader on the mini_cardboard, I made the PC think this is an Arduino Leonardo, another well-known MCU board.
The bootloader used is directly compatible with QMK, my keyboard firmware of choice.
The process of doing this is pretty straight forward:
Make a new keyboard & keymap
Adjust the keymap’s button configuration (what button should do what)
Compile the board and place the .hex in QMK toolbox
Press reset on the board, flash the file and that’s it!
A lot more detail on these steps can be found here: https://beta.docs.qmk.fm/tutorial/newbs
After doing this, my PC picked up the board not as “Arduino Leonardo”, but as “mini_cardboard”. Success!
At this stage I hadn’t soldered on the keyswitches, but I just did that real quick.
I made the keys output 1, 2, 3 and 4 for testing, but changed that to F21 - F24.
Those keys don’t exist on my keyboard (and probably don’t on yours too!), but can be recognized in different programs to do macros.
Obviously the first program I set it up in was Gimp, to bind some often used action to the keys (cropping an image, cropping a layer, that sort of thing).
What keys the keypad outputs is of course up to you, which is the beauty of a project like this!
 The Case
Having just a bare PCB looks cool (in my opinion), but from a standpoint of safety of the components, it’s not great, so a case was the next thing I worked on.
You could choose to make a case from a variety of materials, like cardboard (my original idea), wood, plastic (such as a project box) and much more.
Someone I know has a 3D printer and I was able to 3D print a small case I designed, in return for doing some soldering for them.
Of course there are 3D print services (such as Shapeways), with varying prices.
[5.1] The Starting Idea
I don’t have any prior experience with designing a case of any kind, but I had a simple idea in mind.
The PCB has screw holes in it, so I just needed two pieces - a tray and a top - that would be fastened to the PCB with nuts and bolts.
Because I jumped into the 3D program, I didn’t make a sketch of any kind, so please take this sketch made after the fact to visualize what I had in mind:
This sketch was just the rough idea I had at the time for a case.
As said before, 3D designing a case is not something I’ve done before. The person who would 3D print the model recommended the program ‘OpenSCAD’. A free 3D modeling program, that works with code to generate a model.
[5.2] Creating the bottom piece
The measurements needed for this case were taken right out of the PCB file. I started with a rounded box the same shape of the PCB, added a border and then raised that border to form the walls.
After adding the screw holes, I had to add some room on the bottom for the various components that stick out on the bottom (like the switches, diodes, etc.).
With hindsight I can say the cut-outs for the switches weren't deep enough, so the case is flexed just ever so slightly when installing it.
For the USB port, I made a hole in the model and was left with this:
[5.3] The Top Side
The top side of the case was created in much the same way.
I just took the bottom, enlarged it a bit, so it could slide over the bottom piece and changed the extra room for the components to cutouts, so the components could stick out. I also added a small hole for the reset switch.
[5.4] Printing, Assembly and Small Issues
Printing the case took a little under 2 hours for both pieces. The top piece printed in a bit less time, because of the cutouts in it.
The bottom piece fit on the PCB with no issues, but the top piece did give me some issues.
At first I thought the switch cutout was too small, but it was actually the ICSP header that was in the wrong place. If you scroll back to the case pictures above, you see the ICSP header cutout is much closer to the screw hole on the top side, compared to the bottom side. I really should’ve caught that!
After some percussive maintenance with a rotary tool, the top case fit just fine, but suddenly the board didn’t work anymore!
That was just a small issue, the reset switch hole wasn’t large enough and the top piece of the case pushed that button down, meaning the board was constantly resetting. Whoops! Grabbed the rotary tool again and fixed that up.
It’s not the prettiest end result, but I’ll counter that with “But it gives the prototype a character and a backstory!”, or something like that.
 Final Product and Pictures
After encountering some hurdles in assembly and a lot of learning throughout the design process, here it is!
Middle is the broken one, but still a nice desk ornament I guess!
More pictures in the spoiler below:
[6.1] (Rough) Pricing
To give an indication on how much something like this costs, I’ll list the components I needed and their prices.
I won’t mention the price of the tools, because with most of those you can choose a simple or expensive version.
If you don’t want to read the full list and just want the answer, the price is about €11.49
These are approximate prices, because prices will depend on shipping costs and whether you need everything or have some components already. Some items always have a minimum order quantity/a quantity that just makes the most sense
Just keep that in mind when looking at some of the parts, this is just to give you (and myself!) a rough idea of what I spent.
Price breakdown (for one board):
 Things I would do differently in the future
This project is something I’d generally consider a big success - as my first delve into into PCB’s, DIY keyboards, 3D printing and more (like DIY electronics) - but I’d be lying if I said I wouldn’t do stuff differently with the knowledge I have today.
[7.1] Assembly and testing
The biggest change I’d integrate would have to do with my assembly process. Instead of pulling a “Leeroy Jenkins!” and just going right ahead and doing everything at once, I should take things in steps, testing along the way. This was my biggest issue in both builds and something I can improve on.
[7.2] PCB Changes
The PCB generally was quite nice in my opinion, but the one thing that posted some issue was the crystal’s pads on the board, which just comes down to the crystal having its pads on the bottom. I think making those pads a bit larger would be nice.
The screw holes and USB's through-hole legs should've been connected to ground, to make sure everything is as safe as possible.
The ICSP header on the side doesn't have any printing to indicate what headers do what. Some printing on the silk-screen to indicate what header does what is just proper design and would save some time too, as I wouldn't have had to look up the headers in the board view, when connecting cables to it.
[7.3] The Case
The main issue with the case was the top side not fitting. I kind of rushed that part and should’ve paid better attention.
A fix for the future would be printing out this design to scale on a sheet of paper and fitting it over the board, which would’ve shown the issue right away.
The case was made with a top side that had a wall, but I think the top could’ve been a flat piece too.
I don’t think I am totally in love with the logo used on the board.
Something I have been looking into is the copyright on the Gimp logo, as that is what has become sort of my ‘image’ and go to profile picture online.
With hindsight, I totally should’ve used this image in this prototype. It's just a prototype and I could just wouldn’t include it in any possible open-source release.
This is something I’ll have to think about more and maybe I should just go back to the drawing board for this logo (as I have done about two dozen platypus design already, before getting this).
 What I learned and a Conclusion
This project has taught me a lot, including a better understanding as to how integrated circuits work, what goes into a keyboard, how PCB’s are produced and much more.
Before this project, it was all a mystery to me, but this project has given me a lot more perspective on the work that goes into these products.
After a lot of learning, designing, trial and error, assembly and more here it is. The mini_cardboard!
As of writing this, I have been using the mini_cardboard for a couple weeks and it has been a great help in Gimp. Instead of digging in some menus for frequently used actions, I just press a single button!
I’ve not found a way to use - for example - AutoHotKey to use different key combos in different programs, but any program that supports rebinding of macros would support this board!
 Credits and thank you’s!
Huge shoutout to the PCB guide from ai03, which made this project possible: https://wiki.ai03.com/books/pcb-design/page/pcb-guide-part-1-preparations
Thanks to Eschew’s Introduction to Custom Mechanical Keyboards for additional keyboard info and the inspiration for the chapter codes: https://linustechtips.com/topic/1214368-an-introduction-to-custom-mechanical-keyboards/
 (Re)sources / Further reading / Links
Guides, articles and software used:
 Frequently Used Terms
 Frequently Asked Questions
Feel free to ask questions, but consider checking if your question has been covered in this section already.
 Version history
PCPartPicker Part List
AMD Ryzen 7 3700X 3.6 GHz 8-Core Processor
$319.99 @ Newegg
ASRock B550M Phantom Gaming 4 Micro ATX AM4 Motherboard
$89.99 @ Newegg
Corsair Vengeance LPX 32 GB (2 x 16 GB) DDR4-3000 CL15 Memory
$134.99 @ Corsair
Team MS30 1 TB M.2-2280 Solid State Drive
$89.99 @ Newegg
Zotac GeForce GTX 1060 3GB 3 GB MINI Video Card
DIYPC S2-BK-RGB ATX Mid Tower Case
$42.99 @ Newegg
EVGA 650 W ATX Power Supply
$60.09 @ Amazon
Prices include shipping, taxes, rebates, and discounts
Generated by PCPartPicker 2021-04-02 15:45 EDT-0400
a bit over budget but you can get the Graphics card on ebay. If you really need it to be cheaper go for 16gb ram instead of 32
Disclaimer: I'm also an American so all I know is what I have been taught in schools here and I have no direct experiences with the EU or its functions.
The EU is a supranational organization (a group of states that are working together to promote shared economic and political goals). As such I dont think there is anything to really compare it to here in the US but it does perform some functions covered by the US federal reserve and government. One of the biggest things it has done is help promote trade among its members through open borders and the common currency (the euro). It also helps bring more political power to the members by acting on behalf of all of them and not just single country.