Did you know? Google and other providers have large databases of geolocation-SSID pairs! By sniffing SSIDs in your area, you can get surprisingly accurate location without surprising power use. Using nRF Cloud, you can even define your own SSIDs with location--a very powerful feature for situations in which you cannot get a reliable GNSS fix.

Nordic has a few Wi-Fi chips now, the nRF7002, nRF7001, and (believe it or not) the nRF7000. Here are the key features:

• nRF7002 - Dual-band, Wi-Fi 6, TX/RX
• nRF7001 - Single-band (2.4 GHz), Wi-Fi 6, TX/RX
• nRF7000 - Dual-band, RX only

For situations where you are implementing Wi-Fi based geolocation and have an alternate backhaul (cellular with our nRF9161, for example), the nRF7000 is an excellent choice.

Let's investigate the basics of Wi-Fi scanning in nRF Connect SDK using an nRF52840 and the nRF7002-EK! Since the nRF7000 has a subset of the nRF7002's feature set, we can simply use a board overlay with the nRF7002-EK to emulate the nRF7000's scan-only feature.

To begin, gather your nRF52840-DK, nRF7002-EK, and PPK-2.

I would recommend cutting at least the VBAT solder bridge and adding a couple of pin headers for power characterization.

Note: if using the PPK-2, be sure to set it to source meter.

Next, clone the Wi-Fi scan example from nRF Connect SDK:

Next, add a build configuration for the nRF52840:

We will add the "nrf7002ek_nrf7000" shield to the build. Within "Extra CMake arguments" add:

-DSHIELD=nrf7002ek_nrf7000

Your build configuration should look just like this.

After flashing, enable power output in "Ampere meter" mode:

And here are the results:

Congrats! This data can then be fed into nRF Cloud for geolocationing.

zperf is a Zephyr shell utility modeled after and used in conjunction with the Linux iperf command line tool. If you haven't used the shell module in Zephyr before, be sure to check out Golioth's guide on using and customizing it:

How to add custom shell commands in Zephyr - Golioth

Adding custom shell commands in Zephyr is a great way to interact with your device, from setting values to making custom data readouts.

GoliothMike Szczys

To get started, ensure you have the latest nRF Connect SDK installed. Let's start by cloning the Wi-Fi shell example:

Once it has been cloned, create a new build configuration for the 7002DK:

Be sure to build the version without the _ns extension.

To make sure zperf is enabled as a console command, click the "Add fragment" button and select the "overlay-zperf.conf" file:

Now build your configuration and program your 7002DK:

Using your terminal emulator of choice, select the second enumerated serial port. For me, this was /dev/ttyACM1.

Let's connect to our local Wi-Fi network and run some zperf commands!

Conduct a Wi-Fi scan with the following command:

$ wifi connect <YOUR_SSID> <YOUR_PASSWORD>

After waiting for a few seconds, you should see the IP assigned to your device with DHCP. Be sure to take note of this address!

Now that we are connected, ensure that you have iperf installed by running:

$ iperf -v

If you don't have it installed it should be available on most package managers. For Ubuntu:

$ sudo apt install iperf

Let's test the upload speed of the nRF7002 by setting up iperf to run as a UDP server. Run the following command on the host machine to determine your IP:

$ ip addr

You should see output similar to this:

My local IP for my computer happens to be 192.168.0.130. Let's use that to set up our iperf server:

$ iperf -s -l 1K -u -B <YOUR_IP>

Here we go! It is waiting for communication from our device. Run the following through the Zephyr shell:

$ zperf udp upload <YOUR_IP> 5001 <DURATION_SEC> <PACKET_SIZE> <BPS>
$ zperf udp upload 192.168.0.130 5001 10 1K 10M

If you'd prefer a longer sample, you can always change "10" to something larger like "60." You can also change the target transmit speed. Let's try something like:

$ zperf udp upload 192.168.0.130 5001 60 1K 80M

You can squeeze some performance out of the 7002 if you're able to keep up with it! The rate on the server side will often differ and be lower than on the device side:

Still, ~24Mbps is 3 MB over the air. If the above packet loss is too high for your application, a more reasonable target data rate is somewhere between 10-15Mbps.

Let's see how quickly we can download from the network with the 7002. Use the following commands:

$ zperf udp download 5001

On the host side:

$ iperf -l 1K -u -c <DEVICE_IP> -b <BPS>

I see a typical download maximum of ~9Mbps.

You can run the commands above for TCP as well as UDP. The extra overhead of TCP will show slightly lower throughput. I've compiled a reference list of commands for iperf and zperf that you can refer to below:

iperf commands

• UDP server

$ iperf -s -l 1K -u -B <SERVER_IPV4_ADDR>

• TCP server

$ iperf -s -l 1K -B <SERVER_IPV4_ADDR>

• UDP client

$ iperf -l 1K -u -c <DEVICE_IPV4_ADDR> -b <TARGET_OUTPUT_BPS>

• TCP client

$ iperf -l 1K -c <DEVICE_IPV4_ADDR> -b <TARGET_OUTPUT_BPS>

Wi-Fi commands

• Wi-Fi scan

$ wifi scan

• Wi-Fi connect

$ wifi connect <SSID> <PASS_KEY>

zperf commands

• UDP server

$ zperf udp upload <SERVER_IPV4_ADDR> <PORT> <DURATION> <PACKET_SIZE> <OUTPUT_BPS>

• TCP server

$ zperf tcp upload <SERVER_IPV4_ADDR> <PORT> <DURATION> <PACKET_SIZE> <OUTPUT_BPS>

• UDP client

$ zperf udp download <PORT>

• TCP client

$ zperf tcp download <PORT>

Thanks for reading!

Electronics design is supposed to be hard, isn't it? No longer.

Let's create a 40% PCB as fast as we can with nothing more than KiCAD, Keyboard Layout Editor, and a few scripts.

Let's create a fun KLE...

Download it to a safe place. You'll need it.

Start by cloning the following repo. I created it! If you run into issues, please open one!

