W6 | Electronics Design

The oscilloscope we used was the GW Instek GDS-1152A-U, a digital storage oscilloscope available in our lab. An oscilloscope is a tool that lets you see electrical signals on a screen — instead of just reading a number like a multimeter would, you can actually see the shape of the signal over time, which makes it much easier to understand what a circuit is doing. The "digital storage" part means it can capture and hold a signal on screen, which is very useful when you want to analyze it carefully.

Vertical axis (VOLTS/DIV)

Each square represents a set number of volts. Adjusting this makes the signal appear taller or flatter on screen.

Horizontal axis (TIME/DIV)

Each square represents a set amount of time. Adjusting this zooms in or out on the signal, showing more or fewer pulses at once.

The circuit we tested was a custom-designed red PCB with a XIAO RP2040 microcontroller soldered onto it. The board exposes all pins through headers, making it easy to connect external components and test equipment.

For the tests we connected two components:

• 🖰 D0 — a push button (digital input)
• 🖰 A1 — a potentiometer (analog input)

The following program was running on the XIAO RP2040 during the measurements. It reads both components continuously and prints their values to the Serial Monitor:

#define pinButton D0
#define pinPot A1

bool state;
int valueADC;

void setup() {
  Serial.begin(9600);
  pinMode(pinButton, INPUT);
}

void loop() {
  state = digitalRead(pinButton);
  valueADC = analogRead(pinPot);
  Serial.print("Button state = ");
  Serial.print(state);
  Serial.print("     Potentiometer ADC value = ");
  Serial.println(valueADC);
}
        

1. Connecting the probe
   The oscilloscope probe has two parts: a signal tip and a ground clip. The signal tip connects to the pin being measured, and the ground clip attaches to the GND of the circuit. This step is always necessary — the oscilloscope measures voltage differences and needs a reference point to compare against. Without the ground connection, the measurement is meaningless.
   
   
2. Using Autoset
   Once connected, we pressed the 🖰 Autoset button. This automatically adjusts both VOLTS/DIV and TIME/DIV to display the signal correctly on screen. It was a good starting point, especially when we did not know what the signal would look like.

3. Fine-tuning the scales
   After Autoset, we adjusted the scales manually to get a clearer view:
   • If the signal looked too tall or too flat → adjust VOLTS/DIV
   • If the signal looked too compressed or too stretched → adjust TIME/DIV
   This took some trial and error at first, but it became more intuitive once we understood what each knob does.
   
   
4. Reading the measurements
   The Measure function automatically calculates values like Vmax, Vrms, frequency, duty cycle, and rise time. We did not have to calculate anything manually — the oscilloscope did it for us and displayed the values on the right side of the screen.

The first test was with the push button on pin 🖰 D0. A digital signal has only two possible states — 0 (LOW, 0V) or 1 (HIGH, 3.3V). There is nothing in between. Every time the button was pressed, the signal jumped instantly from 0V to 3.3V, and when released it dropped back to 0V.

On the oscilloscope screen, this looked like a series of clean square pulses. By adjusting TIME/DIV we could zoom in to see individual presses more clearly, or zoom out to see multiple pulses at once. We also used the trigger function to freeze a specific moment of the signal on screen, which made it easier to analyze.

The second test was with the potentiometer on pin 🖰 A1. Unlike the button, the potentiometer generates a continuously varying signal — it can be any value between 0V and 3.3V depending on how far it is rotated.

On screen, this looked completely different from the button. Instead of square pulses, we saw a smooth curve that changed as the potentiometer was turned. Rotating slowly produced a gradual wave, and rotating quickly produced a steeper one. The signal never snapped to a fixed value — it always transitioned smoothly, which is exactly what an analog signal is.

This assignment helped me understand the difference between digital and analog signals more clearly. Seeing the signals directly on the oscilloscope made it easier to relate what the code does with what is actually happening in the circuit. I also learned how basic oscilloscope controls such as VOLTS/DIV, TIME/DIV, Trigger, and Autoset affect the visualization of the signal and help obtain more stable and readable measurements. Finally, I understood that the oscilloscope is useful not only for measuring signals, but also for debugging and verifying how a circuit behaves in real time.

