---
# System prepended metadata

title: How do I design a PCB for an MCU-based project?
tags: [Microcontroller]

---

Designing a PCB for an [MCU](https://www.ampheo.com/c/microcontrollers)-based project requires careful planning to ensure functionality, reliability, and manufacturability. Here’s a step-by-step guide:
![Power_and_ground_planes_will_automatically_adjust_when_routing_in_OrCAD_X_xptwdr](https://hackmd.io/_uploads/SJlpINybxg.png)


**1. Define Requirements**
* MCU Selection: Choose based on processing needs (e.g., [STM32](https://www.ampheo.com/search/STM32), ESP32, [PIC](https://www.ampheo.com/search/PIC)).
* Power Supply: Voltage levels (3.3V/5V), current requirements.
* Peripherals: Sensors, communication modules (UART, SPI, I2C), displays, etc.
* Form Factor: Size constraints, mounting holes.

**2. Schematic Design**
**A. MCU Core Circuit**
1. Power Supply:

* Add decoupling capacitors (100nF ceramic + 10µF electrolytic) near each power pin.
* Use LDOs (e.g., AMS1117) or DC-DC converters for voltage regulation.

2. Clock Circuit:

Include crystal oscillators (HSE/LSE for STM32) with load capacitors (e.g., 8MHz + 22pF).

3. Reset Circuit:

Add a reset button and pull-up resistor (e.g., 10kΩ).

4. Boot Mode:

Configure boot pins (e.g., BOOT0 for STM32) with pull-up/down resistors.

**B. Peripheral Connections**
GPIOs: Connect sensors, LEDs, buttons with current-limiting resistors.

Communication:

* UART: Level-shifting (e.g., MAX3232 for RS232).
* I2C/SPI: Pull-up resistors (2.2kΩ–10kΩ for I2C).

Analog Inputs: Add RC filters (e.g., 100Ω + 100nF) for noise reduction.

**C. Debugging Interfaces**
* SWD/JTAG: For programming/debugging (e.g., ST-Link for STM32).
* UART Header: For serial logs.

**3. PCB Layout**
**A. Layer Stackup**
2-Layer (Budget):

* Top Layer: Signals + components.
* Bottom Layer: Ground plane + some routing.

4-Layer (Recommended for complex designs):

* Layer 1: Signals.
* Layer 2: Ground plane.
* Layer 3: Power plane.
* Layer 4: Signals.

**B. Component Placement**
1. MCU First: Place centrally with shortest paths to peripherals.
2. Power Components: Position regulators and capacitors near power inputs.
3. Noisy vs. Sensitive Areas:

* Keep analog (sensors, ADC) away from digital (oscillators, switching regulators).
* Separate high-speed traces (USB, SPI) from low-speed signals.

**C. Routing Rules**
1. Power Traces:

* Use wide traces (e.g., 20–30mil for 1A current).
* Star topology for multiple voltage rails.

2. Signal Traces:

* Impedance control: Match trace width to target impedance (e.g., 50Ω for USB).
* Avoid 90° angles (use 45° or curves).

3. Grounding:

* Use a solid ground plane.
* Avoid ground loops; connect all grounds at a single point.

**D. Critical High-Speed Signals**
* Clock Lines: Short, direct traces with no vias.
* Differential Pairs (USB, CAN): Route together with matched lengths.
* Shielding: Add ground pours around sensitive traces.

**4. Design Verification**
**A. Electrical Rules Check (ERC)**
* Verify all nets are connected correctly (no floating pins).
* Check for unpowered components.

**B. Design Rule Check (DRC)**
* Trace width/spacing (e.g., 6mil/6mil for fab limits).
* Via sizes (e.g., 0.3mm drill, 0.6mm pad).

**C. Signal Integrity**
* Simulate critical paths (e.g., USB) with tools like HyperLynx (if available).
* Check for crosstalk in dense areas.

**5. Manufacturing Preparation**
1. Gerber Files:

Generate files for all layers (top/bottom copper, silkscreen, solder mask, drill).

2. Bill of Materials (BOM):

List all components with footprints (e.g., 0805 resistors, SOIC-8 ICs).

3. Assembly Drawing:

Mark component orientations (e.g., diode polarity).

**6. Testing & Debugging**
1. Power-Up Test:

Check voltages with a multimeter before connecting the MCU.

2. Programming:

Verify SWD/JTAG connectivity.

3. Peripheral Validation:

Test each sensor/interface (e.g., UART loopback, I2C scans).

**7. Common Pitfalls & Fixes**
![企业微信截图_20250512164306](https://hackmd.io/_uploads/HJisEE1Zlx.png)


**8. Recommended Tools**
* Schematic/PCB Design: KiCad (free), Altium Designer (professional).
* Simulation: LTspice (power), Sigrity (signal integrity).
* Manufacturing: JLCPCB, PCBWay (for prototyping).

**Example 2-Layer STM32 PCB Layout**
1. Top Layer:

* MCU, crystals, USB, and most components.
* Signal traces (avoid long parallel runs).

2. Bottom Layer:

* Ground plane (minimize splits).
* Power traces (short and thick).

**Final Tips**
* Start simple: Use reference designs from [MCU](https://www.ampheoelec.de/c/microcontrollers) datasheets.
* Prototype: Test critical circuits on a breadboard first.
* Iterate: Revise the design based on testing results.

By following these steps, you’ll create a robust PCB for your MCU project!