The Potentiometer

Learning Goals 5 min

By the end of this lesson you will be able to:

1. Identify the three pins of a potentiometer — two ends and a centre wiper — and explain why the wiper voltage sweeps smoothly from 0 V to 5 V as the knob turns.
2. Wire a potentiometer as a built-in voltage divider: end pins to 5V and GND, wiper to an analog input. No partner resistor needed — the pot is the divider.
3. Read the wiper with analogRead (0–1023) and use the value to drive an output continuously — LED brightness, tone frequency, animation speed — whatever needs a smoothly tweakable knob.

Warm-Up 10 min

L01-36 to L01-39 introduced four environmental sensors — the world dictates what they read. Today's sensor is different: it's a human input. A knob the user turns. The chip reads the position. The link between finger and software has never been more direct.

Quick-fire puzzle

Knobs are everywhere — a stereo's volume dial, a car's heating control, a guitar amp's tone, the old-style dimmer switch in a dining room. They all feel the same: turn left, less; turn right, more.

1. Inside any of these, what physical thing do you think changes when you turn the knob?
2. If the dimmer dial were just a regular variable resistor — say, between 0 Ω and 10 kΩ — wired directly to an LED, what would happen as you turned it?
3. Could you wire that same dimmer dial to an Arduino's analog input the way you wired the LDR last week? What new piece would you need?

New Concept — the wiper is the junction 15 min

The big idea — three pins, one knob

A potentiometer (or "pot" for short) is a three-pin component that looks like a small blue or grey cube with a knob or shaft on top. Inside:

• A resistive track shaped in an arc (rotary pots) or strip (slider pots) with a fixed total resistance — typical hobby values are 10 kΩ or 100 kΩ.
• A wiper — a small metal arm that touches the track and moves along it as the knob turns.
• Three external pins: two end pins connected to the two ends of the track, and one wiper pin in the middle.

The trick: connect the two end pins to 5V and GND. The track is now a 10 kΩ resistor with 5 V across it. The wiper taps a point somewhere along that track — depending on knob position. That point's voltage is exactly the junction of a voltage divider, with the two halves of the track playing the roles of R1 and R2 from L01-38.

What the wiper voltage works out to

Reusing L01-38's formula with R_b as the bottom resistor:

Vwiper = 5 V × Rb / (Ra + Rb)

And since Ra + Rb always equals the pot's full rated value, this simplifies into "the fraction of the track between the wiper and GND":

• Wiper at the GND end (R_b = 0): Vwiper = 0 V → analogRead = 0
• Wiper in the middle (R_a = R_b): Vwiper = 2.5 V → analogRead ≈ 512
• Wiper at the +5 V end (R_a = 0): Vwiper = 5 V → analogRead = 1023

So a pot wired with ends to +5 V and GND gives you the full analogRead range, sweeping smoothly as you turn the knob. That's the whole point of the part.

The "value doesn't really matter" rule

You'll see 10 kΩ pots, 100 kΩ pots, even 1 kΩ pots in hobby kits. For analogRead, the value almost doesn't matter — the divider ratio is what determines the wiper voltage, and the ratio is what knob position controls regardless of the total. A 10 kΩ pot at half-turn gives the same 2.5 V as a 100 kΩ pot at half-turn.

The total value only matters for current: a 1 kΩ pot wastes 5 mA continuously (5 V ÷ 1 kΩ) through its track; a 100 kΩ pot wastes only 0.05 mA. Both are fine for a Uno; the 10 kΩ default is a nice middle ground.

Reading the wiper in code

Identical to L01-36 — there is no new function or pattern. Just read A0:

int knob = analogRead(A0);     // 0..1023 across the knob's full sweep

That's the entire interface. Compare against a threshold for binary decisions (if (knob > 512) …), or scale to drive an output continuously (analogWrite(LED_PIN, knob / 4)), or use the number any way that makes sense.

Why it matters

Pots are the bridge between human and machine. Every physical knob on every device — guitar amplifier tone, oven temperature dial, lab-equipment fine-tune, old-school radio volume — is some form of pot. They also make development dramatically easier: instead of editing a constant in code and re-uploading every time you tune a parameter, wire a pot, point your sketch at it, and tune live with your fingers. Today's lesson is the foundation of every "control surface" you'll build, plus the developer's secret weapon for prototyping.

Worked Example — knob to LED brightness 20 min

The wiring

