Input/Output Pins: Your Robot’s Connection to the World

Input/output (I/O) pins are the physical connection points on a microcontroller that interface with the external world — digital pins can read a HIGH or LOW voltage (detecting button presses, limit switches, and digital sensor signals) or output a HIGH or LOW voltage (controlling LEDs, relay coils, and motor driver enable signals), while analog input pins read a continuously variable voltage (0–5V on Arduino Uno) and convert it to a numeric value through an analog-to-digital converter, enabling sensors like potentiometers, temperature sensors, and infrared distance sensors to report measured values as numbers the robot’s code can process.

Introduction

Every sensor reading, every motor command, every button press, every LED state — all of these pass through the microcontroller’s input/output pins. Pins are where the abstract world of code meets the physical world of voltage and current. Understanding how pins work — their electrical properties, their configurable modes, their limits, and their protection requirements — is what enables you to connect the right sensors and actuators in the right way without damaging either the microcontroller or the connected components.

This sounds straightforward, but pins have subtleties that catch beginners regularly. A digital input left unconnected floats to a random voltage and reads garbage values. An output pin asked to source more current than its rating will overheat and eventually fail. A 5V output connected to a 3.3V input without level shifting may damage the input. An analog pin used to read a voltage outside its 0–5V range will give incorrect readings and may damage the ADC input permanently.

Each of these failure modes is easily avoided once you understand the underlying physics and electrical properties of I/O pins. This article gives you that understanding — from the transistors inside a GPIO pin through the practical rules for connecting every common category of sensor and actuator.

The Physical Reality of a GPIO Pin

A GPIO (General Purpose Input/Output) pin is not simply a wire connected to the microcontroller’s logic circuits. It is a sophisticated circuit containing multiple transistors, protection diodes, and configurable resistors, all managed by a few control registers.

Inside a Digital GPIO Pin

Simplified GPIO pin internal structure (AVR-style):

VCC (5V)
  │
  ├──[Pull-up resistor, ~30kΩ]──┐
  │                              │
  │    ┌──────────────────────── PIN (physical pad)
  │    │                         │
  │  [P-channel MOSFET]          │
  │    │  (output HIGH driver)   │
  │    └──────────────────────── Output buffer
  │                              │
  │  [N-channel MOSFET]          │
  │    │  (output LOW driver)    │
  │    └──────────────────────── Output buffer
  │                              │
  ├──[Clamp diode to VCC]────────┤  ← Protects against voltages > VCC + 0.3V
  │                              │
  ├──[Clamp diode to GND]────────┘  ← Protects against voltages < GND - 0.3V
  │
GND

Control registers determine:
  - Direction: is this pin input or output?
  - If output: is the output HIGH or LOW?
  - If input: is the pull-up resistor enabled?
  - In what state is the input Schmitt trigger?

Several elements of this structure have important practical implications:

The output transistors (P-channel and N-channel MOSFETs): When configured as output HIGH, the P-channel transistor connects the pin to VCC through a finite resistance (the on-resistance, typically 25–50Ω on AVR). When output LOW, the N-channel transistor connects to GND through a similar on-resistance. This finite resistance is why a pin “outputting 5V” may actually produce slightly less when sourcing significant current — Ohm’s law applies to the transistor’s on-resistance.

The clamp diodes: Two diodes protect the pin against voltages outside the VCC-to-GND range. If a voltage above VCC + 0.3V appears on the pin, the upper clamp diode forward-biases and conducts current from the pin to VCC. If a voltage below GND − 0.3V appears, the lower diode conducts to GND. These diodes protect the pin from brief transients but cannot handle sustained overcurrent — they’ll fail if significant current flows through them for extended periods.

The pull-up resistor: When enabled (via pinMode(pin, INPUT_PULLUP)), the ~30kΩ pull-up connects the pin to VCC, holding it HIGH in the absence of an external signal. This is the internal pull-up resistor covered in the pull-up and pull-down resistors article.

The Schmitt trigger: The input comparator has hysteresis — it requires the voltage to cross a high threshold (typically 0.7 × VCC = 3.5V for a 5V system) to register HIGH, and requires it to drop below a low threshold (typically 0.3 × VCC = 1.5V) to register LOW. The gap between these thresholds (the hysteresis) means noisy signals near the threshold don’t cause rapid toggling — the input cleanly registers state changes only when the signal crosses fully from one region to the other.

