mini_cardboard: a 4% keyboard build log and how keyboards work

[minibois]

Table of contents (be sure to use Ctrl+F to navigate through the thread):

 

 

[0] Introduction to this project and topic
      [0.1] Why the name ‘mini_cardboard’?
[1] How does a keyboard work?
      [1.1] Keyswitches
      [1.2] MCU
      [1.3] The MCU’s input/output lines and why we use a matrix
            [1.3.1] The alternatives
      [1.4] The Keyboard Matrix 
              [1.4.1] How a matrix works and the issue with the simple approach
              [1.4.2] A Matrix Addition: The Diode

              [1.4.3] Physical vs. Logical/Electrical matrix
[2] The PCB
      [2.1] Doubts and planned changes
      [2.2] Small Alterations and Additions
[3] The Build
      [3.1] Components and Tools
              [3.1.1] Components
              [3.1.2] Tools and supplies
      [3.2] Preparations
      [3.3] The First* Board
              [3.3.1] Component types
              [3.3.2] Two - four leg SMD components
              [3.3.3] Other SMD components
              [3.3.4] The THT components
      [3.4] The troubles
      [3.5] The Redemption Arc
[4] Flashing the bootloader and firmware
      [4.1] Hardware required
      [4.2] Setting up QMK
      [4.3] Testing
[5] The Case
      [5.1] The Starting Idea
      [5.2] Creating the bottom piece 
      [5.3] The Top Side
      [5.4] Printing, Assembly and Small Issues
[6] Final Product and Pictures

      [6.1] (Rough) Pricing
[7] Things I would do differently in the future
      [7.1] Assembly and testing
      [7.2] PCB Changes
      [7.3] The Case
      [7.4] Logo
[8] What I learned and a Conclusion
[9] Credits and thank you’s!
[10] (Re)sources / Further reading / Links
[11] Frequently Used Terms
[12] Frequently Asked Questions
[13] Version History

[0] 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 [10]

 

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

 

[1] 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.

[1.1] Keyswitches
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):

