Qu'est-ce que l'I2C ? SDA, SCL, résistances pull-up et scanner

L'I2C (Inter-Integrated Circuit) est un protocole de communication série qui permet à un microcontrôleur de dialoguer avec des dizaines de capteurs, d'écrans et de modules à l'aide de deux fils de signal seulement (SDA et SCL). On le prononce « I-deux-C » ou « I-carré-C », et certaines fiches techniques le nomment IIC ou TWI (Two Wire Interface). L'écran LCD I2C, l'écran OLED, l'accéléromètre MPU6050, le capteur de pression BMP280 et le module horloge DS1307 de tes projets Arduino utilisent tous ce protocole ; tu peux les brancher en parallèle sur les deux mêmes fils et joindre chacun grâce à sa propre adresse.

Dans ce guide, tu vas apprendre comment l'I2C fonctionne électriquement, ce que signifient les adresses, pourquoi les résistances pull-up sont indispensables et comment calculer leur valeur. Ensuite, étape par étape, tu verras un tableau des broches pour l'Arduino Uno, l'ESP32 et la Raspberry Pi Pico, un code scanner I2C qui trouve tous les appareils du bus, un exemple de lecture de registres sans bibliothèque et les solutions aux problèmes courants comme les conflits d'adresse.

Qu'est-ce que l'I2C et comment fonctionne-t-il ?

L'I2C a été créé en 1982 par Philips (aujourd'hui NXP) pour que les puces d'une même carte communiquent avec peu de fils. Il y a deux rôles sur le bus : le contrôleur (autrefois appelé maître), qui lance chaque échange et génère l'horloge, et les cibles (autrefois esclaves), qui lui répondent. Dans les projets Arduino, le contrôleur est presque toujours l'Arduino, l'ESP32 ou la Pico, tandis que les capteurs et les écrans sont les cibles.

• SDA (Serial Data) : La ligne qui transporte les données dans les deux sens. Le contrôleur envoie les adresses et les commandes, et le capteur renvoie ses mesures sur la même ligne.
• SCL (Serial Clock) : La ligne d'horloge. Un bit de SDA est lu à chaque impulsion d'horloge, et c'est le contrôleur qui génère l'horloge.
• GND (masse commune) : La référence des signaux. Même les modules alimentés séparément doivent partager une masse commune.

Les lignes sont à drain ouvert (open-drain) : aucun appareil ne force une ligne à l'état haut, il peut seulement la tirer vers le bas. Ce qui maintient la ligne à 1, ce sont les résistances pull-up qui relient SDA et SCL à la tension d'alimentation. C'est pourquoi il n'y a pas de court-circuit même si deux appareils tentent de parler en même temps ; si l'un d'eux tire la ligne vers le bas, tout le monde voit un 0. Un message I2C se déroule ainsi :

1. START : Pendant que SCL est à l'état haut, le contrôleur fait passer SDA de 1 à 0, et tous les appareils du bus se mettent à écouter.
2. Adresse et bit de sens : L'adresse sur 7 bits est envoyée, suivie d'un bit de lecture (1) ou d'écriture (0).
3. ACK : L'appareil qui possède cette adresse tire SDA vers le bas pendant la 9e impulsion d'horloge pour dire « je suis là ». Si personne ne le fait, on parle de NACK.
4. Octets de données : Chaque octet est envoyé sur 8 bits et le récepteur répond à chacun par un ACK. Sur la plupart des capteurs, le premier octet est le numéro du registre à lire ou à écrire.
5. STOP : Pendant que SCL est à l'état haut, SDA remonte de 0 à 1 et le bus est de nouveau libre. Pour les lectures, on utilise un START répété (repeated start) au lieu d'un STOP pour changer de sens sans libérer le bus.

Comparer l'I2C aux deux autres protocoles courants du monde Arduino montre clairement quand le choisir :

Vitesses de l'I2C et limites techniques

