O que é I2C? SDA, SCL, resistores de pull-up e um scanner com Arduino

O I2C (Inter-Integrated Circuit) é um protocolo de comunicação serial que permite a um microcontrolador conversar com dezenas de sensores, displays e módulos usando só dois fios de sinal (SDA e SCL). Em inglês se pronuncia “I-squared-C”, e alguns datasheets o chamam de IIC ou TWI (Two Wire Interface). O LCD I2C, o display OLED, o acelerômetro MPU6050, o sensor de pressão BMP280 e o módulo de relógio DS1307 que você usa em projetos com Arduino falam todos esse protocolo; você pode ligar todos em paralelo nos mesmos dois fios e acessar cada um pelo próprio endereço.

Neste guia você vai aprender como o I2C funciona eletricamente, o que significam os endereços, por que os resistores de pull-up são indispensáveis e como calcular o valor deles. Depois, passo a passo, você vai ver uma tabela de pinos para o Arduino Uno, o ESP32 e o Raspberry Pi Pico, um sketch scanner I2C que encontra todos os dispositivos do barramento, um exemplo de leitura de registradores sem biblioteca e soluções para problemas comuns, como conflitos de endereço.

O que é I2C e como funciona?

O I2C foi desenvolvido pela Philips (hoje NXP) em 1982 para que chips na mesma placa de circuito pudessem se comunicar com poucos fios. Há dois papéis no barramento: o controlador (antes chamado de mestre), que inicia toda transferência e gera o clock, e os alvos (antes chamados de escravos), que respondem a ele. Em projetos com Arduino, o controlador quase sempre é o Arduino, o ESP32 ou o Pico, enquanto sensores e displays são os alvos.

• SDA (Serial Data): a linha que transporta os dados nos dois sentidos. O controlador envia endereços e comandos, e o sensor devolve as leituras pela mesma linha.
• SCL (Serial Clock): a linha de clock. Um bit na SDA é lido a cada pulso de clock, e quem gera o clock é o controlador.
• GND (terra comum): a referência dos sinais. Mesmo módulos com fontes de alimentação separadas precisam compartilhar um GND comum.

As linhas são de dreno aberto: nenhum dispositivo leva a linha para nível alto, só consegue puxá-la para baixo. O que mantém a linha em 1 são os resistores de pull-up, que ligam SDA e SCL à tensão de alimentação. Por isso não há curto-circuito mesmo quando dois dispositivos tentam falar ao mesmo tempo; se qualquer dispositivo puxa a linha para baixo, todos veem um 0. Uma mensagem I2C funciona assim:

1. START: com SCL em nível alto, o controlador leva a SDA de 1 para 0, e todos os dispositivos do barramento começam a escutar.
2. Endereço e bit de direção: o endereço de 7 bits é enviado, seguido de um bit de leitura (1) ou escrita (0).
3. ACK: o dispositivo dono do endereço puxa a SDA para baixo durante o 9º pulso de clock para dizer “estou aqui”. Se ninguém fizer isso, chama-se NACK.
4. Bytes de dados: cada byte é enviado como 8 bits, e o receptor responde a cada um com um ACK. Na maioria dos sensores, o primeiro byte é o número do registrador a ser lido ou escrito.
5. STOP: com SCL em nível alto, a SDA sobe de 0 para 1 e o barramento fica livre de novo. Nas leituras, usa-se um START repetido em vez de um STOP para mudar a direção sem liberar o barramento.

Comparar o I2C com os outros dois protocolos comuns no mundo Arduino deixa claro quando escolhê-lo:

Velocidades e limites técnicos do I2C

A biblioteca Wire do Arduino começa em 100 kHz por padrão; a maioria dos sensores também suporta 400 kHz, e você muda para essa velocidade com Wire.setClock(400000). Uma velocidade maior faz os displays atualizarem com mais suavidade, mas também deixa o barramento mais sensível ao comprimento dos fios e ao valor do pull-up. Pelo padrão, a capacitância total do barramento (fios mais pinos dos dispositivos) não pode passar de 400 pF. Jumpers e cabos flat comuns somam 50–100 pF por metro, e cada pino de dispositivo soma até 10 pF; por isso o I2C foi projetado para uso em uma placa ou com fios de algumas dezenas de centímetros. Acima de 1 metro você precisa baixar a velocidade, usar pull-ups mais fortes ou adicionar extensores de barramento como o P82B715.

