This article offers some insight into the development process I took on creating the Riff PCB version 1.0 for the Riffstick. This project was a lot of fun, and I am excited to see where it goes next.

Getting Started

Choosing a development platform

Since I am relatively new to the PCB development scene, I wasn’t all to familiar with a lot of the software designed in the creation of said PCBs. That being said, I did recall some free to use software that I installed and played with briefly during my time at Canyon AeroConnect. That software is KiCAD.

While my plan was to do some research in paid programs for the best experience in learning PCB development, I really liked the fact that KiCAD is free and open source, two qualities I genuinely love in my software. Hence, I began the deep dive into KiCAD and all it’s abilities.

To my surprise, KiCAD is very intuitive (despite claims that were told to me regarding it’s difficult of use), so getting the basics down with it was quite enjoyable. I already have some experience working with PCBs from my Digital Circuits course from Embry-Riddle, so I was able to apply that method of thinking to the design process.

Preliminary development

Since this project is for the Riffstick (a project designed by James Lovett, viewable here), I already knew the layout. James provided me with all of the measurements, general layout of the controller, and zones to which the PCB must have holes for the model to fit through.

Early layout diagram of the PCB (Provided by James):

With this diagram, I was able to begin thinking about how I wanted to build the PCB. For starters, I knew the layout of the buttons, and wanted to reflect that in my early designs of the schematic layout. Each controller has 9 buttons, each being the exact size (this is due to using mechanical key switches). He indicated on this diagram zones to which the PCB cannot be filled in, as well as space that’s likely to be unused (due to an extra PCB used in providing USB-C tethering to the Pico).

Armed with this information, I began to check out KiCAD’s symbol and footprint libraries to ensure I had everything that I would need. Since this project is using the Raspberry Pi Pico as the brains (and not just the RP2048 IC), I needed both the symbol and footprint for a Pico. Sadly, KiCAD doesn’t ship with either, so I had to find one online. This was also the case for the mechanical key switches. After a bit of looking around, I was able to identify some libraries that had what I needed, so I added them both to the global libraries for KiCAD.

Since I also knew I would need some custom symbols and footprints, I added my own custom library so I could work on that later. That library is identified as “Chroma” in the picture. Now that I had everything I needed to get started, I created this schematic:

With this schematic, I was able to link together all of the buttons according to his specifications. And as a plus, with KiCAD I can import this diagram directly into the PCB editor to assist me in not only organizing where each element should go, but for running the traces later on.

With this diagram in place, I began to consider what additional requirements that’ll be necessary to have for both functional, and quality of life additions. For starters, I wanted to create the board with at least a 2mm spacer around the perimeter, allowing it to slot inside of the housing of the Riffstick. While this information wasn’t included in the initial sketch James provided, I knew that adding this spacer would allow for an easier install into the controller.

Working in KiCAD

Since the PCB editor uses actual measurements, I started by drawing the outline of the controller. This outline shows the full size of the working area (including the 2mm gap I planned to add later on) so that I can keep track of the board’s footprint.

This outline allows me to very easily add the spacer I wanted the board to have. Before importing any of the switches over from the schematic, I drew the outline of the board. Initially, it was just shaped to the board outline, though I tweaked it by adding screw holes, vias, and other essential components the board should have. I originally wanted this board to be a 1 layer only board, though due to some of the GPIO decisions I had to utilize 2 layers (front and back) to properly route traces later on (this will be shown soon).

Armed with the outline of the PCB, I imported the buttons and moved them to their correct location. The mechanical key switches that are used in the controller are not Cherry MX switches, though they fit the same profile and sizes as the key switches that are to be used.

With each key cap, they have an edge length of 15.6mm. Initially, the spacing was planned out to be 16mm, so in implementation the spacing will be slightly different than the original, however, we found that this difference will be far within tolerance of the printed product. For a machined component, this would be an issue, however, the shell of the Riffstick is entirely 3D printed, which gives a bit more room for spacing differences (and changes to the model if necessary).

As an additional upgrade to the PCB version of the Riffstick, I added a new pad for a tilt sensor (by request from James). This would allow the controller to track when it’s tilted upright, allowing for an in-game mechanic called ‘Star Power’ to be activated, rather than pressing the ‘Select’ button.

Creating this pad required me to make a custom symbol. This is where my custom library that I made earlier called ‘Chroma’ comes into place.

While not very pretty, this would allow me to stamp this onto the board and give a more ‘finished’ look, as opposed to two vias and some text. Since any footprint requires a symbol, I also created that and added it to my library.

The tilt sensor that was installed is a SW-520D sensor (located here) can work bidirectionally, as it only completes a circuit once a certain angle is achieved. Since I wasn’t all too familiar with creating my own schematics (and it’s been a long time since Digital Circuits), I put this together simply so I could add it to the KiCAD schematic and call it good.

With all of the necessary components now on the board, all that was left was to run traces on the board. When I first started planning on where to run the traces, I realized that some of the GPIO pins leading to the buttons were wired in a way that made connecting everything on just the face of the PCB impossible without swapping out the GPIO pins. Since this was not an option as per the requirements of the board, I had to utilize both the front and back of the PCB to route traces. After playing with a few outlines, this is what I came up with:

In addition to running the traces, I made sure to add accreditation to both myself for creating the PCB, and to James for designing the Riffstick in it’s entirety. Since this was my first project, I didn’t run any verification tests on the PCB and instead had the files sent to PCB way for ordering (which I will make sure not to do again), and a few days later, the boards arrived.

Despite skipping the verification tests on the PCB, the board worked great. All traces were properly routed, and everything was ready for assembly. Here are some photos of how it looks:

Wrapping up

Now that the PCB is done, there’s a few more features I personally would like to add for future versions. This’ll be entirely up to James if he wishes to revise the PCB, though there is a lot of unused GPIO ports that are not connected to anything. A future revision of this board could include breakout pins elsewhere, allowing daughter boards to connect with ease to the PCB and expand functionality, however, there isn’t much space in the controller itself to allow for such changes.

Additionally, I would like to switch out the need of having an entire Raspberry Pi Pico with just the RP2040 IC (the brains of the Pico), and have everything surface mounted on the board. That would eliminate the need of buying more Picos, and allow for mass ordering of components for production.

What I learned

Working on this project, I was able to exercise my engineering skills in an area that I wasn’t well versed in. I was able to learn how to utilize KiCAD in it’s more simplistic forms, which enables me to apply that knowledge to all of my future projects. Overall, I am happy with out everything turned out, and I look forward to the next project like this.