La bibliothèque Wire d'Arduino démarre par défaut à 100 kHz ; la plupart des capteurs acceptent aussi 400 kHz, et tu passes à cette vitesse avec Wire.setClock(400000). Une vitesse plus élevée rend le rafraîchissement des écrans plus fluide, mais le bus devient plus sensible à la longueur des fils et à la valeur des pull-up. Selon la norme, la capacité totale du bus (fils et broches des appareils) ne doit pas dépasser 400 pF. Les câbles Dupont et les nappes ordinaires ajoutent 50 à 100 pF par mètre et chaque broche d'appareil jusqu'à 10 pF ; c'est pourquoi l'I2C a été conçu pour fonctionner sur une même carte ou avec des fils de quelques dizaines de centimètres. Au-delà de 1 mètre, il faut réduire la vitesse, utiliser des pull-up plus fortes ou ajouter des prolongateurs de bus comme le P82B715.

Adresses I2C : 7 bits, 8 bits et adresses réservées

Chaque appareil du bus possède une adresse sur 7 bits, ce qui donne en théorie 128 adresses. Comme les plages 0x00–0x07 et 0x78–0x7F sont réservées à des usages particuliers, les adresses utilisables sont les 112 adresses de 0x08 à 0x77. L'adresse est généralement fixée par le fabricant de la puce, mais sur de nombreux modules tu peux modifier ses derniers bits avec des ponts de soudure ou des broches nommées A0, A1, A2 ou AD0.

Voici le point qui prête à confusion : certaines fiches techniques et les inscriptions au dos des modules donnent l'adresse sur 8 bits, bit de sens compris. Par exemple, le dos d'une carte OLED indique « 0x78 », alors que l'adresse dans le code est 0x3C ; si un module LCD indique 0x4E, l'adresse dans le code est 0x27. La règle est simple : divise la valeur sur 8 bits par 2 (décale-la d'un bit vers la droite) et tu obtiens l'adresse sur 7 bits. Les bibliothèques Arduino, ESP32 et MicroPython attendent toutes des adresses sur 7 bits.

Résistances pull-up : pourquoi elles sont nécessaires et comment choisir leur valeur

Comme les appareils d'un bus I2C ne peuvent que tirer les lignes vers le bas, ce sont les résistances pull-up qui fournissent l'état haut. Si la résistance est trop grande, la capacité du bus ralentit le passage de 0 à 1, les fronts du signal s'arrondissent et des bits sont mal lus à haute vitesse. Si elle est trop petite, le courant qu'un appareil doit absorber en tirant la ligne vers le bas augmente ; la norme exige seulement qu'un appareil puisse absorber au moins 3 mA à 0,4 V, donc la pull-up doit maintenir le courant en dessous.

Ces formules donnent les deux limites : la résistance minimale vaut R(min) = (VCC − 0,4 V) / 3 mA et la maximale R(max) = t(montée) / (0,8473 × C(bus)). Pour 5 V, on obtient R(min) = 4,6 V / 0,003 A ≈ 1,53 kΩ, et pour 3,3 V ≈ 0,97 kΩ. Sur un bus court de 100 pF, R(max) ≈ 11,8 kΩ à 100 kHz et ≈ 3,5 kΩ à 400 kHz. C'est pourquoi, en pratique, les valeurs les plus utilisées sont 4,7 kΩ pour 100 kHz et 2,2 kΩ pour 400 kHz et les bus chargés. Tu peux utiliser l'outil Code couleur des résistances pour lire les anneaux d'une résistance et l'outil Constante de temps RC pour voir le retard créé par la résistance et la capacité.

Sur l'Arduino Uno, l'appel à Wire.begin() active aussi les résistances pull-up internes de 20 à 50 kΩ de l'ATmega328P. Avec un seul module et 10 à 20 cm de fil, elles suffisent souvent, mais elles ne sont pas fiables ; des résistances externes sont toujours préférables. Si tu utilises une carte capteur nue sans pull-up, n'oublie pas d'ajouter une résistance de 4,7 kΩ entre SDA et VCC, et une autre entre SCL et VCC.

Broches I2C : Arduino Uno, Mega, ESP32, ESP8266 et Pico

Pas à pas : trouver les adresses avec le scanner I2C

Quand tu reçois un nouveau module, la première chose à faire est de connaître les adresses des appareils du bus. Un scanner I2C envoie un message vide à chaque adresse de 0x08 à 0x77 et affiche celles qui répondent par un ACK. Tu vérifies ainsi à la fois que le module est bien câblé et quelle adresse tu dois mettre dans ton code.

1. Relie la GND du module à la GND de l'Arduino et son VCC au 5V (au 3.3V pour les modules qui n'acceptent que 3,3 V).
2. Relie SDA à A4 et SCL à A5. Si tu as plusieurs modules, réunis toutes leurs broches SDA et toutes leurs broches SCL sur la breadboard.
3. Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds.
4. Note les adresses affichées. Si rien n'apparaît, vérifie le câblage, la masse commune et les résistances pull-up.
5. Débranche et rebranche les modules un par un pour confirmer quelle adresse correspond à quel appareil ; le scanner relance la recherche toutes les 5 secondes.

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