GitHub - LordsBoards/PyKLE-Schematic: This ingests a kle.json and spits out a schematic with proper symbols and footprints.

This ingests a kle.json and spits out a schematic with proper symbols and footprints. - GitHub - LordsBoards/PyKLE-Schematic: This ingests a kle.json and spits out a schematic with proper symbols a…

GitHubLordsBoards

Follow the instructions in the repo above to generate your schematic with all switches and diodes connected and labelled correctly. It may take a minute to run.

Copy the generated "generated_schematic.kicad_sch" to a fresh and clean new KiCAD project.

Add a hierarchical sheet:

And select your sheetfile + name it something memorable.

Now let's quickly add a microcontroller, regulator, and USB-C port. Go go go!!!

Add a USB-C port with the correct 5.1k pull down resistors. Include a series PTC fuse, ferrite bead, and ESD protection with the USBLC6-2SC6.

Add a regulator for the input USB power to step it down to 3.3V.

For this PCB, we're using the STM32L443CCU. This is a very easy chip to create a keyboard for as it requires few decoupling capacitors, has a USB bootloader, and requires no external crystal or termination resistors for USB.

This is really it! All you need for an ARM microcontroller with 256k of flash, USB, and QMK/Vial support!

A few more niceties are in order. I'm adding a 6 pin tag connect port for SWD programming.

Now go through and assign your footprints. The switch footprints were automatically assigned but things like diodes, push button switches for reset, and capacitors will need to be set.

In your matrix schematic, connect the rows and columns and add global labels per row/column like so:

Next, install the following plugin from Zykrah:

GitHub - zykrah/kicad-kle-placer: KiCAD plugin to help place switch footprints based on a KLE

KiCAD plugin to help place switch footprints based on a KLE - GitHub - zykrah/kicad-kle-placer: KiCAD plugin to help place switch footprints based on a KLE

GitHubzykrah

Once you have it installed, add your keyboard-layout.json and change the key annotation and stab annotations to match my script (MX & STAB).

Your layout is ready! I'm going to flip the bottom stab and get to work routing my microcontroller:

A few notes--I flipped the two switches up top to allow the USB port to sit correctly. I would recommend using a 4 layer board for all boards since they're so cheap from JLC. Keep traces out of your two inner layers and fill one with GND and one with VCC (3.3V in this case).

Here is the board, ready to be routed:

Once you have completed routing, generate your files with JLC. You may have to pre-order this ST part. Here's the complete board! Check the GitHub repo below for the full schematic, PCB, and production files.

GitHub - LordsBoards/KeyboardSpeedrun: Keyboard Speedrun Repo

Keyboard Speedrun Repo. Contribute to LordsBoards/KeyboardSpeedrun development by creating an account on GitHub.

GitHubLordsBoards

Thanks for reading. Check out my Discord below!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 11 other members and enjoy free voice and text chat.

Discord

Now that we've integrated somebody else's microcontroller board into a keyboard PCB, we should take a moment to learn about integrating microcontrollers directly into our keyboard PCBs.

Let's walk through the important steps of schematic capture before doing board layout!

The microcontroller I use for most of my PCBs is the RP2040 from the Raspberry Pi foundation. The highlights are:

• Dual-core Arm Cortex-M0+ processor, flexible clock running up to 133 MHz
• 264kB on-chip SRAM
• 2 × UART, 2 × SPI controllers, 2 × I2C controllers, 16 × PWM channels
• 1 × USB 1.1 controller and PHY, with host and device support
• 8 × Programmable I/O (PIO) state machines for custom peripheral support
• QMK/Via/Vial support
• External SPI flash required

This microcontroller has excellent community support and is relatively easy to integrate into a PCB. As compared to industry focused microcontrollers like ST's offerings (i.e. STM32F411's used in PCBs) the RP2040 requires a couple of extra components to function. As always, check the datasheet!

This is the heart of the keyboard! I use "Shift+L" to create node labels that make the schematic easier to read. Some critical things to note are:

• The RP2040 has an integrated 3.3V->1.1V regulator for internal use.
• The TESTEN pin must be shorted to ground.
• The RUN_ node should be connected to a button to allow restarting the board.

The RP2040 has a built in USB bootloader (which is not typical for most microcontrollers) that enables easy programming. If you need to do mass programming, you might prefer to expose the "SWCLK," "SWD," and "3.3V" pins.

The RP2040 requires a number of decoupling capacitors for proper functioning. Check the last post on decoupling capacitors for more info! One 100nF cap is used per VDD input pin (as specified in the datasheet) and a bulk 1uF cap is used per voltage regulator.

Power is supplied to the microcontroller through USB. However, USB's nominal voltage (for our purposes!) is 5V. The AP2127N3-1.2 is an extremely common 3.3V fixed regulator that has, probably, a million clones available. This will take in our 5V and spit out 3.3V for the RP2040's regulators. Other things to note in this section are the USBLC6 ESD protection IC which protects the data and power lines of your USB port. A 1A PTC resettable fuse is included as well as a 100 Ohm @ 100 MHz ferrite bead. There is a lot of woo surrounding ferrite beads. I haven't done near field testing of any keyboard PCB but it is cheap to include a ferrite bead and can solve EMI issues. For more information check out StackExchange post:

Question on EMI filtering

I have seen people using ferrite beads to suppress EMI from switching power supplies.Recently, I came across the following blog post where the author successfully re-models a switching power suppl…

Electrical Engineering Stack ExchangeUser

Next let's check out our PCB connectors. The USB-C port used has a few pins you may not be familiar with if you have previously used Micro-B USB ports. The CC1/CC2 pins are used for orientation detection. Only one pin is connected to the cable that is inserted. The 5.1k resistors "communicate" with the USB host that the peripheral is requesting a maximum of 500mA. The CC lines are used for USB power delivery. Thankfully, even the most severely gamerfied RGB keyboards should use less than 500mA. Your mileage may vary if you include a solenoid or 600 NeoPixels.