Digital Pin Modes: INPUT, OUTPUT, and INPUT_PULLUP

Every digital pin on an Arduino can be configured in one of three modes using pinMode(). The choice determines both the electrical behavior of the pin and how you interact with it in code.

OUTPUT Mode

pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, HIGH);  // Pin driven to VCC (5V on Uno)
digitalWrite(LED_PIN, LOW);   // Pin driven to GND (0V)

In OUTPUT mode, the microcontroller actively drives the pin to either VCC or GND using its internal transistors. The pin can source (supply) or sink (absorb) current up to its rated maximum.

Current limits — the most important OUTPUT constraint:

Arduino Uno / Nano (ATmega328P) pin current limits:

Per-pin maximum:          40mA (absolute maximum — do not design to this limit)
Per-pin recommended:      20mA (safe continuous operation)
Total for all pins:       200mA (total for entire PORTB, PORTC, PORTD combined)

What 20mA can drive directly:
  ✓ LED with current-limiting resistor (10–20mA typical)
  ✓ Small piezo buzzer (<20mA)
  ✓ Logic-level signal to motor driver IC input
  ✓ Gate of a MOSFET (essentially zero current for switching)

What 20mA CANNOT drive directly — requires a transistor or driver IC:
  ✗ Relay coil (50–100mA typical)
  ✗ DC motor (100mA–several amps)
  ✗ Servo motor (100–500mA)
  ✗ Solenoid (100mA–1A)
  ✗ Multiple LEDs without individual resistors

Exceeding pin current limits causes immediate damage. The output transistor overheats, the on-resistance increases, and in severe cases the transistor fails permanently (the pin gets stuck HIGH or LOW, or stops responding to code). The chip can also be damaged in ways that corrupt other pins or the processor itself.

The practical rule: never connect a load that draws more than 20mA directly to a GPIO pin without an intermediary driver. Use a transistor (NPN for low-side switching), a MOSFET, or a dedicated driver IC for any load beyond an LED.

INPUT Mode

pinMode(SENSOR_PIN, INPUT);
int state = digitalRead(SENSOR_PIN);  // Returns HIGH or LOW

In INPUT mode, the pin’s output transistors are disabled — the pin is high-impedance (the electrical equivalent of a near-open circuit). It samples the voltage present on the pin through the internal Schmitt trigger comparator and reports HIGH if the voltage exceeds the HIGH threshold, LOW if it’s below the LOW threshold.

The critical issue with INPUT mode: A floating pin — one with no voltage source connected to it — reads random values. The high-impedance input picks up electromagnetic interference, capacitive coupling from adjacent traces, and any stray charge present on the pin. Connecting a pull-up or pull-down resistor (or using INPUT_PULLUP) is essential for any INPUT pin not actively driven by an external circuit.

Input voltage limits: The input voltage must stay within 0V to VCC (0V to 5V on an Arduino Uno with a 5V system). Voltages outside this range stress the clamp diodes. Brief transients of a few volts above VCC are handled by the clamp diodes; sustained voltages above VCC + 0.5V will conduct through the upper clamp diode, potentially damaging it if the current is significant.

INPUT_PULLUP Mode

pinMode(BUTTON_PIN, INPUT_PULLUP);
// Pin reads HIGH when button open (pull-up holds it HIGH)
// Pin reads LOW when button pressed (button connects pin to GND)
int state = digitalRead(BUTTON_PIN);

INPUT_PULLUP enables the internal ~30kΩ pull-up resistor while configuring the pin as an input. This is the most convenient mode for buttons, switches, and any other switch-contact input — no external resistor required.

Analog Input Pins: Reading the Physical World as Numbers

While digital pins deal in binary values (HIGH or LOW), analog input pins measure a continuously variable voltage and report it as a number. This is how potentiometers report position, thermistors report temperature, and sharp IR sensors report distance — as a voltage that varies continuously with the measured quantity.

The Analog-to-Digital Converter (ADC)

Analog input pins are connected to an internal ADC — a circuit that compares the input voltage to a reference voltage and produces a digital number representing the ratio. On the Arduino Uno:

