What Are Pull-Up and Pull-Down Resistors and When Do You Need Them?

Floating pin behavior illustration:

Time →  ....continuous....
Actual pin voltage: ~2.3V → ~2.7V → ~2.1V → ~3.1V → ~1.9V → ~2.5V
VCC = 5V, HIGH threshold = 3.5V, LOW threshold = 1.5V

Reading:             LOW       LOW      LOW      LOW     LOW      LOW
                                                                  
...then motor starts nearby, coupling noise onto the wire...

Pin voltage: ~2.3V → ~3.8V → ~1.2V → ~4.1V → ~0.8V → ~3.9V
Reading:      LOW     HIGH    LOW    HIGH    LOW    HIGH
                ↑ apparently "pressed" when motor ran

Pull-up circuit (button connecting pin to GND):

VCC ──────[R pull-up]──────┬──── Input pin (to microcontroller)
                           │
                         [Button]
                           │
                          GND

Button OPEN (not pressed):
- No current path to GND through the button
- Pull-up resistor connects pin weakly to VCC
- Pin voltage = VCC (typically 5V or 3.3V)
- digitalRead() = HIGH

Button CLOSED (pressed):
- Current flows: VCC → R → Pin → Button → GND
- Pin is now connected to GND through the low-resistance button
- Pin voltage ≈ 0V (GND wins over pull-up)
- digitalRead() = LOW

// Pull-up resistor with button — active low logic
const int BUTTON_PIN = 7;

void setup() {
  pinMode(BUTTON_PIN, INPUT);  // External pull-up handles it
  Serial.begin(9600);
}

void loop() {
  int buttonState = digitalRead(BUTTON_PIN);

  if (buttonState == LOW) {
    // Button is PRESSED (pin pulled LOW by button to GND)
    Serial.println("Button pressed!");
  } else {
    // Button is NOT pressed (pin held HIGH by pull-up resistor)
    // This is the default/idle state
  }

  delay(50);
}

Pull-down circuit (button connecting pin to VCC):

VCC ──────[Button]──────┬──── Input pin (to microcontroller)
                        │
                    [R pull-down]
                        │
                       GND

Button OPEN (not pressed):
- No current path to VCC through the button
- Pull-down resistor connects pin weakly to GND
- Pin voltage = 0V (GND)
- digitalRead() = LOW

Button CLOSED (pressed):
- Current flows: VCC → Button → Pin → R pull-down → GND
- VCC drives the pin strongly to HIGH
- Pin voltage ≈ VCC
- digitalRead() = HIGH

// Pull-down resistor with button — active high logic
const int BUTTON_PIN = 7;

void setup() {
  pinMode(BUTTON_PIN, INPUT);  // External pull-down handles it
  Serial.begin(9600);
}

void loop() {
  int buttonState = digitalRead(BUTTON_PIN);

  if (buttonState == HIGH) {
    // Button is PRESSED (pin driven HIGH by button to VCC)
    Serial.println("Button pressed!");
  } else {
    // Button is NOT pressed (pin held LOW by pull-down resistor)
  }

  delay(50);
}

Choose pull-up when:
  ✓ Using the microcontroller's internal pull-up (saves external component)
  ✓ The sensor or switch connects to GND when active (common in limit switches)
  ✓ Using open-collector/open-drain outputs (they can only pull low, not high)
  ✓ The signal source is at a lower voltage than VCC (level-shifting concerns)
  ✓ I2C bus — always uses pull-ups, never pull-downs
  ✓ Buttons in most robotics applications (convention)

Choose pull-down when:
  ✓ The sensor or switch connects to VCC when active
  ✓ Active-high logic is more natural for the application
  ✓ The default state needs to be LOW (e.g., a "ready" signal that goes HIGH when ready)
  ✓ MOSFET gate inputs that must default to OFF (gate LOW = MOSFET off)

// Method 1: Using INPUT_PULLUP in pinMode()
// This is the recommended modern approach (Arduino 1.0.1+)
pinMode(BUTTON_PIN, INPUT_PULLUP);

// With INPUT_PULLUP, a floating pin reads HIGH.
// A button connecting the pin to GND reads LOW.
// Same active-low logic as external pull-up.

