In this week's group work, Antti instructed us on how to manufacture physical PCBs. I've previously made PCBs using the photoresist method and ordered others, but this was my first time making PCBs using the milling method.

PCB milling

For my individual work this week, I manufactured the PCB designed during week 6. Initially, I assumed through-hole coppering was possible so that I could use the bottom side of the board as a ground layer, but since it isn't possible, I had to modify my PCB layout in KiCad.

Since the bottom layer of the board was not easily available, some space had to be made for the ground wiring. I removed the option to use a 12 V power supply, as 5 V is likely sufficient to drive the servos and the fan. I also moved some wires closer together to create space for the ground wires on the top layer. For diagonal wires, the D shortcut ("Drag Track, Keep Slope") is convenient for this operation.

Below is the updated schematic with these changes applied:

Here is the layout with everything placed on the top layer:

The board was manufactured in the same way as documented in the group work. However, the engravings did not fully cut through the isolation areas; only the edges of the isolated regions were milled with the 0.2 mm bit. Later, we realized that the LPKF CircuitPro software had a setting enabled that optimized the milling process by removing only the minimal amount of copper required for isolation gaps. With a solder mask coating, the board should still function correctly. I checked that there are no short circuits. Below is the board after milling, before cleaning:

Solder mask preparation

A solder mask and silkscreen were UV-printed on top of the PCB. The board was first cleaned with isopropanol alcohol. To operate our Mimaki UV printing machine, there should be one PDF with the outlines of the board and another PDF of exactly the same size with the solder mask and silkscreen inside. The parts of the PCB to be left without solder mask should have completely white color in the PDF file.

Our UV printer’s Mimaki RasterLink software was started, and first, the board outline was chosen for printing.

Stuffing (PCB assembly)

The PCB only has a few surface-mount components, so I decided to solder these by hand. When attaching a component with many pins, I first melt a small amount of solder on one of the footprint pads and then place the component on top to hold it in position. After that, I solder the remaining pads by applying heat to the component leg for a few seconds, bringing in a small amount of solder, removing the solder wire, and then lifting the soldering iron once the solder has melted into a smooth, even joint:

The pins for the ESP32-C3 need to be soldered horizontally so that they can slide easily on and off the headers. For this reason, the pins were soldered while being held inside a jig with straight headers. Additionally, the headers must be aligned properly on the board. To ensure this, the outer joints of the surface-mount headers were soldered first while the ESP32-C3 is physically connected. Then, the ESP32-C3 is carefully removed before soldering the remaining joints on the inner side of the headers.

Testing the microcontroller

Connecting to the microcontroller in the same way as described in the group work of week 6. Initially, I had trouble connecting because I chose the board “ESP32C3 Dev Module,” whereas in my case, I needed to choose “XIAO_ESP32C3. I tried a simple example program from the Arduino IDE called

		
		/*
		DigitalReadSerial
		Reads a digital input on pin 2, prints the result to the Serial Monitor
		This example code is in the public domain.
		https://www.arduino.cc/en/Tutorial/BuiltInExamples/DigitalReadSerial
		*/
		
		// digital pin 2 has a pushbutton attached to it. Give it a name:
		int pushButton = 2;
		
		// the setup routine runs once when you press reset:
		void setup() {
		// initialize serial communication at 9600 bits per second:
		Serial.begin(9600);
		// make the pushbutton's pin an input:
		pinMode(pushButton, INPUT);
		}
		
		// the loop routine runs over and over again forever:
		void loop() {
		// read the input pin:
		int buttonState = digitalRead(pushButton);
		// print out the state of the button:
		Serial.println(buttonState);
		delay(1);  // delay in between reads for stability
		}
		  
		
			

This should print 0s in the Serial output when pin 2 is short-circuited to ground. However, this did not work: pin 2 remained in a zero state, except that it occasionally changed to 1 when I touched it with my finger. This was likely caused by static electricity or interference. I realized that I needed to enable the internal pull-up on pin 2 for this to work, so I did this by modifying one line:

		
		/*
		DigitalReadSerial
		Reads a digital input on pin 2, prints the result to the Serial Monitor
		This example code is in the public domain.
		https://www.arduino.cc/en/Tutorial/BuiltInExamples/DigitalReadSerial
		*/
		
		// digital pin 2 has a pushbutton attached to it. Give it a name:
		const int buttonPin = 2; // GPIO2
		
		// the setup routine runs once when you press reset:
		void setup() {
		// initialize serial communication at 9600 bits per second:
		Serial.begin(9600);
		// make the pushbutton's pin an input:
		pinMode(buttonPin, INPUT_PULLUP); // Enable internal pull-up resistor
		}
		
		// the loop routine runs over and over again forever:
		void loop() {
		// read the input pin:
		int buttonState = digitalRead(pushButton);
		// print out the state of the button:
		Serial.println(buttonState);
		delay(1);  // delay in between reads for stability
		}
		
			

Now, the serial output correctly goes to 0 when pin 2 is short-circuited to ground:

Design files

Top copper layer Gerber file

Edge cuts Gerber file

UV printing main graphic

UV printing outline