Mastering I2C Addresses: Scanner Code, Clash Fixes, and Pull-Up Sizing

The 7-Bit Reality: How I2C Addresses Actually Work

Standard I2C relies on a 7-bit address space, yielding 128 total addresses. Because the first 8 addresses (0x00 to 0x07) and the last 8 (0x78 to 0x7F) are reserved for special functions like general call and CBUS compatibility, you are left with exactly 112 usable I2C addresses per bus segment. While a 10-bit addressing mode exists (expanding the space to 1,024 addresses), it is rarely implemented in hobbyist or commercial sensor modules. If you are buying off-the-shelf breakouts from Adafruit or SparkFun, you are working in 7-bit space.

Before wiring anything, you need to understand the hard limits of the bus. The official NXP I2C specification (UM10204) defines the electrical and timing boundaries that dictate whether your bus will communicate or lock up.

Physical Layer: Wiring, Pull-Ups, and Capacitance Limits

I2C is an open-drain (or open-collector) protocol. The microcontroller and the sensors can only pull the SDA and SCL lines low (to ground); they cannot drive them high. To return the lines to a logic HIGH state, you must use pull-up resistors connected to VCC (usually 3.3V or 5V). If you forget pull-ups, the lines float, and your microcontroller will read random noise or a constant 0xFF.

Many breakout boards include 10kΩ pull-ups on the PCB. This is fine for a single sensor at 100 kHz. But when you daisy-chain three or four sensors, the parallel resistance drops, and the bus capacitance increases. If the pull-up resistor is too large, the RC rise time becomes too slow for the clock speed, resulting in corrupted data.

The Classic Failures: Sniffing, Clashes, and Baud Mismatches

When an I2C bus fails, it almost always comes down to one of three physical or logical errors. Here is how to diagnose and fix them on the bench.

1. The Address Clash

You cannot put two devices with the exact same I2C address on the same bus segment. For example, the Bosch BME280 environmental sensor defaults to 0x77. If you buy two, they will clash. The fix: Check the datasheet. The BME280 has an SDO pin; tying it to GND shifts the address to 0x76. If a sensor has no hardware address pins (like the popular VL53L0X ToF sensor, hardcoded to 0x29), you must use an I2C multiplexer like the TCA9548A (approx. $3.50) to create isolated sub-buses.

2. Missing or Weak Pull-Ups

Symptom: The bus scanner finds no devices, or reads return 0xFF. The fix: Measure the SDA and SCL lines with a multimeter relative to GND while the bus is idle. You should read VCC (3.3V or 5V). If you read 0V or a floating millivoltage, add external 4.7kΩ pull-up resistors to the VCC rail.

3. Baud Mismatch and Clock Stretching

Symptom: The scanner finds the device, but reading data yields garbage or NACK errors. Some sensors (like the SHT31) use clock stretching, holding SCL low while they process data. If your microcontroller's I2C hardware peripheral doesn't support clock stretching (or has a timeout that is too short), the bus locks. The fix: Drop the bus speed to 100 kHz in your initialization code and ensure your logic analyzer or oscilloscope shows SCL being held low cleanly without ringing.

How to Sniff and Debug the Bus

Before writing application code, always run an I2C scanner. This minimal sketch pings every valid 7-bit address and reports who answers. For deeper debugging, a $15 logic analyzer (like the Saleae Logic clone) running PulseView/Sigrok is mandatory to visualize the ACK/NACK bits on the 9th clock pulse.

// Minimal ESP32/Arduino I2C Address Scanner
#include <Wire.h>

void setup() {
  Serial.begin(115200);
  // Explicitly define SDA and SCL pins for ESP32
  Wire.begin(21, 22); 
  Serial.println("\nI2C Scanner: Scanning for addresses...");
}

void loop() {
  byte error, address;
  int deviceCount = 0;

  for (address = 0x08; address < 0x78; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) { // 0 = success, device acknowledged
      Serial.print("Device found at 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
      deviceCount++;
    }
  }
  
  if (deviceCount == 0) Serial.println("No I2C devices found. Check pull-ups.");
  delay(5000); // Scan every 5 seconds
}

Minimal Working Exchange: ESP32 to BME280

Let's move from scanning to a concrete data exchange. We will wire an ESP32-WROOM-32 to a BME280 and perform a raw I2C read of the chip ID register to verify communication without relying on heavy third-party libraries.

The BME280's chip ID is hardcoded at register 0xD0. If the sensor is healthy and the address is correct, reading this register will return 0x60.

#include <Wire.h>

#define BME_ADDRESS 0x77 // Change to 0x76 if SDO is tied to GND
#define CHIP_ID_REG 0xD0

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22, 400000); // 400kHz Fast Mode
  
  // Request 1 byte from the Chip ID register
  Wire.beginTransmission(BME_ADDRESS);
  Wire.write(CHIP_ID_REG);
  byte error = Wire.endTransmission(false); // Repeated start condition
  
  if (error != 0) {
    Serial.println("Fatal: Sensor did not ACK the address.");
    while(1); // Halt
  }
  
  Wire.requestFrom(BME_ADDRESS, 1);
  if (Wire.available()) {
    byte chipID = Wire.read();
    Serial.print("BME280 Chip ID: 0x");
    Serial.println(chipID, HEX);
    if (chipID == 0x60) Serial.println("Handshake successful.");
  }
}

void loop() {}

Protocol Decision Tree: I2C vs. SPI vs. UART

Choosing the right communication protocol prevents architectural dead-ends. Use this decision matrix to select the correct bus for your specific hardware constraints. For a deeper dive into physical layer comparisons, refer to the SparkFun SPI vs I2C guide.