Comunicazione I2C tra due Arduino: master-slave e struct
Comunicazione I2C tra due Arduino passo passo: collegamento master-slave, resistenze di pull-up, Wire.onReceive e onRequest, indirizzo, struct ed ESP32.
La comunicazione I2C tra due Arduino è uno dei modi più pratici per collegarli: usa solo due fili di dati (SDA e SCL) e una massa comune, e si imposta in poche righe con la libreria Wire inclusa in Arduino. Una delle schede è il controller (un tempo chiamato master) ed è sempre lei ad avviare la comunicazione; l'altra è il target (lo slave), che ha un indirizzo e ascolta ciò che le viene scritto o risponde quando viene interrogata. Dato che decine di target possono condividere gli stessi due fili, l'I2C è utilissimo nei progetti in cui una scheda principale gestisce diversi Arduino ausiliari.
In questo articolo colleghiamo passo passo due Arduino Uno in I2C: tabella dei collegamenti e dei pull-up, scelta dell'indirizzo, le funzioni Wire.onReceive e Wire.onRequest, invio di un singolo byte, scambio bidirezionale con uno struct, più Arduino sullo stesso bus, comunicazione con ESP32 e Raspberry Pi Pico tramite un convertitore di livello e un confronto tra I2C e UART. Se vuoi prima ripassare le basi dell'I2C e lo sketch scanner, leggi Cos'è l'I2C?.

