Electronic Design

This week’s challenge was all about diving deep into the world of electronic design—from circuit schematics to custom PCB layouts. The goal wasn’t just to connect components and make a board that works, but to understand the entire process behind it: how a circuit is planned, how physical components are chosen and placed, and how design rules keep everything functional and fabricatable.

I used EasyEDA as my primary tool, which made it easier to move between schematic design, footprint selection, and PCB layout. But I didn’t want to stop at just making a working board—I wanted to bring in a bit of my personality too. So, instead of a regular rectangular PCB, I decided to give my board a tank-like shape, just to see how creative and playful electronic design could get while still being technically accurate.

From cluttered beginnings to a refined schematic, from technical hiccups to neat 3D previews, this week really helped me see how electronics can be both logical and expressive at the same time.

Group Assignment

The detailed group assignment, including our process of testing the microcontroller using a multimeter and oscilloscope, is documented on Sharvari page.

What I Learned:

I used the multimeter to check voltages at different points on the board — especially to verify power supply and continuity between pins.
The oscilloscope helped see digital signals in real-time. I observed the PWM output from one of the pins, and it was really cool to watch the waveform change as I modified code or input.
I got a better understanding of signal behavior, and how it’s not always obvious unless you actually measure it.

Overall, it made me realize how important testing tools are — not just for checking if a circuit works, but also for learning why it behaves a certain way.

Individual Assignment

About The Software

https://easyeda.com/?utm_source

For this project, I used EasyEDA, a super user-friendly, browser-based design tool that helped me create my PCB without the need to install any software. As a student, this was really convenient because it’s all cloud-based, so I could access my design from anywhere.

EasyEDA combines everything you need to design a circuit: you can create schematics, simulate circuits, and then move straight into PCB layout. The best part is that it also has a huge library of components, and the design checks are built right in, so you can catch errors before you make the board. It even lets you visualize your design in 3D, so you get a good sense of how the final product will look.

Building the Circuit Schematic

I started my PCB design journey by creating the circuit schematic in EasyEDA. This is where I placed all the electronic components and logically connected them using wires — kind of like drawing a map of how the current would flow.

Steps I followed:

Component Selection
I searched for parts like resistors, LEDs, microcontrollers, and headers from EasyEDA’s library. Most components were already available with symbols and footprints linked.
Logical Connections
I connected the pins using the wire tool and labeled important nets (like VCC and GND). This made the schematic less messy and helped when routing later.
Clarity and Simplification
My first version of the schematic was quite cluttered. So I reorganized it to be easier to read — grouped related components together, spaced things out, and added labels to help during debugging and routing.
DRC (Design Rule Check)
Before moving to the PCB layout, I ran the DRC check to make sure there were no open or wrong connections. It highlighted small mistakes like unconnected pins or floating nets.

So I started off by creating a new file inside the library section of EasyEDA. First thing was choosing the schematic view as the background and giving the file a proper name, just to stay organized.

Once the file opened up, I looked through the components and picked the RP2040 XIAO since that was the microcontroller I was using for this assignment.

I chose the RP2040 XIAO for this assignment because I’d already used it in my previous experiments, so I was familiar with how its pins worked and how to upload code to it. It’s also really compact, which made it perfect for designing a small PCB. Another reason was its SMD castellated pins—they make it easier to solder directly onto a custom board, which saved me a lot of trouble. Since the focus here was on designing and testing the PCB layout, I didn’t want to waste time figuring out a new microcontroller.

After selecting the board, I moved on to choosing header pins to connect everything. At first, I picked a few pins just to try things out—but as I worked further, I ended up changing some of them to make the layout cleaner.

Then I began connecting the components, making sure I included GND, 3.3V, 5V, and also added SCL and SDA for I2C-based communication. These were important since I planned to try different kinds of modules later.

I chose SMD-type resistors and LEDs from the library itself because I wanted the board to be compact. After placing those, I wired them up in the schematic.

Some components like header pins and resistors were either the wrong footprint or didn’t match the final idea—so I swapped them out for the right ones from the library.

When I tried moving to the PCB layout, the software showed errors and it became hard to trace which wire was going where.

Some nets (connections) were just floating around or weren't needed anymore—so I cleaned those up.

After fixing all the technical errors, I took some time to clean up the layout visually. I spaced out the components, aligned the wires neatly, and made sure labels were readable. This made the diagram look much less cluttered and way easier to understand—especially helpful if I ever need to come back and review it later or share it with someone else.

A few nets were just hanging or left from earlier versions of the schematic. I deleted or disconnected them to clean it up and avoid confusion later during PCB routing.

Closed nets which had no poper connection.

Moving to Footprint
Finally, I was ready to switch from schematic to footprint view. This is where I placed the components the way I wanted them to sit on the actual PCB. I focused on keeping the layout clean, with short traces and minimal overlapping lines—just to make it easier to solder later.

Footprint

Building & Assigning Footprints Once I completed my schematic in EasyEDA, the next important step was assigning the footprints — basically telling the software what each component will physically look like on the PCB.

What is a Footprint?

A footprint is the physical layout of a component — including its size, pad positions, and hole locations — that goes on the PCB. It’s what allows the real component to be soldered onto the board. For example, even if I selected a resistor in the schematic, I had to assign the right SMD or through-hole footprint depending on what I was using.

Since I designed my PCB in the shape of a tank, I decided to go with a custom manual layout. This meant I placed each component myself, thinking about both the functionality and how the board would look visually in the final shape.