ADC specifications (ATmega328P):
  Resolution: 10 bits → values from 0 to 1023
  Reference voltage: 5V (default AVCC reference)
  Input range: 0V to 5V
  Mapping: 0V → 0, 5V → 1023, 2.5V → 511 (approximately)
  Conversion formula: ADC_value = (V_in / V_ref) × 1023
  Inverse:            V_in = (ADC_value / 1023.0) × V_ref

  Conversion time: ~104µs at default prescaler (9,615 samples/second)
  Absolute accuracy: ±2 LSB typical (affected by noise, temperature)
  Number of channels: 6 (A0–A5 on Uno), multiplexed to one ADC

  Maximum safe input: 0V to VCC (0V to 5V on Uno)
  Do NOT exceed: input above VCC + 0.3V will damage ADC input

Reading Analog Pins

// Basic analog read
int rawValue = analogRead(A0);     // Returns 0–1023
float voltage = rawValue * (5.0 / 1023.0);  // Convert to volts

// For a 10kΩ potentiometer on A0 (voltage divider between 5V and GND):
// Fully counterclockwise: 0V → 0
// Fully clockwise: 5V → 1023
// Middle: 2.5V → ~511

// For a thermistor voltage divider:
// Temperature → resistance → voltage → ADC value → temperature calculation

// Smoothing with averaging (reduces noise):
int smoothAnalogRead(int pin) {
  long sum = 0;
  for (int i = 0; i < 8; i++) {
    sum += analogRead(pin);
    delayMicroseconds(100);  // Brief pause between reads for ADC settling
  }
  return sum / 8;  // Average of 8 readings
}

Analog Reference Voltage Options

The ADC reference voltage determines the full-scale input range. Changing it trades range for resolution:

// Default: AVCC reference = VCC = 5V
// Full range: 0–5V, 1 LSB = 5V/1023 = 4.887mV
analogReference(DEFAULT);

// Internal 1.1V reference (ATmega328P)
// Full range: 0–1.1V, 1 LSB = 1.1V/1023 = 1.075mV
// Better resolution for small signals; cannot read > 1.1V
analogReference(INTERNAL);

// External reference on AREF pin
// Connect precise voltage reference (e.g., 3.3V, 4.096V) to AREF pin
// Full range: 0–VREF, 1 LSB = VREF/1023
analogReference(EXTERNAL);

// Example: using internal 1.1V reference for precision temperature reading
// LM35 temperature sensor outputs 10mV/°C
// At 25°C: 250mV — within 1.1V range
// Resolution: 1.075mV per LSB → better than 0.1°C resolution
analogReference(INTERNAL);
int tempRaw = analogRead(A1);
float tempC = (tempRaw * (1.1 / 1023.0) * 100.0);  // LM35: 10mV/°C

Warning when changing analog reference: After calling analogReference(), discard the first analogRead() result — the ADC’s internal capacitor needs time to settle to the new reference voltage. The first reading after a reference change may be inaccurate.

PWM Pins: Analog-Like Output from Digital Hardware

Digital pins can only output full HIGH (5V) or full LOW (0V). But many actuators — DC motors, LED brightness controllers, servo position signals — need a continuously variable output. PWM (Pulse Width Modulation) provides this by rapidly switching the pin between HIGH and LOW at a fixed frequency, where the fraction of time spent HIGH (the duty cycle) controls the effective average voltage.

How PWM Works

PWM at 50% duty cycle (analogWrite(pin, 128) out of 255):

     ┌───┐   ┌───┐   ┌───┐   ┌───┐
     │   │   │   │   │   │   │   │
─────┘   └───┘   └───┘   └───┘   └────
  ← T/2 →← T/2 →← T/2 →← T/2 →

Average voltage: 5V × 50% = 2.5V

PWM at 25% duty cycle (analogWrite(pin, 64)):

   ┌─┐     ┌─┐     ┌─┐     ┌─┐
   │ │     │ │     │ │     │ │
───┘ └─────┘ └─────┘ └─────┘ └──────
 ←T/4→← 3T/4 →

Average voltage: 5V × 25% = 1.25V