Come funzionano controller e target (master e slave) nell'I2C?
Nell'I2C tutti i dispositivi sono collegati in parallelo alle stesse due linee. SCL è la linea di clock, generata sempre dal controller; SDA è la linea dati e viene usata in entrambe le direzioni. Per iniziare un messaggio il controller crea una condizione di "start" e poi invia l'indirizzo a 7 bit del target insieme al bit di lettura o scrittura. Il target con quell'indirizzo risponde con un ACK (ricevuto), portando la linea a LOW per un istante alla fine di ogni byte; se nessuno ha quell'indirizzo, la linea resta HIGH e si parla di NACK. Per questo nell'I2C il controller sa subito se un messaggio è arrivato. La regola più importante è questa: un target non può parlare di sua iniziativa. Anche se ha un dato nuovo, aspetta che il controller lo interroghi; il controller deve quindi chiedergli a intervalli regolari. Nella documentazione Arduino questi ruoli si chiamano "controller" e "peripheral", nella versione più recente dello standard I2C "controller" e "target"; indicano la stessa cosa del master e dello slave dei codici più vecchi.
Collegamenti: i fili I2C tra due Arduino
| Arduino A (controller) | Collegamento | Arduino B (target) | Nota |
|---|---|---|---|
| A4 (SDA) | Diretto | A4 (SDA) | Non incrociato |
| A5 (SCL) | Diretto | A5 (SCL) | Non incrociato |
| GND | Diretto | GND | Obbligatorio: riferimento comune |
| 5V | Facoltativo | 5V | Solo se la scheda B è alimentata dalla A |
| SDA e SCL | Con 4,7 kΩ verso 5V | - | Basta una coppia di resistenze per tutto il bus |
| Scheda | SDA | SCL | Nota |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | Sull'Uno R3 i pin SDA e SCL accanto ad AREF sono lo stesso bus |
| Arduino Mega 2560 | D20 | D21 | Ha resistenze di pull-up da 10 kΩ sulla scheda |
| Arduino Leonardo / Micro | D2 | D3 | Pin diversi dall'Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; con Wire.begin(sda, scl) puoi scegliere altri pin |
| Raspberry Pi Pico | GP4 (I2C0) | GP5 (I2C0) | 3,3 V; in MicroPython puoi scegliere altre coppie di pin |
Resistenze di pull-up: quando servono e di che valore?
I dispositivi di un bus I2C possono solo portare le linee a LOW; a riportarle a HIGH sono le resistenze di pull-up. Sulle schede AVR di Arduino, Wire.begin() attiva su SDA e SCL pull-up interni di circa 20–50 kΩ. Con due Uno, cavi corti e 100 kHz di solito funziona, ma per l'I2C sono resistenze deboli; più i cavi sono lunghi, più i fronti di salita rallentano e più compaiono errori. Per un bus affidabile aggiungi una resistenza da 4,7 kΩ da SDA a 5V e un'altra da SCL a 5V. Il limite inferiore deriva dai 3 mA ammessi nello stato LOW: R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. Quello superiore dipende dalla capacità del bus: a 100 kHz, per un bus da 200 pF, R(max) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Per i calcoli usa lo strumento Legge di Ohm, per il principio l'articolo Resistenze di pull-up e pull-down.
| Situazione | Pull-up consigliato | Nota |
|---|---|---|
| Due Uno, cavi sotto i 30 cm, 100 kHz | 4,7 kΩ (spesso funzionano anche quelli interni) | La configurazione più comune |
| Cavi da 50 cm a 1 m o 400 kHz | 2,2 kΩ | Tieni comunque i cavi il più corti possibile |
| Sul bus c'è un Arduino Mega | Potrebbero non servirne altri | Le 10 kΩ del Mega finiscono in parallelo alle altre |
| Sul bus ci sono moduli con pull-up (OLED, RTC, LCD) | Calcola la resistenza totale in parallelo | Il totale non deve scendere sotto 1,5 kΩ |
| Arduino con ESP32 o Pico | Quelle del convertitore di livello, su entrambi i lati | Non collegarli direttamente, vedi la sezione più sotto |
Scelta dell'indirizzo: quale usare?
L'indirizzo dell'Arduino target lo scegli tu con Wire.begin(indirizzo). Nello spazio a 7 bit gli indirizzi 0x00–0x07 e 0x78–0x7F sono riservati, quindi l'intervallo utilizzabile è 0x08–0x77, cioè da 8 a 119 in decimale. Se sul bus ci sono altri moduli, scegli un valore che non vada in conflitto con i loro; la cosa più sicura è collegare tutto e lanciare lo scanner I2C per vedere quali indirizzi sono occupati. Questi sono gli indirizzi dei moduli più diffusi:
| Indirizzo | Moduli che lo usano spesso |
|---|---|
| 0x27 / 0x3F | LCD I2C con PCF8574 |
| 0x3C / 0x3D | Display OLED SSD1306 |
| 0x68 | RTC DS1307 e DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 e BME280 |
| 0x40 | Driver per servo PCA9685, INA219 |
| 0x48 | ADC ADS1115 |
| 0x57 | MAX30102, EEPROM AT24C32 dei moduli RTC |
| 0x08–0x0F | Di solito liberi; un buon intervallo per target Arduino |
Esempio 1: inviare un byte dal controller al target
Nel primo esempio la scheda A legge un potenziometro su A0, divide il valore per 4 per portarlo tra 0 e 255 e lo invia 10 volte al secondo come singolo byte all'indirizzo 8. La scheda B riceve il byte e regola la luminosità del LED su D9. Carica prima lo sketch del controller sulla scheda A e poi quello del target sulla scheda B. La libreria Wire è già inclusa nell'Arduino IDE, non serve installarla. Sketch del controller:
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 del target da caricare sulla scheda 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}Lo sketch del target ha due punti chiave. Il primo è Wire.begin(8): una scheda avviata con un indirizzo diventa un target. Il secondo è Wire.onReceive(): quando il controller invia dati, la libreria Wire chiama da sola questa funzione e le passa il numero di byte ricevuti. Salviamo il valore in una variabile volatile e alziamo solo un flag di "nuovo dato"; regolare il LED e scrivere sul Monitor Seriale avviene in loop(). Sul controller, il valore restituito da Wire.endTransmission() ti dice che fine ha fatto il messaggio:
| Valore di endTransmission() | Significato | Cosa fare? |
|---|---|---|
| 0 | Successo, il target ha confermato ogni byte | - |
| 1 | Dati troppo lunghi per il buffer (oltre 32 byte) | Dividi il messaggio in parti |
| 2 | Nessun ACK sull'indirizzo | Controlla indirizzo, collegamenti, GND e che il target sia alimentato |
| 3 | Nessun ACK su un byte di dati | Il target è occupato o ha ricevuto una lunghezza inattesa |
| 4 | Altro errore | Il bus può essere disturbato o mancare i pull-up |
| 5 | Timeout | Il bus si è bloccato; attiva il ripristino con setWireTimeout() |
onReceive e onRequest: regole dentro l'interrupt
- Tienile brevi: entrambe le funzioni girano dentro l'interrupt I2C. Non usare delay(), Serial.print() né calcoli lunghi; salva il dato in una variabile ed esci.
- Usa volatile: dichiara volatile i flag che cambiano nell'interrupt e vengono letti in loop(); altrimenti il compilatore potrebbe non accorgersi della modifica. Dettagli nell'articolo Interrupt su Arduino.
- In onRequest scrivi tutto in una volta: quando il controller chiede dati, metti tutti i byte nel buffer con un solo Wire.write(array, lunghezza). Prepara i dati in anticipo; leggere un sensore dentro onRequest fa aspettare il controller.
- Il limite di 32 byte: il buffer di Wire su AVR è di 32 byte. Dividi i dati più lunghi in più messaggi o, se serve davvero, usa la UART.
- Controlla la lunghezza: confronta il numero di byte arrivati in onReceive con quello atteso; se sono troppi o troppo pochi, leggili e scartali.
- Prepara la risposta prima: aggiorna le variabili del report prima che il target inizi un lavoro lungo; così il controller trova sempre una risposta pronta.
Esempio 2: comunicazione bidirezionale con uno struct
Nei progetti reali serve più di un byte: il controller invia un comando e il target restituisce un report con più valori. Invece di spezzare i valori in byte a mano, è più leggibile e veloce definire uno struct e inviarlo così com'è. Nell'esempio qui sotto il controller imposta il LED e la sua luminosità con un comando da 2 byte, poi con Wire.requestFrom() chiede al target un report da 7 byte: il valore del potenziometro (uint16_t), lo stato del pulsante (uint8_t) e da quanto tempo è acceso il target (uint32_t). Le strutture devono essere identiche sulle due schede. Sketch del controller:
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}Sketch della scheda target; le definizioni delle strutture sono esattamente le stesse del controller:
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}Nello sketch del target, la funzione registrata con Wire.onRequest() invia la struttura del report così com'è quando il controller chiede dati. Il report vero e proprio viene aggiornato in loop(). Durante l'aggiornamento sospendiamo per un attimo gli interrupt con noInterrupts(); così, se il controller interroga proprio in quell'istante, non riceve un valore metà vecchio e metà nuovo. Anche il comando ricevuto viene copiato in una variabile locale sotto la stessa protezione. Sul controller, la riga Wire.setWireTimeout(25000, true) impedisce che il bus resti bloccato per sempre se un cavo si allenta o il target si blocca: se non arriva risposta entro 25 ms, Wire si resetta da sola.
Collegare più Arduino allo stesso bus
Il grande vantaggio dell'I2C rispetto alla UART è che molti target possono condividere gli stessi due fili. Dai a ogni scheda target un indirizzo diverso (per esempio 8, 9 e 10), unisci tutte le SDA, tutte le SCL e tutte le GND e usa una sola coppia di resistenze di pull-up per l'intero bus. Il controller può scorrere un array di indirizzi, inviare un comando a ogni scheda e chiederle il report. Più il bus è lungo, più aumenta la sua capacità; tieni le schede vicine, la lunghezza totale dei cavi entro qualche decina di centimetri e, se serve, resta a 100 kHz. Sullo stesso bus puoi usare anche moduli come un LCD I2C o un OLED; finché gli indirizzi non si sovrappongono, tutto funziona insieme senza problemi.
I2C tra Arduino ed ESP32: conversione di livello
Arduino Uno lavora a 5 V e l'ESP32 a 3,3 V, e i pin dell'ESP32 non tollerano i 5 V. Poiché sull'Uno Wire.begin() collega i pull-up interni ai 5 V, unire direttamente le due schede porta i pin dell'ESP32 a 5 V. Anche il contrario è un problema: se porti il bus solo a 3,3 V, gli ingressi I2C dell'Uno chiedono almeno 0,7 × 5 V = 3,5 V per leggere HIGH, e 3,3 V restano sotto. La soluzione corretta è un convertitore di livello bidirezionale BSS138 con pull-up su entrambi i lati: il lato HV va al 5V e ad A4/A5 dell'Uno, il lato LV al 3V3 e ai GPIO 21/22 dell'ESP32, le GND sono in comune. Per il collegamento dettagliato leggi Convertitore di livello logico. L'ESP32 può fare anche da target dalla versione 2.0.1 del core, ma preparare i dati proprio al momento di onRequest è più difficile; per questo la configurazione meno problematica è l'ESP32 come controller e l'Uno come target. Lo sketch qui sotto legge lo stesso report dal target Uno dell'esempio 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}Controller I2C con il Raspberry Pi Pico (MicroPython)
Anche il Raspberry Pi Pico lavora a 3,3 V, quindi si collega all'Uno allo stesso modo, tramite un convertitore di livello. MicroPython non ha gli struct del C, ma il modulo struct fa lo stesso lavoro: il formato "<HBI" significa un uint16_t, un uint8_t e un uint32_t in little-endian senza riempimento e corrisponde esattamente al report da 7 byte dell'Uno. Il codice prima scansiona il bus e stampa gli indirizzi trovati, poi invia un comando al target Uno e ne legge il report. Se sei alle prime armi con il Pico, parti da Cos'è il 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 o UART? Il confronto
| Caratteristica | I2C | UART |
|---|---|---|
| Fili | SDA, SCL e GND (diretti) | TX, RX e GND (incrociati) |
| Numero di dispositivi | Un controller e fino a 112 indirizzi | Solo due dispositivi |
| Chi avvia la comunicazione? | Solo il controller | Entrambi i lati, quando vogliono |
| Velocità tipica | 100 kHz o 400 kHz | 9600–115200 baud |
| Distanza | Sulla scheda e cavi corti (fino a 1 m) | Qualche metro; molto di più con RS-485 |
| Conferma di consegna | Sì (ACK e NACK) | No; va aggiunta a mano |
| Dimensione dei messaggi (Wire) | Buffer da 32 byte | Flusso continuo di byte |
| Hardware su Arduino Uno | A4 e A5 | D0 e D1 (condivisi con l'USB) o SoftwareSerial |
In breve: scegli l'I2C quando le schede stanno nella stessa scatola, quando una scheda principale deve gestire più ausiliarie e quando vuoi essere sicuro che ogni messaggio arrivi. Se le schede sono a diversi metri di distanza, se entrambi i lati devono poter inviare in qualsiasi momento o se c'è un flusso di dati lungo e continuo, è più adatta la UART; i dettagli sono nell'articolo Comunicazione seriale UART. Se ti serve tanta velocità, la terza opzione è l'SPI.
Errori comuni e soluzioni
- endTransmission() restituisce 2: il target non risponde a quell'indirizzo. Controlla che l'indirizzo sia lo stesso nei due sketch, che SDA e SCL non siano invertiti, che la GND sia collegata e che lo sketch del target sia caricato; conferma l'indirizzo con lo scanner I2C.
- Incrociare SDA e SCL come nella UART: nell'I2C SDA va su SDA e SCL su SCL; con i fili incrociati non viene trovato nessun dispositivo.
- Il programma si blocca dentro onReceive: nella funzione di interrupt ci sono Serial.print() o delay(), oppure si avvia un'altra trasmissione Wire. Lì copia soltanto il dato e fai il lavoro in loop().
- I valori arrivano mescolati o sfalsati: le definizioni dello struct sono diverse tra le schede, è stato usato un tipo come int la cui dimensione cambia con la scheda, oppure manca packed. Usa tipi a dimensione fissa e la stessa definizione.
- Errori casuali quando i cavi si allungano: i pull-up interni non bastano. Aggiungi resistenze esterne da 4,7 kΩ o 2,2 kΩ, accorcia i cavi e resta a 100 kHz.
- Con l'ESP32 il bus non funziona o l'ESP32 si scalda: sono stati collegati direttamente 5 V e 3,3 V. Metti in mezzo un convertitore di livello bidirezionale.
Far parlare due Arduino in I2C è il modo più semplice per dividere un progetto grande in parti piccole e indipendenti: una scheda gestisce il display e l'utente, mentre le altre leggono sensori o comandano motori. Verifica prima il collegamento con l'esempio a un byte e poi passa all'esempio bidirezionale con struct. Nell'app BlueGrays trovi con schema e codice passo passo i progetti di comunicazione monodirezionale e bidirezionale tra 2 Arduino, l'LCD I2C, la calcolatrice I2C, l'LCD I2C con ESP32 e l'orologio con RTC DS1307.
Domande frequenti
Come comunicano due Arduino in I2C?
Si collegano direttamente i pin A4 (SDA), A5 (SCL) e GND delle due schede. Una si avvia come controller con Wire.begin(), l'altra come target con un indirizzo, per esempio Wire.begin(8). Il controller invia dati con beginTransmission, write ed endTransmission e li chiede con requestFrom; il target risponde con le funzioni onReceive e onRequest.
Servono le resistenze di pull-up per l'I2C tra due Arduino?
Sì; le linee I2C sono open-drain, quindi il livello HIGH lo forniscono le resistenze di pull-up. I pull-up interni di Arduino spesso funzionano con due schede e cavi corti, ma per un bus affidabile si consiglia di aggiungere 4,7 kΩ da SDA e da SCL verso 5V.
Quanti Arduino si possono collegare a un bus I2C?
Con l'indirizzamento a 7 bit si possono usare 112 indirizzi, da 0x08 a 0x77, quindi in teoria 112 target. In pratica il limite lo fissano la capacità totale del bus e la lunghezza dei cavi; con poche schede e cavi corti non avrai problemi.
Un Arduino slave può inviare dati al master di sua iniziativa?
No. Nell'I2C è sempre il controller ad avviare la comunicazione; il target risponde con onRequest solo quando viene interrogato. Se il target deve segnalare un dato nuovo, il controller lo interroga a intervalli regolari oppure il target porta a LOW un pin di interrupt separato per avvisarlo.
Si possono collegare direttamente Arduino ed ESP32 in I2C?
È sconsigliato. L'Uno lavora a 5 V e l'ESP32 a 3,3 V, e i pull-up interni dell'Uno portano i pin dell'ESP32 a 5 V. Usa un convertitore di livello bidirezionale come il BSS138 e fai dell'ESP32 il controller e dell'Uno il target.
Che differenza c'è tra I2C e UART su Arduino?
L'I2C mette molti dispositivi sullo stesso bus con due fili e indirizzi e conferma con un ACK l'arrivo di ogni byte, ma solo il controller può avviare la comunicazione. La UART collega solo due dispositivi, i suoi fili sono incrociati e ciascun lato può inviare quando vuole. L'I2C è adatto a più schede vicine, la UART a cavi lunghi e flussi di dati continui.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Comunicazione unidirezionale tra 2 Arduino
Fai parlare due Arduino con un solo filo: premi il pulsante sull'uno e il LED dell'altro si accende, premi di nuovo e si spegne.

Comunicazione bidirezionale tra 2 Arduino
Due Arduino collegati con dei fili parlano tra loro: premi il pulsante di uno e si accende la luce dell'altro, premilo di nuovo e si spegne.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

Calcolatrice Arduino I2C
Si tratta di un progetto di calcolatore basato su Arduino che esegue operazioni di addizione, sottrazione, moltiplicazione e divisione utilizzando una tastiera a membrana 4x4 e un display LCD I2C 16x2. Grazie all'I2C, il collegamento del display avviene con soli 2 cavi, riducendo così l'ingombro dei cavi e mantenendo un maggior numero di pin utilizzabili. Sono inoltre disponibili l'ingresso di numeri decimali e il supporto di numeri negativi.

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

Orologio digitale con ESP32 e RTC DS1307 (I2C + LCD)
In questo progetto, utilizziamo il modulo orologio in tempo reale (RTC) DS1307 per visualizzare l'ora e la data su un display LCD 16x2 I2C. Il DS1307 è un RTC con batteria di supporto che mantiene l'ora anche se l'ESP32 si spegne. Entrambi i moduli condividono la stessa linea I2C (SDA/SCL), permettendoci di imparare a controllare più dispositivi utilizzando solo due cavi di segnale. Cosi imparerai il protocollo I2C e il funzionamento dei moduli RTC nella pratica.

Gioco delle Racchette - SSD1306
Una pallina, due racchette e tu: giochi a ping pong, uno dei primissimi videogiochi, su un piccolo display OLED.

Orologio e calendario a matrice di punti (MAX7219, DS1307)
Un pannello luminoso per la scrivania o la parete che mostra ora e data con scritte scorrevoli.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

