Arduino PCB Design: Complete Guide to Nano, Uno & ATmega328P Custom Board Tutorial

As a PCB engineer who has designed dozens of Arduino-based boards over the years, I can tell you that understanding Arduino PCB design is one of the most practical skills you can develop in electronics. Whether you’re looking to shrink your prototype into a production-ready product or simply want to understand what’s happening under the hood of your favorite development board, this comprehensive guide will walk you through everything from basic circuit fundamentals to manufacturing-ready designs.

In this tutorial, we’ll cover Arduino Nano PCB design, Arduino Uno PCB design, and how to build your own custom ATmega328P PCB design from scratch. By the end, you’ll have the knowledge to create professional-quality boards that rival commercial offerings.

Why Design Your Own Arduino PCB?

Before diving into schematics and layouts, let’s address the obvious question: why bother designing your own board when you can buy an Arduino for under $25?

From my experience working on commercial products, here are the compelling reasons:

Cost Reduction at Scale: A bare ATmega328P costs around $2-3, while a complete Arduino Uno runs $25+. When you’re producing hundreds of units, this difference matters significantly.

Size Optimization: The Arduino Uno measures 68.6 x 53.4 mm. Your custom board can be as small as 20 x 20 mm if you only need the essential components.

Feature Customization: Why include USB-to-Serial if your final product programs once and runs forever? Custom designs let you include only what you need.

Professional Integration: Shield stacking isn’t suitable for vibration-prone or space-constrained applications. Custom PCBs integrate everything into one reliable board.

Learning and IP: Understanding the hardware gives you troubleshooting superpowers and creates intellectual property you fully control.

Understanding the ATmega328P: The Heart of Arduino

The ATmega328P microcontroller serves as the brain of both the Arduino Uno and Arduino Nano. Before starting any ATmega328P PCB design, you need to understand this chip’s fundamental requirements.

ATmega328P Key Specifications

Parameter	Value
Architecture	8-bit AVR RISC
Operating Voltage	1.8V – 5.5V
Clock Speed	Up to 20 MHz (16 MHz typical)
Flash Memory	32 KB (2 KB used by bootloader)
SRAM	2 KB
EEPROM	1 KB
Digital I/O Pins	23
PWM Channels	6
Analog Inputs	8 (10-bit ADC)
Operating Temperature	-40°C to 85°C

Package Options for PCB Design

Package	Pin Count	Size	Best For
PDIP-28	28	34.67 x 7.62 mm	Prototyping, through-hole
TQFP-32	32	7 x 7 mm	Production, space-constrained
QFN-32	32	5 x 5 mm	Ultra-compact designs
MLF-28	28	4 x 4 mm	Smallest footprint

For your first custom Arduino PCB design, I recommend starting with the TQFP-32 package. It offers a good balance between hand-solderability and compact size, plus it exposes the additional ADC6 and ADC7 pins not available in the DIP package.

ATmega328P Bare Minimum Circuit Configuration

Every successful ATmega328P PCB design starts with understanding the bare minimum components needed to make the microcontroller function. This minimal circuit forms the foundation upon which you’ll build more complex designs.

Essential Components

1. Power Supply Decoupling The ATmega328P requires clean, stable power. Place a 100nF ceramic capacitor as close as possible to each VCC pin:

• Pin 7 (VCC)
• Pin 20 (AVCC)

Additionally, add a 10µF electrolytic capacitor near the power input for bulk filtering.

2. Reset Circuit The RESET pin (Pin 1) is active-low, meaning the chip resets when this pin goes to 0V. For normal operation:

• Connect a 10kΩ pull-up resistor between RESET and VCC
• Add a 100nF capacitor from DTR (if using USB programming) to RESET
• Optionally add a tactile switch between RESET and GND

3. Crystal Oscillator Circuit For 16 MHz operation (Arduino-compatible):

• 16 MHz crystal connected to XTAL1 (Pin 9) and XTAL2 (Pin 10)
• Two 22pF load capacitors from each crystal pin to GND

The formula for load capacitor selection is:

CL = (C1 × C2)/(C1 + C2) + Cstray

Where Cstray is typically 3-5pF on a PCB.