The load (motor, LED) responds to the average voltage because it cannot respond fast enough to each individual pulse (motors integrate current, LEDs are driven by average current). The result behaves electrically like a continuously variable voltage despite the pin only ever outputting 5V or 0V.

PWM Pins on Arduino Uno

Arduino Uno PWM pins: 3, 5, 6, 9, 10, 11 (marked with ~ on the board)

analogWrite(pin, value):  value 0 = 0% duty (always LOW, 0V effective)
                          value 255 = 100% duty (always HIGH, 5V effective)
                          value 128 = 50% duty (2.5V effective average)

PWM frequency (default):
  Pins 5, 6:   976Hz (Timer 0 — also used for millis()/delay())
  Pins 9, 10:  490Hz (Timer 1)
  Pins 3, 11:  490Hz (Timer 2)

Changing PWM frequency requires direct timer register manipulation:
  // Double frequency on pins 9, 10 (Timer 1):
  TCCR1B = TCCR1B & B11111000 | B00000010;  // Prescaler 8: ~3.9kHz PWM
  // Reduce to 30Hz on pins 9, 10 (for servo-like signals):
  TCCR1B = TCCR1B & B11111000 | B00000100;  // Prescaler 64: ~30Hz

Note: Pins 5 and 6 share Timer 0 with millis()/delay()/micros().
      Changing Timer 0 prescaler breaks time functions — avoid.

What PWM Can and Cannot Drive Directly

Can drive with PWM pin directly (< 20mA, PWM frequency adequate):
  ✓ LED brightness control (via current-limiting resistor)
  ✓ Piezo buzzer (frequency control via tone())
  ✓ Motor driver INPUT pins (logic-level signal, near-zero current)

Cannot drive directly — needs driver IC or transistor:
  ✗ DC motor (requires H-bridge like L298N or DRV8833)
  ✗ Servo motor (requires PWM at specific frequency: 50Hz standard)
  ✗ High-power LED strip (requires MOSFET for current amplification)
  ✗ Inductive loads (relay, solenoid — require flyback diode + transistor)

Pin Protection: Preventing Damage

Understanding what can damage a pin is as important as understanding how to use one. Most pin damage is preventable with simple protective measures.

Over-Current Protection

The most common pin damage: drawing more than 40mA from a single pin, or more than 200mA from all pins combined.

Scenario: 10 LEDs driven from 10 pins, each at 20mA
Total pin current: 10 × 20mA = 200mA
This hits the total package current limit exactly — dangerous!

Better approach: drive LEDs through a transistor array (ULN2003),
shifting current draw from the GPIO pins to the transistor's collector supply.
Each GPIO pin then sinks only the transistor base current (~1mA),
while the transistor handles the LED current (20mA × 10 = 200mA from supply).

Over-Voltage Protection

Connecting a 5V Arduino output to a 3.3V device input violates the input device’s absolute maximum rating. Most 3.3V devices tolerate 3.3V + 0.3V = 3.6V maximum. A 5V signal at 3.3V + 0.3V = 3.6V threshold may damage the input protection diodes or internal gate oxide over time.

Level shifting options:

Simple resistor divider (for signals, not I2C):
  5V ──[1kΩ]──┬── 3.3V device input
              │
           [2kΩ]
              │
             GND
  Voltage at junction: 5V × 2/(1+2) = 3.33V ✓
  Works for unidirectional signals, not suitable for I2C (open-drain)

Dedicated level shifter ICs:
  TXS0102/TXS0108: Automatic bidirectional, 1MHz+
  BSS138 MOSFET circuit: Bidirectional, lower speed, common for I2C
  74LVC245: Unidirectional, fast (100MHz+), for SPI and UART

Voltage divider is simplest for simple sensor signals.
BSS138/TXS0102 for I2C and other bidirectional buses.

Inductive Load Protection

When a coil (relay, motor, solenoid) is connected to a GPIO pin via a transistor and the transistor switches off, the collapsing magnetic field generates a voltage spike — back-EMF — that can reach 50–200V even from a 5V coil supply. Without protection, this spike enters the GPIO pin through the flyback path and destroys it.

