The Arduino board is a development tool

Everything on the Arduino board around the ATmega328P chip exists to make programming convenient — not to run your final product.

• Real products are built around the chip itself, soldered onto a custom PCB
• Cost: An ATmega328P chip costs ~$2. An Arduino Uno costs ~$25. You ship the chip, not the board.
• Size: The chip is 3 cm long. The Uno board is 7× bigger.
• Power: The Uno's USB-serial chip and regulators draw current even when idle
• Flexibility: On a custom PCB you place only the components your circuit needs

Ways to get code onto a bare ATmega328P

Why Arduino as ISP?

• No extra hardware to buy — you already have an Arduino Uno
• Works on macOS, Windows, and Linux without special drivers
• Supported natively by the Arduino IDE and avrdude
• Can both upload sketches and burn bootloaders — the most versatile option with what we have

🛒 Components for Today

In-System Programming

• A standard AVR hardware feature — not software
• Uses 4 SPI lines to read and write flash, EEPROM, and fuse bits
• Available on every ATmega328P — even a blank, factory-fresh chip
• The programmer holds RESET LOW to put the chip in programming mode, then clocks data in via MOSI

The 4 ISP pins on ATmega328P

Same pins as SPI — students already know these from earlier in the course.

Who is who today

• Master: Programmer Uno (running ArduinoISP sketch)
• Slave: Target ATmega328P on the breadboard

What it does

• A sketch you flash to the programmer Uno — once, before the lab
• Turns that Uno into a protocol translator between your PC and the target chip
• Translates STK500v1 serial commands from avrdude into SPI signals to the target

Why it's needed

1. When avrdude opens the serial port, it pulses the DTR line
2. DTR normally travels through the auto-reset circuit and resets the Uno
3. A reset mid-programming crashes ArduinoISP → upload fails
4. A 10 µF capacitor blocks the brief DTR pulse from reaching RESET

Wiring the capacitor

Four things to set before uploading

The critical mistake to avoid

What we covered

• ISP uses 4 SPI wires + RESET to write directly to AVR flash hardware
• ArduinoISP sketch turns a Uno into a protocol translator — upload it once to the programmer Uno
• 10 µF cap on programmer RESET → GND blocks the DTR pulse that would crash ArduinoISP
• "Upload Using Programmer" is the correct method — never the normal Upload arrow
• "Burn Bootloader" restores the Optiboot bootloader for USB uploading later

Lab preview

In the next 1.5 hours you will:

1. Flash ArduinoISP to the Arduino Uno
2. Wire the 6 ISP connections + capacitor
3. Upload Blink to the standalone chip
4. Observe the chip running independently

Goal

Flash a Blink sketch to the standalone ATmega328P using Arduino as ISP. At the end, a bare chip on a breadboard blinks an LED. The Uno board is the programmer, not the computer running the sketch.

Materials per group

• 1× Arduino Uno R3 (the programmer)
• 1× ATmega328P-PU with bootloader (the target, on the breadboard)
• 1× 10 µF electrolytic capacitor
• 1× LED + 220 Ω resistor
• Breadboard + jumper wires

Time box

Instructions

1. Connect the Arduino Uno to your PC via USB
2. In Arduino IDE: File → Examples → 11.ArduinoISP → ArduinoISP
3. Confirm Board = Arduino Uno, Port = the Uno's port
4. Click the normal Upload button ▶ (this is the only time you use the normal upload button today)
5. Wait for "Done uploading"
6. Do not unplug the Uno — it stays connected to the PC all session

How to verify it worked

The ArduinoISP source code deliberately blinks pin 9 (error), pin 8 (programming), and pin 7 (heartbeat) — but on a standard Uno, pin 13 acts as the visible heartbeat indicator.

Wire in this order (reduces mistakes)

Chip orientation

Wiring GND first and VCC second ensures no floating supply lines before data wires are connected.

Upload

1. Open File → Examples → 01.Basics → Blink
2. Click Sketch → Upload Using Programmer
3. Watch the IDE progress bar and the flickering LEDs on the Uno
4. Wait for "Done uploading" in the IDE output

Observation questions

• Which components are currently powering the target chip?
• Is the target using its own USB connection to run the sketch?
• What would happen if you disconnected the Uno right now?
• Which parts of the Uno board are NOT needed for the sketch to run?

Debug order

1. Power: Is the target getting 5V from the Uno?
2. Capacitor: Is the 10 µF cap on the Uno, correct polarity?
3. Wiring: Check all 6 connections against the table
4. IDE settings: Programmer = Arduino as ISP, correct port?
5. ArduinoISP: Is the heartbeat LED pulsing on the Uno?

What this proves

Any ATmega328P chip — fresh from the factory, blank, or bricked — can have Optiboot burned onto it using exactly this setup. This is how the "bootloaded" chips you purchased were made.

Steps

1. Keep the ISP wiring exactly as-is
2. In Arduino IDE: Tools → Burn Bootloader
3. Wait for IDE output: "Done burning bootloader."
4. The chip can now receive sketches over USB-to-serial (FTDI adapter) or back in the Uno socket

What happens inside

• Fuses are written to configure 16 MHz external crystal, correct reset behaviour, and boot flash section size
• Optiboot hex is written to the Boot Flash Section (last 512 bytes of flash)
• After reset, the chip checks for a serial upload for ~2 seconds before jumping to the sketch

🕐 Internal RC Oscillator (default)

• Speed: 8 MHz (factory default)
• Extra parts: none — it's built in
• Accuracy: ± 10 % across temperature
• Fuse (CKSEL): 0010 — set from factory
• Problem: Arduino IDE expects 16 MHz for an Uno, so delay(1000) actually waits 2 seconds — your blink runs at half speed

💎 External Crystal (target)

• Speed: up to 20 MHz — we use 16 MHz to match the Uno
• Extra parts: 1× crystal + 2× 22 pF caps
• Accuracy: < 50 ppm (< 0.005 %)
• Fuse (CKSEL): 1111 — set by "Burn Bootloader"
• Result: delay(1000) = exactly 1 second; millis() / micros() correct

Connection table

Steps

1. Keep your Part 1 ISP wiring intact
2. Insert the crystal across XTAL1 (pin 9) and XTAL2 (pin 10)
3. Add a 22 pF cap from XTAL1 to GND and another from XTAL2 to GND
4. In Arduino IDE: Tools → Burn Bootloader
5. Upload your blink sketch via ISP (Sketch → Upload Using Programmer)

The sketch (same both times)

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

What to observe

What you proved today

• ISP communicates over SPI at hardware level — no bootloader, no USB-serial chip required on the target
• ArduinoISP turns a Uno into a programmer — upload it once, use it all session
• The 10 µF cap on the programmer RESET is not optional
• "Upload Using Programmer" bypasses the bootloader — "Burn Bootloader" restores it

Exit question

Name one thing the Arduino board was doing for you that the standalone chip cannot do by itself.

Preview: Week 14