Electronic Design

Electronic design involves creating circuits and PCBs to achieve specific functions, considering factors like component selection, power requirements, and signal integrity. It requires a mix of theoretical knowledge and practical skills, from schematic design to PCB layout and manufacturing.

This week, I will design a PCB for an ESP32 WROOM and give some general ideas for designing another board for a different microcontroller. There are multiple software options for PCB design, such as EasyEDA, Altium, Fusion360, Eagle, etc. However, since it is free and easy to use, I will use KiCad for my PCB design.

Now, I could start explaining how the software works and introduce tools and board functionalities along the way. However, that would only result in a "recipe" for creating a specific PCB for the ESP32, not for other microcontrollers like the Attiny45, which even has a different architecture (as seen in the embedded programming group assignment). Therefore, I will first provide some general considerations to think about before opening any design software.

General considerations

Setting a goal for the PCB: It may sound basic, but before even choosing a microcontroller, you need to define the board's limits and objectives. This simplifies the design and construction process.
Check datasheets for key components: Review operating ranges like voltage, current, temperature, or frequency to ensure compatibility. This is crucial when working with complex circuits.
Look for similar PCB examples: This is especially useful when working with microcontrollers. While the datasheet suggests components, looking at pre-made boards, like the Espressif Devkit for ESP32, helps form a clearer idea of what components are needed. From there, you can rely on your electronics knowledge to decide what is unnecessary.
Choose a design software: Once the basic ideas are set, select the software for designing the PCB.
Create the schematic diagram: In the chosen software, draw the circuit connections for the board.
Design the PCB layout: Using the schematic, place the components and create connections on the PCB. Most PCB design software allows easy import of schematic components.
Extras: Simulate, Validate, and Manufacture: The previous steps cover the PCB design process. From here, you can simulate the circuit in software or on a physical protoboard (with caution). Then, validate that the PCB meets its intended objectives. Finally, manufacture the board, whether by fabricating it yourself or outsourcing production.

For this week, I plan to design a PCB for the ESP32 WROOM using KiCad due to its ease of use and versatility. Initially, I considered making a simple board for the microcontroller, but as I refined the design, I realized it closely resembled an Espressif Devkit, with differences in size, layout, and selected components. I included only the necessary features, such as GPIO connections and I2C/UART communication, basing much of my schematic on Espressif's design.

Figure 1: ESP32 WROOM PCB Espressif Design.

Additionally, while I intend to design a dedicated PCB for my final project, this board should also function as a backup for testing. This means the ESP32 needs a reliable voltage regulator to prevent damage from the battery voltage. To address this, I will use two voltage regulators: one for converting USB input (5V to 3.3V) and another for stepping down an external voltage (Vin to 5V). The output of this second regulator can then be connected to the first one to ensure a stable 3.3V supply for the microcontroller.

To build the PCB, it's essential to understand how each component functions within the schematic. I mention this because each component must have a corresponding footprint in the PCB design software to ensure proper placement and connectivity during fabrication. Without the correct footprints, the physical board won't match the schematic or, if there is no footprint attached to the component, the PCB will simply not be fabricated.

By default, KiCad includes some components with their respective footprints. However, for more complex circuits, this is not always the case. Our instructor, Oliver, provided us with a link to the Fab repository, which contains the necessary files to import additional components into KiCad. These components are also available in the lab, making PCB fabrication easier.

Here is the repository link and the step-by-step process to load new components and footprints into KiCad.

Download the libraries and decompress the files

Figure 2: Downloading the libraries.

Figure 3: Decompressing the files.

Configure Symbol Library

Figure 4: Manage Symbol Libraries access menu.

Figure 5: Create an empty row, name it and link the “fab.kicad_sym”.

Create an empty row: Add a new empty entry for the library.
Name it with fab (in this case): Assign the name "fab" for consistency.
Link the path to the “fab.kicad_sym”: Set the path to the correct symbol library file.

Configure Footprint Library

Figure 6: Manage Footprint Libraries access menu.

Figure 7: Create an empty row, name it and link the “fab.pretty”.

Create an empty row: Add a new empty entry for the footprint library.
Name it with fab (in this case): Assign the name "fab" for consistency.
Link the path to “fab.pretty”: Set the path to the correct footprint library file.

Configure Paths

Figure 8: Configure Paths acces menu.

Figure 9: Create an empty row, name it and link the complete folder that contains the libraries.

Create an empty row: Add a new empty entry for the path.
Name it FAB (in this case, notice it is in capital letters): Assign the name "FAB" in uppercase for distinction.
Link it to the complete folder: Set the path to the main directory containing the libraries.

Once this is done, we can start our project. On the main menu, we can find various tools on the right to edit our project, including schematic editing, PCB layout design, and footprint management. Among these tools, there is one particularly useful for both the schematic diagram and PCB design. It allows calculations for component connections and helps determine the proper trace width. I will use this tool later for the trace width calculations.

Figure 10: KiCad Main Menu.

To begin, we will start by editing the schematics. Here, we will create the connection diagram using the tools on the right to accomplish the following:

Add Symbols (A): Here you can find and add components to the schematic (try to find fab library for footprint).

Figure 11: Adding symbols tool.

Figure 12: Symbol selection menu.