// Method 2: Writing HIGH to a pin configured as INPUT (deprecated, still works)
pinMode(BUTTON_PIN, INPUT);
digitalWrite(BUTTON_PIN, HIGH);  // Enables internal pull-up on AVR chips
// This method is NOT recommended — use INPUT_PULLUP instead.

// Complete button example using internal pull-up
// No external resistor needed — just button connected between pin and GND

const int BUTTON_PIN = 2;
const int LED_PIN    = 13;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);  // Enable internal pull-up
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // With INPUT_PULLUP: not pressed = HIGH, pressed = LOW
  if (digitalRead(BUTTON_PIN) == LOW) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println("Button pressed");
  } else {
    digitalWrite(LED_PIN, LOW);
  }
  delay(20);
}

Internal pull-up: ~30kΩ (typical on Arduino AVR)

Too weak for:
  ✗ I2C bus — 30kΩ is too high; I2C requires 4.7kΩ or lower
  ✗ Long cable runs susceptible to capacitive loading
  ✗ Any application where the signal line capacitance is high
    (high capacitance + high pull-up resistance = slow rise time)

Appropriate for:
  ✓ Buttons and momentary switches at short distances
  ✓ Limit switches directly connected to the board
  ✓ Most simple digital sensor outputs

When to add external pull-up even if internal is available:
  → I2C/SPI/UART communication lines
  → Sensors at the end of long wires (>30cm)
  → Any input line that must respond quickly to state changes

// Raspberry Pi (Python with RPi.GPIO)
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # Pull-up on GPIO 17
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # Pull-down on GPIO 18
button_state = GPIO.input(17)  # LOW = pressed with pull-up

// ESP32 (Arduino IDE)
pinMode(BUTTON_PIN, INPUT_PULLUP);   // Same as Arduino
// or
pinMode(BUTTON_PIN, INPUT_PULLDOWN); // ESP32 also has internal pull-downs!

// STM32 (HAL library)
GPIO_InitStruct.Pull = GPIO_PULLUP;   // Pull-up
GPIO_InitStruct.Pull = GPIO_PULLDOWN; // Pull-down
GPIO_InitStruct.Pull = GPIO_NOPULL;   // No pull (floating — use carefully)

Lower resistance (e.g., 1kΩ pull-up):
  + More robust against noise — harder for induced voltages to overcome
  + Better signal integrity on long cable runs
  + Lower rise time on capacitive lines
  − Higher current when pin is driven LOW: I = VCC / R = 5V / 1kΩ = 5mA
    (continuous when button held pressed — significant for battery life)
  − May load sensitive signal sources (some open-collector devices have limited
    current sinking capability)

Higher resistance (e.g., 100kΩ pull-up):
  + Very low current: I = 5V / 100kΩ = 0.05mA (negligible)
  + Doesn't load signal sources
  − More susceptible to noise pickup on high-impedance input
  − Slow rise time with capacitive loads (long wires, connector capacitance)
  − May not reliably overdrive stray leakage currents in high-humidity environments

Application                    Recommended value  Reasoning
────────────────────────────────────────────────────────────────────
Button/switch (short wire)     10kΩ               Good balance; 0.5mA when pressed
Button/switch (internal)       ~30kΩ (internal)   Convenient, fine for short connections
Limit switch (robot chassis)   4.7kΩ–10kΩ        Low enough for noise immunity
I2C SDA/SCL (up to 400kHz)     4.7kΩ              Standard; see I2C section below
I2C SDA/SCL (1MHz fast mode)   2.2kΩ–1kΩ         Lower for faster rise times
Open-collector sensor output   4.7kΩ–10kΩ        Match sensor's output current spec
UART TX/RX lines               Not usually needed  UART is actively driven both ways
Long wire run (>1 meter)       1kΩ–4.7kΩ         Low <a href="https://techietory.com/electronics/what-is-impedance-how-is-it-different-from-resistance/">impedance</a> fights noise and capacitance
MOSFET gate (default OFF)      10kΩ–100kΩ pull-down Minimal current; gate barely loads resistor
Reset pin (active low reset)   10kΩ               Hold MCU out of reset when not triggered