The other connector is a JST connector to be used with a Unified Daughter Board. This is for the JST variant (which shares cable specs with STEMMA Qt and Qwiic connectors).

Next is the crystal. The RP2040, when it starts up, creates a clock signal using an internal oscillator (probably using an RC circuit). This is a clock signal that is too inaccurate for USB's strict timing tolerance! The RP2040 then starts driving its crystal which provides superior timing precision and allows USB to work well without a hitch. Quartz crystals require load capacitors. C1 = C2, C1 = 2*CL - 4pF should give you values in the ball park. CL is a value given by a crytal's datasheet.

Next, here are the connections to the RP2040's external flash. A button is placed on the chip-select pin of the flash. When this button is held down, it forces the RP2040 to run it's ROM bootloader instead of the SPI flash's program code. This allows you to reprogram the device! The other button simply resets the RP2040.

An indicator LED is provided as an example for a caps lock indicator. For more information on choosing an LED resistor value, check this post. The LED_INDICATOR net label should be applied to a GPIO pin of the microcontroller. In this configuration, the microcontroller will sink a significant amount of current (~5mA).

Do not exceed the rated current sink of the microcontroller! It will never be more than 20mA. If you need an array of LEDs consider using a dedicated LED driver or individual transistors.

Finally, there is the switch matrix.

Each switch requires a diode. The microcontroller alternates what rows/columns are scanned--the diodes prevent "ghosting" and allow n-key rollover. This is just a small example, your matrix will likely have between 10-15 columns and 3-6 rows. Matrices are used in order to allow a microcontroller with relatively few pins (30 for the RP2040) to address many switches.

You can download this RP2040 template project here:

GitHub - hlord2000/Ohmbedded-RP2040-PCB-Template: An RP2040-based keyboard PCB KiCAD Template Project

An RP2040-based keyboard PCB KiCAD Template Project - GitHub - hlord2000/Ohmbedded-RP2040-PCB-Template: An RP2040-based keyboard PCB KiCAD Template Project

GitHubhlord2000

Thanks for reading!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 5 other members and enjoy free voice and text chat.

Discord

Decoupling capacitors are a critical component for circuits that switch at a high speed. Electricity has a limited speed of propagation and, when a large transient current draw is placed on a power supply (as in a bunch of transistors changing state when you print "Hello, world!"), voltage within a microcontroller can drop before adequate current can be supplied.

There are two ways of considering how a capacitor works--in the time domain and in the frequency domain. Let's look at the time domain model first.

\[ I = C \frac{dV}{dt} \]

Where I is current (charge per second), C is capacitance, V is voltage, and t is time. This implies that any change in voltage will necessarily "push" or "pull" current out of or into a capacitor. Let's visualize this with the Falstad Circuit Simulator.

This RLC (resistor, inductor, capacitor) oscillator swings up and down +/-10V. The capacitor here works with the inductor to boost the voltage from ~.3V to 10V. The capacitor sources and sinks current as the oscillations continue--in a sense it is acting as a very very tiny battery.

How does this relate to a circuit using a microcontroller? When a particularly strenuous bit of calculation happens, a ton of gates on the microcontroller change state all at once. MOSFET, the technology used in modern microcontrollers, is used because of its miniscule on current. The switching part of the MOSFET (the gate) simply needs to be charged or discharged. Some discrete MOSFETs have ~18nC gate charge. Microcontroller MOSFETs will be even lower. Not a lot per device but it quickly scales with many thousands of transistors on even simple microcontrollers. Let's take a look at what that might look like in Falstad.

For this toy example, it can be seen that as soon as the transistor is closed a large amount of current is sourced. This causes the voltage to dip close to zero. This effect is greatly exaggerated for demonstration. In reality, the dip in voltage will be significantly shorter and smaller in magnitude.

These variations are important! If a power supply is too noisy, the "high" voltage level of a transistor may not be properly supplied. This may cause the transistor to fall below the threshold of a logic high level and cause a myriad of errors in the microcontroller.

Let's simulate a slightly different scenario with a decoupling capacitor!

You can see as the transistor is switched on and off that the voltage rail becomes quite noisy! +/- 1V around the "logic level" of 5V. Let's add in a decoupling capacitor to source and sink current near the transistor.

Now the voltage ripple is reduced to almost nothing. Thanks decoupling cap.

Another way to consider capacitors is in the "frequency domain." Let's apply a Laplace transform to the above equation describing a capacitor.

\[ I = C \frac{dV}{dt} \]

\[ \mathscr{L} \{ \frac{dV}{dt} \} = sV(s) -V(0) \]

Let's neglect V(0) and assume that it is 0.

\[ I(s) = CsV(s) \]

\[ Z(s) = \frac{V(s)}{I(s)} \]

Substituting the expressions for V(s) and I(s) we derived earlier and canceling out the I(s) terms:

\[ Z(s) = \frac{1}{Cs} \]

Since s represents the complex frequency, we can replace it with jω, where j is the imaginary unit and ω is the angular frequency. This gives us:

\[ Z(jω) = \frac{1}{jωC} \]

Where ω is the angular frequency in radians per second, j is the imaginary unit, and Z is the complex impedance or resistance at a certain frequency.

What does this all mean? Let's take the limiting case where the frequency, ω, is infinite. This would mean that Z approaches zero. It becomes a short. Conversely, let's take the limiting case where the frequency approaches zero. It becomes infinite in impedance. In a decoupling circuit, the capacitor sits across the power rail to ground. Any noise in the circuit sees the capacitor as a very low resistance path to ground! This prevents noise from propagating to the rest of the circuit (i.e. the microcontroller) and ensures that the logic voltage for every transistor is always well defined.

There are a few more rules of thumb about decoupling capacitors. Here's a quick list:

