HackPad

Custom Keyboard

This is a keyboard shortened mainly to optimize mouse space for Valorant while keeping enough keys to everyday computer use. It uses an arduino micro pro as a microcontroller and Kailh Box Thick Clicky switches. PCB is not hot swappable but should be simple to mount microcontroller, switches and keycaps onto it. The case has minimal parts for easy lightweight assembly. Arrow keys have been replaced to serve as customizable macros or other special functions.

PCB

CAD ASSEMBLY

BOM

Keycap set must include: 6.25u spacebar, 2u Backspace, 2u L-Shift, 2.25u Enter, 1.75u Caps, 1.5u Tab + Backslash, 1.25u modifiers. Any standard 60%/64-key ANSI kit works.

Build Guide

Heads up before you start: this whole build took me a weekend, but most of that was waiting for parts. Actual hands-on time is maybe 4–5 hours if you're slow with a soldering iron like me.

Stuff you need

Parts are all in the BOM up there. Beyond that you'll want:

• soldering iron + solder (any decent iron works, I used a TS100)
• flush cutters for trimming diode legs
• tweezers — really helpful for placing diodes, get a pair if you don't have one
• some masking tape

You'll also need a printed case. STL is in CAD/KEEBASSEMBLY.stl, or grab the STEP if you want to tweak it. I printed mine in PETG at 0.2 layer height and it was fine.

1. Get the PCB made

The gerbers are sitting in PCB/kicad/gerbers/Keyboard Gerbers.zip. Just upload that zip to JLCPCB, and order 5.

2. Solder the diodes

The diodes are directional, so the black band on the diode lines up with the square pad on the PCB. If the diode is facing the wrong direction the key won't work, or it will register the wrong keys.

What worked for me:

• bend all 64 diodes into little staples first, in a batch
• drop them all into the board before soldering anything (saves you from picking up the iron 64 separate times)
• tape something flat over the back, flip the board, and the diodes will sit flush from gravity
• solder one leg of each, do a pass for alignment, then solder the other legs
• snip the leads when you're done

3. Solder the Pro Micro

Do the Pro Micro before the switches.

4. Switches

Push 4 switches into the corners, and one in the middle. These hold everything in place, then flip it, and solder just those 5. After that, keep putting switches in and solder them in.

Firmware

Runs QMK. The keyboard.json and keymap.c are in Keyboard_firmware/. There are three layers:

• base — normal typing
• fn (hold the key in the bottom right corner where you'd expect right-arrow) — gives you F1–F12, PrtSc, Pause, and the missing arrow nav keys
• reset (fn + the second mod key) — hitting R on this layer puts the board into the bootloader, so you can re-flash without opening the case

Setting up QMK

If you've never used QMK before:

python3 -m pip install --user qmk
qmk setup

Hit yes when it asks to clone qmk_firmware to your home directory.

Copy the files in

QMK expects keyboards to live under qmk_firmware/keyboards/, so:

mkdir -p ~/qmk_firmware/keyboards/keeb/keymaps/default
cp Keyboard_firmware/keyboard.json ~/qmk_firmware/keyboards/keeb/keyboard.json
cp Keyboard_firmware/keymap.c       ~/qmk_firmware/keyboards/keeb/keymaps/default/keymap.c

Compile

qmk compile -kb keeb -km default

Should drop a .hex in the QMK root after a few seconds. If it complains about LAYOUT_64_ansi not existing, your keyboard.json didn't make it over — re-check the copy.

Flash

Plug the keyboard in, then:

qmk flash -kb keeb -km default

When it says Detecting USB port, reset your controller now..., you've got about 8 seconds to short the RST pin to GND on the Pro Micro twice in quick succession. Tweezers work. The flasher will grab it and write the firmware.

If you ever brick the keymap and lose access to your reset key, the layer-2 bootloader binding saves you — fn + mod + R. So even if you mess up the keymap badly, you can always get back into the bootloader without cracking the case open.

To customize anything — different keys, macros on the arrow positions, whatever — edit keymap.c and rerun the compile + flash steps.

Testing

Don't put the keycaps on yet.

1. Plug it in. The little power LED on the Pro Micro should come on. If it doesn't, unplug right away and look for solder bridges between adjacent pins on the Pro Micro.

2. Check that the OS sees it. On Windows it'll show up under Keyboards in Device Manager. On Mac you'll get the keyboard identification wizard popping up — just close it. On Linux, lsusb will show a feed:0000 device. (That's the default VID/PID baked into the firmware, no, it's not malware.)

3. Hit every key. https://config.qmk.fm/#/test is what I use. Press each key, check it lights up on screen, move on.

If something's wrong, it's almost always one of these:

• one key does nothing → cold joint, reflow both pins
• one key types something else → either a solder bridge between two switches, or a diode flipped on a different key (matrix scanning makes this confusing)
• a whole row or column is dead → cold joint at the Pro Micro pin for that row/col, or a totally fried diode somewhere on the row
• pressing one key triggers two → diode missing or backwards on one of them (the matrix can't isolate without it)
• nothing at all → firmware didn't flash, or you're holding a perfectly good paperweight

4. Test the fn layer. Hold the fn key (bottom-right area, next to up-arrow) and tap the number row — should give you F1 through F12.

5. Test the bootloader combo. fn + the second mod + R. The keyboard should disappear from your machine and reappear as Arduino Leonardo or similar. Unplug and replug and you're back to normal. Once you've confirmed this works, you can flash new firmware forever without touching the reset pins again.

That's it. Keycaps on, screw the case shut, go play Valorant.