La ligne setWireTimeout du code est importante : quand SDA ou SCL est en court-circuit, ou qu'un appareil reste bloqué en maintenant la ligne à l'état bas, la bibliothèque Wire de l'Uno avec ses réglages par défaut peut attendre indéfiniment et figer ton programme. Avec le délai activé, la bibliothèque abandonne au bout de 3 ms, réinitialise le matériel I2C et le scanner signale le problème avec un code d'erreur. La ligne est placée dans un #if pour n'être compilée que sur les cartes AVR (Uno, Nano, Mega) ; les bibliothèques Wire de l'ESP32 et de l'ESP8266 ont déjà leur propre protection par délai, donc le même code se compile et fonctionne sans modification sur les trois plateformes.

L'I2C sans bibliothèque : lire et écrire des registres

Les bibliothèques simplifient le travail, mais en coulisses elles font toutes la même chose : elles envoient le numéro de registre à l'appareil, puis lisent ou écrivent des octets dans ce registre. Le faire toi-même une fois te permet de lire la fiche technique d'un nouveau capteur et de l'utiliser même sans bibliothèque. L'exemple ci-dessous réveille le capteur MPU6050 de son mode veille, lit son registre d'identité (WHO_AM_I), puis calcule la température et l'accélération sur l'axe Z à partir des valeurs brutes.

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

Fais attention à la ligne endTransmission(false) de la fonction de lecture : elle change de sens avec un START répété au lieu d'un STOP, si bien qu'aucun autre appareil ne peut s'intercaler et que le capteur n'oublie pas quel registre a été demandé. Si WHO_AM_I renvoie 0x68, la communication est parfaite. Sur les modules clones bon marché, la valeur peut être 0x70 ou un autre nombre ; cela indique une puce compatible mais différente, comme le MPU6500, et c'est la raison pour laquelle certaines bibliothèques toutes faites affichent « capteur introuvable ». La formule de température (valeur brute / 340 + 36,53) vient directement de la fiche technique du MPU6050 ; pour l'accélération sur la plage ±2 g, une valeur brute de 16384 correspond à 1 g, donc un capteur posé à plat sur la table affiche environ 1,00 sur l'axe Z.

Plusieurs appareils sur un même bus et conflits d'adresse

Le grand avantage de l'I2C est que tu peux brancher des appareils en parallèle sur les deux mêmes fils tant que leurs adresses sont différentes. Par exemple, un LCD (0x27), un OLED (0x3C), un BMP280 (0x76) et une horloge DS3231 (0x68) partagent sans problème les broches A4 et A5 ; chaque bibliothèque parle à sa propre adresse pendant que les autres appareils écoutent en silence. Les ennuis commencent quand deux appareils ont la même adresse : les deux répondent par un ACK, leurs données se mélangent et, en général, aucun ne fonctionne. Voici les solutions :