1. Place the decoupling capacitor as close to the microcontroller power supply pins as is practical. It may not make a difference for low performance systems but it is a best practice.
2. All capacitors should have a via to ground as close to them as possible. Always always always!
3. The rule of thumb is one decoupling capacitor of 0.1u-1u per power supply pin. If you're working with a small QFN, absolutely do this. If you're working with a 1000 ball FPGA, include bulk decoupling and evaluate your performance later.
4. Tantalum capacitors are polarized! If you put it in backwards it will explode.
5. Manufacturer datasheets are the way, the truth, and the light. They are also written by sophomore undergrad interns. Keep both in mind!

I leave you with an excellent presentation by David Jones of EEvblog.

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 5 other members and enjoy free voice and text chat.

Discord

Remember the Keyboard Layout Editor .json file we saved earlier? Turns out that we can use it to generate a plate file! Let's make a simple stand-off based plate for our macropad.

To get started, navigate to the ai03 Plate Generator site.

Paste your KLE file into the text box. If you don't have one, check out Keyboard Design Part 3.

The following plate file will be generated for you. If you are using a different variety of switch, change it from Cherry MX to whatever you have chosen for your PCB.

Caveat: watch out for the orientation of your stabilizers!

If you have a stabilizer oriented on your PCB like this (south-facing) you should use the following stabilizer cutout and footprint combination:

If your footprint is flipped, i.e.

Then simply flip your stabilizer cutout by adding "_rs:180" to the spacebar's footprint in the keyboard layout description.

We will now download the ".dxf" file from ai03's plate generator. This can be used in CAD programs like SolidWorks or Fusion360 but can also be imported directly into KiCAD. We will use KiCAD to create a plate that can be manufactured by JLCPCB!

Create a new blank PCB file and click "File > Import > Graphics..."

Select and import your file. Be sure to change the "Graphic layer" setting to "Edge.Cuts."

Congrats! Now comes the gross mechanical design part of the process.

Ungroup the items you just imported by clicking on the group, right clicking, and selecting "Grouping > Ungroup."

Adjust the outlines of your plate by creating a new rectangle. You will use this to add mechanical holes to place standoffs in, kind of like a CannonKeys Practice series board.

Typically, standoffs are M2.5 or M3. I use M2.5 most of the time. Let's add some mechanical standoff holes!

Press "Shift+A" to directly add footprints. Search for M2.5 and select whatever looks nice! I selected "MountingHole_2.7mm_M2.5_DIN965_Pad"

Add a rectangle on the Edge.Cuts layer to outline these holes.

Got it! I would delete the silkscreen layer text so that it doesn't show up on the manufactured board.

Here ya are!

You can use JLCPCB tools to generate the gerber files for this and order it. It is a best practice to use this in conjunction with a CAD tool to confirm your design if implementing into a machined or 3D printed case.

Click here for part 6!

Hope you enjoyed this post. Join our Discord if you have any questions!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 5 other members and enjoy free voice and text chat.

Discord

Rotary encoders are a reliable, switch-debounce-safe method of detecting (believe it or not) rotary motion. Rotary encoders (aka quadrature encoders) have a number of uses outside of making your keyboard look cool--they have historically been used as part of a closed-loop motor control system as the speed/direction input device.

It is useful to look at Gray code first to understand the exact way that rotary encoders work.

Gray code is a clever numerical encoding system that ensures only one bit changes at a time between adjacent values, minimizing errors during rapid transitions. This is particularly useful in rotary encoders, as it reduces misreadings caused by simultaneous bit changes.

What does this look like practically for human input devices? Two separate contacts that generate two square waves 90° out of phase. As the encoder is rotated, contact A and contact B are sequentially shorted to ground. Using internal pull-ups on a microcontroller, the following waveform is generated.

Each valid transition (Gray code count up!) can show you the direction of the step the rotary encoder has taken. How can you determine that direction and the validity of the transition in software? With a state machine!

Keep state and register a transition interrupt on pins A and B. Since the two independent contacts of the encoder cannot influence each other with switch bounce, we can get very precise and responsive input from a rotary encoder on every detent.

Note: this isn't the only way to handle quadrature encoders. If you don't want to use interrupts for whatever reason you can simply poll them quite quickly. Some detents may get lost but overall implementation could be simpler.

Here is QMK's encoder implementation:
https://github.com/qmk/qmk_firmware/blob/master/quantum/encoder.c

Have questions or comments? Be sure to check out our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 5 other members and enjoy free voice and text chat.

Discord

Embedded engineers bridge the gap between hardware and software. That means we need tools beyond our editor, compiler, and debugger. Oscilloscopes, multimeters, logic analyzers, hardware debuggers, and on and on. Here are my recommendations for the tools you can use to make embedded development easier!

Note: All Amazon links in this post give me a kickback!

Oscilloscope

Start with the basics! Hopefully you aren't doing anything too strenuous with this oscilloscope. Outside of some power supply evaluation, your best friend should be your logic analyzer. So let's keep it simple. Use something like the following:

Siglent Technologies SDS1202X-E 200 mhz

A 200 MHz 2-channel oscilloscope.

Buy Here!

This should cover most of your usecases.

Logic Analyzer

Saleae is the be-all, end-all of logic analyzers. There are cheaper clones that exist but the real power of this LA is in its software package and the ease with which custom plugins can be developed. Buy once cry once! There are a number of options within the Saleae family but for many users (with low speed communication buses) their lower tier devices are just fine.

Saleae Logic 8

An 8-channel logic analyzer with killer software.

Buy Here!

Multimeter

An embedded engineer's multimeter is nowhere near as critical as an electrician's! I mostly use my multimeter for quick voltage measurements or, more often, to verify continuity of new PCBs. Anything will work--I personally use the EEVblog BM786 because it comes with excellent quality probes and supports Dave.

EEVblog BM786 Multimeter

A multimeter with great test leads.

Buy Here!

Hardware Debugger

The Black Magic Debug Probe is a game changer for the beginner. printf()s can only get you so far after a while. Using a hardware debugger allows you to step through your program one line at a time (just like a regular, plebian software developer!). It presents a GDB server to the user, connects via USB-C, and supports pretty much every debugging protocol you could desire (including RTT or real-time transfer). I'm a sucker for open source projects so be sure to purchase directly from 1BitSquared to continue supporting the Black Magic project!

