Pin Mapping Limitations

Learning Goals 5 min

Not every pin can do every thing. UNO has PWM on some pins, interrupts on others, true analog only on A0..A5. Knowing which pin does what before wiring saves hours of debugging. By the end of this lesson you will:

1. Read an Arduino pin-out diagram (the official PDFs) and identify which pins support PWM, interrupts, analog input, and 5V tolerance.
2. Plan a pin map that doesn't collide with hardware peripherals (SPI / I²C / UART).
3. Spot the four most common "wrong pin" mistakes on the UNO and on the Nano 33 BLE.

Warm-Up 10 min

Pull up the UNO R3 pinout diagram (search "Arduino UNO R3 pinout"). You'll see colour-coded blocks: digital pins, analog pins, PWM (~), SPI (MISO/MOSI/SCK/SS), I²C (SDA/SCL), UART (RX/TX), interrupts (INT0/INT1).

Three questions

1. Can you call analogWrite(2, 128) on a UNO?
2. Which two UNO pins support hardware interrupts via attachInterrupt()?
3. Can you use A4 / A5 as digital I/O?

New Concept · The UNO pin map dissected 25 min

Six pin properties to track

UNO R3 — every pin's talents

Pin assignment strategy

1. Start with mandatory pins: I²C → A4/A5; SPI → 11/12/13; UART → 0/1.
2. Allocate interrupts: 2 and 3 if you need them. Use 2 for the most important interrupt.
3. Allocate PWM: pick from 3, 5, 6, 9, 10, 11. Avoid 9/10 if you'll use Servo (it takes those pins' timers and breaks their PWM).
4. Everything else is plain digital: 4, 7, 8, 12, 13 (don't fight the on-board LED unless you want it as a status indicator).

Nano 33 BLE pin map — the differences

• Every pin supports PWM (any digital pin can analogWrite). Different timer assignment.
• Every pin supports interrupts (call attachInterrupt(digitalPinToInterrupt(pin), ...)).
• Analog pins A0..A7 — 8 channels, default 10-bit, supports 12-bit.
• 3.3 V GPIO. Not 5 V tolerant.
• I²C on A4/A5 (same physical position as UNO, different chip pins).
• SPI on D11/D12/D13 (same shield-compatible position).

Common UNO pin mistakes

1. analogWrite on a non-PWM pin. Sets HIGH or LOW only. Symptom: LED is on or off, never dim.
2. SPI device on pins 11–13 + LED on pin 13. The LED flickers with every SPI write. Either move the LED or accept the flicker.
3. Servo on pin 9 + LED on pin 10 expecting PWM. Servo library takes Timer1, killing PWM on both pins 9 and 10. The LED's "fade" will be on/off only.
4. I²C on A4/A5 + Servo (which steals analogRead timing). Rare in practice; mostly an issue with high-frequency analog reads alongside time-sensitive I²C.

Worked Example · Pin-allocate a real project 25 min

Brief — robot with extras

UNO + L298N (2 motors) + HC-05 Bluetooth + HC-SR04 ultrasonic + OLED (I²C) + 2 buttons + 1 status LED. Allocate pins.

Step 1 — list mandatory pins

• I²C (OLED) → A4, A5.
• HC-05 SoftwareSerial → pick any digital pair, say D2 + D3 (D2 also INT0 — use anyway, not using interrupts on Bluetooth).
• USB Serial debug → D0, D1 (don't connect anything else).

Step 2 — motor driver (needs PWM on enable pins)

• L298N ENA → PWM pin → D5 (980 Hz).
• L298N ENB → PWM pin → D6 (980 Hz).
• L298N IN1, IN2 → digital → D7, D8.
• L298N IN3, IN4 → digital → D9 (avoid Servo conflict — no Servo here) or wait, D9 is also PWM. Use D9 anyway; we don't need PWM on IN pins.
• Actually re-allocate: D9 → IN3, D10 → IN4.

Step 3 — sensors

• HC-SR04 TRIG → digital, no PWM needed → D11. Wait, D11 is also SPI MOSI — fine because we're not using SPI here.
• HC-SR04 ECHO → digital, interrupt-capable preferred for accurate timing — but pulseIn doesn't require interrupts → D12.

Step 4 — UI

• Status LED → D13 (on-board; easy).
• Button A → can't use 2/3 (taken by HC-05). Use A0 as digital → D14.
• Button B → A1 as digital → D15.

Final pin map

3 spare pins for expansion. No conflicts. Two PWM channels used out of 6 available.

Step 5 — document the map

Tape the map next to the breadboard. Future-you (or a partner) will instantly know what each pin does. This is the single biggest debugging time-saver in a multi-component project.

Basic 5 min

Challenge 1 5 min

const int SD_CS_PIN = 10;
const int BUTTON_A_PIN = 2;
const int BUTTON_B_PIN = 12;
const int STATUS_LED_PIN = 13;

volatile bool aPressed = false;
volatile bool bPressed = false;

void onA() {
  aPressed = true;
}

void onB() {
  bPressed = true;
}

void setup() {
  pinMode(BUTTON_A_PIN, INPUT_PULLUP);
  pinMode(BUTTON_B_PIN, INPUT_PULLUP);
  pinMode(STATUS_LED_PIN, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(BUTTON_A_PIN), onA, FALLING);
  attachInterrupt(digitalPinToInterrupt(BUTTON_B_PIN), onB, FALLING);
}

void loop() {
}

Challenge 2 5 min

#include <Servo.h>

const int SERVO_PIN = 9;
const int LED_PIN = 10;

Servo arm;

void setup() {
  arm.attach(SERVO_PIN);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  for (int level = 0; level <= 255; level++) {
    analogWrite(LED_PIN, level);
    arm.write(map(level, 0, 255, 0, 180));
    delay(10);
  }
}

Challenge 3 · Pin-allocate a tricky brief 10 min

A UNO must run all of these at once:

• An SD card on SPI.
• An I²C OLED.
• One servo.
• Two buttons that use interrupts.
• Three LEDs that must dim with analogWrite.
• An HC-SR04 and a buzzer.

1. Follow the four-step strategy. Write the const int pin block.
2. One part cannot be given the pin talent it needs. Find it.
3. Give two different fixes for that part.

It works if your pin block compiles with no pin used twice. You must also name the part that does not fit.

Recap 5 min

Every pin has a personality. Plan I²C / SPI / UART / interrupt / PWM allocation before wiring. UNO's six pin properties (digital, PWM, analog, interrupt, peripheral, voltage) cover most assignments. Document the map alongside the build. Tomorrow we go even deeper into the chip — bootloaders and using one Arduino to flash another.

Pinout diagram

The official PDF showing each pin's functions. Found on the Arduino docs site for every board.

PWM pin

A pin that can output a hardware PWM signal via analogWrite. Marked with ~ on the UNO.

Interrupt-capable pin

A pin that can fire an interrupt service routine on edge change. UNO: only 2, 3. Most modern boards: every pin.

Hardware peripheral pin

A pin wired to a specific MCU peripheral (SPI, I²C, UART). Reserved when that peripheral is in use.

5V tolerant

The input accepts 5 V without damage. UNO yes; most 3.3 V boards no.

Pin map

The list of which physical pin does which function in your project. Always document it.

Timer conflict

When a library steals a hardware timer used by another peripheral. Servo + Timer1 disabling PWM on pins 9/10 is the classic UNO example.

Extra Mission 5 min

Part 1 — Design a gadget with a busy pin map

Design a gadget with at least six parts — a desk pet robot, a game buzzer box, a room alarm. On paper, give it a full UNO pin map.

Your design must include:

• The gadget's one job, in one sentence.
• A pin table with every part and the talent each pin needs (PWM, interrupt, analog, bus).
• The spare pins left for later.
• One clash you avoided, and how.

Part 2 — Make it

Wire at least four of the parts exactly as your map says. Write a test sketch that uses your const int block and checks each part in turn. Print "OK" to the Serial Monitor after each one.

Bring back next class: your pin map, the uploaded sketch, and a photo of the circuit. For ARD-L04-05, bring two UNOs if you can.