I2C line states:

Line HIGH: no device pulling LOW → pull-up resistor holds line at VCC
Line LOW:  a device (master or slave) actively pulling the pin to GND
           (the pull-up current flows through the device's output transistor)

Without pull-up:
  Line transitions LOW (device pulls it) → stays LOW forever
  The "HIGH" state cannot occur — I2C completely non-functional

With pull-up:
  Line goes LOW (device pulls it) → device releases → pull-up pulls line back HIGH
  Normal I2C communication is possible

I2C pull-up resistance constraints:

Minimum resistance (too low = too much current):
  Rmin = (VCC - VOL) / IOL
  where VOL = max LOW output voltage (0.4V), IOL = max sink current (3mA for standard)
  Rmin = (5V - 0.4V) / 3mA = 4.6V / 3mA = 1.53kΩ → use at least 1.5kΩ
  (For 3.3V systems: (3.3V - 0.4V) / 3mA = 967Ω → at least 1kΩ)

Maximum resistance (too high = too slow rise time):
  Rmax = rise_time / (0.8473 × Cbus)
  where rise_time = max allowable at that speed, Cbus = total bus capacitance

Standard mode (100kHz): max rise time 1000ns
  For 100pF bus capacitance: Rmax = 1000ns / (0.8473 × 100pF) ≈ 11.8kΩ
  → 4.7kΩ is safely within range for standard mode with typical cable length

Fast mode (400kHz): max rise time 300ns
  For 100pF: Rmax = 300ns / (0.8473 × 100pF) ≈ 3.54kΩ
  → Use 2.2kΩ for fast mode

Practical recommendations:
  Short connections (< 30cm, one or two devices):  4.7kΩ — always works
  Multiple devices or longer wires (30–100cm):      2.2kΩ
  Fast mode I2C (400kHz):                           2.2kΩ
  Fast-plus mode (1MHz):                            1kΩ–1.5kΩ

Three devices each with 4.7kΩ pull-ups on SDA:
Effective pull-up = 4.7kΩ / 3 = 1.57kΩ
→ Below minimum resistance for 3.3V systems
→ Excessive current sink required from every device when driving LOW

Correct approach: one 4.7kΩ on SDA, one 4.7kΩ on SCL — regardless
of how many devices are on the bus.

In practice: many I2C sensor breakout boards include their own pull-up
resistors (typically 4.7kΩ or 10kΩ) as a convenience for single-device use.
When multiple breakout boards share a bus, these per-board pull-ups combine
to create too-low effective resistance. The fix: remove (or lift one leg of)
the pull-up resistors on all but one breakout board, OR rely on the internal
pull-ups being disabled/absent on most boards in your collection.

Check your breakout board schematics — many have a solder jumper to
disconnect the on-board pull-ups for exactly this multi-device scenario.

// Arduino I2C master setup — pull-ups handled externally
// The Arduino's Wire library enables I2C automatically
// Just ensure 4.7kΩ pull-ups are present on SDA (A4) and SCL (A5) on Uno
// or SDA (pin 20) and SCL (pin 21) on Mega

#include <Wire.h>

void setup() {
  Wire.begin();          // Initialize I2C as master
  Wire.setClock(400000); // 400kHz fast mode — requires 2.2kΩ pull-ups
  Serial.begin(9600);

  // Scan for I2C devices (useful for debugging pull-up issues)
  Serial.println("Scanning I2C bus...");
  int found = 0;
  for (int addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      Serial.print("Device found at 0x");
      Serial.println(addr, HEX);
      found++;
    }
  }
  if (found == 0) {
    Serial.println("No devices found — check pull-up resistors on SDA/SCL!");
  }
}

Open-collector output behavior:

State = 0 (active): Transistor turns ON → output pulled to GND (LOW)
State = 1 (inactive): Transistor turns OFF → output floating (no drive)

Without pull-up: "1" state is FLOATING — undefined, susceptible to noise
With pull-up:    "1" state is VCC — defined HIGH