Black Magic Probe V2.3

Best debugger in its SEGment.

Buy Here!

Power Supply

Unless you have very exacting requirements, DC power supplies should almost be treated as consumables. Grab the cheapest one you can with constant current so that you can more effectively smoke test boards.

DC Power Supply Variable, 30V 10A

Jellybean power supply.

Buy Here!

Probes/Leads

Just buy dozens of these. Truly consumable parts. I would recommend getting some with the little hooks and some with dupont connectors.

Sumnacon 39 Inch Multimeter Test Lead Set

Disposable but DO NOT throw into the ocean.

Buy Here!

Goupchn Stackable Banana Plug to Breadboard Male Jumper

Keep out of bodies of water.

Buy Here!

Board Probing/Fixturing System

PCBite is a game changer for board fixturing and probing. The probes are actually sharp pogo pins (that will cut through flux) and have an excellent weight to them. When you place them on a pad, test-point, or lead they stay there. The board fixtures themselves are also excellent--they are insulated and have strong magnets in their bases to keep things nice and steady. I would recommend picking up a kit with an oscilloscope BNC connector probe included.  

PCBite kit with 2x SP200 and 4x SP10 probes

These things are sharp.

Buy Here!

Hand Tools

Pick up a pair of flush cutters ASAP if you don't have them already! They may be called flush cutters, but they are the greatest multitool of all time. Tweezers, pliers, cutters--they fixed my marriage. Get the Hakko ones--they have the nicest jaws.

Hakko-CHP-170 Micro Cutter - Red

Panacea.

Buy Here!

Wire strippers will come in handy eventually. Ben Eater showed off these in one of his breadboarding videos and they are what I have used since then.

IRWIN VISE-GRIP Wire Stripping Tool / Wire Cutter

Eater approved.

Buy Here!

An exacto knife is your best friend on a prototype board spin. When you inevitably swap TX/RX lines, use this little guy to scrape off solder mask and bodge together a temporary fix.

Elmer's X-ACTO

Probably sharper than the PCBite.

Buy Here!

Pick up some tweezers and screwdrivers (including hex keys and torx) from a great brand.

Mako Driver Kit + Precision Tweezer Set

Mako? Like the shark?

Buy Here!

Soldering

You will probably not use your soldering iron that often with microelectronics. I elect to spend a little bit less on my soldering iron proper and quite a lot on my actual solder. Grab something super cheap and a handful of tips.

Aipudi Soldering Iron Kit Electric 60W

Hot.

Buy Here!

Spend your real money on nice, leaded solder. Loctite makes some nice stuff. Be sure to wash your hands after handling!

MULTICORE / LOCTITE 3096525-M

Metal hot glue (if you think about it).

Buy Here!

Pick up a spool holder. You could use spool for leaded, one for unleaded.

Hakko 611-2 Dual Solder Reel Stand

So much room for activities.

Buy Here!

Grab some nice flux!

Chipquik SMD4300TF10 Tack Flux

Don't eat the glue.

Buy Here!

And some solder wick to clean up pads after desoldering.

Lesnow Solder Wick

Gets hot! Cut off a piece and hold it with tweezers.

Buy Here!

Also spend the couple bucks on tip tinner and a brass sponge to stretch the lifespan of your iron's tips.

Thermaltronics TMT-TC-2 Tip Tinner

Like new.

Buy Here!

Weller Soldering Brass Sponge Tip Cleaner with Silicone Holder

Also like new.

Buy Here!

Get a hot air reflow station and a hotplate.

YIHUA 959D-Digital Hot Air Rework Station

The Merrymen

Buy Here!

Soiiw Upgraded 110V 800W LED Microcomputer Electric Hot Plate

Nelly

Buy Here!

Also pick up a decent microscope with a light. I use this one but you could probably get away with a USB microscope.

AmScope SE400-Z Professional Binocular Stereo Microscope

Best debugger in its SEGment.

Buy Here!

Chipquik makes excellent solder paste. Be sure to keep it in a cool place when not in use. Get the little jar so that you can save excess solder paste after stenciling.

Chip Quik SMD291AX50T3

Try the gray stuff, it's delicious! (Do not eat lead.)

Buy Here!

Grab some magnet wire and solid core tinned wire for fixing PCB errors. The enamel wire can have its plastic coating burnt off with a blob of solder but is insulated elsewhere. Louis Rossmann uses magnet wire for many of his repairs.

BNTECHGO 28 AWG Magnet Wire

Used to make electro magnets.

Buy Here!

Silicone Wire Kit

Like an electric eraser.

Buy Here!

Be sure to use Kapton tape. It is very thermally stable and holds great. You will find a million uses for it.

MYJOR High Temperature Kapton Tape

Think they used this stuff on the space shuttle

Buy Here!

Finally, pick up an Omnivise for holding boards when soldering.

Hakko C1390C Omnivise

Omnipotent?

Buy Here!

You're on the way to being a true blue embedded engineer. I use many of these tools on a daily basis and hope you find use from them too! If you feel that I've missed something don't hesitate to reach out on our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 5 other members and enjoy free voice and text chat.

Discord

Time to design something you can really hold in your hand! If you've been following along, you should have a cool macropad layout planned and footprints for everything you need.

Click "Tools > Update PCB from Schematic." KiCAD should open up the PCB editor.

Keep everything checked for now. If you are updating a PCB from a schematic in the future you should look more carefully at these options.

Nice! Keyboard switches are 0.75" or 19.05mm square. This is a bit of a simplification--keycaps are something close to 18mm square and plate cutouts are 14mm square.

Here is a diagram of relevant keyswitch dimensions!

Let's set up the "snap grid" to fit keyboard switches.

Click the grid drop-down. Click on "Edit User Grid..."

