Arduino Uno 10kΩ Potentiometer: Precision Analog Controller

Professional 10kΩ linear taper potentiometer forms precision 0-5V voltage divider on Arduino A1 delivering 1024-step (4.88mV) analog resolution. Wiper position continuously variable through 270° rotation provides smooth analog input for proportional control systems.

Counterclockwise = 0V (0 ADC), center = 2.5V (512 ADC), clockwise = 5V (1023 ADC). Real-time Serial Monitor displays raw ADC, voltage, percentage enabling immediate HMI calibration and system tuning.

How It Works

A potentiometer is a resistive track with a wiper that slides along it. Connecting the two ends across the supply makes it a voltage divider whose output follows the wiper position — turn the knob and the voltage at the wiper sweeps smoothly between 0 V and the supply rail.

This is the simplest possible analog input, and it is the standard way to learn analogRead(). The Arduino Uno samples with a 10-bit ADC, so analogRead() returns 0–1023 across 5 V. With a linear-taper pot, the reading is directly proportional to rotation.

Taper matters. Linear pots change resistance evenly with rotation and are what you want for position and setpoint input. Logarithmic (audio taper) pots change slowly then rapidly, matching how hearing works — excellent for volume, confusing for anything else.

Resistance value barely affects the reading, since the divider ratio is what counts, but it does affect current draw. A 10 kΩ pot across 5 V draws about 0.50 mA continuously, which is negligible on USB power but worth considering on a battery.

Components Needed

Arduino Uno
B10K 10kΩ linear rotary potentiometer
Male-to-male jumper wires (3 pieces)
Arduino Uno
Optional 220Ω LED for PWM demo
Multimeter for voltage verification

Wiring to the Arduino Uno

Connect one outer terminal to GND, the other to the 5 V rail, and the centre wiper to A0. Swapping the two outer terminals simply reverses the direction of travel, which is sometimes the easiest way to fix a control that works backwards.

Any of A0–A5 (six channels) is suitable.

If only two terminals are connected — one end and the wiper — the pot acts as a plain variable resistor (a rheostat) rather than a divider, and the reading will not sweep the full range. Make sure all three are wired.

Pot terminal	Arduino Uno pin	Function
Left (end 1)	GND	One end of the track
Centre (wiper)	A0	Variable output voltage
Right (end 2)	5V	Other end of the track

Example Code

Reading a potentiometer with smoothing and change detection. Upload it with the board set to Arduino Uno and open the Serial Monitor at 9600 baud.

Reading a potentiometer with smoothing and change detection

const int POT_PIN = A0;
const int NOISE_GATE = 4;   // ignore ADC jitter

int lastReported = -100;

void setup() { Serial.begin(9600); }

void loop() {
  long total = 0;
  for (int i = 0; i < 8; i++) { total += analogRead(POT_PIN); delay(2); }
  int value = total / 8;

  // Only report real movement, not the last-bit wobble
  if (abs(value - lastReported) > NOISE_GATE) {
    lastReported = value;

    int percent = map(value, 0, 1023, 0, 100);
    int angle   = map(value, 0, 1023, 0, 270);   // typical pot travel

    Serial.print("raw=");   Serial.print(value);
    Serial.print("  ");     Serial.print(percent);
    Serial.print("%  approx "); Serial.print(angle);
    Serial.println(" degrees");
  }
  delay(50);
}

Applications

A potentiometer turns up in a wide range of projects. These are the uses where it is the right choice rather than a compromise:

Setpoint entry for thermostats, timers and speed controllers
Menu scrolling and value selection on devices with a display
Calibration trimmers that tune a threshold without reflashing
Volume and brightness control
Teaching analog input, mapping and ADC resolution

Working with the Arduino Uno

The Arduino Uno is built around the ATmega328P and runs on 5 V logic with 2 KB of SRAM and 32 KB of program flash. These details change how this circuit is wired and what the sketch can do, so they are worth stating plainly before you build.

The Uno runs at 5 V, so most hobby sensor modules connect directly with no level shifting.

With only 2 KB of SRAM, avoid large buffers and prefer the F() macro for constant strings.

The single hardware UART is shared with the USB connection, so heavy Serial printing competes with uploads.

Arduino Uno characteristic	Value	Why it matters here
Logic voltage	5 V	Matches most hobby modules directly
ADC resolution	10-bit (0–1023)	Sets how finely an analog reading can be resolved
Analog inputs	A0–A5 (six channels)	Determines how many analog sensors can share the board
PWM outputs	D3, D5, D6, D9, D10 and D11	Needed for brightness, speed and tone control
I²C pins	A4 (SDA) and A5 (SCL)	Fixed by hardware — wiring copied from another board may not match
Interrupt pins	D2 and D3 only	Required for counting fast or asynchronous events
Serial	a single hardware UART shared with USB	Monitor runs at 9600 baud by default

Troubleshooting

Most problems with this module fall into a handful of categories. Work through these before suspecting the part itself:

The reading never reaches 0 or full scale — one outer terminal is not connected, or the pot is wired as a rheostat.
The value jitters by a few counts — that is normal ADC noise. Average, and apply a noise gate as the sketch does.
Rotation feels reversed — swap the two outer terminals, or subtract the reading from the maximum.
The response is uneven, slow then sudden — it is a logarithmic pot. Use a linear one.
The reading jumps erratically at certain positions — the track is worn or dirty; a scratchy pot needs replacing.
Code written for an ESP board gives odd analog values — the Arduino Uno uses a 10-bit ADC returning 0–1023; rescale any constant taken from a 12-bit example.
An I²C sensor is not found after copying wiring from another Arduino — on the Arduino Uno I²C is on A4 (SDA) and A5 (SCL).

Taking It Further on the Arduino Uno

Once the basic reading works, where you go next depends very much on which board you are using. These are the directions that suit the Arduino Uno specifically:

The Uno’s shield ecosystem is its real advantage. Once the circuit works on a breadboard, a prototyping shield turns it into something permanent that still stacks with a data-logging or Ethernet shield without rewiring.

Logging to an SD card via a shield is the natural next step, since the Uno has no onboard storage and no network. Timestamp each reading with a DS3231 real-time clock so the log survives power cuts with correct times.

Because SRAM is limited to 2 KB, keep logged strings short and write them out immediately rather than buffering. Building a long String in memory is the most common cause of an Uno sketch that runs for hours and then freezes.

Notes and Practical Limits

The noise gate matters more than it looks. Without it, the last ADC bit flickers constantly and anything driven from the pot — a servo, a display value — twitches even when nobody is touching the knob.

For a control that should not drift when knocked, a rotary encoder is better: it reports changes rather than absolute position, so it has no physical end stops and never disagrees with the stored value.