Fundamentos · 12 min de leitura

I2C mestre e escravo no Arduino: conecte dois Arduinos e envie structs

I2C mestre e escravo no Arduino: ligação entre dois Arduinos, valores de pull-up, Wire.onReceive e onRequest, escolha do endereço, envio de structs e conversão de nível com ESP32.

Uma ligação I2C mestre e escravo entre Arduinos é um dos jeitos mais práticos de conectar duas placas: ela precisa só de dois fios de dados (SDA e SCL) e de um GND comum, e fica pronta em poucas linhas com a biblioteca Wire, que já vem com o Arduino. Uma placa é o controlador (antes chamado de mestre, ou master) e é sempre ela que inicia a conversa; a outra é o alvo (o escravo, ou slave), que tem um endereço e ou escuta o que lhe enviam ou responde quando é consultado. Como dezenas de alvos podem dividir os mesmos dois fios, o I2C é muito útil em projetos em que uma placa principal gerencia vários Arduinos auxiliares.

Neste artigo conectamos dois Arduino Uno por I2C passo a passo: uma tabela de ligações e de pull-ups, a escolha do endereço, as funções Wire.onReceive e Wire.onRequest, o envio de um único byte, a troca de dados nos dois sentidos com uma struct, vários Arduinos no mesmo barramento, a comunicação com um ESP32 e com um Raspberry Pi Pico por meio de um conversor de nível lógico e uma comparação entre I2C e UART. Se você quiser revisar antes os fundamentos do I2C e o sketch do scanner, dê uma olhada em O que é I2C?.

Placa Arduino Uno
Arduino Uno: o barramento I2C fica nos pinos A4 (SDA) e A5 (SCL); nas placas R3, o mesmo barramento também sai nos pinos SDA e SCL ao lado do AREF.

Como funcionam o controlador e o alvo (mestre e escravo) no I2C?

No I2C, todos os dispositivos são ligados em paralelo às mesmas duas linhas. SCL é a linha de clock, e é sempre o controlador que a aciona; SDA é a linha de dados e leva dados nos dois sentidos. Para começar uma mensagem, o controlador gera uma condição de “start” e depois envia o endereço de 7 bits do alvo junto com um bit de leitura ou de escrita. O alvo que tem esse endereço responde com um ACK (recebi), puxando a linha para LOW por um instante no fim de cada byte; se ninguém tiver esse endereço, a linha continua em HIGH, o que se chama NACK. É por isso que, no I2C, o controlador sabe na hora se a mensagem chegou. A regra mais importante é esta: um alvo não pode falar por conta própria. Mesmo quando tem um dado novo, ele espera o controlador perguntar; por isso o controlador precisa consultá-lo com regularidade. A documentação do Arduino chama esses papéis de “controller” e “peripheral”, e a revisão mais recente do padrão I2C usa “controller” e “target”; eles significam a mesma coisa que master e slave nos códigos mais antigos.

Ligação: as conexões I2C entre dois Arduinos

Arduino A (controlador)ConexãoArduino B (alvo)Observação
A4 (SDA)DiretaA4 (SDA)Sem cruzar
A5 (SCL)DiretaA5 (SCL)Sem cruzar
GNDDiretaGNDObrigatória: referência comum
5VOpcional5VSó se a placa B for alimentada pela placa A
SDA e SCL4,7 kΩ para o 5V-Um par de resistores basta para o barramento inteiro
Ao contrário da UART, os fios do I2C não são cruzados: SDA vai em SDA e SCL vai em SCL. Una sempre também os GNDs das duas placas; sem um GND comum, a comunicação ou não se estabelece ou dá erros aleatórios. Você pode ler por que o terra comum é indispensável em GND e terra comum.
PlacaSDASCLObservação
Arduino Uno / NanoA4A5No Uno R3, os pinos SDA e SCL ao lado do AREF são o mesmo barramento
Arduino Mega 2560D20D21Tem resistores de pull-up de 10 kΩ na placa
Arduino Leonardo / MicroD2D3Pinos diferentes dos do Uno
ESP32GPIO 21GPIO 223,3 V; com Wire.begin(sda, scl) dá para escolher outros pinos
Raspberry Pi PicoGP4 (I2C0)GP5 (I2C0)3,3 V; no MicroPython dá para escolher outros pares de pinos

Resistores de pull-up: quando são necessários e com que valor?