Common open-collector/open-drain devices:
- I2C bus (as described above)
- Many hall-effect sensors and encoders
- Comparator outputs (LM393, LM358 in comparator mode)
- Some temperature sensors (DS18B20 one-wire interface)
- Many <a href="https://techietory.com/electronics/understanding-relays-small-signals-control-large-loads/">relay</a> driver outputs
- Interrupt outputs from many sensor ICs
- Level shifter circuits

// HC-SR04 alternative: some ultrasonic sensors use open-drain echo pin
// Similarly, DS18B20 temperature sensor uses single-wire open-drain protocol
// Requires external 4.7kΩ pull-up on the data line

// OneWire library example (DS18B20 thermometer)
// Hardware: DS18B20 data pin → Arduino pin 2
//           4.7kΩ pull-up between pin 2 and 5V (MANDATORY)

#include <OneWire.h>
#include <DallasTemperature.h>

const int ONE_WIRE_BUS = 2;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

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

void loop() {
  sensors.requestTemperatures();
  float tempC = sensors.getTempCByIndex(0);
  if (tempC == DEVICE_DISCONNECTED_C) {
    Serial.println("Error: Check 4.7kΩ pull-up on data line!");
  } else {
    Serial.print("Temperature: ");
    Serial.print(tempC);
    Serial.println("°C");
  }
  delay(1000);
}

// Debounced button read with internal pull-up
const int BUTTON_PIN = 2;
const unsigned long DEBOUNCE_DELAY = 50; // ms

int lastButtonState = HIGH;     // Previous raw reading (HIGH = not pressed with pull-up)
int buttonState = HIGH;         // Debounced state
unsigned long lastDebounceTime = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int reading = digitalRead(BUTTON_PIN);

  // If reading changed, reset debounce timer
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  // Only accept state change if stable for DEBOUNCE_DELAY ms
  if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
    if (reading != buttonState) {
      buttonState = reading;
      // Only act on press (HIGH→LOW transition with pull-up = press)
      if (buttonState == LOW) {
        Serial.println("Button pressed (debounced)");
      }
    }
  }

  lastButtonState = reading;
}

I2C level shifting with pull-ups:

5V system (Arduino)         3.3V system (sensor/RPi)
     │                              │
VCC(5V) ──[4.7kΩ]──┬──[MOSFET]──┬── VCC(3.3V)──[4.7kΩ]
                   │            │
                  SDA          SDA
                  (shared bus)

This bidirectional level shifter (BSS138 MOSFET) uses the pull-up
resistors on BOTH sides to define the voltage levels:
- 5V side pull-up holds that side at 5V when not driven
- 3.3V side pull-up holds that side at 3.3V when not driven
- MOSFET connects the two sides and handles level translation

Pre-built I2C level shifter modules (SparkFun, Adafruit, generic) include
the BSS138 MOSFETs and the pull-up resistors in a convenient package.
The pull-up values on these modules are typically 4.7kΩ on both sides.

Quick decision guide:

Q: Does this digital input need a pull resistor?
A: Yes, if the pin is not ALWAYS actively driven to a known voltage.
   (Buttons, switches, open-drain sensors, communication buses → always need pull)

Q: Pull-up or pull-down?
A: Pull-up if active device pulls LOW (most common — buttons to GND, I2C, open-drain)
A: Pull-down if active device drives HIGH (button to VCC, some enable signals)

Q: What value?
A: 10kΩ for buttons, switches, general inputs
   4.7kΩ for I2C (up to 400kHz)
   2.2kΩ for I2C fast mode or long cable runs
   1kΩ for I2C fast-plus (1MHz)

Q: External resistor or internal?
A: Internal (~30kΩ) is fine for buttons/switches with short wires
   External required for I2C, long wires, open-drain sensors
   External gives more control over exact value

Robot arm limit switch circuit:

VCC (5V) ──[10kΩ pull-up]──┬──── Arduino Pin 3
                           │
                    [Limit Switch - NO]
                           │
                          GND

Pin state: HIGH (5V) = arm within limits (switch open, pull-up active)
           LOW (0V) = arm at limit (switch closed, pin pulled to GND)

// Limit switch protection for robot arm
const int JOINT1_LIMIT_MIN = 3;  // Minimum angle limit switch
const int JOINT1_LIMIT_MAX = 4;  // Maximum angle limit switch

