Overview
This slide potentiometer module puts a 10k linear-taper fader — the same control you'd find on a mixing console — onto a breadboard-friendly PCB. Instead of twisting a knob you push a slider along a 60mm track, and the module reports the position as a smooth analog voltage. Sliders communicate position at a glance in a way rotary pots can't, which is why they're the natural choice for volume faders, lighting dimmers, game controllers, and any UI where "how far along" should be visible from across the room.
The module actually contains two independent 10k tracks moved by the same lever — a dual-gang design broken out as two 3-pin groups: OTA/VCC/GND for channel A and OTB/VCC/GND for channel B. Use one channel and ignore the other, average the pair for a cleaner reading, or exploit both to feed two circuits from one physical control (classic stereo-volume trick).
Being purely resistive, it works at any voltage your ADC likes — 3.3V or 5V — and needs no library, no protocol, and no timing: wire VCC and GND across the track, read the wiper with analogRead(), and map the number to whatever you're controlling. The examples below turn it into a percentage readout and a live LED dimmer on every platform.
At a Glance
Specifications
| Parameter | Value |
| Element | Dual-gang linear-taper slide potentiometer |
| Resistance | 10k ohm per track (B103 marking) |
| Taper | Linear — position maps directly to voltage |
| Slider Travel | ~60 mm usable |
| Supply Voltage | Any ADC reference — 3.3V or 5V typical |
| Output | 0V to VCC analog on OTA / OTB wipers |
| Channel A Pins | OTA (wiper), VCC, GND |
| Channel B Pins | OTB (wiper), VCC, GND |
| Current Draw | ~0.33 mA per track at 3.3V (~0.5 mA at 5V) |
| Rated Power | 0.1 W per element |
| Mounting | 4 corner holes, panel- or breadboard-friendly |
Pinout Diagram
Both 3-pin groups sit on the right edge. Within each group, VCC and GND connect across the full resistive track and the OT pin is the wiper. Sliding toward the "increase" end raises the wiper voltage toward VCC; sliding the other way lowers it toward GND. The two channels are electrically independent — they only share the physical lever.
Wiring Guide
Arduino Wiring
| Module Pin | Arduino Pin | Details |
|---|---|---|
| VCC (channel A) | 5V | |
| GND (channel A) | GND | |
| OTA | A0 | Wiper output |
| LED (optional) | D9 via 220 ohm to GND | PWM dimming demo |
ESP32 Wiring
| Module Pin | ESP32 Pin | Details |
|---|---|---|
| VCC | 3V3 | Keeps wiper <= 3.3V |
| GND | GND | |
| OTA | GPIO 34 | ADC1, input-only pin |
Raspberry Pi Wiring
The Pi has no analog inputs, so an ADS1115 I2C ADC reads the wiper.
| Wire / Pin | Connects To | Details |
|---|---|---|
| Module VCC / GND | Pin 1 (3.3V) / Pin 6 (GND) | |
| OTA | ADS1115 A0 | Analog channel 0 |
| ADS1115 VDD / GND | Pin 1 / Pin 6 | |
| ADS1115 SDA / SCL | Pin 3 / Pin 5 | I2C (GPIO 2 / GPIO 3) |
Raspberry Pi Pico Wiring
| Module Pin | Pico Pin | Details |
|---|---|---|
| VCC | 3V3(OUT) (pin 36) | |
| GND | GND (pin 38) | |
| OTA | GP26 (pin 31) | ADC0 input |
Code Examples
Each example reads channel A, smooths it, prints position as a percentage, and (where the platform makes it easy) dims an LED with PWM so the slider physically controls brightness.
Arduino
// 10K Slide Potentiometer - Arduino Example
// OTA->A0, VCC->5V, GND->GND, optional LED on D9
const int potPin = A0;
const int ledPin = 9; // PWM pin
int readSmooth() {
long total = 0;
for (int i = 0; i < 16; i++) total += analogRead(potPin);
return total / 16;
}
void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
Serial.println("Slide the fader!");
}
void loop() {
int raw = readSmooth(); // 0..1023
int percent = map(raw, 0, 1023, 0, 100);
int pwm = map(raw, 0, 1023, 0, 255);
analogWrite(ledPin, pwm); // slider dims the LED
Serial.print("Raw: ");
Serial.print(raw);
Serial.print(" | Position: ");
Serial.print(percent);
Serial.println(" %");
delay(100);
}
ESP32 (MicroPython)
# 10K Slide Potentiometer - ESP32 MicroPython Example
# OTA->GPIO 34, VCC->3V3, GND->GND, optional LED on GPIO 25
from machine import ADC, Pin, PWM
import time
adc = ADC(Pin(34))
adc.atten(ADC.ATTN_11DB) # full 0-3.3V range
led = PWM(Pin(25), freq=1000)
def read_smooth(n=16):
return sum(adc.read() for _ in range(n)) // n # 0..4095
print("Slide the fader!")
while True:
raw = read_smooth()
percent = raw * 100 // 4095
led.duty(raw >> 2) # 0..1023 duty
print("Raw: {:4d} | Position: {:3d} %".format(raw, percent))
time.sleep(0.1)
Raspberry Pi (Python + ADS1115)
#!/usr/bin/env python3
# 10K Slide Potentiometer - Raspberry Pi + ADS1115 Example
# OTA->ADS1115 A0, SDA/SCL->GPIO 2/3, VCC->3.3V
# Install: pip3 install adafruit-circuitpython-ads1x15
import time
import board
import busio
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn
i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
ads.gain = 1 # +/-4.096V range
chan = AnalogIn(ads, ADS.P0)
print("Slide the fader!")
try:
while True:
volts = chan.voltage
percent = max(0, min(100, volts / 3.3 * 100))
bar = "#" * int(percent / 5)
print("{:5.3f} V | {:5.1f} % | {}".format(volts, percent, bar))
time.sleep(0.1)
except KeyboardInterrupt:
print("Stopped by user")
Raspberry Pi Pico (MicroPython)
# 10K Slide Potentiometer - Pico MicroPython Example
# OTA->GP26 (ADC0), VCC->3V3(OUT), GND->GND
# Optional LED on GP15 via 220 ohm
from machine import ADC, Pin, PWM
import time
adc = ADC(26)
led = PWM(Pin(15))
led.freq(1000)
def read_smooth(n=16):
return sum(adc.read_u16() for _ in range(n)) // n # 0..65535
print("Slide the fader!")
while True:
raw = read_smooth()
percent = raw * 100 // 65535
led.duty_u16(raw) # direct 16-bit dimming
print("Raw: {:5d} | Position: {:3d} %".format(raw, percent))
time.sleep(0.1)