Os dispositivos de um barramento I2C só conseguem puxar as linhas para LOW; quem as leva de volta para HIGH são os resistores de pull-up. Nas placas AVR do Arduino, o Wire.begin() ativa pull-ups internos de aproximadamente 20–50 kΩ em SDA e SCL. Com dois Unos, fios curtos e 100 kHz, isso costuma funcionar, mas esses resistores são fracos para o I2C; conforme os fios ficam mais longos, as bordas de subida ficam mais lentas e os erros começam. Para um barramento confiável, coloque um resistor de 4,7 kΩ de SDA para o 5V e outro de SCL para o 5V. O limite inferior vem dos 3 mA permitidos no estado LOW: R(mín) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. O limite superior é definido pela capacitância do barramento: a 100 kHz, para um barramento de 200 pF, R(máx) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Use a ferramenta Lei de Ohm para as contas e leia Resistores de pull-up e pull-down para entender a ideia por trás deles.

SituaçãoPull-up recomendadoObservação
Dois Unos, fios com menos de 30 cm, 100 kHz4,7 kΩ (os internos também costumam funcionar)A montagem mais comum
De 50 cm a 1 m de fio, ou 400 kHz2,2 kΩMesmo assim, mantenha os fios o mais curtos possível
Há um Arduino Mega no barramentoTalvez você não precise de mais nenhumOs resistores de 10 kΩ do Mega ficam em paralelo com os demais
Módulos com pull-ups no barramento (OLED, RTC, LCD)Calcule a resistência total em paraleloO total não deve ficar abaixo de 1,5 kΩ
Arduino com ESP32 ou PicoOs resistores de cada lado do conversor de nível lógicoNão ligue diretamente; veja a seção mais abaixo

Escolha do endereço: qual usar?

É você quem escolhe o endereço do Arduino alvo, com Wire.begin(endereço). No espaço de endereços de 7 bits, 0x00–0x07 e 0x78–0x7F são reservados, então a faixa que você pode usar é 0x08–0x77, ou de 8 a 119 em decimal. Se houver outros módulos no barramento, escolha um valor que não entre em conflito com os deles; o caminho mais seguro é ligar tudo e rodar o scanner I2C para ver quais endereços estão ocupados. Estes são os endereços dos módulos mais comuns:

EndereçoMódulos que costumam usá-lo
0x27 / 0x3FLCD I2C com adaptador PCF8574
0x3C / 0x3DDisplay OLED SSD1306
0x68RTCs DS1307 e DS3231, MPU-6050
0x76 / 0x77BMP280 e BME280
0x40Driver de servos PCA9685, INA219
0x48ADC ADS1115
0x57MAX30102, a EEPROM AT24C32 dos módulos RTC
0x08–0x0FNormalmente livres; uma boa faixa para alvos Arduino

Exemplo 1: enviando um byte do controlador para o alvo

No primeiro exemplo, a placa A lê um potenciômetro em A0, divide o valor por 4 para trazê-lo à faixa de 0–255 e o envia 10 vezes por segundo, como um único byte, para o endereço 8. A placa B recebe o byte e ajusta o brilho do LED em D9. Carregue primeiro o sketch do controlador na placa A e depois o sketch do alvo na placa B. A biblioteca Wire vem com a Arduino IDE, então não há nada para instalar. Sketch do controlador:

C++ (Arduino IDE)
1// Denetleyici (master): potansiyometre değerini hedefe gönderir / Controller (master): sends the pot value to the target
2#include <Wire.h>
3
4const byte TARGET_ADDR = 8;          // hedef kartın adresi / address of the target board
5
6void setup() {
7  Wire.begin();                      // adres verilmedi = denetleyici / no address = controller
8  Serial.begin(9600);
9}
10
11void loop() {
12  byte value = analogRead(A0) / 4;   // 0-1023 -> 0-255
13  Wire.beginTransmission(TARGET_ADDR);
14  Wire.write(value);
15  byte status = Wire.endTransmission();   // 0 = başarılı / 0 = success
16  if (status != 0) {
17    Serial.print(F("I2C hatasi / error: "));
18    Serial.println(status);          // 2 = adres yanıt vermedi / 2 = no ACK on address
19  }
20  delay(100);
21}

Sketch do alvo, para carregar na placa B:

C++ (Arduino IDE)
1// Hedef (slave): gelen baytla LED parlaklığını ayarlar / Target (slave): sets the LED brightness from the received byte
2#include <Wire.h>
3
4const byte MY_ADDR = 8;              // bu kartın adresi / this board's address
5const int LED_PIN = 9;               // PWM pini / PWM pin
6
7volatile byte received = 0;
8volatile bool newData = false;
9
10void onReceiveEvent(int howMany) {   // kesme içinde çalışır: kısa tut / runs inside an interrupt: keep it short
11  for (int i = 0; i < howMany; i++) received = Wire.read();   // son bayt kalır / keep the last byte
12  newData = true;
13}
14
15void setup() {
16  Wire.begin(MY_ADDR);               // adresle başlat = hedef / start with an address = target
17  Wire.onReceive(onReceiveEvent);
18  pinMode(LED_PIN, OUTPUT);
19  Serial.begin(9600);
20}
21
22void loop() {
23  if (newData) {
24    newData = false;
25    analogWrite(LED_PIN, received);
26    Serial.println(received);        // Serial'ı kesmenin dışında kullan / use Serial outside the interrupt
27  }
28}

O sketch do alvo tem dois pontos-chave. O primeiro é o Wire.begin(8): uma placa iniciada com um endereço vira um alvo. O segundo é o Wire.onReceive(): quando o controlador envia dados, a biblioteca Wire chama essa função sozinha e passa para ela o número de bytes recebidos. Guardamos o valor em uma variável volatile e apenas levantamos uma flag de “dado novo”; o ajuste do LED e a escrita no Monitor Serial acontecem no loop(). No controlador, o valor retornado por Wire.endTransmission() mostra o que aconteceu com a mensagem:

Valor de endTransmission()SignificadoO que fazer
0Sucesso, o alvo confirmou todos os bytes-
1Dados longos demais para o buffer (mais de 32 bytes)Divida a mensagem em partes
2Sem ACK no endereçoConfira o endereço, a fiação, o GND e se o alvo está alimentado
3Sem ACK em um byte de dadosO alvo está ocupado ou recebeu um tamanho inesperado
4Outro erroO barramento pode estar com ruído ou sem pull-ups
5Tempo limite esgotadoO barramento travou; ative a recuperação com setWireTimeout()

onReceive e onRequest: regras dentro da interrupção

  • Mantenha as funções curtas: as duas rodam dentro da interrupção do I2C. Não use delay(), Serial.print() nem cálculos demorados ali; guarde o dado em uma variável e saia.
  • Use volatile: declare como volatile as flags que mudam na interrupção e são lidas no loop(); senão o compilador pode não enxergar a mudança. Para mais detalhes, veja Interrupções no Arduino.
  • Escreva tudo de uma vez no onRequest: quando o controlador pedir dados, coloque todos os bytes no buffer com um único Wire.write(array, tamanho). Deixe os dados prontos com antecedência; ler um sensor dentro do onRequest deixa o controlador esperando.
  • O limite de 32 bytes: o buffer da Wire no AVR tem 32 bytes. Divida dados mais longos em várias mensagens ou, se realmente precisar, use UART.
  • Confira o tamanho: compare o número de bytes que chega no onReceive com o que você espera; se vierem bytes a mais ou a menos, leia-os e descarte-os.
  • Prepare a resposta com antecedência: atualize as variáveis do relatório antes de o alvo começar uma tarefa demorada, para que o controlador sempre encontre uma resposta pronta.

Exemplo 2: comunicação nos dois sentidos com uma struct

Projetos de verdade precisam de mais de um byte: o controlador envia um comando e o alvo devolve um relatório com vários valores. Em vez de dividir os valores em bytes na mão, é mais limpo e mais rápido definir uma struct e enviá-la do jeito que está. No exemplo abaixo, o controlador define o LED e o brilho dele com um comando de 2 bytes e depois usa Wire.requestFrom() para pedir ao alvo um relatório de 7 bytes: o valor do potenciômetro (uint16_t), o estado do botão (uint8_t) e o tempo que o alvo está ligado (uint32_t). As structs precisam ser idênticas nas duas placas. Sketch do controlador:

C++ (Arduino IDE)
1// Denetleyici: komut gönderir, rapor ister / Controller: sends a command, requests a report
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyici -> hedef / controller -> target (2 bayt / bytes)
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {    // hedef -> denetleyici / target -> controller (7 bayt / bytes)
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte TARGET_ADDR = 8;
16
17void setup() {
18  Wire.begin();
19  Wire.setClock(100000);                   // standart hız 100 kHz / standard mode 100 kHz
20  Wire.setWireTimeout(25000, true);        // hat takılırsa 25 ms'de kurtul / recover if the bus hangs for 25 ms
21  Serial.begin(9600);
22}
23
24void loop() {
25  Command cmd;
26  cmd.ledOn = 1;
27  cmd.brightness = (millis() / 20) % 256;  // yavaşça artan parlaklık / slowly rising brightness
28
29  Wire.beginTransmission(TARGET_ADDR);
30  Wire.write((const uint8_t*)&cmd, sizeof(cmd));
31  byte err = Wire.endTransmission();
32
33  Report r;
34  byte n = Wire.requestFrom(TARGET_ADDR, (byte)sizeof(Report));
35  if (err == 0 && n == sizeof(Report)) {
36    Wire.readBytes((uint8_t*)&r, sizeof(r));
37    Serial.print(F("Pot: "));
38    Serial.print(r.potValue);
39    Serial.print(F("  Buton / button: "));
40    Serial.print(r.buttonPressed);
41    Serial.print(F("  Sure / uptime ms: "));
42    Serial.println(r.uptimeMs);
43  } else {
44    while (Wire.available()) Wire.read();  // yarım veriyi at / drop partial data
45    Serial.println(F("Hedef yanit vermedi / target not responding"));
46  }
47  delay(200);
48}

O sketch da placa alvo; as definições das structs são exatamente as mesmas do controlador:

C++ (Arduino IDE)
1// Hedef: komutu uygular, istenince rapor gönderir / Target: applies the command, sends a report on request
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyicideki yapının aynısı / same struct as on the controller
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte MY_ADDR = 8;
16const int LED_PIN = 9;
17const int BUTTON_PIN = 2;
18
19Command cmd;
20Report report;
21volatile bool newCmd = false;
22
23void onReceiveEvent(int howMany) {
24  if (howMany != sizeof(Command)) {        // beklenmeyen uzunluk: at / unexpected length: discard
25    while (Wire.available()) Wire.read();
26    return;
27  }
28  Wire.readBytes((uint8_t*)&cmd, sizeof(cmd));
29  newCmd = true;
30}
31
32void onRequestEvent() {                    // denetleyici veri istedi / the controller asked for data
33  Wire.write((const uint8_t*)&report, sizeof(report));   // tek seferde yaz / write it in one go
34}
35
36void setup() {
37  pinMode(LED_PIN, OUTPUT);
38  pinMode(BUTTON_PIN, INPUT_PULLUP);
39  Wire.begin(MY_ADDR);
40  Wire.onReceive(onReceiveEvent);
41  Wire.onRequest(onRequestEvent);
42}
43
44void loop() {
45  uint16_t pot = analogRead(A0);
46  uint8_t pressed = (digitalRead(BUTTON_PIN) == LOW);
47  uint32_t now = millis();
48
49  noInterrupts();                          // kopyalarken onRequest araya girmesin / keep onRequest out while copying
50  report.potValue = pot;
51  report.buttonPressed = pressed;
52  report.uptimeMs = now;
53  Command c = cmd;
54  bool fresh = newCmd;
55  newCmd = false;
56  interrupts();
57
58  if (fresh) analogWrite(LED_PIN, c.ledOn ? c.brightness : 0);
59}

No sketch do alvo, a função registrada com Wire.onRequest() envia a struct do relatório do jeito que está sempre que o controlador pede dados. O relatório em si é atualizado no loop(). Durante a atualização, pausamos as interrupções por um instante com noInterrupts(); assim, se o controlador perguntar exatamente nesse momento, ele não recebe um valor metade antigo e metade novo. O comando recebido também é copiado para uma variável local dentro dessa mesma proteção. No controlador, a linha Wire.setWireTimeout(25000, true) evita que o barramento fique travado para sempre se um fio se soltar ou se o alvo travar: se não houver resposta em 25 ms, a Wire se reinicia sozinha.

Nas suas structs, use sempre tipos de tamanho fixo, como uint8_t, int16_t e uint32_t. No Arduino Uno um int tem 2 bytes; no ESP32, 4. Um double tem 4 bytes no Uno e 8 no ESP32. O __attribute__((packed)) impede o compilador de inserir bytes de preenchimento entre os campos; sem ele, a mesma struct teria 7 bytes no Uno e 8 no ESP32, e os dados ficariam deslocados. Tanto o AVR quanto o ESP32 são little-endian, então a ordem dos bytes coincide. Para relembrar bits e bytes, veja Sistemas numéricos e operações bit a bit.

Conectando vários Arduinos ao mesmo barramento

A grande vantagem do I2C sobre a UART é que muitos alvos podem dividir os mesmos dois fios. Dê a cada placa alvo um endereço próprio (por exemplo, 8, 9 e 10), una todos os SDAs, todos os SCLs e todos os GNDs e use um único par de resistores de pull-up para o barramento inteiro. O controlador pode percorrer um array de endereços, enviando um comando a cada placa e pedindo o relatório dela. Quanto mais longo o barramento, maior a capacitância; mantenha as placas próximas, limite o comprimento total dos fios a algumas dezenas de centímetros e, se for preciso, fique nos 100 kHz. Você também pode colocar no mesmo barramento módulos como um LCD I2C ou um OLED; desde que os endereços não entrem em conflito, tudo funciona bem em conjunto.

I2C entre Arduino e ESP32: conversão de nível

O Arduino Uno funciona com 5 V e o ESP32 com 3,3 V, e os pinos do ESP32 não toleram 5 V. Como o Wire.begin() do Uno liga os pull-ups internos aos 5 V, conectar as duas placas diretamente puxa os pinos do ESP32 para 5 V. O caminho inverso também dá problema: se você puxar o barramento só para 3,3 V, as entradas I2C do Uno precisam de pelo menos 0,7 × 5 V = 3,5 V para ler HIGH, e 3,3 V não chegam lá. A solução correta é um conversor de nível BSS138 bidirecional, com resistores de pull-up dos dois lados: o lado HV vai para o 5V e para A4/A5 do Uno, o lado LV vai para o 3V3 e para os GPIO 21/22 do ESP32, e os GNDs são comuns. Para a ligação detalhada, veja Conversor de nível lógico. O ESP32 também pode atuar como alvo a partir da versão 2.0.1 do core, mas preparar os dados bem na hora do onRequest é mais difícil no ESP32; por isso a montagem que dá menos trabalho é o ESP32 como controlador e o Uno como alvo. O sketch abaixo lê o mesmo relatório do Uno alvo do Exemplo 2:

C++ (Arduino IDE)
1// ESP32 denetleyici, Arduino Uno hedeften rapor okur / ESP32 controller reads the report from an Arduino Uno target
2#include <Wire.h>
3
4struct __attribute__((packed)) Report {    // Uno'daki yapıyla birebir aynı / exactly the same as on the Uno
5  uint16_t potValue;
6  uint8_t buttonPressed;
7  uint32_t uptimeMs;
8};
9
10const uint8_t TARGET_ADDR = 8;
11
12void setup() {
13  Serial.begin(115200);
14  Wire.begin(21, 22);                      // SDA = GPIO 21, SCL = GPIO 22 (seviye dönüştürücü üzerinden / through a level shifter)
15  Wire.setClock(100000);
16}
17
18void loop() {
19  Report r;
20  uint8_t n = Wire.requestFrom(TARGET_ADDR, (uint8_t)sizeof(Report));
21  if (n == sizeof(Report)) {
22    Wire.readBytes((uint8_t*)&r, sizeof(r));
23    Serial.printf("Pot: %u  Buton / button: %u  Sure / uptime: %lu ms\n",
24                  (unsigned int)r.potValue, (unsigned int)r.buttonPressed, (unsigned long)r.uptimeMs);
25  } else {
26    Serial.println("Uno yanit vermedi / Uno not responding");
27  }
28  delay(500);
29}

Controlador I2C no Raspberry Pi Pico (MicroPython)

O Raspberry Pi Pico também funciona com 3,3 V, então ele se conecta ao Uno do mesmo jeito, por meio de um conversor de nível lógico. O MicroPython não tem as structs do C, mas o módulo struct faz o mesmo trabalho: o formato "<HBI" significa um uint16_t, um uint8_t e um uint32_t em little-endian e sem preenchimento, o que corresponde exatamente ao relatório de 7 bytes do Uno. O código primeiro varre o barramento e mostra os endereços que encontrou; depois envia um comando ao Uno alvo e lê o relatório dele. Se você está começando com o Pico, comece por O que é o Raspberry Pi Pico?.

MicroPython
1from machine import I2C, Pin
2import struct, time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)   # seviye dönüştürücü üzerinden / through a level shifter
5print("Bulunan adresler / found:", [hex(a) for a in i2c.scan()])
6
7while True:
8    i2c.writeto(8, bytes([1, 128]))                  # Command: ledOn = 1, brightness = 128
9    data = i2c.readfrom(8, 7)                        # Report: 7 bayt / 7 bytes
10    pot, button, uptime = struct.unpack("<HBI", data)   # küçük endian, dolgusuz / little-endian, no padding
11    print("Pot:", pot, "Buton:", button, "ms:", uptime)
12    time.sleep(0.5)