For this week, we had to use an EDA tool to design a PCB that communicates with a microcontroller. Jorge and I decided to use this task as an opportunity to design the PCB for the microcontroller that will be used in my final project. So... I began by identifying the core functions that my project will perform and then determining the necessary components that the PCB should have — both inputs and outputs — to make sure the system works as intended.

We started with a fun brainstorming session to decide which inputs and outputs my main board should include. It was exciting to imagine how each component would interact as part of my final project. After several ideas, we decided to include the following components:

🔹 Outputs

Two servo motors (to control the robot's arms), one Digital Output (for an external actuator or similar), a Display connected through RX and TX, an OLED Screen using the SDA and SCL pins (as an alternative if the main display isn't available), and one LED as a visual indicator during the testing phase.

🔸 Inputs

One Digital Sensor (such as a PIR or obstacle sensor), and one Push Button for testing.

And before jumping into the PCB design using the EDA tool, I needed to understand how the microcontroller connects to each part. This meant checking the function of every pin, identifying which ones provide power (VCC), which ones are for ground (GND), and which pins can send or receive data. I also verified the voltage levels that each device uses — some components work with 3.3 volts, while others require 5 volts.

In the following image, you can see the result of this planning process, where I mapped out each connection before starting the PCB design.

For the design stage, I used KiCad EDA, an open-source tool widely used for electronic design. One of its greatest advantages is that it combines schematic capture, PCB layout, and even 3D visualization of the board within the same environment. It's intuitive, flexible, and completely free, which makes it perfect for learning and professional projects alike. You can download the program from the following link according to the type of computer you have.

1. Downloading the libraries

The first step was to download the folder 📁 kicad-master from the official repository: Fab Lab - KiCad Repository. This folder includes everything needed for PCB design in KiCad:

• 📁 fab.kicad_sym — the symbol library
• 📁 fab.pretty — the footprint library
• 📁 fab.3dshapes and 📁 fab.3dsource — optional 3D models

2. Adding the Symbol Library

I opened KiCad and went to 🌐 Preferences → Manage Symbol Libraries. In that window, I clicked 🖰 + and added the file 📁 fab.kicad_sym.

• Place Symbols — used to add symbols from the library to your schematic. It's the tool to insert new components into your design.
• Place Power Symbols — provides different voltage options that help define the electrical connections in your schematic.
• Place Global Labels — allows you to name a connection so that it links automatically to other parts of the schematic, even if the wires are not physically drawn together.

After finishing the schematic, I opened the PCB Editor from KiCad's main menu to start designing the physical board. The first step was to update the PCB from the schematic, using the option found in the Tools menu. This automatically loaded all the components and their connections onto the board workspace.

Before starting the routing, I configured some important parameters in the Board Setup menu. I defined the trace widths, setting 0.4 mm for signal lines and 0.8 mm for the ground traces, since they need to handle higher current. I also adjusted the design constraints, setting the clearance to 0.4 mm — this is essential to avoid spacing errors and ensure that the dimensions don't exceed the milling tool's diameter.

Once all the design rules were set, I began the routing process — the stage where every electrical connection from the schematic is physically drawn on the PCB. For this design, I used a trace width of 0.4 mm for all routes, keeping the layout simple and consistent. While routing, I made sure to avoid 90-degree angles in the traces. Instead, I used 45-degree corners, which help the current flow more smoothly and reduce electromagnetic interference.

As I started connecting the components, I noticed that some traces were crossing each other, which made the layout look messy and difficult to route properly. To fix this, I began reassigning pin connections and rearranging component positions until I found a cleaner and more efficient layout.