Enter 0.75" / x to get fractions of a key switch unit, commonly referred to as "u" (as in 2u, 6.25u, 10u keys). I personally use 16 as my divisor but you can use whatever you'd like!

Tip: KiCAD will evaluate unit conversions for you in most input boxes!

Click back and forth between the schematic and PCB to find footprints. This is what I do when not using an auto-placing script and I recommend you do it to get the hang of navigating between the schematic and PCB editor. When you click on a symbol in the schematic, it highlights its footprint in the PCB editor!

Once you have laid out your macropad's keys, you should see something like this.

Note: the stabilizer orientation changes the direction of the cutout you will use on the keyboard's plate.

Position your pro-micro somewhere nice looking. This will be relatively easy to route!

Place your diodes in a way that minimizes the number of crossing traces. This is an art! Don't worry if it isn't perfect, just make sure that everything connects properly.

Next, press "X" to start routing. You're really doing it!

Here I am halfway through routing. Notice that the ratsnest (the little lines running between traces and their destinations) is crossing itself. Let's change some pin numbers around in the schematic to simplify this. Remember: we should only use pins labelled "D*" because these are available GPIOs on all pro micros.

I've flipped the COL1-COL5 pins by selecting them and pressing "y" to flip vertically.

Be sure to update the PCB from the schematic in order to transfer these changes.

There! Much better.

Routing complete! Let's take a look at its 3D render.

See that error? That means that we need to define the actual physical edges of our board by drawing them on the "edgecuts" layer. Let's define edgecuts for this board.

Select the "Edge.Cuts" layer. Switch your grid spacing to the key-unit size.

Next, select the rectangle tool in the toolbar to the right.

Draw out the edgecuts! I added a bit of extra distance up top.

The edges are a bit sharp, though. If you were to order this board as-is, you would probably poke yourself on the edges. Let's add some fillets (aka radii) to the edges.

Right click the rectangle you created and "Fillet Lines."

Set your radius to whatever you'd like. Let's try 2.5mm.

Nice! Now we have our board in a good place. One last step. Let's add "ground fills" connected to the ground net. I personally prefer the look of boards with ground fills. Practically, ground fills are important for signal integrity for all electronics. Since this is a carrier board, signal integrity isn't necessarily a big concern. The frequency of matrix scanning is only ~1KHz.

Click "Add a filled zone" and draw it a bit larger than the edge cuts of the board. Don't worry, there are default rules that will prevent the copper from actually being exposed on the edges.

Select the top and bottom copper layers and select the "GND" net to connect the pours to ground. Be sure to change the clearance to 0.127mm

This should be the result! Let's take a look in the 3D viewer.

Congrats! Let's use Bouni's JLCPCB tool to generate board files.

From the PCB editor, click "Tools >  External Plugins > JLCPCB Tools."

Allow it a moment to download the latest JLCPCB parts inventory. Then simply click "Generate" in the top left! We will explore more of the features of the JLCPCB Tools plugin in future posts.

Navigate to https://jlcpcb.com and click "Instant Quote."

Next, open your project folder. You should see a new "jlcpcb" folder that contains your production files.

Open the "production_files" folder and then drag your "GERBER-*.zip" folder to the JLCPCB site.

Let's use the defaults at first. We will explore other options in future posts.

The total cost for 5 boards comes out to ~$30. They should take about a week to arrive. I would recommend using DHL shipping.

In the next post we will design a plate + case for this macropad using KiCAD!

Click here for part 5!

For more information and to ask keyboard specific or general electronics questions join our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 4 other members and enjoy free voice and text chat.

Discord

It's time to get into the best part of keyboard design--coming up with a cool idea and bringing it to life. By the end of this post, we should be ready to start our PCB layout for a pro micro based keyboard.

To get started, lets play around with https://keyboard-layout-editor.com

You will be greeted with the following interface.

Click on "Preset" in the toolbar and select "Blank Layout"

Let's add a few keys. Click the "Add Key" button to add a few keys. Play around!

If you want to change the width of keys, click on it and modify the "width," and "height," properties.

Here is my macropad design. Find something that you think looks cool!

When you're ready, click "Download," in the top right and save the .json output to your project folder. This output can be used to create renders and will be helpful when creating our keyboard's QMK/Vial firmware.

Open up your KiCAD schematic.

Tip: to quickly open the schematic symbol placing dialog, use the shortcut "Shift+A"

Search for the pro micro symbol you created in the last tutorial. If you don't have this, refer to Keyboard Design Part 2!

Press "OK," to place it on the schematic.

Next, press "P" to place power symbols on the schematic.

Search for GND and for +3V3 power symbols and place them on the top and bottom of the symbol.

Now press "Shift+A" to add switches to the schematic. You can select either "solder," or "hotswap," switch symbols. These are just convenient ways that marbastlib has set up links between your footprint and symbol--in many other cases you will have to set footprint/symbol relationships as described in the previous tutorial. Also note the two different varieties of switch. "MX" switches are most commonly used but "choc" switches from Kailh have become increasingly popular for low profile keyboard designs. Both have hotswap footprint variants available.

If you are a beginner to soldering, I would recommend using the "solder" variant as it is easier (in the opinion of the author) to solder these switches as opposed to manually soldering hotswap sockets. In the future we will discuss how to order assembled keyboards with hotswap sockets.

Add enough symbols to fill the keymap you created before. I typically place one symbol and then copy and paste as many as required.

Next, add diode symbols to the schematic. Diodes are used so that modern matrix scanning algorithms will work properly. For more information, refer to the following page: https://pcbheaven.com/wikipages/How_Key_Matrices_Works/

In short, the diodes are added to prevent ghosting and to allow n-key rollover.

After adding the symbol to the schematic, double click on it and assign a footprint. The diode footprint depends on the specific diode you choose to use--in this case, we are using through hole diodes available on Adafruit.

1N4148 Signal Diode - 10 pack

You have some electrons over here, and you want them over there but you don't want the electrons from over there to be able to come over here? That's what a diode is for, these are…