I2C ou UART? Uma comparação

CaracterísticaI2CUART
FiosSDA, SCL e GND (diretos)TX, RX e GND (cruzados)
Número de dispositivosUm controlador e até 112 endereçosSó dois dispositivos
Quem inicia a conversa?Só o controladorQualquer um dos lados, quando quiser
Velocidade típica100 kHz ou 400 kHz9600–115200 baud
DistânciaDentro da placa e fios curtos (até 1 m)Alguns metros; muito mais com RS-485
Confirmação de entregaSim (ACK e NACK)Não; você precisa acrescentar a sua própria verificação
Tamanho da mensagem (Wire)Buffer de 32 bytesFluxo contínuo de bytes
Hardware no Arduino UnoA4 e A5D0 e D1 (compartilhados com o USB) ou SoftwareSerial

Resumindo: escolha o I2C quando as placas estiverem na mesma caixa, quando uma placa principal for gerenciar várias auxiliares e quando você quiser ter certeza de que cada mensagem chegou. Se as placas estiverem a vários metros uma da outra, se os dois lados precisarem enviar dados quando quiserem ou se houver um fluxo de dados longo e contínuo, a UART é a melhor opção; os detalhes estão em Comunicação serial UART. Se você precisar de muita velocidade, a terceira opção é o SPI.