Note: The ATmega328P has an internal 8 MHz oscillator. If accuracy isn’t critical and you want to reduce component count, you can use this instead by setting the appropriate fuse bits.

Bare Minimum Schematic Connections

ATmega328P Pin	Connection
Pin 1 (RESET)	10kΩ to VCC, optional switch to GND
Pin 7 (VCC)	5V with 100nF bypass capacitor
Pin 8 (GND)	Ground
Pin 9 (XTAL1)	16 MHz crystal + 22pF to GND
Pin 10 (XTAL2)	16 MHz crystal + 22pF to GND
Pin 20 (AVCC)	5V with 100nF bypass capacitor
Pin 21 (AREF)	100nF to GND (optional)
Pin 22 (GND)	Ground

Arduino Uno PCB Design: Complete Schematic Breakdown

The Arduino Uno Rev3 is the reference design most engineers study when learning Arduino Uno PCB design. Let’s break down its major subsystems.

Power Supply Section

The Uno’s power system is more sophisticated than it might appear:

Input Options:

• USB 5V (limited to 500mA)
• DC barrel jack (7-12V recommended, 20V max)
• VIN header pin (same specs as barrel jack)

Voltage Regulation: The Uno uses an NCP1117ST50T3G (or similar) linear regulator to convert the input voltage to 5V. Key specifications:

Parameter	Value
Input Voltage	Up to 20V
Output Voltage	5V
Max Current	1A (with adequate heatsink)
Dropout Voltage	~1.2V

Important Design Note: The voltage regulator dissipates power as heat according to P = (Vin – Vout) × I. At 12V input and 200mA draw, you’re dissipating 1.4W! This is why the Uno can get warm during heavy use.

For the 3.3V rail, the Uno uses an LP2985 regulator fed from the 5V rail, providing up to 150mA for 3.3V peripherals.

USB-to-Serial Interface

The Arduino Uno Rev3 uses an ATmega16U2 microcontroller as a USB-to-Serial converter. For custom Arduino PCB design projects, you have several alternatives:

Chip	Pros	Cons
ATmega16U2	Native USB, official Arduino	Complex, expensive
FT232RL	Reliable, well-documented	$4-5, requires drivers on some OS
CH340G	Cheap ($0.30), works well	Driver required, some quality variance
CP2102	Good balance, $1-2	Limited GPIO options

For cost-sensitive designs, I typically recommend the CH340G. Yes, it requires a driver on Windows, but modern Windows 10/11 handles it automatically, and the price difference adds up quickly in production.

ICSP Header Design

The In-Circuit Serial Programming (ICSP) header is essential for:

• Burning the bootloader to new chips
• Programming without USB
• Recovery from bricked bootloaders

Standard ICSP pinout (2×3 header, 2.54mm pitch):

Pin 1	Pin 2
MISO	VCC
Pin 3	Pin 4
SCK	MOSI
Pin 5	Pin 6
RESET	GND

PCB Layout Tip: Orient the ICSP header consistently. Pin 1 is typically marked with a dot on both the header and your silkscreen.

Read more different PCB Design services:

Arduino Nano PCB Design: Compact Form Factor

The Arduino Nano represents an elegant example of compact Arduino Nano PCB design. At just 45 x 18 mm, it packs nearly identical functionality to the Uno in a fraction of the space.

Nano vs Uno: Design Differences

Feature	Arduino Uno	Arduino Nano
Dimensions	68.6 x 53.4 mm	45 x 18 mm
USB Connector	Type-B	Mini-B
Power Jack	Yes (2.1mm barrel)	No
Extra Analog Pins	A0-A5 (6 pins)	A0-A7 (8 pins)
Breadboard Compatible	No	Yes
USB-Serial Chip	ATmega16U2	FT232RL/CH340G
Reset Button	Yes	Yes
Mounting Holes	Yes	No

Key Design Considerations for Nano-Style Boards

1. Component Selection To achieve Nano-like density, you must use surface-mount components:

• 0805 or 0603 passives (resistors, capacitors)
• Mini-USB or USB-C connector
• TQFP-32 ATmega328P