Auto-layout was available as an option in EasyEDA — it can automatically arrange components and route connections. But in my case, using it wouldn’t have worked well because:

It doesn’t follow creative shapes — like the curves or turret area of my tank design.
It often prioritizes shortest routing, not aesthetics or mounting space.
The auto-layout can get a bit messy if the schematic is even slightly complex.

So I went ahead with a manual layout, where I:

Positioned all the footprints neatly inside the tank outline.
Made sure the components were not overlapping or too close to the edge.
Left space for mounting holes and the name engraving.
Tried to keep similar signals (like power and ground) routed cleanly.

It took more time, but it gave me full control over how everything was placed. And in the end, the board didn’t just work — it actually looked like the design I had in mind.

Importance of Footprints

Footprints were one of the most important parts of my PCB design. Even though I added components in the schematic, it’s the footprint that decides how those components will actually sit and get soldered on the real board.

If the footprint is wrong:

The pads might not match the component legs.
Soldering becomes difficult or impossible.
The whole board might not work even if the schematic is correct.

By carefully checking and sometimes editing footprints, I made sure everything would fit perfectly — especially for custom components or headers. It also helped me plan the layout properly and avoid spacing issues later on.

So basically, footprints are like the blueprint for placing each part physically — without them, the design can fall apart even if the circuit is right.

Design Rule Check (DRC)

After placing and routing all my components on the PCB, I ran the Design Rule Check (DRC) in EasyEDA. This step felt a bit like proofreading before submitting a final assignment — it helped me catch small errors that I might’ve missed while designing.

Followed these measurement for making bard more accessible, fabricated, clean.

What DRC Does:

It checks if any traces are too close to each other or to pads.
It flags unconnected nets — basically reminding me if I forgot to route a wire.
It checks for clearance issues, like if a component is overlapping the board outline or another part.
It verifies that hole sizes, trace widths, and distances follow fabrication rules.

Why It Was Important for Me:

When I first finished routing, I thought everything was fine visually. But after running DRC, I found:
One trace was too close to a pad, which could have caused a short.
I had forgotten to connect one net — the DRC made that super clear.
A via was overlapping a mounting hole (which I didn’t notice at all).

Without running the DRC, these small mistakes would’ve led to a board that doesn’t work or can’t be fabricated properly. Fixing these early saved time, cost, and effort

In EasyEDA, running the DRC was simple — I just clicked “Design Manager” → “DRC Errors”, and it gave a full list of what needed fixing. After making the changes, I ran the check again until everything was clear.

Fabricating the PCB

For the fabrication part of the assignment, I wanted to go beyond a regular rectangular PCB and give it a unique shape. I chose to design my PCB like a tank — just for fun and to make it more personalized. This involved not just circuit design but also thinking about how the final board would look physically.

Finalising PCB Shape

I used EasyEDA to finalize my schematic. After checking the connections and making sure everything passed the DRC (Design Rule Check), I moved on to the PCB layout. At this stage, I had already simplified my earlier messy schematic for better clarity and neat routing. Instead of going with the default PCB outline, I used the mechanical layer (in EasyEDA, it’s usually called Board Outline or Mechanical Layer 1) to draw a tank-like shape. I traced the outline using the Line Tool and made sure all angles and curves were properly closed so it would be cut correctly during fabrication.

This step made my PCB look more customized and added a personal, creative touch to the project.

Routing PCB

I placed all components carefully within the tank shape and manually routed the tracks. I also

Used vias to jump signals across layers if needed.
Made sure that none of the traces crossed over the outline.
Kept power and ground lines thicker for better current flow.

Mounting PCB Holes

To make the PCB mountable, I added mounting holes using the "circle" tool in EasyEDA. I placed them in the corners and also near the 'turret' of the tank. These holes were set to the standard 3.2mm diameter, which works for most M3 screws.

These holes were important because they’d let me fix the PCB onto a case or panel if I wanted to display or use it practically.

To personalize it even more, I added text on the silkscreen layer that displayed my name. In EasyEDA, I used the "Text" tool and placed it on the Top Layer (Silkscreen). This doesn't affect the circuit but makes it feel more like my design.

Alternatively, you can engrave your name on the copper layer if you want it etched during the milling process — just make sure it's not interfering with traces or pads.

Visualizing the Layout

2D View

When I worked on my PCB design, the 2D view was like the blueprint. It showed everything flat, allowing me to see how the components were placed and how the traces were routed. It was important because:
It helped me make sure everything was in the right place and connected correctly. Without it, I could have missed things like components being too close to each other or traces overlapping.
It was where I could measure everything and ensure there was enough space between components, which was essential for the board to work properly and be manufacturable.
When I ran the Design Rule Check (DRC), the 2D view was correct which helped.

3D View

For the 3D view, it gave me a chance to see the board from a more realistic perspective. It wasn't just about the layout anymore but how everything would actually fit together. Here's why it was helpful:
It showed me if components would fit properly, especially when height was a factor (for example, taller components interfering with others).
I could also visualize the final product, helping me ensure everything would work as expected in the real world, not just on paper. It was useful for checking if there were any space or alignment issues I might have missed in 2D.
The 3D view helped me see how the PCB would look once assembled, which was important for things like fitting it into an enclosure or ensuring there was enough clearance for components.

Original Design Files

BOARD GERBER FILE