The project works. It's an Uno, a breadboard and a nest of jumper wires, and every time you pick it up one of them comes loose. The next step is obvious: put it on a printed circuit board. And that's usually where projects stall, because it feels like a different skill.
It's less of a jump than it looks. Most of what goes wrong comes from one thing: forgetting what the Arduino board was doing for you.
Three ways off the Uno
There isn't one right answer here, and choosing deliberately saves a lot of grief.
- A shield. Your circuit on a board that plugs onto the Uno's headers. Fastest, and the Uno keeps doing USB, power and programming.
- A module on your board. Sockets for a Nano or a Pro Mini on your own PCB. Smaller, and you still don't design the microcontroller circuit.
- A bare ATmega328P. The chip itself on your board, with everything around it. Smallest and cheapest per board, and the most to get right.
If it's your first PCB, the module route gets you a real board with the fewest new things to learn. Plenty of finished products are a module on a carrier board.
What the Uno was hiding
Around its ATmega328P, an Uno carries:
Everything the Uno does around its chip, as a KiCad schematic that passes its electrical rules check.
- A 16 MHz clock (custom boards usually use a crystal with two 22 pF capacitors to ground)
- A 10 kΩ reset pull-up and a reset button
- Decoupling: 100 nF at VCC, at AVCC (tied to VCC) and at AREF
- A regulator to make 5 V
- A second chip that turns USB into serial, plus a 100 nF capacitor from DTR to reset, which is how the IDE resets the chip at the start of each upload
Shield and module routes keep all of that. The bare-chip route means putting every item on your board.
The one people leave off is decoupling. A bare ATmega328P on a breadboard often runs fine without capacitors at its power pins, so they don't make it onto the PCB either, and then the board resets whenever a motor or relay switches.
Draw the schematic before anything else
The breadboard hides mistakes that a PCB makes permanent, so write every connection down as a schematic first, wire by wire. Use the chip's real pins, not the Arduino names: D13 is PB5 (pin 19 on the 28-pin DIP), A0 is PC0 (pin 23), the serial pins D0/D1 are PD0/PD1 (pins 2 and 3). Every pin should be on exactly one net. A pin on two nets is a short.
A handful of layout rules that matter on a first board
- Connectors, buttons and anything you plug in go on the board edges.
- The crystal and its capacitors sit right at the XTAL pins, nothing routed under them.
- Each decoupling capacitor sits at the pin it serves.
- Two layers, one of them mostly ground pour.
- Power traces wider than signal traces.
- Mounting holes placed before routing, not after.
- Label connectors, polarity and pin 1 on the silkscreen.
- 0805 parts or through-hole if you'll hand-solder.
Doing it with AI, honestly
I build an AI PCB tool, so here's how I'd use one for this, including what to check.
- Describe precisely. Parts, packages, connections. The less it has to guess, the better.
- Review the plan before anything is built. Wrong parts are cheapest to fix here.
- Check the schematic. One net per pin, power and ground where they belong, LEDs the right way round.
- Let it place and route, then read the report. You want zero unrouted nets and a design-rule check with zero errors.
- Open the Gerbers in a viewer the tool didn't make.
- Order five boards, not fifty.
On a small real example (a 2-pin power header and three LED-and-resistor branches, described in one paragraph), our tool placed and routed all five nets and the design-rule check came back with 0 errors and 0 warnings. The guide on the site shows the actual board and the actual log rather than a mock-up, because "it routed" is a claim you should be able to check.
The point isn't that the tool is never wrong. Each step has a check you can do yourself.
Getting code onto it
A bare ATmega328P usually arrives without the Arduino bootloader. Burn it once through a 6-pin ISP header (an Uno running the Arduino as ISP example works as the programmer), then upload sketches through a USB-to-serial adapter on a 6-pin serial header, with that 100 nF capacitor from DTR to reset doing the auto-reset. Or skip the bootloader and upload everything over ISP.
The full guide, with the Uno-to-standalone diagram, the pin map and the AI example, is on pcbeditor.com.
What made your first Arduino-to-PCB move go wrong? I'm collecting the failures that aren't on this list.
Top comments (0)