Bus I2C con Arduino e libreria Wire: pull-up, indirizzi, scanner ed EEPROM 24LC256
Linee open-drain, dimensionamento delle resistenze di pull-up, START/STOP/ACK, 100 e 400 kHz, level shifter 3,3–5 V, codici di errore di Wire ed EEPROM 24LC256 con scrittura a pagine e ACK polling.

Display OLED, sensori, orologi in tempo reale, espansori di I/O, memorie EEPROM: molti dei moduli che si collegano ad Arduino comunicano attraverso il bus I2C, due soli fili condivisi da tutti i dispositivi. La libreria Wire rende l’uso del bus quasi banale, al punto che spesso si copia uno sketch d’esempio senza chiedersi perché servono le resistenze di pull-up, cosa significa che un dispositivo “non risponde” o perché una scrittura di 64 byte su una EEPROM restituisce dati sbagliati.
In questa guida vediamo il bus I2C dal punto di vista elettrico e del protocollo: linee open-drain, dimensionamento delle pull-up in funzione della capacità del bus, indirizzi a 7 bit, condizioni di START, STOP, ACK e NACK, velocità a 100 e 400 kHz, convivenza tra dispositivi a 5 V e a 3,3 V. Poi passiamo alla pratica con Arduino UNO: uno scanner I2C, la gestione dei codici di errore di Wire.endTransmission() e un esempio completo con la EEPROM 24LC256, con scrittura a pagine, attesa della fine scrittura tramite ACK polling e lettura sequenziale.
Come funziona il bus I2C
L’I2C (Inter-Integrated Circuit) è un bus seriale sincrono a due linee: SDA (Serial Data) trasporta i dati in entrambe le direzioni, SCL (Serial Clock) porta il clock generato dal dispositivo che gestisce la comunicazione. La specifica ufficiale NXP (UM10204, revisione 7 del 2021) chiama controller il dispositivo che genera il clock e avvia le transazioni e target quelli che rispondono; nella documentazione Arduino e in molti datasheet si trovano ancora i termini master e slave. Nei nostri esempi il controller è l’ATmega328P di Arduino UNO, con la sua periferica hardware TWI (Two-Wire Interface).
Su Arduino UNO R3 le linee del TWI sono sui pin A4 (SDA) e A5 (SCL), cioè PC4 e PC5 del microcontrollore; le stesse linee sono riportate anche sui due pin vicini ad AREF. Quando il bus è in uso, A4 e A5 non sono disponibili come ingressi analogici.
Linee open-drain e “AND cablato”
Nessun dispositivo collegato al bus porta mai attivamente una linea a livello alto. Le uscite sono di tipo open-drain (o open-collector): un transistor verso massa che può solo “tirare giù” la linea oppure lasciarla libera. Il livello alto è imposto da una resistenza di pull-up verso l’alimentazione, una per SDA e una per SCL, comune a tutto il bus.
Questa scelta ha due conseguenze importanti. La prima è che due dispositivi che parlano contemporaneamente non entrano mai in cortocircuito: se uno lascia la linea alta e l’altro la porta bassa, vince il livello basso e nessuno si danneggia. Il bus si comporta come una porta AND cablata, ed è su questo che si basano l’ACK, l’arbitraggio tra più controller e il clock stretching (un target lento può tenere SCL basso per chiedere tempo). La seconda è che il fronte di salita non è comandato da un transistor ma dalla carica della capacità della linea attraverso la pull-up: è una curva RC, e la sua velocità dipende da quanto valgono la resistenza e la capacità del bus.
La specifica fissa le soglie logiche in proporzione alla tensione di alimentazione: VIL = 0,3·VDD e VIH = 0,7·VDD. Con il bus a 5 V una linea è letta bassa sotto 1,5 V e alta sopra 3,5 V.
Le resistenze di pull-up: come dimensionarle
Il valore delle pull-up è un compromesso. Una resistenza piccola carica in fretta la capacità del bus, ma quando un dispositivo porta la linea a livello basso deve assorbire tutta la corrente che scorre nella resistenza. Una resistenza grande consuma poco, ma rende i fronti di salita lenti e, oltre un certo limite, la linea non raggiunge il livello alto in tempo per il campionamento.
Il valore minimo si ricava dalla corrente che un’uscita I2C deve garantire: 3 mA con una tensione di uscita bassa non superiore a 0,4 V (Standard-mode e Fast-mode):
\(R_{p,min} = \frac{V_{DD} – V_{OL,max}}{I_{OL}}\)
Il valore massimo dipende dal tempo di salita consentito e dalla capacità del bus Cb, che comprende i pin di tutti i dispositivi, le piste o i fili e i connettori. Il tempo di salita tr è misurato tra il 30 % e il 70 % di VDD; per una carica RC vale tr = (ln 0,7 − ln 0,3)·Rp·Cb ≈ 0,8473·Rp·Cb, da cui:
\(R_{p,max} = \frac{t_r}{0{,}8473 \cdot C_b}\)
con tr massimo pari a 1000 ns in Standard-mode (fino a 100 kHz) e 300 ns in Fast-mode (fino a 400 kHz), e capacità del bus non superiore a 400 pF.
Esempio di calcolo: pull-up per un bus a 5 V
Dati: VDD = 5 V, VOL max = 0,4 V, IOL = 3 mA
Cb stimata = 50 pF (Arduino + 2 moduli, fili corti)
Valore minimo:
Rp min = (5 - 0,4) V / 3 mA = 1,53 kOhm
Valore massimo, Standard-mode (tr = 1000 ns):
Rp max = 1000 ns / (0,8473 x 50 pF) = 23,6 kOhm
Valore massimo, Fast-mode (tr = 300 ns):
Rp max = 300 ns / (0,8473 x 50 pF) = 7,1 kOhm
Scelta: 4,7 kOhm
tr = 0,8473 x 4,7 kOhm x 50 pF = 199 ns -> va bene anche a 400 kHz
corrente con linea bassa = 4,6 V / 4,7 kOhm = 0,98 mA (< 3 mA)
Con 10 kOhm: tr = 424 ns -> adatto a 100 kHz, troppo lento per 400 kHz
Con Cb = 100 pF e 4,7 kOhm: tr = 398 ns -> a 400 kHz si scende a 3,3 kOhm o meno
Da qui nascono i valori che si trovano in quasi tutti gli schemi: 4,7 kΩ è una scelta che funziona sia a 100 sia a 400 kHz su bus corti, 10 kΩ va bene a 100 kHz ed è il valore che il datasheet della 24LC256 indica come tipico a 100 kHz (per 400 kHz suggerisce 2 kΩ). La stima della capacità è il punto debole del calcolo (ogni dispositivo aggiunge qualche picofarad, un filo decine per metro): su bus lunghi o affollati conviene verificare il fronte di salita con l’oscilloscopio.
Pull-up interne e moduli con pull-up a bordo
La libreria Wire, in Wire.begin(), attiva le resistenze di pull-up interne dell’ATmega328P su A4 e A5. Sono resistenze deboli, tra 20 e 50 kΩ: con 35 kΩ e 50 pF il tempo di salita supera già 1,4 µs, oltre il limite della Standard-mode. Possono bastare per un singolo sensore a pochi centimetri a 100 kHz, ma non vanno considerate un sostituto delle pull-up esterne.
L’errore opposto è altrettanto comune: molti moduli (sensori, RTC, display) hanno già le loro pull-up da 4,7 kΩ o 10 kΩ. Collegandone tre con pull-up da 4,7 kΩ, la resistenza equivalente scende a circa 1,57 kΩ, appena sopra il minimo di 1,53 kΩ; con altri moduli si va sotto. In un bus con molti moduli si lasciano le pull-up su uno solo (spesso basta dissaldare un ponticello o una resistenza SMD) oppure si montano pull-up esterne e si rimuovono quelle dei moduli.
Indirizzi a 7 bit e struttura di una trama
Ogni target ha un indirizzo a 7 bit, in parte fissato dal costruttore e in parte selezionabile con piedini dedicati. Gli indirizzi da 0x00 a 0x07 e da 0x78 a 0x7F sono riservati dalla specifica (chiamata generale, indirizzamento a 10 bit, modalità high-speed e altro): i dispositivi normali usano l’intervallo 0x08–0x77, 112 indirizzi in tutto.
Una transazione inizia con la condizione di START: SDA scende mentre SCL è alto. È l’unico caso, insieme allo STOP, in cui SDA cambia con SCL alto; durante il trasferimento dei dati SDA cambia solo mentre SCL è basso e deve restare stabile mentre SCL è alto. Dopo lo START il controller invia un byte formato dai 7 bit di indirizzo seguiti dal bit R/W (0 = scrittura, 1 = lettura). Al nono impulso di clock il controller rilascia SDA e il target che ha riconosciuto il proprio indirizzo la porta bassa: è l’ACK (acknowledge). Se nessuno risponde, SDA resta alta per effetto della pull-up: è il NACK. Seguono i byte di dati, ciascuno con il proprio bit di ACK, e la transazione termina con la condizione di STOP: SDA sale mentre SCL è alto.
Nella lettura i ruoli dell’ACK si invertono: è il controller che conferma con ACK ogni byte ricevuto e risponde con NACK all’ultimo, per dire al target di smettere di trasmettere prima dello STOP. Esiste infine lo START ripetuto: il controller genera un nuovo START senza passare dallo STOP, tipicamente per scrivere l’indirizzo di un registro interno e subito dopo leggerlo senza cedere il bus.
Una fonte frequente di confusione è il modo di scrivere l’indirizzo. La 24LC256 ha indirizzo 1010 A2 A1 A0, cioè 0x50 con i tre piedini a massa. Alcuni datasheet riportano invece il byte completo con il bit R/W, 0xA0 per la scrittura e 0xA1 per la lettura. La libreria Wire vuole sempre l’indirizzo a 7 bit (0x50) e aggiunge da sola il bit R/W.
Velocità: 100 kHz, 400 kHz e Wire.setClock()
La specifica definisce più modalità: Standard-mode fino a 100 kbit/s, Fast-mode fino a 400 kbit/s, Fast-mode Plus fino a 1 Mbit/s e high-speed fino a 3,4 Mbit/s. Il TWI dell’ATmega328P arriva alla Fast-mode. Wire parte a 100 kHz; per cambiare frequenza si usa Wire.setClock() dopo Wire.begin(). Il registro che fissa la frequenza è TWBR e la relazione, con prescaler pari a 1, è:
\(f_{SCL} = \frac{f_{CPU}}{16 + 2 \cdot TWBR}\)
Valori di TWBR calcolati da Wire con F_CPU = 16 MHz 100 kHz: TWBR = (16 MHz / 100 kHz - 16) / 2 = 72 400 kHz: TWBR = (16 MHz / 400 kHz - 16) / 2 = 12 Durata di un byte (8 bit + ACK = 9 periodi di clock): 100 kHz -> 90 us 400 kHz -> 22,5 us
La frequenza va scelta in base al dispositivo più lento presente sul bus e alle pull-up: a 400 kHz il tempo di salita ammesso scende da 1000 a 300 ns, quindi una configurazione che funziona a 100 kHz può diventare instabile a 400 kHz senza cambiare nulla nel cablaggio. Alcuni moduli economici dichiarano 400 kHz ma hanno pull-up da 10 kΩ: in quel caso si resta a 100 kHz o si aggiunge una pull-up esterna più bassa.
Dispositivi a 5 V e a 3,3 V: livelli e level shifter
Arduino UNO lavora a 5 V, mentre molti sensori recenti sono a 3,3 V e non tollerano 5 V sui pin. Collegarli direttamente al bus con pull-up verso 5 V significa applicare 5 V ai loro ingressi: la corrente scorre nei diodi di protezione verso l’alimentazione a 3,3 V e può danneggiare il dispositivo o alzare la sua tensione di alimentazione. Attenzione anche alle pull-up interne: Wire.begin() le collega a 5 V.
Il caso opposto è più subdolo: pull-up verso 3,3 V e ATmega328P a 5 V. Con VIH = 0,7·VDD = 3,5 V, un livello alto di 3,3 V è sotto la soglia garantita. Spesso funziona lo stesso, perché la soglia reale è più bassa di quella garantita, ma è un progetto fuori specifica che può fallire con un altro esemplare o con la temperatura.
La soluzione corretta è un level shifter bidirezionale. Il circuito classico, presente su quasi tutti i moduli “I2C level converter”, usa un MOSFET a canale N per linea, come il BSS138, con il gate alla tensione più bassa e una pull-up per lato.
Il funzionamento è il seguente. A riposo entrambe le linee sono alte: il source è a 3,3 V come il gate, quindi VGS = 0 e il MOSFET è spento, e ciascun lato resta al proprio livello grazie alla sua pull-up. Se il dispositivo a 3,3 V porta la linea bassa, il source scende, VGS sale a 3,3 V e il MOSFET conduce, portando bassa anche la linea a 5 V. Se invece è Arduino a portare bassa la linea a 5 V, inizialmente conduce il diodo di body del MOSFET, che trascina in basso il source finché VGS supera la soglia e il canale si accende. Il MOSFET deve avere una tensione di soglia ben inferiore alla tensione del lato basso: il BSS138 è adatto a 3,3 V. Per approfondire il funzionamento dei MOSFET vedi MOSFET: funzionamento e pilotaggio con Arduino ed ESP32.
Lo scanner I2C per Arduino: chi c’è sul bus?
Il primo programma da caricare quando si collega un modulo nuovo è uno scanner: prova tutti gli indirizzi validi e segnala quelli che rispondono con ACK. Serve a scoprire l’indirizzo effettivo del modulo, che non sempre coincide con quello indicato dal venditore, e a controllare il cablaggio.
// Scanner I2C per Arduino UNO (ATmega328P)
// Prova tutti gli indirizzi a 7 bit non riservati (0x08-0x77)
// e stampa quelli che rispondono con ACK.
#include <Wire.h>
void setup() {
Serial.begin(115200);
Wire.begin(); // UNO: SDA = A4, SCL = A5
Wire.setClock(100000); // Standard-mode, 100 kHz
Wire.setWireTimeout(25000, true); // 25 ms, reset del TWI in caso di blocco
Serial.println(F("Scanner I2C"));
uint8_t trovati = 0;
for (uint8_t indirizzo = 0x08; indirizzo <= 0x77; indirizzo++) {
Wire.beginTransmission(indirizzo);
uint8_t esito = Wire.endTransmission(); // solo indirizzo + STOP
if (esito == 0) {
Serial.print(F("Dispositivo trovato a 0x"));
if (indirizzo < 0x10) Serial.print('0');
Serial.println(indirizzo, HEX);
trovati++;
} else if (esito == 4 || esito == 5) {
Serial.print(F("Errore "));
Serial.print(esito);
Serial.print(F(" a 0x"));
Serial.println(indirizzo, HEX);
}
// esito 2 = NACK sull'indirizzo: nessun dispositivo, si prosegue
}
Serial.print(F("Dispositivi trovati: "));
Serial.println(trovati);
}
void loop() {
}
Per ogni indirizzo lo sketch invia solo START, byte di indirizzo e STOP. endTransmission() restituisce 0 se il target ha risposto con ACK e 2 se l’indirizzo è caduto nel vuoto. I codici 4 e 5 indicano invece un problema del bus (linee bloccate, disturbi, pull-up mancanti) e vengono stampati. In simulazione, con una 24LC256 modellata a 0x50 e un secondo dispositivo fittizio a 0x68, l’uscita seriale è:
Scanner I2C Dispositivo trovato a 0x50 Dispositivo trovato a 0x68 Dispositivi trovati: 2
Se lo scanner non trova nulla, le cause più comuni sono SDA e SCL invertiti, la massa non in comune, la mancanza di pull-up o un modulo a 3,3 V non alimentato. Se trova indirizzi “a caso” o si blocca, il problema è quasi sempre elettrico: pull-up troppo deboli, fili lunghi, disturbi.
Gestione degli errori: endTransmission() e setWireTimeout()
Wire.endTransmission() trasmette quanto accumulato con Wire.write() e restituisce un codice che conviene sempre controllare:
| Codice | Significato | Cause tipiche |
|---|---|---|
| 0 | Successo | Il target ha risposto con ACK a indirizzo e dati |
| 1 | Dati troppo lunghi per il buffer di trasmissione | Più di 32 byte in una transazione; sull’AVR, in pratica, la write() oltre il 32° byte restituisce 0 e scarta il byte |
| 2 | NACK sull’indirizzo | Dispositivo assente, indirizzo sbagliato, dispositivo occupato (per esempio una EEPROM che sta scrivendo) |
| 3 | NACK su un dato | Registro inesistente, dispositivo che rifiuta il comando, scrittura protetta in alcuni dispositivi |
| 4 | Altro errore | Errore di bus, arbitraggio perso, disturbi |
| 5 | Timeout | Linea SDA o SCL bloccata bassa, clock stretching troppo lungo |
Il codice 5 esiste solo se il timeout è abilitato. Nel core AVR 1.8.6 il timeout è disattivato per impostazione predefinita: se una linea resta bloccata bassa (un target che si è “incantato” a metà trasmissione, un disturbo, un cortocircuito) lo sketch rimane fermo per sempre dentro endTransmission() o requestFrom(). Per evitarlo si chiama, dopo Wire.begin():
Wire.setWireTimeout(25000, true); // 25 ms, reset del TWI in caso di timeout
Il primo parametro è il timeout in microsecondi (0 lo disattiva), il secondo chiede di reinizializzare il TWI quando scatta. Il valore di 25 ms suggerito dalla documentazione corrisponde al massimo clock stretching ammesso dal protocollo SMBus. Dopo un timeout, Wire.getWireTimeoutFlag() restituisce true finché non si chiama Wire.clearWireTimeoutFlag(). Il timeout evita il blocco del programma ma non risolve la causa: se scatta, va cercato il problema elettrico.
Progetto completo: EEPROM I2C 24LC256
La memoria interna dell’ATmega328P comprende 1 KB di EEPROM, sufficiente per qualche parametro di configurazione (vedi Arduino: gestione memorie interne). Quando serve più spazio, per esempio per un registratore di dati, una EEPROM I2C esterna è la soluzione più semplice: la 24LC256 di Microchip contiene 32 KB in un contenitore DIP8 o SOIC8 e costa pochissimo.
Dati principali della 24LC256 (datasheet Microchip DS20001203) Organizzazione: 32.768 x 8 bit (256 Kbit), celle 0x0000-0x7FFF Alimentazione: 2,5 ... 5,5 V (24AA256: da 1,7 V) Clock massimo: 400 kHz (24FC256: 1 MHz) Indirizzo I2C: 1010 A2 A1 A0 -> da 0x50 a 0x57 (fino a 8 memorie) Pagina di scrittura: 64 byte Tempo di scrittura tWC: 5 ms max (byte o pagina) Cicli di scrittura: 1.000.000 (a 25 °C) Conservazione dati: > 200 anni WP (pin 7): a VCC protegge dalla scrittura, a VSS la abilita A0, A1, A2: vanno collegati a VCC o a VSS, non lasciati aperti Pull-up tipiche su SDA: 10 kOhm a 100 kHz, 2 kOhm a 400 kHz
Lo schema è minimo: A0, A1, A2 e WP a massa (indirizzo 0x50, scrittura abilitata), condensatore di disaccoppiamento da 100 nF vicino al pin 8, pull-up da 4,7 kΩ su SDA e SCL. Il secondo dispositivo rappresenta un qualsiasi altro modulo sullo stesso bus: le pull-up restano due in tutto. Se le linee sono corte, con 4,7 kΩ si può lavorare a 400 kHz come mostrato nel calcolo precedente.
Scrittura a pagine e limite del buffer Wire
Per scrivere si invia il byte di controllo con R/W = 0, i due byte dell’indirizzo della cella (prima quello alto: sono usati solo i 15 bit da A14 ad A0) e poi i dati. La memoria accetta fino a 64 byte in una sola transazione, ma con una regola precisa: le pagine sono blocchi fisici di 64 byte allineati (0x0000–0x003F, 0x0040–0x007F e così via) e il contatore interno incrementa solo i 6 bit bassi. Se una scrittura supera la fine della pagina, i byte in eccesso ricominciano dall’inizio della stessa pagina e sovrascrivono dati esistenti. Nessun errore viene segnalato: la memoria risponde con ACK a ogni byte.
A questo si aggiunge un limite della libreria: su Arduino UNO il buffer di trasmissione di Wire è di 32 byte, e due sono occupati dall’indirizzo della cella. In una transazione si possono quindi scrivere al massimo 30 byte di dati, e una pagina intera non entra in una sola chiamata. Anche in lettura il buffer è di 32 byte: requestFrom() con un numero maggiore viene limitato a 32.
La funzione di scrittura deve perciò spezzare i dati in blocchi che rispettino entrambi i vincoli: non oltre la fine della pagina corrente e non più di 30 byte. È la parte che più spesso manca negli esempi che si trovano in rete.
Attesa della fine scrittura: ACK polling
Lo STOP finale avvia il ciclo di scrittura interno, che dura al massimo 5 ms. In questo intervallo la memoria ignora il bus e non risponde con ACK al proprio indirizzo. Invece di aspettare sempre 5 ms con un delay(), il datasheet suggerisce l’ACK polling: il controller invia ripetutamente START e byte di controllo in scrittura; finché riceve NACK la scrittura è in corso, al primo ACK la memoria è pronta. Con Wire basta ripetere beginTransmission() ed endTransmission() finché il codice restituito vale 0 (anziché 2). Nello sketch il polling ha un limite di 10 ms, il doppio del tempo massimo: se scade, eepromScrivi() restituisce 5 (lo stesso codice del timeout di Wire, scelto per comodità) e il problema è nel circuito.
Lettura sequenziale
Per leggere si scrive l’indirizzo della cella senza STOP (endTransmission(false)), poi si genera uno START ripetuto con R/W = 1 tramite requestFrom(). La memoria trasmette i byte uno dopo l’altro incrementando il puntatore interno, senza vincoli di pagina: in lettura l’unico limite è il buffer da 32 byte di Wire, e alla fine dello spazio (0x7FFF) il puntatore riparte da 0x0000.
Il codice completo
Lo sketch scrive 100 byte di prova a partire dalla cella 0x0030, scelta apposta a cavallo dei confini di pagina 0x0040 e 0x0080, li rilegge e li confronta. Alla fine prova un indirizzo dove non c’è nessun dispositivo, per mostrare il codice di errore 2.
// EEPROM I2C 24LC256 con Arduino UNO e libreria Wire
// Scrittura a pagine, ACK polling, lettura sequenziale e verifica.
#include <Wire.h>
const uint8_t EEPROM_ADDR = 0x50; // 1010 A2 A1 A0, con A2=A1=A0=GND
const uint8_t PAGINA = 64; // dimensione di pagina della 24LC256
const uint8_t MAX_SCRITTURA = 30; // buffer Wire 32 byte - 2 byte di indirizzo
const uint8_t MAX_LETTURA = 32; // buffer di ricezione Wire
const bool DEBUG = true; // stampa i blocchi scritti
const uint16_t CELLA_TEST = 0x0030; // a cavallo dei confini 0x0040 e 0x0080
const uint8_t N_TEST = 100;
uint8_t scritti[N_TEST];
uint8_t letti[N_TEST];
void stampaEsito(const __FlashStringHelper *cosa, uint8_t esito) {
Serial.print(cosa);
Serial.print(F(": codice "));
Serial.print(esito);
switch (esito) {
case 0: Serial.println(F(" (OK)")); break;
case 1: Serial.println(F(" (dati oltre il buffer)")); break;
case 2: Serial.println(F(" (NACK sull'indirizzo)")); break;
case 3: Serial.println(F(" (NACK su un dato)")); break;
case 4: Serial.println(F(" (altro errore del bus)")); break;
case 5: Serial.println(F(" (timeout)")); break;
default: Serial.println(); break;
}
}
// ACK polling: durante il ciclo di scrittura interno la memoria
// non risponde (NACK). Ritorna i microsecondi attesi, -1 se scade.
long attendiFineScrittura(uint8_t dev) {
unsigned long t0 = micros();
while (micros() - t0 < 10000UL) { // 10 ms = 2 x tWC max
Wire.beginTransmission(dev);
if (Wire.endTransmission() == 0) return (long)(micros() - t0);
}
return -1;
}
// Scrive len byte a partire da "cella", in blocchi che non superano
// il confine di pagina e che stanno nel buffer della libreria Wire.
uint8_t eepromScrivi(uint8_t dev, uint16_t cella, const uint8_t *dati, uint16_t len) {
while (len > 0) {
uint8_t n = PAGINA - (cella % PAGINA); // spazio fino a fine pagina
if (n > MAX_SCRITTURA) n = MAX_SCRITTURA;
if (n > len) n = len;
Wire.beginTransmission(dev);
Wire.write((uint8_t)(cella >> 8)); // indirizzo, byte alto
Wire.write((uint8_t)(cella & 0xFF)); // indirizzo, byte basso
Wire.write(dati, n);
uint8_t esito = Wire.endTransmission(); // STOP: parte la scrittura
if (esito != 0) return esito;
long attesa = attendiFineScrittura(dev);
if (attesa < 0) return 5;
if (DEBUG) {
Serial.print(F(" blocco 0x"));
Serial.print(cella, HEX);
Serial.print(F(" n="));
Serial.print(n);
Serial.print(F(" ACK dopo "));
Serial.print(attesa);
Serial.println(F(" us"));
}
cella += n;
dati += n;
len -= n;
}
return 0;
}
// Lettura sequenziale: indirizzo + repeated START + fino a 32 byte.
uint8_t eepromLeggi(uint8_t dev, uint16_t cella, uint8_t *buf, uint16_t len) {
while (len > 0) {
uint8_t n = (len > MAX_LETTURA) ? MAX_LETTURA : len;
Wire.beginTransmission(dev);
Wire.write((uint8_t)(cella >> 8));
Wire.write((uint8_t)(cella & 0xFF));
uint8_t esito = Wire.endTransmission(false); // niente STOP
if (esito != 0) return esito;
if (Wire.requestFrom(dev, n) != n) return 4;
for (uint8_t i = 0; i < n; i++) *buf++ = Wire.read();
cella += n;
len -= n;
}
return 0;
}
void setup() {
Serial.begin(115200);
Wire.begin();
Wire.setClock(400000); // Fast-mode: la 24LC256 lo supporta da 2,5 V
Wire.setWireTimeout(25000, true);
// 1) La memoria risponde?
Wire.beginTransmission(EEPROM_ADDR);
uint8_t esito = Wire.endTransmission();
stampaEsito(F("Presenza EEPROM 0x50"), esito);
if (esito != 0) {
Serial.println(F("Controlla cablaggio, pull-up e pin A0-A2"));
while (true) {}
}
// 2) Scrittura di 100 byte di prova
for (uint8_t i = 0; i < N_TEST; i++) scritti[i] = (uint8_t)(i * 7 + 3);
unsigned long t0 = millis();
esito = eepromScrivi(EEPROM_ADDR, CELLA_TEST, scritti, N_TEST);
stampaEsito(F("Scrittura"), esito);
Serial.print(F("Tempo di scrittura: "));
Serial.print(millis() - t0);
Serial.println(F(" ms"));
// 3) Rilettura e verifica
esito = eepromLeggi(EEPROM_ADDR, CELLA_TEST, letti, N_TEST);
stampaEsito(F("Lettura"), esito);
uint8_t errori = 0;
for (uint8_t i = 0; i < N_TEST; i++) {
if (letti[i] != scritti[i]) errori++;
}
Serial.print(F("Verifica: "));
Serial.println(errori == 0 ? F("PASS") : F("FAIL"));
// 4) Indirizzo senza dispositivo: atteso codice 2
Wire.beginTransmission(0x51);
stampaEsito(F("Prova a 0x51"), Wire.endTransmission());
}
void loop() {
}
La funzione eepromScrivi() calcola per ogni blocco lo spazio fino a fine pagina (64 − cella % 64) e lo limita a 30 byte. Per 100 byte da 0x0030 i blocchi diventano 16 + 30 + 30 + 4 + 20: il primo si ferma a fine pagina 0, il secondo e il terzo sono limitati dal buffer, il quarto chiude la pagina 1. La costante DEBUG stampa i blocchi e il tempo di polling; in un’applicazione reale si mette a false.
Risultato della simulazione
Lo sketch è stato eseguito nel simulatore avr8js con un modello della 24LC256 scritto per l’occasione: puntatore a 15 bit (A14–A0), scrittura a pagine con il ritorno all’inizio pagina descritto dal datasheet, NACK al proprio indirizzo per 5 ms dopo ogni scrittura (il caso peggiore di tWC) e lettura sequenziale. L’uscita seriale ottenuta è:
Presenza EEPROM 0x50: codice 0 (OK) blocco 0x30 n=16 ACK dopo 5092 us blocco 0x40 n=30 ACK dopo 5052 us blocco 0x5E n=30 ACK dopo 5040 us blocco 0x7C n=4 ACK dopo 5028 us blocco 0x80 n=20 ACK dopo 5048 us Scrittura: codice 0 (OK) Tempo di scrittura: 33 ms Lettura: codice 0 (OK) Verifica: PASS Prova a 0x51: codice 2 (NACK sull'indirizzo)
Oltre al messaggio dello sketch, lo script di prova controlla direttamente il contenuto della memoria modellata, che nessun blocco abbia attraversato un confine di pagina e che il bus fosse davvero a 400 kHz. La figura seguente ricostruisce, dai dati registrati durante la simulazione, la posizione dei blocchi nelle pagine e la sequenza nel tempo di scritture, polling e letture.
La simulazione mostra il collo di bottiglia: trasferire 30 byte a 400 kHz richiede meno di un millisecondo, ogni ciclo di scrittura fino a 5 (gli spazi tra polling e scrittura successiva sono dovuti alle stampe di debug). Su un componente reale tWC è di solito inferiore al caso peggiore e l’ACK polling ne approfitta automaticamente. Per scritture lunghe conviene usare blocchi grandi e allineati: scrivere un byte alla volta costerebbe 5 ms per ogni byte.
Errori comuni
Il primo errore è dimenticare le pull-up, o affidarsi solo a quelle interne: il bus sembra funzionare sul banco con un modulo a pochi centimetri e smette di funzionare aggiungendo un secondo modulo o allungando i fili. Il secondo è l’opposto: troppi moduli con pull-up a bordo collegati in parallelo, con una resistenza equivalente sotto il minimo. Il terzo è usare l’indirizzo a 8 bit del datasheet (0xA0) al posto di quello a 7 bit (0x50) richiesto da Wire.
Sul lato software, gli errori tipici sono non controllare il valore restituito da endTransmission(), scrivere su una EEPROM più byte di quanti ne entrino nella pagina o nel buffer Wire, leggere subito dopo una scrittura senza attendere la fine del ciclo interno e lasciare il timeout disattivato in un’applicazione che deve funzionare senza sorveglianza.
Checklist per un bus I2C con Arduino UNO
1. SDA su A4, SCL su A5, massa in comune tra tutti i dispositivi.
2. Una sola coppia di pull-up per bus (4,7 kOhm tipico a 5 V).
3. Controllare le pull-up già presenti sui moduli: in parallelo
la resistenza equivalente non deve scendere sotto ~1,5 kOhm a 5 V.
4. Dispositivi a 3,3 V: level shifter, mai pull-up verso 5 V.
5. 400 kHz solo se tutti i dispositivi lo supportano e tr <= 300 ns.
6. Prima prova: scanner I2C, verificare gli indirizzi attesi.
7. Indirizzi a 7 bit in Wire (0x50, non 0xA0).
8. Controllare sempre il codice di endTransmission().
9. Wire.setWireTimeout() in ogni sketch che deve girare a lungo.
10. EEPROM: blocchi entro la pagina e max 30 byte, ACK polling
dopo ogni scrittura, letture a blocchi di max 32 byte.
Fonti e verifiche
Il codice di questo articolo è stato compilato con arduino-cli 1.3.1 e il core arduino:avr 1.8.6 (scheda Arduino UNO, compilatore avr-gcc 14.1) ed eseguito in simulazione (avr8js, ATmega328P a 16 MHz, con un modello della 24LC256 e di un secondo dispositivo I2C); la prova su hardware reale va eseguita con la checklist fornita. I dati dei componenti provengono dalle fonti ufficiali:
- NXP UM10204, I2C-bus specification and user manual, rev. 7.0
- Microchip 24AA256/24LC256/24FC256, datasheet DS20001203W
- Texas Instruments SLVA689, I2C Bus Pullup Resistor Calculation
- Arduino, riferimento della libreria Wire: endTransmission()