Endereços I2C: 7 bits, 8 bits e endereços reservados

Cada dispositivo no barramento tem um endereço de 7 bits, o que em teoria dá 128 endereços. Como as faixas 0x00–0x07 e 0x78–0x7F são reservadas para fins especiais, os endereços utilizáveis são os 112 de 0x08 a 0x77. O endereço geralmente é fixado pelo fabricante do chip, mas em muitos módulos você pode mudar os últimos bits com jumpers de solda ou pinos chamados A0, A1, A2 ou AD0.

Agora a parte confusa: alguns datasheets e as etiquetas no verso dos módulos dão o endereço em 8 bits, incluindo o bit de direção. Por exemplo, o verso de uma placa OLED diz “0x78”, mas o endereço no código é 0x3C; se um módulo LCD diz 0x4E, o endereço no código é 0x27. A regra é simples: divida o valor de 8 bits por 2 (desloque um bit para a direita) e você obtém o endereço de 7 bits. As bibliotecas do Arduino, do ESP32 e do MicroPython esperam todas endereços de 7 bits.

Resistores de pull-up: por que são necessários e como escolher o valor

Como os dispositivos de um barramento I2C só conseguem puxar as linhas para baixo, são os resistores de pull-up que fornecem o nível alto. Se o resistor for grande demais, a capacitância do barramento deixa lenta a passagem de 0 para 1, as bordas do sinal ficam arredondadas e os bits são lidos errado em velocidades altas. Se for pequeno demais, a corrente que um dispositivo precisa absorver para puxar a linha para baixo aumenta; o padrão só exige que um dispositivo absorva pelo menos 3 mA a 0,4 V, então o pull-up precisa manter a corrente abaixo disso.

Estas fórmulas dão os dois limites: a resistência mínima é R(min) = (VCC − 0,4 V) / 3 mA, e a máxima é R(max) = t(subida) / (0,8473 × C(barramento)). Para 5 V, R(min) = 4,6 V / 0,003 A ≈ 1,53 kΩ, e para 3,3 V é ≈ 0,97 kΩ. Em um barramento curto com 100 pF de capacitância, R(max) ≈ 11,8 kΩ a 100 kHz e ≈ 3,5 kΩ a 400 kHz. Por isso, na prática, 4,7 kΩ para 100 kHz e 2,2 kΩ para 400 kHz e barramentos cheios são os valores mais comuns. Você pode usar a ferramenta Código de cores de resistores para ler as faixas de um resistor e a ferramenta Constante de tempo RC para ver o atraso criado pela resistência e pela capacitância.

No Arduino Uno, chamar Wire.begin() também ativa os resistores de pull-up internos de 20–50 kΩ do ATmega328P. Com um único módulo e 10–20 cm de fio, eles muitas vezes funcionam, mas não são confiáveis; resistores externos são sempre melhores. Se você está usando uma placa de sensor simples sem pull-ups, não esqueça de colocar um resistor de 4,7 kΩ da SDA e da SCL até o VCC.

Pinos I2C: Arduino Uno, Mega, ESP32, ESP8266 e Pico

Passo a passo: encontrando endereços com um sketch scanner I2C

Quando você recebe um módulo novo, a primeira tarefa é descobrir os endereços dos dispositivos no barramento. Um scanner I2C envia uma mensagem vazia para cada endereço de 0x08 a 0x77 e lista os que respondem com um ACK. Assim você descobre tanto que o módulo está ligado corretamente quanto qual endereço precisa colocar no código.

1. Ligue o GND do módulo no GND do Arduino e o VCC no 5V (no 3.3V para módulos que só suportam 3,3 V).
2. Ligue a SDA no A4 e a SCL no A5. Se você tiver vários módulos, junte todos os pinos SDA e SCL deles na protoboard.
3. Carregue o sketch abaixo e abra o Monitor Serial em 115200 baud.
4. Anote os endereços listados. Se nada aparecer, confira a ligação, o GND comum e os resistores de pull-up.
5. Desconecte e reconecte os módulos um por um para confirmar qual endereço pertence a qual dispositivo; o scanner refaz a varredura a cada 5 segundos.