To start, I measured the approximate size of the board based on the components' arrangement and space needed for connections. Then, I created the 2D outline in CorelDRAW, carefully sketching the curves to give it an organic look while keeping it functional for fabrication. Once the design was ready, I exported it in DXF format, so I could import it directly into KiCad's Edge.Cuts layer. To do this, I followed these steps:

1. Opened the file through 🌐 File → Import → Graphics
2. Adjusted the scale and set the default line width to 0.2 mm
3. Made sure to select the correct layer: Edge.Cuts, since this layer defines the actual border of the PCB during manufacturing.

📝 Note: After running the check, the software automatically highlighted a few small issues — mostly traces that were too close or slightly misaligned pads. I carefully reviewed and corrected each one until the message "No errors found" finally appeared on the screen ✅.

With the routing completed and all design rules checked, I opened KiCad's 3D Viewer to see how the board would look in its final form. The 3D Viewer is a powerful tool because it allows you to visualize the PCB with all its components in three dimensions, giving a much more realistic idea of spacing, orientation, and assembly.

When the viewer loads, KiCad automatically replaces each footprint with its corresponding 3D model. Most Fab Academy components already include compatible 3D models, but sometimes a specific part may not be available. In those cases, it is possible to add your own:

📝 Note: Once linked, the component will appear correctly in the 3D Viewer as part of your board.

The KiCad FabLib file can be found at the official repository: gitlab.fabcloud.org. To install it from file, the following steps were followed:

1. Go to 🌐 Tools → Plugin and Content Manager or press 🖰 Ctrl + M
2. Click 🖰 Install from File...
3. Look for the 📁 kicad-fablib zip file
4. Click 🖰 Open

The first version was a starting point — it helped establish the KiCad workflow and validate the basic circuit. As the robot's design became more defined, each component was reconsidered. The single test button evolved into three buttons with specific emotional meanings. The indicator LED became a visible LED ring integrated into the robot itself. A PIR sensor was added so the robot can react to nearby presence instead of waiting for manual activation. The buzzer was incorporated to provide small sound cues and feedback, helping reinforce the robot's interactions. In addition, the trace widths were updated to follow better design practices for power distribution — using 0.8 mm traces for the 5V lines to safely support the higher current required by components such as the servomotors and LED ring.

🔌 The Schematic

The schematic was designed in KiCad connecting all components to the XIAO ESP32S3. Each peripheral has its own labeled connector, making it easy to identify, connect, and disconnect components during assembly and testing. Power is distributed through PWR_3V3 for logic components and PWR_5V for higher power components like the servomotors and LED ring.

PCB Layout & Routing

With the schematic complete, the components were arranged on the board keeping power and signal traces as separate as possible. One important decision during routing was using different trace widths depending on the type of signal:

• 0.4–0.5mm for signal traces (3.3V)
• 0.8mm for power traces (5V)

This is standard practice in PCB design — power traces need to be wider because they carry more current. If they were too thin, they could overheat or fail when components like the servomotors draw current.

🔸 Traces too close together

When trying to keep the board small, some traces ended up too close to each other. This is a problem because traces that are too close can cause short circuits during fabrication. The solution was to rearrange some components and reroute the affected traces until there was enough clearance — the DRC helped identify exactly where the issues were.

🔹 Reordering pins for cleaner routing

Sometimes the logical pin order in the schematic — for example VCC, GND, OUT — created trace crossings on the board that were difficult to route cleanly. In those cases, the pin order in the connector was changed directly in the schematic — for example to OUT, GND, VCC — so that the traces could flow naturally without crossing each other. It required going back and forth between the schematic and the PCB layout, but the result was a much cleaner design.

Once the routing was complete and all design rules passed, the 3D viewer was used to visualize how the final board would look. All connectors are clearly labeled and positioned around the XIAO ESP32S3, making the board easy to assemble.

The board was designed with a simple square shape intentionally. While the first version had a more creative brain-shaped outline, for this final version practicality took priority — a square board is much easier to mount inside the robot's structure. A complex shape would make it harder to fit, align, and secure the board in place, while a square can be positioned and fixed with minimal effort during assembly.