void setup() {
  // Use internal pull-ups — perfectly adequate for limit switches
  // mounted on the robot chassis (short wires)
  pinMode(JOINT1_LIMIT_MIN, INPUT_PULLUP);
  pinMode(JOINT1_LIMIT_MAX, INPUT_PULLUP);
}

bool isAtMinLimit(int pin) {
  return digitalRead(pin) == LOW;  // LOW means switch tripped
}

bool isAtMaxLimit(int pin) {
  return digitalRead(pin) == LOW;
}

void moveJointForward() {
  if (isAtMaxLimit(JOINT1_LIMIT_MAX)) {
    Serial.println("At maximum limit — stopping!");
    stopMotor();
    return;
  }
  // Continue moving...
  driveMotorForward();
}

volatile bool limitTriggered = false;

void limitSwitchISR() {
  limitTriggered = true;
  // Immediately cut motor power in ISR for fastest response
  analogWrite(MOTOR_PWM_PIN, 0);
}

void setup() {
  pinMode(JOINT1_LIMIT_MAX, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(JOINT1_LIMIT_MAX),
                  limitSwitchISR, FALLING);  // FALLING = HIGH→LOW transition
}

Encoder index pulse circuit (open-collector output):

VCC (5V) ──[4.7kΩ pull-up]──┬──── Arduino Pin 2 (interrupt pin)
                            │
                    [Encoder Index Output - Open Collector]
                            │
                           GND

Without pull-up: index output is floating when encoder is not at index position
                 → interrupt triggers continuously from floating noise

With 4.7kΩ pull-up: clean HIGH when not at index, clean LOW pulse at index
                     → interrupt triggers cleanly once per revolution

// Zero-position detection using encoder index pulse with pull-up
volatile bool indexPulseDetected = false;

void indexPulseISR() {
  indexPulseDetected = true;
}

void setup() {
  pinMode(2, INPUT);  // External 4.7kΩ pull-up handles it — don't use INPUT_PULLUP
                      // here because encoder is open-collector and needs precise value
  attachInterrupt(digitalPinToInterrupt(2), indexPulseISR, FALLING);
}

void homeJoint() {
  indexPulseDetected = false;
  driveMotorSlow();           // Move slowly toward home

  while (!indexPulseDetected) {
    delay(1);
    // Wait for index pulse...
  }
  stopMotor();
  encoderCount = 0;           // Reset encoder position to zero at index
  Serial.println("Homed successfully");
}

I2C bus with multiple devices:

Arduino SDA (A4) ──────────────────────────────────┐
Arduino SCL (A5) ──────────────────────────────────┐
                                                   │
VCC (3.3V) ──[4.7kΩ]──── SDA bus                   │
VCC (3.3V) ──[4.7kΩ]──── SCL bus                   │
                                                   │
MPU-6050 SDA ──────────────────────────────────────┤
MPU-6050 SCL ──────────────────────────────────────┤
(Board has 4.7kΩ on-board pull-ups — DISABLE THEM) │
                                                   │
BMP280 SDA ────────────────────────────────────────┤
BMP280 SCL ────────────────────────────────────────┤
(Board has 4.7kΩ on-board pull-ups — DISABLE THEM) │
                                                   │
SSD1306 SDA ───────────────────────────────────────┤
SSD1306 SCL ───────────────────────────────────────┤
(Board may have 10kΩ — DISABLE THEM)               │
                                                   │
VL53L0X SDA ───────────────────────────────────────┘
VL53L0X SCL ───────────────────────────────────────┘
(Keep or disable board pull-ups depending on total)

TOTAL pull-up resistance on SDA and SCL:
  Two sets at 4.7kΩ: parallel = 2.35kΩ → borderline for 5V (approaching minimum)
  Four sets at 4.7kΩ: parallel = 1.18kΩ → below minimum for some devices!

SOLUTION: Disable on-board pull-ups on all breakout boards.
          Add one clean 4.7kΩ from SDA to 3.3V.
          Add one clean 4.7kΩ from SCL to 3.3V.
          All devices share these two pull-ups.