• Change la broche d'adresse : Si tu relies la broche AD0 du MPU6050 au 3,3 V, son adresse devient 0x69 et le conflit avec le DS3231 (0x68) disparaît.
• Utilise les ponts de soudure : Les ponts A0–A2 des modules LCD offrent 8 adresses et la broche ADDR de l'ADS1115 en offre 4.
• Ouvre un second bus I2C : Déplace l'appareil en conflit sur d'autres broches avec Wire1 sur l'ESP32 ou I2C1 sur la Pico.
• Ajoute un multiplexeur I2C : Le TCA9548A ouvre huit sous-bus séparés à partir d'une seule adresse (0x70) ; tu pourrais même brancher huit OLED ayant la même adresse.
• Appareils à adresse fixe : Sur certaines puces, comme le DS1307 ou le HTU21D, l'adresse ne peut pas être changée du tout ; seuls un bus séparé ou un multiplexeur règlent alors le problème.

L'I2C sur l'ESP32 : les broches de ton choix et deux bus séparés

Sur l'ESP32, le matériel I2C peut être routé de manière flexible vers les broches. Les broches par défaut sont GPIO 21 (SDA) et GPIO 22 (SCL), mais avec Wire.begin(SDA, SCL) tu peux choisir presque n'importe quelle paire de GPIO. L'ESP32 classique et l'ESP32-S3 ont deux contrôleurs I2C : tu peux donc faire fonctionner deux capteurs de même adresse sur deux bus séparés ; l'ESP32-C3 n'a qu'un seul contrôleur. Les GPIO 34 à 39 sont uniquement des entrées et ne peuvent pas servir à l'I2C. Pour le brochage complet de la carte, consulte l'outil Pinout, et pour une introduction générale l'article Qu'est-ce que l'ESP32 ?.

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

L'I2C avec la Raspberry Pi Pico (MicroPython)

La puce RP2040 de la Pico possède deux contrôleurs, I2C0 et I2C1, et chacun peut être routé vers plusieurs paires de broches. Pour I2C0, tu peux utiliser GP0/GP1, GP4/GP5, GP8/GP9, GP12/GP13, GP16/GP17 et GP20/GP21 ; pour I2C1, GP2/GP3, GP6/GP7, GP10/GP11, GP14/GP15, GP18/GP19 et GP26/GP27. Dans chaque paire, la broche de numéro pair est SDA et celle de numéro impair est SCL. En MicroPython, le scanner tient en une ligne : i2c.scan() renvoie la liste des adresses qui répondent par un ACK. Comme la Pico fonctionne en 3,3 V, alimenter les modules par la broche 3V3(OUT) est la solution la plus sûre ; même si le RP2040 gère aussi le mode rapide plus à 1 MHz, rester à 400 kHz sur une breadboard réserve moins de surprises. Pour tes premiers pas avec la Pico, lis Qu'est-ce que la Raspberry Pi Pico ?.

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

Idées de projets avec l'I2C

• Mini station météo : Mesure la pression et la température avec un BMP280 et affiche-les sur un écran OLED ; les deux modules partagent les deux mêmes fils.
• Horloge numérique : Lis l'heure d'un module DS3231 et affiche-la sur un écran LCD I2C.
• Indicateur d'inclinaison : Calcule l'angle avec un MPU6050 et dessine le résultat sur l'OLED comme un niveau à bulle.
• Nœud capteur Wi-Fi : Surveille depuis ton téléphone un capteur branché sur les broches D1 et D2 d'un ESP8266 NodeMCU.
• Bras robotique à 16 servos : Pilote 16 servos avec deux broches seulement grâce au driver PCA9685.
• Enregistreur de données : Écris une mesure par minute dans une EEPROM AT24C256 pour que les données survivent à une coupure de courant.

Erreurs fréquentes et solutions

L'I2C est le moyen le plus pratique d'ajouter des écrans, des horloges, des capteurs et de la mémoire à ton projet avec seulement deux fils ; une fois que tu maîtrises les adresses, les résistances pull-up et le code scanner, tu résous la plupart des problèmes en quelques minutes. Dans l'application BlueGrays, tu trouveras des projets qui utilisent l'I2C, comme l'écran LCD I2C, le jeu Pong sur écran OLED, une horloge numérique avec DS1307 et un affichage météo avec ESP32, avec schémas de câblage et code pas à pas.