This week we focused on electronics production by physically fabricating a PCB (Printed Circuit Board) using the lab's milling machine. The process went from reviewing a digital design all the way to a soldered and functional board. The general workflow was:
Reviewing and correcting the PCB design from week 6 to make sure it was ready for fabrication.
Exporting the Gerber files from KiCad, which contain the trace and drill information of the board.
Converting the Gerber files to PNG using the FabLab's Gerber2PNG tool.
Loading the PNGs into Mods Project to generate the RML files for the milling machine (a different one for the traces/outline/drill, each with its own tool configuration).
Setting up the Roland SRM-20 machine: loading the correct tool, setting the X, Y and Z origins, and sending the RML files (drills, then traces, and lastly the board outline).
Repeating in case its needed (I did the milling process twice since the first attempt had issues, so I adjusted and re-ran it until I had a clean board).
Soldering the components onto the milled PCB.
Programming the board to verify it works correctly.
To know more about our FabLab's machines check the group assignment:
The board I fabricated is a NeoPixel controller: it uses potentiometers to control the behavior of NeoPixel RGB LEDs, allowing manual adjustment of parameters like color or brightness through analog input. The digital side of the process covered the PCB design review, Gerber export, image conversion and toolpath generation. Here you can explore my process:
PCB Design Review in KiCad
Before fabricating, I reviewed and corrected the PCB design I had made in week 6. Once everything looked good, I exported the necessary files for fabrication.
1. Here is my corrected schematic, with all the components and connections properly reviewed.
2. And here is the corrected PCB layout, with traces routed and components placed correctly.
3. To export the Gerber files from KiCad, go to File > Fabrication Outputs > Gerbers. Select the layers you want to export and click Generate.
4. A window will appear, select the layers you want to export and click Generate.
1. This is the default Gerber2PNG page when you first open it.
2. Here we select our Gerber files and drill files.
3. The page will process the files and generate a preview of your board.
4. Once processed, we can download the resulting PNG images that will be used in the next step (Mods Project).
Generating RML files in Mods Project
Mods Project converts our PNG images into RML files that the milling machine can read. We generate separate files for the traces, the outline, and the drills (each with its own tool configuration).
1. This is the default Mods Project interface when you open it.
2. We right-click to open the menu and select our machine in this case the Roland Minimill (SRM-20).
3. After selecting the machine, a default node interface will appear.
4. Then we load our PNG image into the corresponding input node. And select the tool type depending of the work. For the traces, we use a 60º #501 V-bit engraving tool. For drilling a 1/32 drill and for cutout a 1/16 cutout.
5. Here we modify the tool parameters: diameter to 0.4 mm, a cut depth of 0.1016 mm, and offset overlap of 4 (these for the traces).
6. We also set the origin position to 0 (X, Y, Z offset) and the cutting speed of 4 mm/s.
7. Once all parameters are set, we calculate the toolpath.
8. Here is the preview on how it looks. Then download the RML file by activating the "Edit info collapse node".
9. Then we download and rename our RML file.
And we repeat the process for each operation, changing the tool and parameters as needed. For example for the cut out we set the tool diameter to 1.6 mm, a cut depth of 0.6096 mm, and a max depth of 1.7018 mm. Lastly we can maintain the 4 mm/s speed.
This is the V-bit tool used for the traces.
And this is the 1/16 cutout tool for the outline.
Physical Process
With all the digital files ready, the next step was to actually cut, solder and program the board. This part of the process is more hands-on and requires careful machine setup, patience during soldering, and troubleshooting when things don't go as planned.
Cutting the PCB on the Roland Minimill
With our RML files ready, we proceed to physically mill the board. The order of operations is: traces first, then drills, and finally the board outline.
1. We attach our copper board to the sacrificial bed using double-sided tape, making sure it is flat and well secured.
2. Then we secure the sacrificial bed to the machine table using the fixing screws/nuts so nothing moves during the cut.
3. We install the V-bit tool for the traces (this tool is for traces, for drills and cutout we need another one).
4. We turn on the machine and open VPanel on the computer, making sure the USB cable is connected.
5. We set the X and Y origins by moving the tool to the desired starting corner of the board.
6. Then we set the Z origin with the tool spinning, carefully lowering it until it just touches the copper surface and setting that as Z zero.
7. After configuring the origins, we go to Cut in VPanel.
8. Then we select our RML file (traces first), click Output.
This way the machine will run the cutting process automatically.
Lastly we repeat the process for the cutout traces.
Soldering the components
Once the board was milled, I soldered all the components onto it. The process requires patience and precision, especially with small SMD components.
1. Here is how the milled PCB looked before soldering with clean copper traces ready for components.
2. Before starting I ensured I had all the necessary tools and materials ready. Including a soldering iron, flux, solder, brass sponge or damp sponge.
3. Then I prepared the board with all components placed before soldering to ensure proper alignment, and do a component check.
4. I also added insulation tape to protect the board and prevent short circuits.
5. Here is a video of the soldering process.
6. I also used a soldering stand with clamp magnifying tool for pieces that require more precision. However I didn't find the magnify glass comfortable to use.
This was the final result of the soldered board (front view).
6. Final result (another angle showing all the components soldered).
Programming the board
This section is still in progress, programming will be completed and documented soon. Stay tuned!
Coming soon.
Errors & Troubleshooting
Things didn't go perfectly on the first try. Here are the issues I ran into and how I dealt with them.
1. My first cut had areas where the tool didn't engrave properly. The board had a slight uneven surface, so the V-bit didn't reach the copper consistently in all zones.
2. I tried lowering the Z origin to compensate, but this caused the tool to lose its edge. The outline cut file also didn't cut all the way through because it wasn't configured correctly.
3. On the third attempt I repeated the process more carefully (it had a cleaner result overall, however, the uneven surface and Z origin affected the result).
4. After soldering, I also noticed some joints didn't look great (a couple of components may not have been soldered correctly, which could caused me issues during programming).
Learning Outcomes
This week taught me that fabricating electronics is a multi-step process where precision matters at every stage from the digital design to the physical cut, soldering and programming.
Surface flatness is critical: Even a small warp or unevenness in the copper board can cause the V-bit to miss the surface in certain areas, resulting in incomplete traces. Using double-sided tape evenly and pressing the board flat is essential.
Each tool needs its own Z calibration: Every time you change the milling tool, you must re-set the Z origin. Skipping this step or being imprecise leads to cuts that are too shallow or too deep.
Soldering for the first time: This was my first time soldering SMD components, and I learned that temperature control is crucial (too much heat can burn components or bridge nearby traces, while too little prevents a proper joint). Taking the time to inspect each joint before moving to the next one saves a lot of debugging later.
Programming and libraries: Getting the board to run correctly requires not just writing the logic, but also managing the right libraries. In my case I used C++, where understanding how libraries are imported and configured makes a big difference in how clean and functional the code ends up being.
Finally this week was fundamental to start understanding the principles behind electronics, inputs and outputs. Additionally, I tried to make the PCB to be modular, so it can be adapted and expanded during testing phases.