(Source: https://blog.adafruit.com/2016/09/16/animated-gifs-help-visually-explain-cherry-mx-mechanical-keyboard-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/

[1.2] MCU
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.

 

[2] 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 [4].

[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!

[3] 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.
[3.1.1] Components
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::

• Soldering iron
• Solder tin (0.5mm for SMD and 0.7mm for THT)
• Flux
• Desoldering braid/wick
• Multimeter (at least needs to have continuity mode)
• Sidecutters/flushcutters
• Tweezers
• 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.

[3.2] Preparations
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:

1. Place a small blob of solder on one of the pads on the board
2. Hold the components with tweezers, heat up the blob of solder and place the component in that blob
3. Heat up the blob of solder again and push down the components so its flat on the board
4. Heat up the other side and apply solder
5. 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:

1. Solder one of the four sides of the MCU
2. Test

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.

 

[4] 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:

• Setup QMK
• 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.

[4.3] Testing
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!

[5] 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.

[6] 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:

Spoiler

The end result of the mini_cardboard gave me some GameBoy Pocket vibes, with this color case

 

I think my Goomy figurine likes the board! 

 

(I think I might have to make one with Jade BOX switches

 

[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):

Spoiler

(Prices listed are in euros/EUR/€

Component	Amount	Price (per part)	Total price	Price based on quantity	Note(s)
PCB	1	2.21	2.21	5
ATMEGA32U4	1	3.54	3.54	10
Mini USB 2.0 connector	1	0.94	0.94	10
Tactile (reset) switch	1	0.457	0.457	10
16Mhz Crystal	1	0.288	0.288	10
Polyfuse	1	0.307	0.307	10
Resistor (22 Ω)	2	0.042	0.084	20
Resistor (10k Ω)	2	0.256	0.512	20
Diodes 1N4148W (SMD) or 1N4148 (THT)	4	0.006	0.024	100	Board supports SMD or THT
Capacitor (22pF)	1	0.102	0.102	10
Capacitor (0.1μF)	3	0.036	0.036	30
Capacitor (1μF)	1	0.066	0.066	10
Capacitor (10μF)	1	0.037	0.037	10
2.56mm headers	1	0.086	0.086	10	6 total headers needed
Any Cherry MX-like keyswitches	4	0.40+	1.20	25	Cheaper and more premium options exist
Keycaps	4	0.25+	1.00+	25	Cheaper and more premium options exist
3D printed case	1	0.50	0.50	-	Price based on filament
Mini USB 2.0 cable	1	0.10+	0.10+	1	I just looked up the simplest cable, because that’s what I use. More premium options exist
Nuts/Bolt	6	-	-	-	Just some random nuts/bolts I had
Total	-	-	€11.49	-

[7] 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.

[7.4] Logo
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).

[8] 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!

[9] 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/

[10] (Re)sources / Further reading / Links

Guides, articles and software used:

Spoiler

Guides:
Ruiqimao PCB guide: https://github.com/ruiqimao/keyboard-pcb-guide
ai03 PCB guide (what I used): https://wiki.ai03.com/books/pcb-design/page/pcb-guide-part-1-preparations
hadi’s PCB design video series: https://www.youtube.com/playlist?list=PLbtY7JsOJDYkHNuTmBtGgaWv_qipKeL-u (using Eagle, not KiCAD. Gives a lot of info and inspiration regardless)

EEVBlog soldering guide: https://www.youtube.com/watch?v=J5Sb21qbpEQ

 

QMK: https://docs.qmk.fm/#/newbs

Keyboard Matrix:
http://blog.komar.be/how-to-make-a-keyboard-the-matrix/
https://beta.docs.qmk.fm/developing-qmk/for-a-deeper-understanding/how_a_matrix_works
https://www.dribin.org/dave/keyboard/one_html/ (this was the one that finally made me understand it)
 

Software used:
KiCAD (the recommend 5.1.4 version): https://kicad-downloads.s3.cern.ch/index.html?prefix=windows/stable/ (Windows) / https://kicad-downloads.s3.cern.ch/index.html?prefix=osx/stable/ (MacOS)
Inkscape: https://inkscape.org/
Krita: https://krita.org/en/
Gimp: https://www.gimp.org/
OpenSCAD: https://openscad.org/
*Insert a link to your favorite Git client here*: I used GitHub, but everyone has their own preference.

Misc. links:
Keyboard layout editor: http://www.keyboard-layout-editor.com/
Arduino ISP guide: https://www.arduino.cc/en/Tutorial/BuiltInExamples/ArduinoISP

[11] Frequently Used Terms

Spoiler

[Microcontroller]:
MCU: Microcontroller Unit. See it as a microprocessor, with a few more components (such as memory) to make it a full computer. In this project it will refer to the ATmega32U4.
Arduino: The company behind the ATmega MCU powered microcontroller boards, such as the Arduino UNO.
Bootloader: A small piece of the MCU’s memory, which allows the user to load firmware via USB. See this as the BIOS of the MCU.
Firmware: A program on the MCU that allows it to function as a device.
Flashing [the firmware/bootloader]: The process of installing either to the MCU.
ICSP: In-Circuit Serial Programmer (header). A way to program an MCU that is soldered onto a PCB.
I/O: The Input/Output lines of an MCU

[Mechanical keyboard components/concepts]:
Keyswitch: a component that can be pressed down to connect two pieces of metal together, which in turn can be used to detect a keypress
Cherry MX: The largest/most well-known manufacturer within mechanical keyswitches. 
Cherry MX-like: Keyswitches with a design based on Cherry MX switches, because of Cherry’s expired patent on keyswitches. Includes companies like Kailh, Gateron and much more. PCB’s and keycaps typically advertise compatibility with “MX-Like” switches, to indicate it works with all of those. 
Matrix: A process of efficiently using the I/O lines of an MCU, by using rows/columns to detect keypresses. See “The Keyboard Matrix” for more info.
QMK: One of the most well-known open-source keyboard firmwares.

[Electronics]:
PCB: Printed Circuit Board. A board made from fiberglass, with its purpose in a keyboard being to hold the components in place and connecting them together with traces (wires on a PCB)
Ground: The ‘return’ part of electricity, such as Anti-static discharges.
Diodes: An electrical component that allows power to flow one way, but not another. Used in the keyboard matrix, see “The Matrix Addition: The Diode” for more info.
THT: Through Hole Technology components have long legs that stick through a PCB and get soldered to a plate through hole to the board. These components include the switches, header pins and diodes.
SMT: Surface Mount Technology uses pads on the board to solder SMD (Surface Mount Device) components in place. SMD components can be smaller than THT components and because they don’t stick through the board, it’s possible to design a PCB with SMD components on both sides.

[Soldering]:
Soldering: The process of joining two components together (like the PCB and component) with soldering tin
Soldering iron: A tool to heat up the two components, to make the soldering tin flow between them
Soldering station: A device that includes a soldering iron, but also has a base station which allows you to change the temperature of the iron.

 

Solder(tin): a metal (combination) used to melt between the components you want to solder together. Typically consists of Sn (tin) and Pb (lead) in a 60/40 ratio. Lead free options typically include - other than tin - metal like Ag (silver), Cu (copper), etc. 
Lead-free/leaded solder: Leaded solder is easier to work with, because of its lower melting temperature, but additional safety precautions need to be taken and it may be more difficult to get.
Flux: A substance used to make soldertin flow better to the pads and flow away from the rest of the PCB.
Desoldering braid/wick: A braid from copper strands with flux in it, used to wick away soldertin. Used in drag-soldering too.
IPA: Isopropyl alcohol, a cleaning agent to clean off the flux form the board.
Drag soldering: A popular method to install a chip with a lot of pins, like the MCU. Place a lot of tin over the legs/pads and wick it away. More info in “The Build IV: The First* Board”

[12] Frequently Asked Questions 
Feel free to ask questions, but consider checking if your question has been covered in this section already.

Spoiler

Q: Why didn’t you just use an Arduino Pro Micro/Teensy/whatever other Microcontroller board?
A: Great question, I asked myself that dozens of times in this project. At the end of the day I am glad I didn’t though.
To be fair, making a keypad/keyboard with a bare ATmega chip is a lot more difficult, both in the design and assembly process. However, it does give me a lot more flexibility in design.
This project is more of a prototype towards a larger project, so this was a viability concept too.

 

Q: Is this project open-source?

A: My plan is to open-source this yes, but I need some time to figure out the specifics on that first.

Q: Why did you go for a matrix? Just using a bunch of I/O pins would’ve worked too!
A: That’s correct! I chose to make it a matrix anyways, as practice for a larger project I’ll be working on and because the trace would be neater.

Q: I can’t make this project because I don’t have a 3D printer/Soldering iron/etc.
A: Well first of all, that is not a question. Second of all, certain parts of this project are optional, such as the 3D printed case. You can also commission someone to do the soldering, or see this as the opportunity to get an iron!

Q: 4 keys is not enough for me.
A: Again, not a question! I’ve linked the tutorial I used, feel free to follow it yourself too!
If there is any interest, I might open-source the project files, so people can adjust it to their liking.

Q: Why the name “mini_cardboard”?
A: Please see section [0.1]

Q: What program(s) did you use?
A: Depends on what part of the process/topic. The main programs would’ve been:
Schematic/PCB design: KiCAD
3D Case design: OpenSCAD
Case sketch: Krita
Misc. diagrams in this topic: Inkscape

All links are contains in section [10]

[13] Version history

Spoiler

2021-04-18: Thread created

2021-04-19: Added additional information regarding personal safety, grounding on the USB shield/through-hole pins and added to [7.2] the importance of silk-screening the ICSP header layout.

2021-04-28: Added section [1.4.3], fixed small spelling mistake ("saying" > "saving")

[Radium_Angel]

Very impreeive.

Very much indeed.

 

But you have 1 key too many.

All you really need is this:

 

[Guest]

Nothing impresses me more than seeing something go from an idea to reality. Especially when it's done by someone I know and admire. A great start to what is hopefully a long line of many mini things.

[kelvinhall05]

Awesome guide, cute build, good job  

[minibois]

52 minutes ago, Radium_Angel said:

But you have 1 key too many.

All you really need is this:

Hear me out.. What if.. I mapped all four keys to Ctrl+Alt+Delete?!

40 minutes ago, Den-Fi said:

Nothing impresses me more than seeing something go from an idea to reality. Especially when it's done by someone I know and admire. A great start to what is hopefully a long line of many mini things.

Going into this project, I was a novice with keyboards and didn't know anything about PCB's/soldering/3D printing and more, but through the process I feel like I've gained much more confidence with it

I am hoping to make something more in the near future, if everything goes well!

32 minutes ago, kelvinhall05 said:

Awesome guide, cute build, good job  

The guides by ai03/ruiqimao were great, lacked just a little bit in the final stages, so I felt like it would be helpful to have something that covered the step after. Hope that can prove helpful to someone in the future 

 

 

Thanks all for the kindness!

[Eschew]

 

mini_cardboard, putting the ayyy in wordplay, hehe. 

 

Thoroughly enjoyed reading through this build log-slash-guide! It was equal parts entertaining and informative, and I particularly appreciated the MCU section explained in layman's terms.

 

...Admittedly I'm veeery  when it comes to electronics and circuitry. The last time I hardcore-focused on electricity and related components was back in secondary school Physics/D.T. classes.

 

Miiight I squeeze a few mentions to this thread in the Custom Mechanical Keyboards thread and elongate it even further? Er, what I mean is, I could see it being relevant to custom keebs since your thread: (1) goes into significant detail about electronic components (MCU, diodes, resistors -- how they work and why they're needed), (2) is a very easy-to-understand starter guide for peepos interested in designing their custom PCBs/keebs, and (3) is about as custom as custom keebs get! 

 

InB4 many pings aaaaaa. 

[minibois]

8 hours ago, Eschew said:

Miiight I squeeze a few mentions to this thread in the Custom Mechanical Keyboards thread and elongate it even further? 

Please, go ahead!

I think it would help a lot of people identify what their PCB's are made from, which I think would help people in demystifying  what all the parts do and possibly even help in troubleshooting.

9 hours ago, Eschew said:

goes into significant detail about electronic components (MCU, diodes, resistors -- how they work and why they're needed), (2) is a very easy-to-understand starter guide for peepos interested in designing their custom PCBs/keebs

yaaaay! That was really what I was aiming for!

Easy enough for starters to understand and learn something from, but in-depth enough that advanced users can learn a thing or two from it.

9 hours ago, Eschew said:

...Admittedly I'm veeery  when it comes to electronics and circuitry. The last time I hardcore-focused on electricity and related components was back in secondary school Physics/D.T. classes.

It has been tough to learn about them and I admittedly only know enough to apply it to a PCB like this, but it has been a fun and rewarding thing to learn about.

I wish school would've had a lesson on these sort of consumer electronics, I think that would have gotten me interested in it much earlier.

9 hours ago, Eschew said:

mini_cardboard, putting the ayyy in wordplay, hehe. 

[sub68]

this would be perfect for osu

[minibois]

1 hour ago, sub68 said:

this would be perfect for osu

I have seen the prices for those osu! boards, this seems like a lucrative business idea

45 minutes ago, James Evens said:

1. Consider making the ground plane large (being nice to the manufacturer).

Could you elaborate further on that, or share a link to somewhere that goes into a bit more depth?

I think I understand why a larger ground plane is easier to manufacture, my main concern would be that it would be more difficult to solder to, because there is more material to soak in the heat.

48 minutes ago, James Evens said:

2. Consider changing the diode silk layer footprint. This design might cause visibility issues with low cost protype PCBs.

You mean like those small lines? yea, I think I am wanting to switch that up a bit. This is the standard included in the mechanical keyboard footprint, but I think something a bit more clear would be better.

I've looked online during the design process and didn't find a real 'standard' of sorts for diode silkscreening though.

49 minutes ago, James Evens said:

3. For tin I just go paste or 0.5 mm for everything. No need to have additionally 0.7 mm. (personal preference; you could even solder 0603 SMD with 1.0 mm solder but I guess nobody agrees on this idea as feasible).

I found 0.7mm to work a bit easier for THT.

Of course the idea is you want to apply enough, but not too much solder and you want to keep the heat on the board for as little time as possible.

0.5mm is perfect for SMD, as that requires very little solder, but the THT components required a bit more solder and using 0.7mm just took less time, meaning less time with heat on the board (plus that just sped up the process)

51 minutes ago, James Evens said:

4. Add safety googles to tools. I had a LED package blow up and for side cutters they are anyway needed.

5. Consider labeling (pinout) the ISP header. It is a nice touch. At least make sure you know/see pin1 position with everything soldered to it.

Thank you! I forgot to mention these two and have added them to the topic.

The goggles is something good for soldering in general, as flux could splatter a bit too. The ISP header I had in mind to change, but forgot to mention in the article.

52 minutes ago, James Evens said:

6. Not sure how great it is to keep the USB connector shielding/case floating.

Do you mean like how it is not connected to the ground on the board? Yeah, that is something I figured out too late in the process of making this board, I think it's not a great idea either.

I will edit the topic to mention this along the screw-hole grounding too.

56 minutes ago, James Evens said:

either use short screws made for plastic or just take the M3 and screw into the plastic (basically integrating the nut into the top shell).

I wanted to keep the case easily disassembled, so decided against clips to hold the case together, or self-tapping screws.

57 minutes ago, James Evens said:

For opensource look at/consider this idea: https://www.eevblog.com/oshw/

Place text, logos or qr-codes to your website in the solder mask layer if your PCB layout allows it. This gives you much more details/sharp text compared to the silkscreen layer.

Thank you for all the feedback and resource for Open-source hardware!

Good luck with your own keypad project!

[minibois]

1 hour ago, James Evens said:

Heat soak won't be a problem as the switches aren't connected to ground.

Since I am not just soldering the switches into place, but also the other components (i.e. MCU, capacitors, etc.) I was more worried about the ground connections there becoming a bit of a heat soak.

The person who 3D printed the case parts for me did that in return for me to solder a project of them. That project board was about 2.5 times larger than my board, but has a full ground plane. On some of the pads I had some difficulty getting that to solder in place, but I will do some more research to see the best option out there.

 

 

Would you recommend making both sides of the board a ground plane? (since I don't have grounded components on one side of the board)

[Kaboom1]

On 4/18/2021 at 10:03 PM, minibois said:

as with a 2x2 keypad you aren’t saying any I/O pins with a matrix.

think it should read "saving"

Thanks for the nice guide

 

[minibois]

On 4/27/2021 at 12:06 PM, Kaboom1 said:

think it should read "saving"
Thanks for the nice guide

Thank you for the correction and kind words!