I2C Scanner Finds Nothing: Wiring, Pull-Ups and Address Problems

/ Troubleshooting

An I2C scanner is one of the most useful troubleshooting tools for Arduino, ESP32, ESP8266, RP2040 and similar microcontroller projects. It sends test messages to all possible I2C addresses and reports which devices answer.

When everything is wired correctly, an I2C scanner usually prints one or more addresses such as 0x3C, 0x27, 0x68 or 0x48. But sometimes the scanner finds nothing at all.

This does not always mean the sensor or display is defective. In most cases, the problem is wiring, power, pin selection, missing pull-up resistors, wrong voltage, or a missing common ground.

Typical Symptoms

  • The I2C scanner reports “No I2C devices found.”
  • A display stays blank even though it has power.
  • A sensor library reports connection failure.
  • The same module works on another Arduino but not on the current board.
  • The scanner works with one module, but not when several modules are connected.
  • The scanner sometimes finds the device and sometimes does not.

What an I2C Scanner Actually Checks

An I2C scanner does not test whether the sensor or display is fully working. It only checks whether an I2C device answers at an address.

If the scanner finds an address, it means:

  • The device has power.
  • The SDA and SCL lines are connected well enough for basic communication.
  • The device is responding to its I2C address.
  • The microcontroller can at least start a basic I2C transaction.

If the scanner finds nothing, the problem is usually more basic. Before changing libraries or rewriting code, check the hardware first.

The Four Wires That Must Be Correct

Most I2C modules need four connections:

  • VCC or VIN: power supply
  • GND: ground
  • SDA: serial data
  • SCL: serial clock

If any one of these connections is missing or wrong, the scanner may find nothing.

This sounds obvious, but many I2C problems are caused by swapped SDA/SCL wires, missing ground, loose breadboard contacts, or using the wrong board pins.

Quick Check 1: Confirm Power and Ground

Start with power. Do not assume that a module has power just because wires are connected.

  • Measure voltage between VCC and GND on the module itself.
  • Check whether the module expects 3.3V or 5V.
  • Make sure GND from the module is connected to GND of the microcontroller.
  • Do not rely only on breadboard rail colors; some breadboards have split rails.

If the module has no power, wrong power, or no common ground, I2C communication cannot work.

Quick Check 2: Check SDA and SCL

SDA and SCL are easy to swap by mistake.

  • SDA must go to SDA.
  • SCL must go to SCL.
  • Do not trust wire colors unless you wired them yourself.
  • Check the pin labels on the actual board, not only a random online pinout.

On some boards, pin labels are confusing. For example, one board may label I2C pins as SDA/SCL, another may label them by GPIO number, and another may use Arduino-style pin numbers.

Quick Check 3: Use the Correct I2C Pins for Your Board

Different boards use different default I2C pins.

Board Type Typical SDA Typical SCL Important Note
Arduino Uno / Nano A4 A5 Also often available on dedicated SDA/SCL header pins
Arduino Mega 2560 20 21 Not A4/A5 like Uno
ESP8266 NodeMCU Often D2 / GPIO4 Often D1 / GPIO5 Can depend on board definition and sketch
ESP32 Often GPIO21 Often GPIO22 Pins are flexible, but must match the sketch
RP2040 / XIAO RP2040 Board-specific Board-specific Check the exact board pinout

On ESP32 and many RP2040 boards, the pins are flexible, but the sketch must define them correctly. If the wires are connected to GPIO22 and GPIO23, but the code initializes I2C on GPIO21 and GPIO22, the scanner may find nothing.

ESP32 Example: Define SDA and SCL

On ESP32, it is often better to explicitly define the I2C pins instead of relying on defaults.

#include <Wire.h>

#define I2C_SDA 21
#define I2C_SCL 22

void setup() {
  Serial.begin(115200);
  Wire.begin(I2C_SDA, I2C_SCL);
}

void loop() {
}

Change the pin numbers to match your board and wiring.

Quick Check 4: Check Pull-Up Resistors

I2C lines do not work like normal push-pull digital outputs. SDA and SCL need pull-up resistors to pull the lines high. Devices on the bus then pull the lines low when needed.

Many I2C modules already include pull-up resistors. Some do not. Some microcontrollers have weak internal pull-ups, but these are often not strong enough for reliable I2C communication.

  • If there are no pull-ups, the scanner may find nothing.
  • If pull-ups are too weak, communication may be unreliable.
  • If too many modules with pull-ups are connected, the combined pull-up may become too strong.

For many small 3.3V or 5V I2C projects, pull-up values between 2.2kΩ and 10kΩ are commonly used. A typical starting point is 4.7kΩ on SDA and SCL.

Quick Check 5: Measure the Idle Voltage on SDA and SCL

With the circuit powered and no communication happening, SDA and SCL should normally sit high.

  • On a 5V Arduino I2C bus, idle voltage is usually close to 5V.
  • On a 3.3V system, idle voltage is usually close to 3.3V.
  • If one line is stuck near 0V, something is pulling it low.
  • If the lines float or show strange voltages, pull-ups or wiring may be missing.

This simple voltage check can quickly reveal wiring mistakes, damaged modules, or a device holding the bus low.

Quick Check 6: Try One Module Only

If multiple I2C devices are connected, remove all except one known-good module.

  • Connect only one I2C device.
  • Run the scanner.
  • Write down the address.
  • Disconnect it and test the next module.

This helps identify address conflicts, bad modules, wiring mistakes, or one device that locks the whole bus.

Common Cause: Missing Common Ground

I2C needs a shared reference. If the microcontroller and module are powered from different supplies, their grounds must still be connected together.

