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?.

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ão | Arduino B (alvo) | Observação |
|---|---|---|---|
| A4 (SDA) | Direta | A4 (SDA) | Sem cruzar |
| A5 (SCL) | Direta | A5 (SCL) | Sem cruzar |
| GND | Direta | GND | Obrigatória: referência comum |
| 5V | Opcional | 5V | Só se a placa B for alimentada pela placa A |
| SDA e SCL | 4,7 kΩ para o 5V | - | Um par de resistores basta para o barramento inteiro |
| Placa | SDA | SCL | Observação |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | No Uno R3, os pinos SDA e SCL ao lado do AREF são o mesmo barramento |
| Arduino Mega 2560 | D20 | D21 | Tem resistores de pull-up de 10 kΩ na placa |
| Arduino Leonardo / Micro | D2 | D3 | Pinos diferentes dos do Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; com Wire.begin(sda, scl) dá para escolher outros pinos |
| Raspberry Pi Pico | GP4 (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ção | Pull-up recomendado | Observação |
|---|---|---|
| Dois Unos, fios com menos de 30 cm, 100 kHz | 4,7 kΩ (os internos também costumam funcionar) | A montagem mais comum |
| De 50 cm a 1 m de fio, ou 400 kHz | 2,2 kΩ | Mesmo assim, mantenha os fios o mais curtos possível |
| Há um Arduino Mega no barramento | Talvez você não precise de mais nenhum | Os 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 paralelo | O total não deve ficar abaixo de 1,5 kΩ |
| Arduino com ESP32 ou Pico | Os resistores de cada lado do conversor de nível lógico | Nã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ço | Módulos que costumam usá-lo |
|---|---|
| 0x27 / 0x3F | LCD I2C com adaptador PCF8574 |
| 0x3C / 0x3D | Display OLED SSD1306 |
| 0x68 | RTCs DS1307 e DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 e BME280 |
| 0x40 | Driver de servos PCA9685, INA219 |
| 0x48 | ADC ADS1115 |
| 0x57 | MAX30102, a EEPROM AT24C32 dos módulos RTC |
| 0x08–0x0F | Normalmente 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:
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:
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() | Significado | O que fazer |
|---|---|---|
| 0 | Sucesso, o alvo confirmou todos os bytes | - |
| 1 | Dados longos demais para o buffer (mais de 32 bytes) | Divida a mensagem em partes |
| 2 | Sem ACK no endereço | Confira o endereço, a fiação, o GND e se o alvo está alimentado |
| 3 | Sem ACK em um byte de dados | O alvo está ocupado ou recebeu um tamanho inesperado |
| 4 | Outro erro | O barramento pode estar com ruído ou sem pull-ups |
| 5 | Tempo limite esgotado | O 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:
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:
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.
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:
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?.
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ística | I2C | UART |
|---|---|---|
| Fios | SDA, SCL e GND (diretos) | TX, RX e GND (cruzados) |
| Número de dispositivos | Um controlador e até 112 endereços | Só dois dispositivos |
| Quem inicia a conversa? | Só o controlador | Qualquer um dos lados, quando quiser |
| Velocidade típica | 100 kHz ou 400 kHz | 9600–115200 baud |
| Distância | Dentro da placa e fios curtos (até 1 m) | Alguns metros; muito mais com RS-485 |
| Confirmação de entrega | Sim (ACK e NACK) | Não; você precisa acrescentar a sua própria verificação |
| Tamanho da mensagem (Wire) | Buffer de 32 bytes | Fluxo contínuo de bytes |
| Hardware no Arduino Uno | A4 e A5 | D0 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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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…

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.

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).

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.

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.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

