Installing KiCad

The first step is to install KiCad and complete the additional online workspace setup instructions if you have not done so already.

Creating a Project in the KiCad Workspace

Open up KiCad and hit File->New Project. Name the project FMRadio_[your kerb]. Save the project to the local repository that you linked to the class GitHub Enterprise Organization during software setup named pcb-iap-2026-[your kerb]. Check ‘Create a new folder for the project’ and save your new project.

On the left side of your KiCad window, you should now see your project and its respective kicad_sch and kicad_pcb files.

Introduction

This lab is a super simple, super short lab! It’s basically just to get you familiar with the following in KiCad.

• Project Structure
• Schematic Capture

Creating a Block Diagram

The first, most important step in putting our electrical system into a schematic is first creating the top-level schematic (or block diagram). This is like the system-level block diagram that was discussed in lecture 01 except that it contains more detail about how the electrical device will actually work and is located at the root of our schematic sheets.

Having this top-level schematic is crucial to ensuring that we can effectively keep the whole system structure of the FM radio in mind as we create it. Doing so also allows us to break down the schematic design into separate parts (e.g., amplifier, speakers, power), which makes our life a whole lot easier.

Top Level Schematic Sheet

Navigate to your FMRadio_[your kerb].kicad_sch file. You should see a ‘Schematic Hierarchy’ sidebar pop up on the left. The Root file will contain our top level block diagram. Now, we’re going to get started with building out this block diagram with all its different parts.

Hit Place->Sheet (alternatively, you can use the shortcut S or click on the corresponding toolbar button which looks like a schematic square with a plus button) and draw a rectangle on your top level sheet. Afterwards, edit both the reference designator and file name to what block the sheet symbol is to represent. In this case, let’s have it be the FMReceiverChip. (you may want to turn off the visibility for the sheetfile so the name doesn’t appear twice).

Now, we need to add ports to the block in order to connect it to other sheet symbols. In Altium, these ports are known as Hierarchical Labels (or sheet pins) and can be found in the same dropdown as where we found the sheet symbols (or alternatively, can be accessed through the shortcut H or the button above the Add a Hierarchical Sheet button on the toolbar).

Right now, we don’t know exactly what ports we need to have on each sheet symbol, and we don’t need to. We should, however, make sure we create the major connections and we can add additional sheet entries later on when we build out each block on the schematic.

For the FMReceiverChip sheet, let’s add an antenna, speaker, and digital I/O port to it. Make sure to assign the I/O Type of each label to Input, Output, and Bidirectional, respectively. In KiCad, hierarchical labels need to be created in the child sheet and then imported into the parent sheet. So, to create these ports, click into your FMReceiverChip sheet and place three hierarchical labels as described above. Don’t worry about connecting them to anything yet, just make sure they exist.

Then, navigate back to your Root file, right-click on the FMReceiverChip sheet, and hit Import Sheet Pin. Place all three pins on your sheet symbol.

With one block down, let’s complete the whole block diagram! Hopefully in doing so, you’ll get an intuitive understanding for how the whole FM radio will be set up.

Notice that we had to adjust the ports on the FMReceiverChip to have two speaker output ports (one for the left and right speaker) since we want stereo audio. Building out these top-level diagrams/schematics helps us realize such discrepancies.

Also, with these sheet entries it becomes easy to duplicate identical circuits - without having to draw them out twice. Just copy and paste the sheet entry. Such is the case with the left and right stereo audio paths. KiCad will by default name the sheet with a new version (feel free to change it back by right-clicking on the sheet and going to Properties), but the Sheetfile name will be the same as the original.

Finally, notice how the Power block is not connected to anything. In theory, since it is the power block, it should connect to every other block - but that would make the whole schematic quite messy. So instead, in KiCad (and all other EDA tools) power connections are considered global nets, which means that they connect to each other across the schematics and blocks without the need for explicit ports. This is just like how the GND symbol always implicitly connects to other GND symbols in a drawn schematic. Therefore, the power block just needs to exist and doesn’t need any ports.

We aren’t finished with the block diagram just yet. With each block or sheet, we abstract out lower-level block diagrams to simplify our schematics. We’ve done so with the antenna block, which is going to consist of some sheets within it.

Click into the Antenna sheet and create blocks within the schematic named LowNoiseAmplifier and MatchingNetwork. We won’t connect them right now, but we will need to later.