Erros comuns e como resolver

  • endTransmission() retorna 2: o alvo não está respondendo nesse endereço. Confira se o endereço é o mesmo nos dois sketches, se SDA e SCL não estão trocados, se o GND está ligado e se o sketch do alvo foi carregado; confirme o endereço com o scanner I2C.
  • Cruzar SDA e SCL como na UART: no I2C, SDA vai em SDA e SCL em SCL; com os fios cruzados, nenhum dispositivo é encontrado.
  • O programa congela dentro do onReceive: a função da interrupção usa Serial.print() ou delay(), ou inicia outra transação da Wire. Ali, só copie os dados e faça o trabalho no loop().
  • Os valores chegam embaralhados ou deslocados: as definições das structs são diferentes entre as placas, foi usado um tipo como int, cujo tamanho depende da placa, ou falta o packed. Use tipos de tamanho fixo e a mesma definição.
  • Erros aleatórios quando os fios ficam mais longos: os pull-ups internos não bastam. Acrescente resistores externos de 4,7 kΩ ou 2,2 kΩ, encurte os fios e mantenha a velocidade em 100 kHz.
  • O barramento para de funcionar ou o ESP32 esquenta depois de conectado: 5 V e 3,3 V foram ligados diretamente. Coloque um conversor de nível lógico bidirecional no meio.

Fazer dois Arduinos conversarem por I2C é o jeito mais fácil de dividir um projeto grande em partes pequenas e independentes: uma placa cuida do display e do usuário enquanto as outras leem sensores ou acionam motores. Primeiro confirme a ligação com o exemplo de um único byte e depois passe para o exemplo de struct nos dois sentidos. No app BlueGrays você encontra os esquemas do circuito e o código passo a passo dos projetos de comunicação entre 2 Arduinos em um sentido e nos dois sentidos, do LCD I2C, da calculadora I2C, do LCD I2C com ESP32 e do relógio com RTC DS1307.

Perguntas frequentes

Como dois Arduinos se comunicam por I2C?

Ligue diretamente os pinos A4 (SDA), A5 (SCL) e GND das duas placas. Uma placa inicia como controlador com Wire.begin(), e a outra como alvo, com um endereço, por exemplo Wire.begin(8). O controlador envia dados com beginTransmission, write e endTransmission e pede dados com requestFrom; o alvo responde por meio das funções onReceive e onRequest.

Preciso de resistores de pull-up no I2C entre dois Arduinos?

