Electronics Design

For the individual assignment I used KiCad 9.0 as my EDA tool to design a custom 8x8 LED matrix board. The matrix uses surface mount LEDs and is designed to interact and communicate with an Arduino Uno.

Why an LED Matrix?

An LED matrix is a good project for learning EDA because it involves repetitive but precise component placement, multi-layer routing, and direct microcontroller interfacing. The 8x8 grid gives you 64 individually addressable LEDs using only 16 I/O pins through multiplexing — each LED sits at the intersection of a row and column, and you light it by driving the correct row HIGH and column LOW.

Design Decisions

I decided to go with an 8x8 matrix — 64 LEDs total — which is a straightforward multiplexed design. The circuit itself is fairly simple: 8 rows and 8 columns, with each LED addressed by activating the correct row and column combination. The board interacts and communicates with an Arduino Uno (ATmega328P microcontroller), which drives the matrix using 16 of its I/O pins — digital pins D2 through D13 for 12 of the lines, plus analog pins A0 through A3 (used as digital outputs) for the remaining 4.

The board is a two-sided PCB, which was necessary to route all the traces without running into each other. Row traces run on the front copper layer (F.Cu) and column traces on the back copper layer (B.Cu), with 77 vias connecting signals between the two sides where needed.

Schematic Design

I started in KiCad's schematic editor (Eeschema) by placing the Arduino Uno R3 module symbol and all 64 LED symbols. Each row of 8 LEDs shares a common anode connection, and each column shares a common cathode. The schematic is straightforward but large — wiring 64 LEDs with proper net labels for all 8 rows and 8 columns took careful organization to keep it readable.

PCB Layout

The most time-consuming part was the PCB editor. After assigning the LED_0201_0603Metric_Pad0.64x0.40mm_HandSolder footprint to each LED and the Arduino UNO R3 module footprint, I moved to the board layout.

Individually spacing out all 64 surface mount LEDs in a tight, even grid without wasting board space took a lot of careful work. Each LED had to be precisely positioned while keeping the traces clean on both sides of the two-sided PCB. The front copper layer carries the row connections and the back copper layer carries the column connections, with 77 vias punching through wherever a trace needs to switch sides.

Routing was done manually — auto-router struggled with the density of connections in such a compact grid. Getting the traces to flow cleanly without crossing or creating clearance violations was the real challenge of this project.

Grid Alignment Problem

One issue I ran into was that KiCad's PCB editor doesn't have a built-in tool to grid-align components into an evenly spaced matrix. There's no "arrange in grid" feature for footprints, so I couldn't just select all 64 LEDs and snap them into an 8x8 layout automatically. Instead, I had to manually calculate and plot the X and Y coordinates for each LED on the board, then do the same for each of the 77 vias. Every component had to be positioned by entering exact coordinate values to ensure the grid was perfectly uniform — any small offset would throw off the trace routing and make the final board look uneven. It was tedious but necessary to get a clean, professional layout.

3D Board Preview

KiCad Project Files

Bill of Materials

• 64x 0603 surface mount LEDs (footprint: LED_0201_0603Metric_Pad0.64x0.40mm_HandSolder): Hand soldered onto the board. The 0603 package is small (1.6mm × 0.8mm), which made soldering by hand a careful process but keeps the matrix compact. The "HandSolder" footprint variant has slightly extended pads to make manual soldering easier.
• 77x vias: Plated through-holes with conductive inserts that connect traces from the front copper layer (F.Cu) to the back copper layer (B.Cu). Since the board is two-sided with rows on one side and columns on the other, vias are needed wherever a trace needs to cross to the opposite layer.
• Arduino Uno R3: The embedded microcontroller (ATmega328P) that drives the matrix. It uses 16 I/O pins — D2 through D13 and A0 through A3 — to control the 8 row lines and 8 column lines. The board mounts directly using the Arduino UNO R3 footprint with mounting holes.

How Multiplexing Works

With 64 LEDs but only 16 pins, the matrix uses multiplexing to address each LED individually. The Arduino rapidly scans through each row, turning on the correct column LEDs for that row before moving to the next. This happens fast enough that persistence of vision makes it look like all the LEDs are on simultaneously. Each LED only needs to be at the intersection of an active row and active column to light up.

How an LED Matrix Works

An LED matrix is fundamentally a grid of LEDs arranged in rows and columns, where each LED sits at a unique intersection point. Instead of wiring each LED to its own dedicated pin — which would require 64 pins for an 8x8 grid — the matrix takes advantage of the fact that current only flows through an LED when both its anode (positive) and cathode (negative) are connected to the correct voltage levels.

In an 8x8 common-anode configuration, all 8 LEDs in a row share the same anode connection, and all 8 LEDs in a column share the same cathode connection. To light a specific LED, you drive its row HIGH (supplying voltage to the anode) and its column LOW (sinking current from the cathode). Every other LED in that row stays dark because their columns aren't pulled LOW, and every other LED in that column stays dark because their rows aren't driven HIGH. This row-column addressing scheme is the same principle used in keyboard scanning, memory arrays, and display panels — it scales efficiently because an N×N grid only needs 2N control lines instead of N².

For the week 6 group assignment, our team used the test equipment in the lab to observe the operation of a microcontroller circuit board, including demonstrating the use of a logic analyzer. You can view the full group page here: Week 6 Group Assignment.

My Contributions — Capacitor Testing

After observing the microcontroller circuit board's behavior at the signal level with the oscilloscope and the Analog Discovery 2, I wanted to go a step further and verify the individual passive components that make those circuits work. Capacitors are one of the most common components on any circuit board, so I pulled a selection of electrolytic capacitors from our lab's inventory and tested them with a multimeter to see how closely their actual capacitance matched their rated values.

I wrote up a full section covering what capacitors are, how electrolytic capacitors work, and the testing process with results. You can read my full contribution here: Capacitor Testing — Oliver Abbott.