Our Schematic Hierarchy toolbar ends up looking like below. Notice how sheets that present within other sheets are indented? This shows the hierarchy of the schematic sheets as provided by our top-level block diagram.

Filling in the Microcontroller

With all of our schematic sheets setup, we can begin filling them in. We’ll start small by doing a straightforward sheet: the microcontroller.

For the microcontroller, we’re using an ESP32, or more specifically the ESP32-C3-WROOM-02U-N4, which comes as a module and handles a lot of the complicated supporting circuitry that’s required for a microcontroller. However! We still need to do some circuit layout ourselves for the ESP32 within the Microcontroller sheet.

While KiCad’s default library comes with an extensive set of built in parts, it does not include a few of the components we will need for our Microcontroller schematic. For the rest of this class, we will wrap these unincluded components into a custom library that you can directly import. To add the required parts, download the FMRadioPartsSymbolLibrary file below and place it in your repository.

FMRadioPartsSymbolLibrary

Now, we need to add the symbols and footprints of these components to our project. To do so, first navigate to Preferences → Manage Symbol Libraries. Switch to Project Specific Libraries, and hit the Folder icon in the bottom left. Navigate to your repository and select the FMRadioPartsSymbolLibrary.kicad_sym file. When you’re done, the Project Specific Libraries tab should look like this:

Now that we’ve added the library, we can access the symbols through the Place Symbol button. You can find this near the top of the right side-bar or with the keyboard shortcut “A”.

For components that aren’t in the FMRadioPartsSymbolLibrary symbol library (e.g., resistors and capacitors) place their corresponding generic symbol from the KiCad built-in libraries, such as R and C, which can be found under the same Place Symbol button. Then, to indicate the value of the generic component simply edit its properties. Select the part you wish to edit, then Right Click → Properties or press “E”. Now edit the Value property. Values for our passive components always take the form of a number followed by the appropiate metric prefix such as “k” or “u” for “kilo” or “micro”, respectively.

Wonderful! We’re now ready to fill in our schematic.

Following the Datasheet

Taking a look at the typical application circuit in the ESP32-C3-02U datasheet, draw out the schematic for the microcontroller. From the typical application circuit, you should exclude the components with the following reference designators¹ and their corresponding connections:

• JP1 and JP2
• JP4
• R3
• R5
• R8 and R9
• R7
• X1
• C5 through C8

Use the following components from the Components Panel for the following reference designators found in the datasheet application circuit (note: your reference designators for these components on the KiCad schematic sheet need not be the same):

Use values of 10 kOhm for R1 and 0.1uF for C3.

JP3 in particular is a USB-C receptacle, so there are some additional connections that you will need to make in addition to connecting it to the microcontroller:

1. Attach a global power net to the VBUS pins and name the global power net: VUSB. We’ll use this later to draw power from the USB-C connection
2. In order to control the amount of current that flows through the USB-C connection, the USB-C standard utilizes current-control resistor (CC) in order to communicate how much current a device should be provided. In the case of this FM radio, we want the maximum current that can be provided over a USB connection (about 1 A). To do so, place a shunt 5.1 kOhm resistor on each of the CC pins.
3. Pins named shield/shell/mnt should always been connected to ground.
4. Basic USB 2.0 communication (which is what we’ll be using to program the microcontroller) occurs over a bidirectional data line that is configured as a differential pair, which we’ll explain more about in the upcoming lectures. For now, we just need to make sure that we specify the two USB data (D) pins as a differential pair. To do so, attach a net label named USB_D_N and USB_D_P to the respective sets of pins on JP3. The combonation of the _N and _P tells KiCad that the USB data lines are a differential pair, which is important for later.
5. The 0 Ohm resistors between JP3 and the microcontroller cause an end to the differential pair net. To resolve this, name the wires on the other side of the 0 ohm resistors USB1_D_N and USB1_D_P.
6. Change the global power net named VDD33 in the datasheet application circuit to 3.3V. We’ll need this consistency later for other devices powered by 3.3 V.

Conclusion

Congratulations on completing the first lab! You have create a full top-level schematic and began building out one of its blocks, the microcontroller.

Be sure to save to commit to main and push to origin so that your local changes get saved to your GitHub repository! Please do so by midnight so that course staff can grade your work.