// Motor relay circuit with protection:
//
//   Arduino pin 7 ──[1kΩ]── NPN transistor base
//   NPN transistor emitter ── GND
//   NPN transistor collector ── Relay coil (−)
//   Relay coil (+) ── 12V supply
//   Flyback diode: anode to collector side, cathode to 12V supply
//   (diode clamps the back-EMF spike to 12V + 0.7V instead of 200V)
//
// This configuration keeps the spike entirely off the Arduino's pins

const int RELAY_PIN = 7;

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

void activateRelay() {
  digitalWrite(RELAY_PIN, HIGH);  // Turns on transistor → energizes relay
}

void deactivateRelay() {
  digitalWrite(RELAY_PIN, LOW);   // Transistor off → flyback diode catches spike
}

The flyback diode (1N4007 or similar) must be present for any inductive load switched by a GPIO-controlled transistor. Without it, every relay de-energization sends a voltage spike into the circuit that gradually degrades or suddenly destroys the transistor and potentially the GPIO pin driving it.

Special-Function Pins: Hardware Peripherals Share the GPIO

On the Arduino Uno, many pins serve double duty: they can be used as general-purpose digital I/O or as a hardware peripheral interface. Using them for their hardware function gives access to capabilities (precise timing, high-speed communication, interrupt-driven operation) that software-only I/O cannot match.

Arduino Uno special-function pin assignments:

Pin 0 (RX):   UART receive — Serial.read()
Pin 1 (TX):   UART transmit — Serial.print()
              Note: using these for GPIO conflicts with USB serial communication

Pin 2 (INT0): External interrupt 0 — attachInterrupt(digitalPinToInterrupt(2), ...)
Pin 3 (INT1): External interrupt 1 — hardware-triggered ISR

Pins 10–13:   SPI bus
  Pin 10 (SS):   Slave Select (chip select for SPI devices)
  Pin 11 (MOSI): Master Out Slave In (data from Arduino to device)
  Pin 12 (MISO): Master In Slave Out (data from device to Arduino)
  Pin 13 (SCK):  Serial Clock
  Note: Pin 13 also has the built-in LED (with 1kΩ series resistor)

Pins A4, A5:  I2C bus
  Pin A4 (SDA): Serial Data
  Pin A5 (SCL): Serial Clock
  Note: These pins can still be used as digital I/O (pins 18, 19) if I2C unused

Pins 3, 5, 6, 9, 10, 11: PWM capable (hardware timers)
Pins A0–A5:  ADC inputs (also usable as digital I/O: pins 14–19)

The consequence: if you’re using I2C sensors (MPU-6050, BMP280, OLED display), pins A4 and A5 are unavailable for other use. If you’re using SPI (SD card, fast sensor), pins 10–13 are dedicated. Planning pin assignments at the start of a project — before wiring anything — prevents conflicts that require redesigning the circuit later.

Practical Pin Assignment Planning

A pin assignment table is one of the first design documents in any serious robot project. Before connecting a single wire, map every component to every pin:

Example: Line-following robot pin assignment table

Pin  | Mode        | Connected to               | Notes
-----|-------------|----------------------------|-----------------------------
0    | UART RX     | (reserved for Serial)      | Don't use for GPIO
1    | UART TX     | (reserved for Serial)      | Don't use for GPIO
2    | INPUT_PULLUP| Left bumper switch         | Hardware interrupt (INT0)
3~   | OUTPUT/PWM  | Left motor speed (L298N)   | PWM to ENA
4    | OUTPUT      | Left motor dir 1 (L298N)   | IN1
5~   | OUTPUT/PWM  | Right motor speed (L298N)  | PWM to ENB
6~   | OUTPUT      | Left motor dir 2 (L298N)   | IN2
7    | OUTPUT      | Right motor dir 1 (L298N)  | IN3
8    | OUTPUT      | Right motor dir 2 (L298N)  | IN4
9~   | OUTPUT/PWM  | Status LED (brightness)    | 220Ω series resistor
10   | INPUT_PULLUP| Right bumper switch        |
11   | —           | (available)                |
12   | —           | (available)                |
13   | OUTPUT      | Onboard LED (debug blink)  | Built-in 1kΩ resistor
A0   | ANALOG IN   | IR sensor 1 (leftmost)     | Voltage divider output
A1   | ANALOG IN   | IR sensor 2                |
A2   | ANALOG IN   | IR sensor 3 (center)       |
A3   | ANALOG IN   | IR sensor 4                |
A4   | I2C SDA     | MPU-6050 IMU               | 4.7kΩ pull-up to 5V
A5   | I2C SCL     | MPU-6050 IMU               | 4.7kΩ pull-up to 5V