1#include <Wire.h>
2
3void printHex(byte addr) {
4  Serial.print(F("0x"));
5  if (addr < 16) Serial.print('0');    // tek haneliye sıfır ekle / pad single digit
6  Serial.print(addr, HEX);
7}
8
9void setup() {
10  Serial.begin(115200);
11  Wire.begin();                         // Uno: A4 = SDA, A5 = SCL
12#if defined(ARDUINO_ARCH_AVR)
13  Wire.setWireTimeout(3000, true);      // AVR (Uno, Nano, Mega): hat kilitlenirse 3 ms sonra kurtar / recover a stuck bus after 3 ms
14#endif
15  Serial.println(F("I2C tarayici / I2C scanner"));
16}
17
18void loop() {
19  byte found = 0;
20  for (byte addr = 0x08; addr <= 0x77; addr++) {   // geçerli 7 bit adresler / valid 7-bit addresses
21    Wire.beginTransmission(addr);
22    byte err = Wire.endTransmission();             // 0 = cihaz ACK verdi / device acknowledged
23    if (err == 0) {
24      Serial.print(F("Bulundu / found: "));
25      printHex(addr);
26      Serial.println();
27      found++;
28    } else if (err == 4 || err == 5) {
29      Serial.print(F("Hat hatasi / bus error at "));
30      printHex(addr);
31      Serial.println();
32    }
33  }
34  if (found == 0) {
35    Serial.println(F("Cihaz yok: kablolari ve pull-up'lari kontrol et / no devices: check wiring and pull-ups"));
36  } else {
37    Serial.print(found);
38    Serial.println(F(" cihaz bulundu / device(s) found"));
39  }
40  Serial.println();
41  delay(5000);                          // 5 sn sonra yeniden tara / rescan after 5 s
42}

A linha setWireTimeout no sketch é importante: quando a SDA ou a SCL está em curto, ou um dispositivo trava segurando a linha em nível baixo, a biblioteca Wire do Uno com as configurações padrão pode esperar para sempre e congelar o seu programa. Com o timeout ativado, a biblioteca desiste depois de 3 ms, reinicia o hardware I2C e o scanner informa o problema com um código de erro. A linha está dentro de um #if para ser compilada só em placas AVR (Uno, Nano, Mega); as bibliotecas Wire do ESP32 e do ESP8266 já vêm com a própria proteção de timeout, então o mesmo sketch compila e roda sem mudanças nas três plataformas.

I2C sem biblioteca: lendo e escrevendo registradores

As bibliotecas facilitam a vida, mas, por baixo, todas fazem a mesma coisa: enviam ao dispositivo o número do registrador e depois leem bytes desse registrador ou escrevem bytes nele. Fazer isso você mesmo uma vez significa que você consegue ler o datasheet de um sensor novo e usá-lo mesmo sem biblioteca. O exemplo abaixo acorda o sensor MPU6050 do modo de repouso, lê o registrador de identidade (WHO_AM_I) e depois calcula a temperatura e a aceleração no eixo Z a partir dos valores brutos.

1#include <Wire.h>
2
3const byte MPU_ADDR = 0x68;             // AD0 GND'de; AD0 = 3.3V ise 0x69 / AD0 low; 0x69 if AD0 high
4
5void writeReg(byte reg, byte value) {
6  Wire.beginTransmission(MPU_ADDR);
7  Wire.write(reg);                      // önce yazmaç adresi / register address first
8  Wire.write(value);                    // sonra veri / then the data
9  Wire.endTransmission();               // STOP gönder / send STOP
10}
11
12int16_t readWord(byte reg) {
13  Wire.beginTransmission(MPU_ADDR);
14  Wire.write(reg);
15  Wire.endTransmission(false);          // STOP yok, tekrarlı START / no STOP, repeated START
16  Wire.requestFrom(MPU_ADDR, (byte)2);  // 2 bayt iste / request 2 bytes
17  uint8_t hi = Wire.read();
18  uint8_t lo = Wire.read();
19  return (int16_t)(((uint16_t)hi << 8) | lo);
20}
21
22void setup() {
23  Serial.begin(115200);
24  Wire.begin();
25  Wire.setClock(400000);                // hızlı mod 400 kHz / fast mode 400 kHz
26  writeReg(0x6B, 0x00);                 // PWR_MGMT_1: uykudan uyandır / wake up from sleep
27  Wire.beginTransmission(MPU_ADDR);
28  Wire.write(0x75);                     // WHO_AM_I yazmacı / WHO_AM_I register
29  Wire.endTransmission(false);
30  Wire.requestFrom(MPU_ADDR, (byte)1);
31  Serial.print(F("WHO_AM_I = 0x"));
32  Serial.println(Wire.read(), HEX);     // 68 beklenir / expect 68
33}
34
35void loop() {
36  int16_t raw = readWord(0x41);         // TEMP_OUT_H ve TEMP_OUT_L / TEMP_OUT_H and TEMP_OUT_L
37  float tempC = raw / 340.0 + 36.53;    // veri sayfasındaki formül / datasheet formula
38  int16_t az = readWord(0x3F);          // Z ekseni ivmesi / Z-axis acceleration
39  Serial.print(F("Sicaklik / temp: "));
40  Serial.print(tempC, 1);
41  Serial.print(F(" C   AccZ: "));
42  Serial.println(az / 16384.0, 2);      // +-2g aralığında 16384 = 1 g / 16384 = 1 g at +-2g
43  delay(500);
44}