Without common ground, the SDA and SCL voltages have no reliable reference. The module may power up, but the microcontroller may not be able to understand the signals.

This is especially common when people use:

  • An external power supply for sensors or displays.
  • A separate 5V supply for LED modules.
  • A battery-powered module connected to a USB-powered controller.
  • A relay or motor supply next to an I2C circuit.

Common Cause: Wrong Voltage Level

Some I2C modules are 5V-friendly. Others are 3.3V only. ESP32, ESP8266 and most RP2040 boards use 3.3V GPIO.

If a module pulls SDA and SCL up to 5V, that can be unsafe for a 3.3V microcontroller unless the board includes proper level shifting or the chip is 5V tolerant.

For reliable mixed-voltage I2C, use a proper I2C level shifter or keep the entire bus at 3.3V when all devices support it.

Common Cause: Breadboard Rail Problems

Breadboards are convenient, but they can cause very annoying problems.

  • Some power rails are split in the middle.
  • Loose jumper wires may make intermittent contact.
  • Cheap breadboards may have weak spring contacts.
  • Long wires increase noise and capacitance.
  • A wire may be inserted one row off from where it should be.

If the scanner finds the device only sometimes, do not immediately blame the code. Wiggle the wires, move the circuit to another part of the breadboard, or rebuild the wiring from scratch.

Common Cause: Device Holding the Bus Low

Sometimes one device locks the I2C bus by holding SDA or SCL low. When that happens, the scanner may find nothing, even if other devices on the same bus are fine.

This can happen because of:

  • A damaged module.
  • Wrong voltage connection.
  • Incorrect wiring.
  • A module stuck after a bad reset.
  • Power sequencing problems.

Disconnect modules one at a time and measure SDA/SCL voltage. The device that pulls a line low is usually the problem.

Common Cause: Wrong I2C Address Assumption

Many example sketches assume a default address, but real modules are not always built the same way.

  • Small OLED displays are often 0x3C or 0x3D.
  • LCD backpacks are often 0x27 or 0x3F.
  • DS3231 RTC modules are usually 0x68.
  • ADS1115 ADC modules are often 0x48, but can usually be changed.

If the scanner finds a different address than the example code uses, update the sketch to use the address found by the scanner.

Common Cause: Address Conflict

I2C allows many devices on the same two wires, but each device must have a unique address.

If two modules use the same address and neither one can be changed, they cannot normally share the same I2C bus directly.

Solutions include:

  • Changing the address with solder jumpers, if the module supports it.
  • Using a different version of the module with another address.
  • Using an I2C multiplexer such as TCA9548A or TCA9546A.
  • Using a second I2C bus if the microcontroller supports it.

Common Cause: Bus Too Long

I2C was designed for communication over short distances on a PCB or inside a small device. It is not a long-distance cable protocol.

Long wires add capacitance and pick up noise. The result can be missing devices, unstable readings, or communication that works only at lower speeds.

  • Keep SDA and SCL wires short.
  • Keep wiring neat and close to ground where possible.
  • Lower the I2C clock speed for longer wiring.
  • Do not run I2C wires next to motors, relays, or high-current LED wiring.

Try Lowering the I2C Clock Speed

If the scanner sometimes finds the device but communication is unreliable, try reducing the I2C clock speed.

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(100000); // 100 kHz standard mode
}

void loop() {
}

Some systems work at 400 kHz, but 100 kHz is often more reliable for troubleshooting, longer wires, or mixed modules.

Basic I2C Scanner Sketch

This simple scanner works for many Arduino-compatible boards. For ESP32 or other boards with flexible I2C pins, add the correct pins to Wire.begin().

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    ;
  }

  Wire.begin();

  Serial.println("I2C scanner started");
}

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

  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("I2C device found at 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
      count++;
    }
  }

  if (count == 0) {
    Serial.println("No I2C devices found");
  } else {
    Serial.println("Scan complete");
  }

  delay(3000);
}

Step-by-Step Troubleshooting Method

  1. Disconnect all I2C modules.
  2. Connect only one simple known-good I2C module.
  3. Check VCC and GND with a meter.
  4. Check SDA and SCL wiring.
  5. Confirm the correct I2C pins for your board.
  6. Run the I2C scanner.
  7. If nothing is found, try external 4.7kΩ pull-ups.
  8. Try a lower I2C speed.
  9. Try shorter wires.
  10. Test the module on another board if possible.

What If the Scanner Finds an Address?

If the scanner finds an address, that is good news, but it does not mean the project is finished.

The next problems may still be:

  • The sketch uses the wrong address.
  • The wrong display or sensor library is selected.
  • The display controller is not the one expected by the library.
  • The device needs a different initialization sequence.
  • The sensor library expects a different chip version.

For example, an OLED display may answer at address 0x3C, but still remain blank if the library expects an SSD1306 controller and the display actually uses SH1106.

CANABLOX Practical Note

CANABLOX modules are built around clean modular wiring, which makes I2C troubleshooting much easier. Instead of many loose jumper wires, modules connect through standardized I2C cables and a defined system layout.

When troubleshooting a CANABLOX setup, start with the controller module and one I2C module only. Confirm the address with an I2C scanner. Then add the next module and scan again. This makes it much easier to find address conflicts, bad cables, or one module that causes the bus to fail.

Conclusion

If an I2C scanner finds nothing, do not start by changing libraries. First check the basic electrical connection: power, ground, SDA, SCL, correct pins, pull-up resistors, and voltage levels.

Most “no I2C device found” problems are caused by simple hardware issues. Once the scanner finds the device address reliably, then it makes sense to move on to library selection, display controller type, sensor initialization, and project code.

Shopping Cart
Scroll to Top