Adafruit LogoAdafruit Industries

These are packaged in a "DO-35," formfactor. Refer to the datasheet to find this information for the diodes you choose to use.

Continue populating your matrix.

Once you have completed it, connect the "rows" of your keyboard to the cathodes of the diodes.

Connect the columns to the other side of the switches.

Click the "Add a net label" button (or press "L") and label the connections between rows and columns.

Once you have placed the rows/column labels, you can rotate them by pressing "R".

This completes the matrix layout.

Good work! Just a few more details.

Add an MX_stab symbol from marbastlib. Double click on the symbol and change its footprint to the applicable stabilizer footprint.

Note: all keys >2 units in width/height require a stabilizer.

Copy your column and row labels to pins on the pro micro symbol. Be sure to select pins that are eligible GPIO pins as shown in the pinout image below.

D2-D9 are pins we can use! To keep compatibility with other pro micro form factor devkits I would recommend using pins labeled "D*."

One last step--press "Q" over all unconnected pins to prevent an error in the design rules checker or "DRC." This adds a small "X" icon over pins that are not going to be routed in your PCB design.

Congrats! You are one step closer to your first custom board design. In the next tutorial, we will learn a bit about the process of routing and ordering a PCB from JLCPCB!

Click here for part 4!

For more information and to ask keyboard specific or general electronics questions join our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 4 other members and enjoy free voice and text chat.

Discord

From a question someone posted in Discord.

what's a safe bet on how many ohms resistors for 2-pin leds should be

This is the basic circuit for an LED, right? LEDs are simply diodes. Diodes are non-linear circuit elements that have a decently high resistance until they reach their Vf or forward voltage. Once they reach their forward voltage (between 1-2V for typical LEDs you will encounter and a key piece of info to find from the datasheet) they lose nearly all resistance and you can treat the circuit as the following:

The LED is actually just another battery with voltage Vf, but opposing the voltage V of your system.

Do some ohm's law stuff. I1 = (V-Vf)/R1.

If you want your current through the LED to be something like 5-10mA, just set I1 to 5*10^-3 and solve for R1

Another thing to keep in mind is the power through the resistor. It's a good check to P = R*I^2 to verify that the power rating for the resistor is high enough and it won't get super hot.

In practice,  look at the datasheet and use this calculator:  https://www.digikey.com/en/resources/conversion-calculators/conversion-calculator-led-series-resistor

Here is a quick example with a random LED.

Max current, If, of 30mA. I will use 5mA here.

Typical Vf of 2.0V.

Into the calculator, we get 260 ohms with a power use of 6.5mW. Looking up the closest resistor value, I would recommend 270 ohms.

Thanks!

Designing a wholly integrated keyboard PCB from the ground up can be a tough ask. That's why I started by integrating an existing development board into a "carrier" PCB that I designed and ordered. That project can be found here.

The concept of using a devkit to build a keyboard isn't new. People in the hobby have used the Pro Micro from SparkFun for years to iterate quickly and to do away with some of the complications of having a fully integrated board assembled. The Pro Micro's history in the hobby has also meant that a number of other devkits with extended functionality are available with Pro Micro backwards compatibility.

To get started, let's take a look at the microcontroller development board we'll be using!

Adafruit KB2040 - RP2040 Kee Boar Driver