Summary:
  Digital outputs: 3, 4, 5, 6, 7, 8, 9, 13
  Digital inputs:  2, 10
  Analog inputs:   A0, A1, A2, A3
  I2C:             A4, A5
  PWM used:        3, 5, 9 (pins 6, 10, 11 available as backup)
  Unused:          11, 12

Creating this table before building reveals: are there enough analog pins for all sensors? Are there enough PWM pins for all motors? Do any hardware peripheral conflicts exist? Does the total output current stay within safe limits? Five minutes of planning prevents hours of rewiring.

Pins on Other Platforms

The Arduino Uno’s 20 pins (14 digital + 6 analog) are modest. Different robotics platforms provide more or differently-capable pins:

Platform pin comparison:

Arduino Nano:    14 digital + 8 analog (A6 and A7 are input-only, no digital)
Arduino Mega:    54 digital + 16 analog, 15 PWM pins — good for large robots
ESP32:           34 GPIO total, 18 ADC channels, 16 PWM channels, 3.3V logic
                 Capacitive touch inputs (no resistor needed for touch sensing)
                 Hall effect sensor input (internal)
RP2040 (Pico):  30 GPIO, 3 ADC channels, 16 PWM channels
                 3.3V logic; pins are NOT 5V tolerant (unlike Arduino Uno)
STM32F4:        Up to 114 GPIO, 16 ADC channels, 12 PWM timers
                 3.3V logic, many pins are 5V tolerant (check datasheet per pin)
Raspberry Pi 4: 40-pin header, 28 usable GPIO, 3.3V logic
                 NO analog inputs (requires external ADC like MCP3008 via SPI)
                 All pins are 3.3V — 5V on a GPIO pin will damage the chip

The Raspberry Pi’s lack of analog inputs is a significant difference from Arduino-family boards — a common misconception among beginners moving from Arduino to Pi. Connecting an analog sensor (potentiometer, thermistor, IR distance sensor) to a Raspberry Pi requires an external ADC chip (MCP3008, ADS1115) interfaced via SPI or I2C. The Arduino Uno’s built-in 6-channel ADC handles this invisibly.

I/O pins are the interface between robot code and the physical world — the points where digital logic becomes voltage and voltage becomes digital logic. Understanding their electrical properties — the output transistors that drive current within rated limits, the clamp diodes that protect against out-of-range voltages, the configurable pull-up resistors that define idle states, and the Schmitt trigger inputs that cleanly resolve noisy signals — gives you the foundation for connecting any sensor or actuator correctly.

The key rules that prevent most pin-related failures are simple: configure every pin’s mode explicitly before using it; never draw more than 20mA from a single output pin without a driver; never connect a 5V signal to a 3.3V input without level shifting; always use a pull-up or pull-down on every input that isn’t actively driven; always protect inductive loads with flyback diodes; and plan pin assignments before wiring to avoid hardware conflicts between peripherals.

With digital outputs, PWM, analog inputs, and hardware peripheral pins all available on a single microcontroller, the Arduino Uno’s 20 pins can interface with an impressive range of sensors and actuators simultaneously. Planning which capability each pin provides — and confirming the planned pin assignments fit within electrical limits before building — is the engineering discipline that separates reliable robots from frustrating ones.

Common Wiring Patterns: Connecting Real Components to Pins

The theory of pins becomes practical when applied to the actual components you’ll connect. Here are the most common wiring patterns in robotics, each with the pin configuration and protective elements needed.

Pattern 1: LED Output

The most fundamental output circuit. A current-limiting resistor prevents the pin from exceeding its 20mA safe current limit:

Wiring:
Arduino Pin 9 ──[220Ω]──→ LED Anode (+)
                           LED Cathode (−) ──── GND

Pin mode: OUTPUT
Code: analogWrite(9, brightness);  // 0=off, 128=half, 255=full