Three components: the pot, one LED with a 220 Ω resistor, and the breadboard's shared rails.

• Pot straddling three columns: one end-pin column jumpers to the + rail (5V), the other end-pin column to the − rail (GND), the middle (wiper) column runs a yellow signal wire to A0.
• LED on ~D9 with a 220 Ω resistor (L01-07 wiring), cathode to the − rail. ~D9 is PWM-capable, which you'll need for the brightness control.
• The + rail jumpers to the Arduino's 5V pin; the − rail jumpers to GND.

Step 1 — Print the wiper value live

// Pot reader — see the value as you turn the knob
void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(analogRead(A0));
  delay(100);
}

Upload at 9600 baud, open the Monitor. Turn the knob fully one way — the reading should pin at 0 or 1023. Turn the other way — pins at the opposite extreme. Turn through the middle — readings sweep smoothly through every value in between. Roughly half a turn = roughly 512. If your minimum isn't 0 and your maximum isn't 1023, you've wired only two of the three pins; recheck the divider connections.

Step 2 — Drive the LED brightness from the knob

The killer app of pots: live continuous control of an output.

// Knob dimmer — turn pot, LED brightens or dims
const int POT_PIN = A0;
const int LED_PIN = 9;

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  int knob = analogRead(POT_PIN);     // 0..1023
  int bright = knob / 4;             // 0..255 (1023/4 ≈ 255)
  analogWrite(LED_PIN, bright);
  Serial.print("knob=");   Serial.print(knob);
  Serial.print(" bright="); Serial.println(bright);
  delay(30);
}

Upload. Turn the knob; the LED brightens and dims smoothly. Watch the Monitor — knob value sweeps 0–1023, brightness value sweeps 0–255, both move in lockstep. Your finger now controls a continuous PWM output through twenty lines of code.

Trace the maths on paper

For each knob position, fill in what the sketch sends to the LED.

Notice that 1023 / 4 = 255 remainder 3 — integer division throws away the remainder. The biggest possible PWM value you can get from this formula is 255, not 256, which is conveniently the maximum analogWrite accepts. The maths is exact at both ends — no clamping needed.

Try It Yourself — three knob sketches 20 min

const int POT_PIN    = A0;
const int BUZZER_PIN = 8;

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

void loop() {
  int knob = analogRead(POT_PIN);
  int freq = knob * 2 + 200;     // 200..2246 Hz
  tone(BUZZER_PIN, freq);            // no duration — continuous
  delay(20);
}

const int POT_PIN = A0;
const int LED_PIN = 8;

unsigned long lastToggle = 0;
int ledState = LOW;

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

void loop() {
  int knob = analogRead(POT_PIN);          // 0..1023
  int interval = knob + 50;               // 50..1073 ms
  if (millis() - lastToggle >= (unsigned long)interval) {
    lastToggle = millis();
    ledState = !ledState;
    digitalWrite(LED_PIN, ledState);
  }
}

const int LDR_PIN = A0;
const int POT_PIN = A1;
const int LED_PIN = 8;

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  int light     = analogRead(LDR_PIN);
  int threshold = analogRead(POT_PIN);
  bool dark     = light < threshold;
  digitalWrite(LED_PIN, dark);
  Serial.print("light=");     Serial.print(light);
  Serial.print(" threshold="); Serial.print(threshold);
  Serial.print(" dark=");      Serial.println(dark);
  delay(200);
}

Mini-Challenge — pot-controlled animation speed 10 min

"Take last week's chase animation, add a tempo knob"

Open your L01-34 sketch — the five-LED chase / bounce / wave animation that used 2D arrays. Today, replace the hardcoded stepMs value in your playPattern calls with a live reading from a pot wired to A1. Turning the knob speeds the animation up or slows it down without uploading.

Your task:

1. Keep the L01-34 wiring (5 LEDs on D7–D11, sharing GND). Add a pot wired the L01-40 way (ends to 5V and GND, wiper to A1). You'll use 6 Arduino pins total: D7–D11 + A1.
2. At the top of loop(), read int speed = analogRead(A1);.
3. Convert that to a sensible step interval. int stepMs = speed / 5 + 30; gives a range from 30 ms (super fast) to about 235 ms (relaxed) — fits well visually.
4. Pass stepMs to your playPattern calls so each frame's hold time tracks the knob.
5. Walk around your setup turning the knob while the chase runs. You should see the animation respond in real time.

It works if:

• Fully-left knob: the animation crawls one step every quarter-second or so.
• Fully-right knob: the animation blurs into a continuous moving glow.
• Mid-knob: the chase looks like the default L01-34 speed.
• You can change the speed during the animation — the next step picks up the new value.

// Drop-in replacement for L01-34's loop()
const int POT_PIN = A1;

void loop() {
  int speed = analogRead(POT_PIN);
  int stepMs = speed / 5 + 30;        // 30..235 ms per frame
  playPattern(chase,  CHASE_FRAMES,  stepMs);
  playPattern(bounce, BOUNCE_FRAMES, stepMs);
  playPattern(wave,   WAVE_FRAMES,   stepMs);
}

Recap 5 min

A potentiometer is a three-pin component containing a built-in voltage divider — a resistive track between two end pins with a sliding wiper (middle pin) that taps a point along it. Wire the two ends to 5 V and GND; the wiper now sweeps from 0 V to 5 V as you turn the knob. Read it with analogRead(A0) — no partner resistor needed because the divider is inside the part. The value (10 kΩ, 100 kΩ) hardly matters for ADC reading; only ratio matters. Use the result to drive any continuous output — LED brightness, tone frequency, animation speed, threshold value — turning your finger into a live software dial.

Potentiometer (pot)

A three-pin variable resistor with a moving wiper. The two end pins are fixed at the ends of the resistive track; the wiper taps a point along it. The most common manually-adjusted analog input.

Wiper

The sliding contact inside a pot. Its position along the resistive track is what the knob controls. The middle pin connects to it.

End pins

The two pins at the ends of a pot's resistive track. Interchangeable — swap them and the knob simply turns the other way for the same reading.

Built-in voltage divider

The key insight about pots: with the two end pins at 5 V and GND, the part already is a divider. No partner resistor needed; the wiper voltage gives you the full ADC sweep from 0 to 1023.

Live tuning

The developer's practice of wiring a pot to a code parameter — speed, threshold, brightness — so it can be adjusted while the sketch is running, instead of editing constants and re-uploading. One of the most useful prototyping tricks.

Linear vs audio (log) taper

Linear pots change voltage evenly with knob angle. Audio-taper pots crowd the change into one end (matching how the ear hears volume). Hobby-kit pots are almost always linear; check the label if it matters.

Homework 5 min

The dual-pot mixer. Wire two pots — one on A0, one on A1 — and an RGB LED (D9 red, D10 green, D11 blue, the L01-30 wiring). Then build a sketch where:

1. Pot A controls the LED's brightness overall (0 = off, 1023 = full).
2. Pot B controls the colour position on a simple gradient — left = red, middle = green, right = blue.

This means each pot does something independent and the two together let you mix any of three colours at any brightness. Your hands are doing the work that the L01-31 rainbow-fade sketch did automatically.

Hint for the gradient: read pot B (0–1023), split it into three roughly equal bands (0–340 = red, 341–682 = green, 683–1023 = blue), and only light the matching channel. (A continuous interpolation would be nicer — but L01-41 introduces map(), which will make that genuinely elegant. For today, the three-band version is fine.)

Also: a design reflection on paper.

• What's the resolution of a pot on a Uno's ADC — i.e. how many distinguishable positions does the knob have? ____ (Hint: 0–1023 = 1024 positions.)
• If you wanted finer control near the middle of the knob and coarser near the ends — like an audio fader — what could you do in code, without changing the pot? ____ (Hint: don't read the value linearly; apply a curve.)
• Three pots controlling R, G, B directly would let you mix any of 16 million colours by hand. Why isn't that how digital colour pickers usually work? ____ (Hint: most people don't think in RGB — they think in "hue + saturation + brightness".)
• The L01-29 Serial Light Show used typed digits 1–9 to set animation speed. If you bolted on a pot for the same job, what's the user-experience trade-off compared to the typed digit? ____

Bring back next class:

• The saved .ino file (call it dual-pot-mixer).
• A 30-second phone video showing both pots changing the LED's colour and brightness independently.
• Your four written reflection answers, in your notebook.

Heads up for next class: L01-41 "The map() Function" introduces the one-liner that replaces every knob / 4, knob * 2 + 200, knob / 5 + 30 in today's lesson. Same idea — scale a value from one range to another — but the built-in map() makes it readable in a glance. After today, you'll be doing these conversions manually; tomorrow you'll have a clean tool for them.