2. Layer Count While a 2-layer board is possible for Nano designs, I recommend 4 layers for:

• Better power distribution
• Reduced EMI
• Easier routing
• Dedicated ground plane

3. Crystal Placement Place the 16 MHz crystal as close as possible to pins 9 and 10. Keep traces short and avoid routing other signals nearby. The crystal is the most EMI-sensitive part of your design.

Nano Power Circuit

The Arduino Nano’s power system is simpler than the Uno:

USB 5V ──┬── Schottky ──┬── 5V Rail ── ATmega328P VCC         │              │VIN ─────┴── LM1117 ────┘             5V Regulator

The Schottky diode prevents backfeeding from VIN to USB, and the LM1117 handles unregulated input.

Designing Your Custom ATmega328P Board

Now let’s walk through the complete process of creating your own ATmega328P PCB design.

Step 1: Define Requirements

Before opening your EDA software, answer these questions:

1. What’s the primary purpose? (General dev board, specific application, learning)
2. Size constraints? (Maximum dimensions, mounting hole locations)
3. Power requirements? (Voltage range, current draw, battery operation)
4. Programming method? (USB, ICSP, Bluetooth)
5. Required peripherals? (Which I/O pins do you actually need?)

Step 2: Choose Your EDA Software

For Arduino PCB design, these are the popular options:

Software	Cost	Learning Curve	Best For
KiCad	Free	Moderate	Serious hobbyists, open-source advocates
EasyEDA	Free	Easy	Beginners, quick prototypes
Eagle	Free (limited)	Moderate	Industry standard, large libraries
Altium Designer	$$$$	Steep	Professional, complex designs
Fritzing	Free/Cheap	Very Easy	Absolute beginners, documentation

I personally use KiCad for all my Arduino-related projects. It’s free, powerful, and has excellent community support with ready-made Arduino libraries.

Step 3: Schematic Design

Create your schematic in logical blocks:

Block 1: Microcontroller Core

• ATmega328P with all required bypass capacitors
• Crystal oscillator circuit
• Reset circuit with pull-up and capacitor

Block 2: Power Supply

• Input protection (reverse polarity, overvoltage)
• Main voltage regulator (5V)
• Secondary regulator if needed (3.3V)
• Power indicator LED

Block 3: Programming Interface Choose one or more:

• USB with CH340G/FT232RL
• ICSP header
• FTDI header (6-pin)

Block 4: User I/O

• Pin headers for all I/O
• Status LEDs (power, TX, RX, user)
• Reset button

Step 4: PCB Layout Best Practices

After years of designing boards, here are my essential Arduino PCB design rules:

Power Integrity

• Use wide traces for power (minimum 0.5mm for 5V rail)
• Place decoupling capacitors within 3mm of IC power pins
• Create a solid ground plane on one layer
• Use thermal reliefs on ground connections for easier soldering

Signal Routing

• Keep crystal traces short (<10mm) and equal length
• Route analog signals away from digital noise sources
• Use 45° angles or curves, avoid 90° corners
• Maintain consistent trace width for impedance-matched signals

Component Placement

• Group related components together
• Place tall components away from board edges
• Consider assembly order for hand soldering
• Leave space for test points

Design Rule Check (DRC) Settings for Standard Manufacturing

Parameter	Minimum Value
Trace Width	0.2mm (8 mil)
Trace Spacing	0.2mm (8 mil)
Via Diameter	0.6mm
Via Drill	0.3mm
Annular Ring	0.15mm
Silkscreen Line	0.15mm
Board Outline	0.2mm

Step 5: Generate Manufacturing Files

Most PCB manufacturers accept Gerber files. Generate the following layers:

• Top Copper (GTL)
• Bottom Copper (GBL)
• Top Soldermask (GTS)
• Bottom Soldermask (GBS)
• Top Silkscreen (GTO)
• Bottom Silkscreen (GBO)
• Board Outline (GKO/GML)
• Drill File (DRL/XLN)

Pro Tip: Always generate and view your Gerbers in a standalone viewer before ordering. I use gerbv (free) or the online viewer at your PCB fab’s website.

Burning the Bootloader