Sim; as linhas do I2C são de dreno aberto (open-drain), então o nível HIGH vem dos resistores de pull-up. Os pull-ups internos do Arduino costumam funcionar com duas placas e fios curtos, mas, para um barramento confiável, o recomendado é colocar 4,7 kΩ de SDA e de SCL para o 5V.

Quantos Arduinos podem ser conectados em um barramento I2C?

Com endereçamento de 7 bits, dá para usar 112 endereços, de 0x08 a 0x77; então, em teoria, cabem 112 alvos. Na prática, o limite é definido pela capacitância total do barramento e pelo comprimento dos fios; com algumas placas e fios curtos você não terá problema nenhum.

Um Arduino escravo pode enviar dados ao mestre por conta própria?

Não. No I2C é sempre o controlador que inicia a comunicação; o alvo só responde, pelo onRequest, quando é consultado. Se o alvo precisar avisar que tem um dado novo, ou o controlador o consulta com regularidade, ou o alvo puxa para LOW um pino de interrupção separado para alertar o controlador.

Posso conectar um Arduino e um ESP32 diretamente por I2C?

Não é recomendado. O Uno funciona com 5 V e o ESP32 com 3,3 V, e os pull-ups internos do Uno puxam os pinos do ESP32 para 5 V. Use um conversor de nível lógico bidirecional, como o BSS138, e faça do ESP32 o controlador e do Uno o alvo.

Qual é a diferença entre I2C e UART no Arduino?

O I2C coloca muitos dispositivos no mesmo barramento, com dois fios e endereços, e confirma com um ACK que cada byte chegou, mas só o controlador pode iniciar uma conversa. A UART liga apenas dois dispositivos, tem os fios cruzados e qualquer um dos lados pode enviar dados quando quiser. O I2C é indicado para várias placas próximas umas das outras; a UART, para fios longos e fluxos contínuos de dados.

Ver todos os projetos
Comunicação unidirecional entre 2 Arduinos
AR-57Intermediário
Premium

Comunicação unidirecional entre 2 Arduinos

Faça dois Arduinos conversarem por um único fio: ao pressionar o botão de um, o LED do outro acende; ao pressionar de novo, ele apaga.

4.4(37)
50
Comunicação bidirecional entre 2 Arduinos
AR-58Intermediário
Premium

Comunicação bidirecional entre 2 Arduinos

Dois Arduinos se conectam por fios e conversam entre si: ao pressionar o botão de um, a luz do outro acende; ao pressionar novamente, ela apaga.

4.5(20)
26
Uso do display LCD com I2C
AR-32Iniciante
Premium

Uso do display LCD com I2C

Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

4.8(53)
70
Calculadora I2C com Arduino
AR-94Intermediário
Premium

Calculadora I2C com Arduino

Projeto de calculadora com Arduino que faz operações de adição, subtração, multiplicação e divisão usando um teclado de membrana 4x4 e um display LCD I2C 16x2. Com I2C, a conexão do display usa apenas 2 fios, reduzindo a quantidade de cabos e deixando mais pinos livres. Também permite inserir números decimais e negativos.

5.0(31)
43
Display LCD I2C com ESP32 (16x2)
ES-17Intermediário
Premium

Display LCD I2C com ESP32 (16x2)

Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

4.9(23)
40
Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermediário
Premium

Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)

Neste projeto, exibimos a hora e a data em um display LCD I2C 16x2 usando o módulo de relógio de tempo real (RTC) DS1307. O DS1307 é um RTC com bateria de reserva que mantém a hora mesmo quando o ESP32 é desligado. Os dois módulos compartilham o mesmo barramento I2C (SDA/SCL), permitindo aprender a controlar vários dispositivos com apenas dois fios de sinal. Você aprenderá na prática o protocolo de comunicação I2C, o funcionamento dos módulos RTC e a exibição de dados dinâmicos em um LCD.

4.6(26)
40
Jogo de bola e raquetes - SSD1306
AR-86Intermediário
Premium

Jogo de bola e raquetes - SSD1306

Uma bola, duas raquetes e você: jogue tênis de mesa, um dos primeiros videogames, em um pequeno display OLED.

4.5(47)
65
Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
AR-84Intermediário
Premium

Relógio e calendário de matriz de LEDs (MAX7219, DS1307)

Um painel luminoso para a mesa ou a parede que mostra a hora e a data em texto deslizante.

5.0(37)
59