Week 08 - Electronics Production

This week we have the following tasks to complete:

• characterize the design rules for your in-house PCB production process
• submit a PCB design to a board house
• make and test a microcontroller development board that you designed
• optional: make it with another process

Group Assignment

The weekly group assignment can be accessed here.
To evaluate the performance of our Carvera, we conducted Neil’s test. For milling, we utilized a 0.2 mm V-bit for the traces and a 0.8 mm end mill for the outlines.

Since mods offers two preconfigured programs for the machine, we applied the default cutting parameters. The only modifications we made were to the tool diameters, offset count, cut depth, and maximum cut depth to optimize the process for FR-4 using HSS end mills.

To achieve optimal results and minimize the risk of mill bit breakage, we ensured that the PCB stock material was perfectly flat. Typically, this is verified using a straight edge, but since one was not readily available, we used a caliper gauge instead. By holding it against the back of the material and observing it against a light source, we could detect any gaps. If gaps were present, we carefully adjusted the stock material until it was as flat as possible.

To secure the stock material to the machine bed, we used thin, non-reinforced double-sided tape. In general, the cheapest double-sided tape yields the best results, as reinforced tapes can introduce surface irregularities. For optimal adhesion while allowing easy removal, we applied three strips of tape across the entire width of the material.

A flat machine bed is essential for precision milling. To ensure this, Ferdi surfaced the entire machine bed. To minimize machining time, he used a 6 mm flat end mill with the 6 mm collet for the Carvera.

To replace the collet, he used the official tool provided by Makera. If an end mill exceeds the size limit for the tool changer, it can be manually replaced using the following commands:

M490.1 // Tightens the spindle collet to secure a new tool
M490.1 // Loosens the spindle collet and releases the current milling bit

A complete list of supported G-code commands is available on Makera’s website.

Setting the Z = 0 Position

There are three methods to accurately set the Z = 0 position:
1. Using the machine’s wireless probe

2. Using a multimeter in continuity test mode (or a dedicated continuity tester) by placing the probes between the copper layer and the V-bit, then gradually lowering the Z-axis in small increments
To prevent damage to the milling bit, the spindle must be spinning during this process. This can be achieved using the command:
M3 S5000 which sets the spindle speed to 5000 RPM.

3. Listening for the V-bit making contact with the copper layer—this method should also be performed slowly and in small increments
As with the previous method, the spindle must be running to avoid damaging the tool.

The final result appears as follows:

Analysis and Design Adjustments

Since we are machining FR4 with HSS end mills, we cleaned the board using a razor blade and steel wool before comparing it to the original design file.

Neil’s test features track widths ranging from 0.001" (0.0254 mm) to 0.02" (0.508 mm). For consistency, all further comparisons will use millimeters.
The thinnest successfully milled track measured 0.254 mm.
The smallest acceptable clearance was 0.1778 mm.

For my design, I will apply the following parameters:
Clearance: 0.2 mm, except:
* 0.3 mm clearance to the board outline
* 0.3 mm clearance between traces and large copper areas
Trace width: 0.26 mm – 2.54 mm, with a typical width of 0.4 mm, ensuring all routing can be completed without manual modifications.

Designing a Development Board

For designing my development board, I used EasyEDA Pro, as described in week 06. The objective was to create a Xiao ESP32-C3 board that supports an onboard display, a power LED, an ARGB LED for testing, a rotary encoder with an integrated push button, and one or more connectors for additional modules and components. I drew some inspiration from Oxocard.

For the display, I selected a 0.96" 128x64 px OLED display (link), which communicates via I2C and is similar to the one from the FabInventory. The rotary encoder is a small KY-040 module that I had available, similar to these ones.

All critical components, such as the Xiao, the rotary encoder, and the display module, are connected via pin headers instead of being directly soldered to the board.
The finalized circuit remains relatively simple and appears as follows:

A key design requirement was ensuring that the rotary encoder’s pins could still be repurposed if the encoder was not needed. To achieve this, I routed the Xiao’s encoder-related pins to both the rotary encoder and an additional pin header. For the display, I followed a similar approach, assuming multiple I2C devices could be connected while still utilizing the onboard display. Additionally, I included mounting holes for future enclosure integration.

To ensure proper alignment, I copied the Xiao’s footprint and removed all unnecessary pads and holes.
The first design iteration revealed an issue: the 3.3V trace passed between two Xiao pads, which was problematic. Although the DRC check indicated sufficient clearance, mods (link) failed to generate a proper toolpath due to the tight spacing. To resolve this, I modified the footprint further, reducing the pad height from 2 mm to 1.2 mm.