Repare na linha endTransmission(false) da função de leitura: ela muda a direção com um START repetido em vez de um STOP, então nenhum outro dispositivo consegue se intrometer e o sensor não esquece qual registrador foi pedido. Se o WHO_AM_I ler 0x68, a comunicação está perfeita. Em módulos clones baratos o valor pode ser 0x70 ou outro número; isso significa que o chip é um modelo compatível, mas diferente, como o MPU6500, e é por isso que algumas bibliotecas prontas dizem “sensor not found” (sensor não encontrado). A fórmula da temperatura (valor bruto / 340 + 36,53) vem direto do datasheet do MPU6050; para a aceleração na faixa de ±2 g, um valor bruto de 16384 equivale a 1 g, então um sensor deitado sobre a mesa mostra cerca de 1,00 no eixo Z.

Vários dispositivos em um barramento e conflitos de endereço

A maior vantagem do I2C é que você pode ligar dispositivos em paralelo nos mesmos dois fios, desde que os endereços sejam diferentes. Por exemplo, um LCD (0x27), um OLED (0x3C), um BMP280 (0x76) e um relógio DS3231 (0x68) compartilham numa boa os mesmos pinos A4 e A5; cada biblioteca fala com o próprio endereço enquanto os outros dispositivos só escutam. O problema começa quando dois dispositivos têm o mesmo endereço: os dois enviam ACK, os dados colidem e geralmente nenhum funciona. Estas são as formas de resolver:

• Mude o pino de endereço: se você ligar o pino AD0 do MPU6050 em 3,3 V, o endereço passa a ser 0x69 e o conflito com o DS3231 (0x68) acaba.
• Use os jumpers de solda: os jumpers A0–A2 dos módulos LCD oferecem 8 endereços, e o pino ADDR do ADS1115 oferece 4.
• Abra um segundo barramento I2C: passe o dispositivo em conflito para outros pinos com o Wire1 no ESP32 ou o I2C1 no Pico.
• Adicione um multiplexador I2C: o TCA9548A abre oito sub-barramentos separados a partir de um único endereço (0x70); dá até para ligar oito OLEDs com o mesmo endereço.
• Dispositivos com endereço fixo: alguns chips, como o DS1307 ou o HTU21D, têm um endereço que não pode ser mudado de jeito nenhum; para eles, só um barramento separado ou um multiplexador resolve.

I2C no ESP32: qualquer pino e dois barramentos separados

No ESP32, o hardware I2C pode ser direcionado aos pinos com flexibilidade. Os pinos padrão são o GPIO 21 (SDA) e o GPIO 22 (SCL), mas com Wire.begin(SDA, SCL) você escolhe praticamente quaisquer dois GPIOs. O ESP32 clássico e o ESP32-S3 têm dois controladores I2C, então você pode rodar dois sensores com o mesmo endereço em dois barramentos separados; o ESP32-C3 tem só um controlador. Os GPIO 34–39 são só de entrada e não podem ser usados para I2C. Para o mapa completo de pinos da placa, consulte a ferramenta de pinagem e, para uma introdução geral, veja O que é ESP32?.