Once your custom ATmega328P PCB design is assembled, you’ll need to burn the Arduino bootloader. This small program (2KB) allows programming via serial instead of requiring an ISP programmer every time.

Method 1: Arduino as ISP

The easiest method uses an existing Arduino as a programmer:

Connections from Arduino Uno to Target Board:

Arduino Uno	Target ATmega328P
Pin 10	RESET
Pin 11	MOSI (Pin 17)
Pin 12	MISO (Pin 18)
Pin 13	SCK (Pin 19)
5V	VCC
GND	GND

Procedure:

1. Upload ArduinoISP sketch to your Uno
2. Make the connections above
3. In Arduino IDE, select “Arduino as ISP” under Programmer
4. Select “Arduino Uno” as the target board
5. Click “Burn Bootloader”

Method 2: USBasp Programmer

The USBasp is a dedicated AVR programmer costing around $5:

Connections:

USBasp	Target ATmega328P
MOSI	Pin 17
MISO	Pin 18
SCK	Pin 19
RESET	Pin 1
VCC	VCC
GND	GND

Important: If programming a fresh chip with factory fuses (1MHz internal clock), you may need to use the “slow clock” jumper on USBasp.

Common Bootloader Burning Issues

Problem	Solution
“Device signature 0x000000”	Check wiring, especially RESET
“Invalid device signature”	Wrong board selected in IDE
“Programmer not responding”	Check COM port, try different USB port
Timeout errors	Verify target has correct crystal/power

Testing Your Custom Arduino Board

After assembly, follow this systematic testing procedure:

1. Visual Inspection

• Check for solder bridges, especially on fine-pitch components
• Verify all components are present and correctly oriented
• Look for cold solder joints

2. Power Test (Before Programming)

• Apply power gradually with a current-limited supply
• Measure voltages: VCC should be 4.75-5.25V
• Check current draw: bare ATmega328P should draw ~15mA at 16MHz

3. Programming Test

• Burn bootloader
• Upload blink sketch
• Verify LED blinks at correct rate

4. Peripheral Test

• Test all I/O pins with simple input/output sketch
• Verify analog readings with known voltage
• Test serial communication

Useful Resources and Downloads

Here are essential resources for your Arduino PCB design projects:

Official Arduino Resources

• Arduino Uno Schematic: arduino.cc/en/uploads/Main/Arduino-uno-schematic.pdf
• Arduino Nano Schematic: arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf
• Arduino Nano Eagle Files: Available at store.arduino.cc

ATmega328P Documentation

• Complete Datasheet: microchip.com/ATmega328P
• Application Notes: Search Microchip AN for specific topics

PCB Design Software

• KiCad (Free): kicad.org
• EasyEDA (Free, Web-based): easyeda.com
• Fritzing: fritzing.org

KiCad Arduino Libraries

• Arduino KiCad Library: github.com/Alarm-Siren/arduino-kicad-library
• Complete UNO KiCad Files: github.com/rheingoldheavy/arduino_uno_r3_from_scratch

PCB Manufacturing Services

• JLCPCB: Low-cost prototypes, $2 for 5 boards
• PCBWay: Good quality, design review service
• OSH Park: Made in USA, purple boards, $5 per square inch

Component Suppliers

• LCSC: Best for Chinese PCB assembly integration
• DigiKey: Comprehensive catalog, excellent search
• Mouser: Similar to DigiKey, good for comparison shopping
• AliExpress: Lowest cost, longer shipping times

Common Mistakes to Avoid in Arduino PCB Design

Over the years, I’ve seen (and made) plenty of mistakes. Here’s how to avoid the most common ones:

Schematic Errors

1. Missing Decoupling Capacitors Every VCC pin needs its own 100nF capacitor. The ATmega328P has multiple power pins that all require decoupling.

2. Wrong Crystal Load Capacitors Using the wrong value prevents reliable oscillation. Always check your crystal’s datasheet for the specified load capacitance.

3. Floating AREF Pin If you’re not using an external reference, either leave AREF unconnected or add a 100nF capacitor to ground for noise filtering.

Layout Errors

1. Crystal Too Far from MCU Long traces add capacitance and act as antennas. Keep crystal traces under 10mm.