Since I planned to use pin headers instead of soldering the Xiao directly onto the PCB, the reduced pad size did not affect functionality. Other pin sockets had even smaller pads (1 mm height), ensuring adequate clearance while maintaining a secure connection.

The two large rectangles on the top silkscreen were merely reference guides for aligning the display and rotary encoder module.
During the initial milling attempt, I mistakenly used an inverted image for the traces, resulting in an incorrect toolpath. The issue was not immediately apparent, as using four offsets made the discrepancy less noticeable in the preview.

Despite this, holding my first self-designed, milled PCB was a great moment. Even the text engraving appeared promising. Adjusting the position of the dots on the "i" significantly improved legibility.

Before milling, I processed the exported .png file from EasyEDA Pro using Inkscape. The native export from EasyEDA had correct shapes, but the colors were inconsistent. I manually adjusted them to be pure black and white, ensuring the alpha component was set to 100% for proper toolpath generation in mods.

Generating G-code

To generate the G-code, I used mods with the Carvera Mill 2D PCB program. The design files were exported from EasyEDA Pro by following the path:
File → Export → PDF/Image

The export settings were configured as follows:

The separated design layers were adjusted accordingly:

Milling the Dev Board

Before starting the milling process, I secured the PCB stock to the machine bed using thin double-sided tape and loaded a 0.2 mm V-bit for milling the traces.

Since my board had the correct dimensions and was properly secured with sufficient double-sided tape, I disabled tab generation in the toolpath settings.

To set Z = 0, I received assistance from Niclas. We used a multimeter in continuity test mode by placing probes between the end mill and the copper layer.

I started the spindle and set the RPM to 5000 using the following command:

M3 S5000  

Then, I slowly lowered the spindle until Niclas detected electrical continuity between the end mill and the copper layer. Normally, the Carvera's wireless probe could be used for this, but it stopped working after the first test milling. The exact reason is unknown, so we resorted to this manual method to accurately set Z = 0.

It is essential that the spindle is running during this process to prevent damage to the end mill. The bit should also be lowered in very small increments, ideally 0.01 mm or less.

The result was as follows:

After removing the PCB from the machine bed, I peeled off the double-sided tape. Most of it came off cleanly, though some small adhesive residues remained, which were easily removed. I then cleaned the copper surface using a razor blade and steel wool.

My first milling attempt had a major issue: the trace image was inverted. The invert function in mods did not work as expected, which resulted in the traces and pads being milled away instead of the surrounding copper.

To resolve this, I corrected the trace image in Inkscape and then reprocessed it through mods to generate a new G-code file.

During this process, I realized that I had overlooked a pull-up or pull-down resistor for the rotary encoder’s push button.

• On the Xiao ESP32-C3, GPIO9 includes a built-in pull-up resistor.
• However, on other models like the Xiao ESP32-S3, this feature is not available on the same pin.

To ensure compatibility across different Xiao variants, I modified my design by adding a 10kΩ pull-up resistor between the button and +5V. I then updated the design files and regenerated the toolpath using Inkscape and mods.

After milling the revised board, the results were as follows:

Peeling off the double-sided tape was more difficult than expected due to its strong adhesion. Even when removing it parallel to the board, it often tore into multiple pieces instead of peeling off in one strip.

I first attempted to clean the copper surface using steel wool alone, but this quickly wore down the steel wool without effectively removing debris.

Using a razor blade first, followed by steel wool, resulted in a much cleaner surface, though still not perfect.

Key Considerations When Using Steel Wool:
- Fine metallic fibers from the steel wool can cause short circuits if left on the PCB.
- To prevent issues, I vacuumed the board and wiped it with isopropanol to remove any remaining debris.
- Ferdi later suggested applying stronger, parallel strokes with the steel wool for an even cleaner finish.
- I implemented this after soldering, so the improvement is only visible in the final hero shot.

To ensure no steel wool fibers remained, I also used compressed air.

Residual adhesive from the double-sided tape was removed using 90% isopropanol and a paper towel.

• After several passes, the adhesive was completely removed, leaving a clean backside.
• Up to this stage, the adhesive was actually beneficial, as it kept the board firmly in place during cleaning, reducing the need for manual stabilization.

To solder the parts on the pcb I used the ERSA I-CON Vario 4 MK 2 i-Tool with an Ersa i-Tool Trace 2 mm chisel tip.