1#include <Wire.h>
2
3// Klasik ESP32'de iki I2C denetleyicisi vardır: Wire ve Wire1 / the classic ESP32 has two I2C controllers: Wire and Wire1
4
5void scan(TwoWire &bus, const char *name) {
6  Serial.printf("%s:\n", name);
7  for (uint8_t addr = 0x08; addr <= 0x77; addr++) {
8    bus.beginTransmission(addr);
9    if (bus.endTransmission() == 0) {
10      Serial.printf("  bulundu / found 0x%02X\n", addr);
11    }
12  }
13}
14
15void setup() {
16  Serial.begin(115200);
17  Wire.begin(21, 22);                   // SDA, SCL: varsayılan pinler / default pins
18  Wire1.begin(32, 33, 400000);          // SDA, SCL, hız: başka iki GPIO / SDA, SCL, speed: any two other GPIOs
19  scan(Wire, "Wire  (SDA 21, SCL 22)");
20  scan(Wire1, "Wire1 (SDA 32, SCL 33)");
21}
22
23void loop() {
24}

I2C no Raspberry Pi Pico (MicroPython)

O chip RP2040 do Pico tem dois controladores, chamados I2C0 e I2C1, e cada um pode ser direcionado a vários pares de pinos diferentes. Para o I2C0 você pode usar GP0/GP1, GP4/GP5, GP8/GP9, GP12/GP13, GP16/GP17 e GP20/GP21; para o I2C1, GP2/GP3, GP6/GP7, GP10/GP11, GP14/GP15, GP18/GP19 e GP26/GP27. Em cada par, o pino de número par é a SDA e o de número ímpar é a SCL. No MicroPython o scanner tem uma linha só: i2c.scan() retorna uma lista com os endereços que respondem com ACK. Como o Pico funciona em 3,3 V, alimentar os módulos pelo pino 3V3(OUT) é a opção mais segura; embora o RP2040 também suporte o modo rápido plus de 1 MHz, ficar em 400 kHz na protoboard dá menos surpresas. Para os primeiros passos com o Pico, veja O que é Raspberry Pi Pico?.

1from machine import Pin, I2C
2
3i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # I2C0: GP4 = SDA, GP5 = SCL
4devices = i2c.scan()                                 # ACK veren adresler / addresses that ACK
5
6if devices:
7    for addr in devices:
8        print("Bulundu / found:", hex(addr))
9else:
10    print("Cihaz yok / no devices")
11
12# MPU6050 varsa WHO_AM_I yazmacını oku / if an MPU6050 is present, read WHO_AM_I
13if 0x68 in devices:
14    i2c.writeto_mem(0x68, 0x6B, b"\x00")             # uykudan uyandır / wake up
15    who = i2c.readfrom_mem(0x68, 0x75, 1)[0]
16    print("WHO_AM_I:", hex(who))                     # 0x68 beklenir / expect 0x68

Ideias de projetos com I2C

• Mini estação meteorológica: meça pressão e temperatura com um BMP280 e mostre os valores em um display OLED de 0,96 polegada; os dois módulos compartilham os mesmos dois fios.
• Relógio digital: leia a hora de um módulo de relógio DS3231 e mostre em um display LCD I2C.
• Indicador de inclinação: calcule o ângulo com um MPU6050 e desenhe o resultado no OLED como um nível de bolha.
• Nó de sensores com Wi-Fi: acompanhe pelo celular um sensor ligado aos pinos D1 e D2 de um ESP8266 NodeMCU.
• Braço robótico com 16 servos: controle 16 servos com só dois pinos usando um driver PCA9685.
• Registrador de dados: grave uma leitura por minuto em uma EEPROM AT24C256 para que os dados sobrevivam a uma queda de energia.

Erros comuns e como corrigir

O I2C é o jeito mais prático de adicionar displays, relógios, sensores e memória ao seu projeto com só dois fios; depois que você entende os endereços, os resistores de pull-up e o sketch scanner, resolve a maioria dos problemas em poucos minutos. No app BlueGrays você encontra projetos que usam I2C, como o display LCD I2C, o jogo Pong em um display OLED, um relógio digital com DS1307 e um display de previsão do tempo com ESP32, cada um com esquema do circuito e código passo a passo.