Add Power Symbols (P): With this you can add power symbols that work like power labels (ground and different voltages).

Figure 13: Adding power symbols tool.

Figure 14: Power symbol menu.

Draw Wires (W): To connect components.

Figure 15: Draw Wires tool.

Figure 16: Example of a wire connection.

Place Global Labels (Ctrl+L): To reduce wires and maintain a cleaner view, making a connection between two components without a visible wire.

Figure 17: Adding Global Labels tool.

Figure 18: Place Global Labels menu.

Draw Text (T): If you want to add a note.

Figure 19: Draw text tool.

Figure 20: Example of text in schematic.

No Connection Flags (Q): For pins that have no connection.

Figure 21: Adding no connection flags tool.

Figure 22: Example of no connection flag usage.

An important consideration for my board design is that the Espressif schematic includes a section on wiring a USB port and a USB-to-UART converter, which can be added for programming the ESP32. However, I will be using an external converter, so instead of integrating it into the board, I left the RX, TX, GND, and VCC pins accessible for easy connection. For the GPIOs, I just leave their pins accessible for easy connection. Finally, to test the board, I connected an LED to GPIO 15 and a button to GPIO 2. This way, once the board is manufactured, these components can be used to verify the board functionality.

Figure 23: ESP32 custom board schematic.

One detail I want to highlight is that my original schematic was different. When it came time to lay out the PCB, I ran into several issues, so I made some changes. In some cases, I reduced the number of pins, rearranged them, and added 0-ohm resistors as bridges to make the connections easier.

To ensure everything is correct, KiCad provides a tool called "Electrical Rules Checker", which checks for electrical issues in the design. It helps identify possible mistakes, but it is not foolproof. We still need to analyze our connections carefully, as some warnings might simply indicate unused component pins, which is not necessarily an error if they were intentionally left unconnected.

Figure 24: Running the Electrical Rules Checker.

Figure 25: Example of ERC with minor warnings and errors.

After fixing any errors or important warnings, we can move on to designing the PCB. To do this, we select the "Open PCB in board editor" option. Here, we will start working on the PCB layout by following these steps:

Click "Update" at the top: To import schematic footprints.

Figure 26: Open PCB editor.

Figure 27: Footprint import (Update base in the schematic).

Arrange the components: Position the components in a logical layout.

Figure 28: Arranging components in PCB editor (v1).

Another thing I want to highlight is that when placing the components, you can choose how to arrange them, but if you have limited PCB layers, it's best to plan their order based on the connections. In other words, focus on the hardest components to place and connect first, before the most important ones. I mention this because I did not consider it at first, and later I had to redesign the entire PCB.

In fact, while arranging the board, I was also making certain connections that I thought were a priority because of their complexity.

Set the track width: Define the track width according to power requirements. I use the Calculator Tools mentioned earlier to determine the appropriate width.

Figure 29: Track width calculation using KiCads calculator.

Figure 30: Adjusting track width based on power requirements.

Route all the tracks: Connect all components using PCB traces.

Figure 31: Laying out PCB tracks.

Switch to the edge cuts: Create a 1mm border in any shape (this because of the diameter of the tool during the fabrication).

At first, I wanted to create a more visually appealing design. However, due to the complexity of the circuit, I did not distribute the components well enough to achieve a more interesting shape. I could go for a more extravagant design, but at this point, it would just be forcing the layout and wasting material. So, for now, this PCB will have a simpler shape.

Figure 32: Creating the border in the edge cuts mask.

Figure 33: Finalized mask of 1mm border.

Finally, just like the Electrical Rules Checker, KiCad has a Design Rules Checker for the PCB. It works similarly by identifying potential issues. Running this tool helps verify the design, and if any critical errors or warnings appear, adjustments should be made accordingly.

Figure 34: Running the Design Rules Checker in KiCad.

In this case, even though there are over 40 errors and 11 warnings, there is no reason to worry. Just like with the previous rules tool, it is important to review the marked errors carefully, as they aren't always critical. Here, for example, I get an error because I set a minimum spacing of 0.4 in the Board Setup, while some footprints have a spacing of 0.3-0.37. This is not a major issue, I set this parameter to help prevent soldering problems during manufacturing. So, as for the warnings, they are all related to the text. Since these will not affect the manufacturing process, they are completely negligible

After resolving the errors, the PCB design is complete. To get a better view, we can use the KiCad 3D Viewer. Here are the results…

Figure 35: 3D view of the finalized PCB design.

The pins may look odd and could cause issues on the PCB, there is no nothing to worry about. Their orientation will be vertical once the PCB is made. I chose these superficial pins to avoid any manufacturing complications

HEROSHOT! (The board looks better like this :3).

LEARNINGS

Without a doubt, the biggest lesson I learned here was not to underestimate PCB design. I already had some experience with KiCad, because a board I designed for the ATmega328P in a submarine project; and I have the necessary circuit design knowledge from my studies. However, I had never designed a board with surface-mount components, less for the ESP32. So, because of the pin distribution and component sizes, I had to make several adjustments on the fly.

Additionally, in previous projects, all my boards were manufactured in China, and I never made one myself. This added another layer of difficulty since I did not have a second layer for routing connections. This experience has truly shown me everything that goes into designing a PCB.

Documents and software links!

Schematic

PCB