The final board assembly appears as follows:

Overall, I am dissatisfied with the final result. The trace quality is suboptimal, the solder joints barely meet acceptable standards, and the presence of excess solder droplets around the joints is both unnecessary and aesthetically unappealing.

Test dev board

To test the board I firstly use a multimeter in continuity test mode to check everything that should be connected is connected and everything that should not be connect is not connected. This went smoothly, everything looks perfect. In the next step I tested the ARGB LED for that I used following code:

#include <Adafruit_NeoPixel.h> // library for NeoPixels

#define PIN_NEO_PIXEL D3       // Xiao pin that connects to NeoPixel
#define NUM_PIXELS 1           // The number of LEDs

Adafruit_NeoPixel NeoPixel(NUM_PIXELS, PIN_NEO_PIXEL, NEO_GRB + NEO_KHZ800); // set the NeoPixel initialization

void setup() {
  NeoPixel.begin();  // initialize the NeoPixel strip object
}

void loop() {
  NeoPixel.setPixelColor(0, 255, 20, 0);  // set color
  NeoPixel.show();                        // output the color
}

After seeing that the LED response I wanted to implement a color cycle. To achieve this I edit my void loop and add a 3 variables for red, green and blue. These variables get manipulated with running variable i. i cycle from 0 to 255 and each color got manipulated after the same rules but in different areas of this number range. This range is split in to three equal areas from 0 to 84, from 85 to 169 and from 170 to 255. In one area the variable is increased in relation to i, in the next is decreased and in the last it's 0. This allows the representation of an color cycle.

void loop() {
    for (int i = 0; i < 256; i++) {
        byte r = (i < 85) ? i * 3 : (i < 170) ? 255 - (i - 85) * 3 : 0;
        byte g = (i < 85) ? 255 - i * 3 : (i < 170) ? 0 : (i - 170) * 3;
        byte b = (i < 85) ? 0 : (i < 170) ? (i - 85) * 3 : 255 - (i - 170) * 3;

        NeoPixel.setPixelColor(0, r, g, b);  // set color
        NeoPixel.setBrightness(10);             // reduce brightness to 10 from 255, only for filming otherwise not need it
        NeoPixel.show();                     // output the color
        delay(10);                           // short delay for the color change
  }
}

Order a PCB

For better clarity, I added some labels on the top silkscreen. The file used for ordering looked like this:

To order the PCB, I first needed a Gerber file. Since I'm using EasyEDA Pro, I could automatically submit the design to JLCPCB by navigating to:
File → Export → PCB Fabrication File (Gerber)

A new window opened where I could set a filename for the Gerber file and configure the export. To submit the design directly to JLCPCB, I used the Order PCB button. If I just wanted to export the Gerber file, I used the Export Gerber button.

A window appeared asking if I wanted to run a DRC before proceeding. Normally, I had already done this, but I ran it again to be sure everything was correct. After confirmation, a small window informed me that all necessary files had been generated.

Your browser will open, and if you're not already logged in to JLCPCB, it will prompt you to log in.

It automatically loads the Gerber file into the configurator.

I normally use the following settings when ordering PCBs, except for the number of layers, which is typically 2 or 4. In most cases, I prefer using thinner 1 mm PCBs because it's a clean, round number and makes integration into a housing easier. The color of the silkscreen and the mark removal are purely aesthetic choices. White PCBs with blue silkscreen also look great, but flux residues will be much more visible.

Keep in mind that if you need your PCBs quickly, you shouldn't adjust these settings, as they can increase production time. Apart from that, I always recommend some type of Flying Probe Test. The random test is free, while the full test costs a few bucks.

At the bottom, you will also find options to order PCBA (Printed Circuit Board Assembly) and stencils for applying solder paste.

Once everything is set up, simply add the order to your cart and proceed to checkout.

What I learn this week

• Routing single-sided PCBs can be quite challenging, and it felt a bit strange not to use any vias, which I normally rely on.
• How to break end mills—I'm still unsure why it happened, as we milled the same G-code lines before without any issues, and similar ones afterward worked perfectly.

What I want to improve next week

• I need to plan more time for recovery and take longer breaks from time to time.

Design Files

dev board project
dev board schematic
dev board traces
dev board holes outline
dev board test

To create this page, I used ChatGPT to check my syntax and grammar.

Copyright 2025 < Benedikt Feit > - Creative Commons Attribution Non Commercial

Source code hosted at gitlab.fabcloud.org