2. Insufficient Ground Plane A fragmented ground plane increases noise and EMI. Prioritize an unbroken ground on at least one layer.

3. Small Power Traces 5V and GND traces carry most of your current. Use traces at least 0.5mm wide, preferably 1mm or more.

Assembly Errors

1. Reversed Electrolytic Capacitors Polarized caps must be installed correctly. Mark polarity clearly on your silkscreen.

2. Wrong ATmega328P Variant The ATmega328P-PU and ATmega328P-AU have different footprints. Double-check your BOM.

3. Missing Reset Pull-up Without the pull-up resistor, your board will randomly reset or fail to start.

Frequently Asked Questions

Q1: Can I design an Arduino PCB without USB and program it via ICSP only?

Absolutely, and many production designs do exactly this. USB adds cost, complexity, and size that aren’t needed if you program the board once during manufacturing. Simply include an ICSP header and use a USBasp or Arduino-as-ISP to burn the bootloader and upload your sketch. For production, you can even skip the bootloader entirely and upload code directly via ICSP, which also saves 2KB of flash memory.

Q2: What’s the minimum number of components needed for a working ATmega328P circuit?

With the right fuse settings (internal 8MHz oscillator), you can run an ATmega328P with just three components: the chip itself, a 100nF decoupling capacitor on VCC, and a 10kΩ pull-up resistor on RESET. However, this runs at 8MHz instead of 16MHz and may have timing accuracy issues. For reliable operation matching Arduino behavior, you need the crystal, two load capacitors, decoupling caps, and the reset circuit components—typically 7-8 components total.

Q3: How do I choose between designing a 2-layer and 4-layer PCB for my Arduino project?

For simple Arduino designs with few additional components, 2 layers work fine and cost less. However, consider 4 layers when your design includes high-speed signals (USB, SPI at high frequencies), RF components like WiFi or Bluetooth modules, or when you need a dedicated ground plane for noise-sensitive analog circuits. The cost difference is typically $5-15 for prototype quantities, which is often worth it for easier routing and better signal integrity.

Q4: Why does my custom ATmega328P board work with the bootloader but fail when I try to upload sketches?

This usually indicates a problem with the auto-reset circuit. When you upload a sketch, the computer asserts DTR, which should pulse the RESET line through a 100nF capacitor. Common issues include a missing or wrong-value capacitor (must be 100nF), problems with the USB-to-serial chip’s DTR pin, or conflicts with other devices on the serial lines. Test by manually pressing the reset button just as “Uploading…” appears in the Arduino IDE. If that works, your auto-reset circuit needs debugging.

Q5: Can I use a different crystal frequency than 16MHz for my Arduino PCB design?

Yes, but with caveats. The ATmega328P officially supports up to 20MHz, and many designs use 8MHz (with the internal oscillator or external crystal) to run at lower voltages or reduce power consumption. However, changing the crystal frequency requires modifying the bootloader and updating the boards.txt file in your Arduino installation to reflect the new F_CPU value. All time-dependent functions (delay, millis, Serial baud rates) calculate timing based on this value, so getting it wrong causes communication failures and incorrect timing.

Conclusion: Taking Your Arduino PCB Design to Production

Designing your own Arduino-compatible PCB is a rewarding journey that transforms you from a hobbyist into a true electronics engineer. You now understand the core principles behind Arduino PCB design, whether that’s a full-featured Arduino Uno PCB design, a compact Arduino Nano PCB design, or a completely custom ATmega328P PCB design.

The key takeaways from this guide are:

1. Start with the bare minimum circuit and understand why each component exists
2. Use appropriate EDA software and follow good layout practices
3. Always verify your design before manufacturing
4. Test systematically after assembly
5. Don’t be afraid to iterate—even professional engineers rarely get it perfect on the first revision

Your first custom Arduino board might not be perfect, and that’s okay. Every revision teaches you something new. The open-source nature of Arduino means you can study reference designs, learn from community projects, and contribute your own improvements.

Now it’s your turn. Fire up KiCad, download those Arduino reference designs, and start creating. The maker community is waiting to see what you’ll build.