Current calculation:
  V_pin = 5V (output HIGH)
  V_LED = 2.0V (red LED forward voltage)
  I = (V_pin - V_LED) / R = (5 - 2.0) / 220 = 13.6mA ✓ (under 20mA limit)

Alternative (pin as current sink — LED connected to VCC):
VCC (5V) ──[220Ω]──→ LED Anode
                      LED Cathode (−) ──── Arduino Pin 9

This "sinking" configuration: pin LOW = LED on, pin HIGH = LED off
Some microcontrollers can sink more current than they source — check datasheet

Pattern 2: Push Button Input

Active-low button with internal pull-up — the simplest input circuit requiring no external components:

Wiring:
Arduino Pin 2 ──────────┬──── One side of button
                        │     Other side of button ──── GND
                        │
                     [Internal ~30kΩ pull-up, enabled in code]

Pin mode: INPUT_PULLUP
Code: bool pressed = (digitalRead(2) == LOW);  // LOW = pressed

Debouncing recommendation: add 10ms software debounce (see article 66)
or a 100nF capacitor from pin to GND (hardware debounce — slows edge,
Schmitt trigger still cleanly reads it after 1-2ms RC settling time)

Pattern 3: Analog Sensor (Potentiometer)

A 3-terminal potentiometer creates a voltage divider whose midpoint voltage varies with shaft position:

Wiring:
VCC (5V) ──── Potentiometer terminal 1 (end)
              Potentiometer wiper (middle) ──── Arduino A0
              Potentiometer terminal 3 (end) ──── GND

Pin: A0 (analog input, no pinMode() needed — analogRead() handles it)
Code:
  int raw = analogRead(A0);       // 0–1023
  float angle = raw * (270.0 / 1023.0);  // Map to 270° rotation range

Important: potentiometer must have end terminals connected to VCC and GND.
Leaving an end terminal floating creates an undefined reference voltage.

Pattern 4: Digital Sensor with Active Output

Many sensors (PIR motion detectors, magnetic hall-effect sensors, some IR sensors) have a digital output pin that actively drives HIGH or LOW — no pull-up needed if the output is push-pull (actively drives both states):

Wiring (push-pull output):
VCC ──── Sensor VCC
GND ──── Sensor GND
Sensor Output ──── Arduino Pin 4

Pin mode: INPUT (no pull-up needed — sensor drives actively)
Code: bool detected = (digitalRead(4) == HIGH);

Wiring (open-collector/open-drain output):
VCC ──── Sensor VCC
GND ──── Sensor GND
VCC ──[4.7kΩ]──┬──── Sensor Output
               │      (external pull-up required)
             Arduino Pin 4

Check sensor datasheet: does it say "open-collector output"?
If yes: add external pull-up. If "push-pull": no pull-up needed.

Pattern 5: NPN Transistor for High-Current Load

For loads exceeding 20mA (relay, solenoid, motor with driver, high-power LED), an NPN transistor amplifies the GPIO’s 20mA into the load’s required current:

Wiring:
Arduino Pin 7 ──[1kΩ]──── NPN Base (2N2222 or similar)
NPN Emitter ──────────── GND
NPN Collector ────────── Load (−) terminal

Load (+) terminal ──── Supply voltage (5V, 12V, depending on load)

For inductive loads (relay, solenoid): add flyback diode
  Diode anode ──── Collector (= Load − terminal)
  Diode cathode ── Load + supply voltage

Pin mode: OUTPUT
Code: digitalWrite(7, HIGH);  // Turns transistor ON → load energized
      digitalWrite(7, LOW);   // Turns transistor OFF → load de-energized

Base resistor calculation:
  I_load = relay coil current (e.g., 70mA)
  I_base needed = I_load / hFE = 70mA / 100 = 0.7mA minimum
  V_base = V_pin - V_BE = 5V - 0.7V = 4.3V
  R_base = V_base / I_base = 4.3V / 2mA (use 2× for saturation margin) = 2.15kΩ
  Use: 1kΩ (provides 4.3mA base current — well into saturation for 70mA load)

Pattern 6: MOSFET for PWM-Controlled Load

For PWM speed control of a motor or LED strip, a logic-level N-channel MOSFET allows the PWM pin to switch large currents at PWM frequency:

Wiring:
Arduino PWM Pin 3 ──[10kΩ]── MOSFET Gate
                  ──[10kΩ to GND]── (pull-down ensures gate is OFF when pin floating)
MOSFET Source ──── GND
MOSFET Drain ──── Load (−) terminal

Load (+) ──── 12V supply (or whatever load voltage requires)
Flyback diode across load if inductive

Recommended MOSFET: IRLZ44N or similar logic-level (Vgs(th) < 3V)
  Standard MOSFETs require 10V gate drive — won't fully turn on at 5V GPIO

Code:
  analogWrite(3, 128);  // 50% PWM → ~50% motor speed

MOSFET advantages over NPN transistor:
  - No gate current needed (GPIO drives only capacitance — near zero DC current)
  - Lower on-resistance (IRLZ44N: 22mΩ) → less heat at high current
  - Better for continuous PWM at high current

Reading Pin States: Polling vs. Interrupts

There are two fundamental approaches to reading digital input pins — polling and interrupts — and the choice between them determines both the responsiveness and efficiency of the robot’s response to events.

Polling

Polling reads the pin state in the main loop at each iteration:

void loop() {
  if (digitalRead(LIMIT_SWITCH_PIN) == LOW) {
    stopMotors();
  }
  // ... rest of loop (takes maybe 5ms)
}

The problem: between consecutive polls (5ms apart in this example), the pin could briefly go LOW and return HIGH — and the event would be entirely missed. For a limit switch hit at high motor speed, 5ms is enough time for the mechanism to travel several millimeters past the limit before the software detects it.

Hardware Interrupts

Interrupt-driven pin reading guarantees detection of every state transition, regardless of what the main loop is doing:

volatile bool limitHit = false;

void limitSwitchISR() {
  stopMotors();    // Immediate response in ISR
  limitHit = true;
}

void setup() {
  pinMode(LIMIT_SWITCH_PIN, INPUT_PULLUP);
  // FALLING: interrupt fires when pin goes from HIGH to LOW
  // (button press = pin goes LOW with pull-up)
  attachInterrupt(
    digitalPinToInterrupt(LIMIT_SWITCH_PIN),
    limitSwitchISR,
    FALLING
  );
}

void loop() {
  if (limitHit) {
    Serial.println(F("Limit reached!"));
    limitHit = false;
    // Recovery behavior...
  }
  // Main loop continues unaffected while ISR handles events
}

Interrupt latency on the ATmega328P is 3.5–4.5 clock cycles (~250–280ns at 16MHz) — the ISR begins executing within 280 nanoseconds of the pin transition. This is vastly faster than polling at any reasonable loop rate.

When to use polling: non-time-critical inputs checked at the loop rate (mode selection buttons, configuration switches, sensors that can be sampled at the loop rate without missing events).

When to use interrupts: limit switches, encoder pulses, button presses needing instant response, communication signals that arrive asynchronously.

Only pins 2 and 3 support hardware interrupts on the Arduino Uno. The Arduino Mega adds pins 18–21 (INT2–INT5). For more interrupt pins, the Pin Change Interrupt (PCINT) system allows interrupts on any pin but with less precision (the ISR detects that a pin in a group changed, requiring software to identify which one).

Pin Diagnostics: Troubleshooting Common Problems

Summary

I/O pins translate between the abstract world of code and the physical world of voltage and current. Every robot interaction with the physical world passes through these pins: sensor readings arrive as voltages on input pins, motor commands leave as PWM signals on output pins, communication happens through dedicated peripheral pins, and interrupts fire when time-critical hardware events require immediate response.

Mastering pin usage means understanding three things: the electrical limits (current, voltage, direction), the configuration options (INPUT, OUTPUT, INPUT_PULLUP, analog reference, PWM frequency), and the connection patterns that satisfy those limits while correctly interfacing real components. A 20mA output limit, a 0-to-VCC input range, a clamp diode protection window, and a handful of hardware peripheral assignments are the fundamental constraints within which all robot circuits operate.

These constraints are not obstacles — they are the engineering specifications that make reliable, repeatable circuits possible. Work within them, plan pin assignments before wiring, protect outputs with appropriate driver transistors, and protect inputs with appropriate pull resistors, and the pins will faithfully connect your robot’s code to its physical environment for as long as the robot operates.