A wild Kee Boar appears! It’s a shiny KB2040! An Arduino Pro Micro-shaped board for Keebs with RP2040. (#keeblife 4 evah) A lot of folks like using Adafruit parts for their Keeb builds…

Adafruit LogoAdafruit Industries

The Adafruit KB2040 integrates an RP2040 from the Raspberry Pi Foundation (yes, that Raspberry Pi) into a Pro Micro footprint. Some other fun bells and whistles include 16MB (!) of flash, an addressable RGB LED (or NeoPixel), and STEMMA QT support. For more information on STEMMA QT (which is really an I2C bus + power in a JST connector) check here.  

I have chosen this board because of its availability and the popularity of the RP2040 in the hobby at the time of writing. The RP2040 has been available when few other microcontrollers have. The flash size mentioned above also enables keyboards based on the RP2040 to store dozens of layers, macros, and other fun QMK features you will be introduced to soon.

Let's get started. Open up KiCAD (check here for installation instructions from the last post) and create a new project.

You will see two files generated by creating this project:

Start by opening the "*.kicad_sch" file. You will be greeted with a blank schematic. Unlimited possibilities!

To get started, let's place a Pro Micro schematic symbol. You may notice that we don't actually have a "Pro Micro" schematic symbol or footprint. Fret not! A key part of learning an ECAD suite is picking up the ability to generate good looking and functional schematic symbols and footprints.

Note: skip ahead to simply download the KiCAD symbol and footprint I will show how to design. I encourage you to try it out yourself as you will almost certainly discover a part with a poor schematic symbol or incorrect footprint.

The Pro Micro's pinout is relatively simple. To get started, let's look at the Adafruit KB2040 documentation.

The specific pins broken out can be seen in the pin headers on the left and right.

Lets create the schematic symbol! Open the Symbol Editor from your project in KiCAD.

Click "File > New Library" and create a Project specific library. You can also create a global project library if you intend to use this symbol in other PCB designs.

Name the library "Pro_Micro.kicad_sym" and save.

Click the "create a new symbol" button in the top left.

In the "New Symbol" dialog, add the symbol name ("Pro_Micro") and leave everything else default.

Now it is time to create pins that match the pinout above.  

Tip: Use the shortcut "Shift+P" to place pins.

There are a ton of options here! Leave most as default. Let's name the first pin "D+" to match up with the pinout and set its number to 1. Make it a "Passive" pin under "Electrical Type."

Continue assigning pins! We will add their layout shortly. This should be the result you see. Note: the right row starts with 26 because it will be used with the footprint generation wizard later.

Tip: While moving a pin with the mouse, press "x" to mirror it horizontally.

Tip: While moving a pin with the mouse, press "y" to mirror it vertically.

To flip the right side pins, I select them all and press "x."

It is a best practice for your schematic symbols to place their power pins on the top and their ground pins on the bottom.

To simplify your schematic, place pins that have identical functions (like GND) over each other with all but one pin being set invisible like so.

When invisible, pins look grayed out.

Stack them over eachother.

Next add a rectangle with the rectangle tool on the right side tool bar.

Be sure to set your grid size to 0.05" (1.27mm)!

Select the rectangle and set its "Fill Style" to "Fill with body background color."

Save! You are now the owner of a fresh new pro micro schematic symbol.

Now time for the footprint.

Look specifically at the sides of the KB2040. You will see that there are two ways to actually mount the device. The little "scoops" beside the pin holes are called castellations (because of their resemblance to the notches on a castle wall) and can be used to surface-mount the devkit. For now, lets just use the through holes with commonly available 0.1" (2.54mm) spaced pin headers.

To begin, open the footprint editor.

Next, click the "Footprint Wizard" button. It is a DIP chip with a star icon.

Select the S-DIP generator.

Using the above mechanical drawing, set the S-DIP generator settings to the following.

This corresponds to the 26 pins of the pro micro, the 2.54mm spacing between them, and the 15.24mm distance between the two rows of pins.

Next, click the "export to editor" button. I would recommend rotating the footprint to sit vertically, but it doesn't really matter.

Click "New Library..." upon saving the footprint. Rename it to Pro-Micro when saving.

Add a library to the project's scope. Name the library something like "Pro-Micro.pretty."

You should see something like this.

Go ahead and update your schematic symbol to refer to this specific footprint.

Open the schematic editor, select the Pro-Micro schematic symbol you just created, and click the "display symbol properties editor," button.

Click the footprint box and select the Pro-Micro footprint you just created. Congrats!

The process for creating any symbol and footprint is mostly the same! Don't be afraid to make the symbols you need when doing any project--it is certianly fine to use something like SnapEDA's library but you should be able to make modifications to footprints if necessary.

Here is the GitHub repo with the example pro micro footprint and symbol!

GitHub - hlord2000/example_pro_micro: This is part of the Ohmbedded example project used to create a schematic’s symbols and footprints.

This is part of the Ohmbedded example project used to create a schematic's symbols and footprints. - GitHub - hlord2000/example_pro_micro: This is part of the Ohmbedded example project used to…

GitHubhlord2000

Thanks for reading. Next up--a custom macropad using the pro micro!

Click here for part 3!

For more information and to ask keyboard specific or general electronics questions join our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 4 other members and enjoy free voice and text chat.

Discord

Welcome to the first part in a series on mechanical keyboard design.

KiCAD is the hobbyist's greatest weapon in creating bespoke electronics. It is a completely free and open-source electronic design automation (EDA) suite. It is available on most commonly used platforms including Windows, Linux, and macOS.

The process of creating a PCB design in KiCAD involves first creating a schematic to describe the abstract electronic parts of a device (i.e. the individual resistors, capacitors, integrated circuits, etc.) to create a list of "nets" or connections between parts.

Here is an example of a schematic for a keyboard using an RP2040 microcontroller. Throughout the series you will learn what every part of the above schematic means.

This "netlist" is then used to create the physical layout of a PCB.

The above may sound a bit abstract. Let's dive into the nitty gritty of PCB design by setting up a stellar KiCAD configuration for mechanical keyboard electronics design.

Start by downloading KiCAD for your specific platform at https://www.kicad.org/. Select the latest stable release. N.B. at the time of writing, the latest stable release is 7.0.1.

Start the installer.

Be sure to select all libraries offered.

Install to the default location.

Now launch KiCAD. Open the "Plugin and Content Manager." Select the "Color themes" tab.

N.B. packages will not install until you have clicked "Apply Pending Changes." Select the packages you want to install first.

Select the "wDark Theme" and click "Install" to save your eyesight.

Next, click the "Manage..." button. You will be greeted with a dialogue that will become familiar once working with symbol/footprint tables.

For now, copy and paste the following link to add the kicad-jlcpcb-tools plugin repository by Bouni.

https://raw.githubusercontent.com/Bouni/bouni-kicad-repository/main/repository.json

Click "Apply Pending Changes," select the respository dropdown to switch to Bouni's repository.

Install KiCAD JLCPCB tools and click "Apply Pending Changes."

The final step is to install a very useful KiCAD schematic symbol and footprint library specific to mechanical keyboard development.

Marbastlib is a mechanical keyboard switch/general part library that I have used for almost every mechanical keyboard I have designed.

GitHub - ebastler/marbastlib: A library collecting MX and Choc style footprints, as well as various other parts used to design custom keyboards

A library collecting MX and Choc style footprints, as well as various other parts used to design custom keyboards - GitHub - ebastler/marbastlib: A library collecting MX and Choc style footprints,…

GitHubebastler

To install, download or clone the above repository.

Next, in KiCAD, click "Preferences" and select "Manage Symbol Libraries..."

Copy the three files in the repository ending in "*.kicad_sym" to the default ${KICAD7_SYMBOL_DIR} seen in the Path Substitutions section of the Symbol Libraries table.

Next click the "Add existing library to table" button and select the three files you just added. Three new rows should be added to your Symbol Libraries table.

Next, open the "Manage Footprint Libraries..." dialogue from the Preferences dropdown. Much the same process here. Find the ${KICAD7_FOOTPRINT_DIR}, copy over the folders this time, and add them to the table. Generally, KiCAD footprint library folders end with "*.pretty" Optionally, copy the "3d" folder to the ${KICAD7_3DMODEL_DIR}.

You have now completed setup of KiCAD for mechanical keyboard design! In the next tutorial, we will take a look at the basics of keyboard electronics.

Click here for part 2!

For more information and to ask keyboard specific or general electronics questions join our Discord!

Join the Ohmbedded Discord Server!

Check out the Ohmbedded community on Discord - hang out with 1 other members and enjoy free voice and text chat.

Discord