Communication I2C entre deux Arduino : maître-esclave et struct
Communication I2C entre deux Arduino pas à pas : câblage maître-esclave, résistances pull-up, Wire.onReceive et onRequest, adresse, structs et ESP32.
La communication I2C entre deux Arduino est l'une des façons les plus pratiques de les relier : elle n'utilise que deux fils de données (SDA et SCL) et une masse commune, et se met en place en quelques lignes avec la bibliothèque Wire fournie avec Arduino. L'une des cartes est le contrôleur (autrefois appelé maître) et c'est toujours elle qui commence l'échange ; l'autre est la cible (l'esclave), qui possède une adresse, écoute ce qu'on lui envoie ou répond quand on l'interroge. Comme des dizaines de cibles peuvent partager les deux mêmes fils, l'I2C est très utile dans les projets où une carte principale pilote plusieurs Arduino auxiliaires.
Dans cet article, nous relions pas à pas deux Arduino Uno en I2C : tableau de câblage et de pull-up, choix de l'adresse, fonctions Wire.onReceive et Wire.onRequest, envoi d'un octet, échange bidirectionnel avec un struct, plusieurs Arduino sur le même bus, communication avec un ESP32 et un Raspberry Pi Pico via un convertisseur de niveau, et comparaison entre I2C et UART. Si tu veux d'abord revoir les bases de l'I2C et le programme scanner, lis Qu'est-ce que l'I2C ?.

Comment fonctionnent le contrôleur et la cible (maître-esclave) en I2C ?
En I2C, tous les appareils sont branchés en parallèle sur les deux mêmes lignes. SCL est la ligne d'horloge, toujours générée par le contrôleur ; SDA est la ligne de données, utilisée dans les deux sens. Pour commencer un message, le contrôleur crée une condition de "start", puis envoie l'adresse 7 bits de la cible avec le bit de lecture ou d'écriture. La cible qui porte cette adresse répond par un ACK (bien reçu) en tirant brièvement la ligne à LOW à la fin de chaque octet ; si personne ne porte cette adresse, la ligne reste à HIGH, c'est un NACK. C'est pourquoi, en I2C, le contrôleur sait immédiatement si un message est arrivé. La règle la plus importante : une cible ne peut pas parler d'elle-même. Même si elle a une nouvelle donnée, elle attend que le contrôleur l'interroge ; le contrôleur doit donc la consulter régulièrement. La documentation Arduino nomme ces rôles "controller" et "peripheral", et la version récente de la norme I2C "controller" et "target" ; ils désignent la même chose que le maître et l'esclave des anciens programmes.
Câblage : les fils I2C entre deux Arduino
| Arduino A (contrôleur) | Liaison | Arduino B (cible) | Remarque |
|---|---|---|---|
| A4 (SDA) | Directe | A4 (SDA) | Pas de croisement |
| A5 (SCL) | Directe | A5 (SCL) | Pas de croisement |
| GND | Directe | GND | Obligatoire : référence commune |
| 5V | Facultative | 5V | Seulement si la carte B est alimentée par la carte A |
| SDA et SCL | 4,7 kΩ vers 5V | - | Une paire de résistances suffit pour tout le bus |
| Carte | SDA | SCL | Remarque |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | Sur l'Uno R3, SDA et SCL près d'AREF sont le même bus |
| Arduino Mega 2560 | D20 | D21 | Résistances de pull-up de 10 kΩ sur la carte |
| Arduino Leonardo / Micro | D2 | D3 | Broches différentes de l'Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V ; Wire.begin(sda, scl) permet de choisir d'autres broches |
| Raspberry Pi Pico | GP4 (I2C0) | GP5 (I2C0) | 3,3 V ; en MicroPython, d'autres paires de broches sont possibles |
Résistances de pull-up : quand et quelle valeur ?
Les appareils d'un bus I2C ne peuvent que tirer les lignes à LOW ; ce sont les résistances de pull-up qui les ramènent à HIGH. Sur les cartes AVR d'Arduino, Wire.begin() active sur SDA et SCL des pull-up internes d'environ 20 à 50 kΩ. Avec deux Uno, des fils courts et 100 kHz, cela fonctionne le plus souvent, mais ces résistances sont faibles pour l'I2C ; plus les fils sont longs, plus les fronts montants ralentissent et plus les erreurs apparaissent. Pour un bus fiable, ajoute une résistance de 4,7 kΩ de SDA vers 5V et une autre de SCL vers 5V. La limite basse vient du courant de 3 mA autorisé à l'état LOW : R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. La limite haute dépend de la capacité du bus : à 100 kHz, pour un bus de 200 pF, R(max) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Pour les calculs, utilise l'outil Loi d'Ohm, et pour le principe, Résistances de pull-up et pull-down.
| Situation | Pull-up conseillée | Remarque |
|---|---|---|
| Deux Uno, fils de moins de 30 cm, 100 kHz | 4,7 kΩ (les internes fonctionnent souvent) | Le montage le plus courant |
| 50 cm à 1 m de fil ou 400 kHz | 2,2 kΩ | Garde malgré tout les fils aussi courts que possible |
| Un Arduino Mega sur le bus | Pas forcément besoin d'autres | Les 10 kΩ du Mega se retrouvent en parallèle avec les autres |
| Modules avec pull-up sur le bus (OLED, RTC, LCD) | Calcule la résistance totale en parallèle | Le total ne doit pas descendre sous 1,5 kΩ |
| Arduino avec ESP32 ou Pico | Celles du convertisseur de niveau, de chaque côté | Pas de liaison directe, voir la section plus bas |
Choix de l'adresse : laquelle utiliser ?
C'est toi qui choisis l'adresse de l'Arduino cible avec Wire.begin(adresse). Dans l'espace d'adresses 7 bits, 0x00–0x07 et 0x78–0x7F sont réservées, la plage utilisable est donc 0x08–0x77, soit 8 à 119 en décimal. S'il y a d'autres modules sur le bus, choisis une valeur qui n'entre pas en conflit avec les leurs ; le plus sûr est de tout brancher et de lancer le scanner I2C pour voir les adresses occupées. Voici les adresses des modules courants :
| Adresse | Modules qui l'utilisent souvent |
|---|---|
| 0x27 / 0x3F | Écran LCD I2C avec PCF8574 |
| 0x3C / 0x3D | Écran OLED SSD1306 |
| 0x68 | RTC DS1307 et DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 et BME280 |
| 0x40 | Contrôleur de servos PCA9685, INA219 |
| 0x48 | CAN ADS1115 |
| 0x57 | MAX30102, EEPROM AT24C32 des modules RTC |
| 0x08–0x0F | Généralement libres ; une bonne plage pour des cibles Arduino |
Exemple 1 : envoyer un octet du contrôleur vers la cible
Dans le premier exemple, la carte A lit un potentiomètre sur A0, divise la valeur par 4 pour la ramener entre 0 et 255 et l'envoie 10 fois par seconde sous forme d'un seul octet à l'adresse 8. La carte B reçoit cet octet et règle la luminosité de la LED sur D9. Téléverse d'abord le programme du contrôleur sur la carte A, puis celui de la cible sur la carte B. La bibliothèque Wire est fournie avec l'Arduino IDE, rien à installer. Programme du contrôleur :
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}Programme de la cible à téléverser sur la carte 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}Le programme de la cible comporte deux points clés. Le premier est Wire.begin(8) : une carte démarrée avec une adresse devient une cible. Le second est Wire.onReceive() : quand le contrôleur envoie des données, la bibliothèque Wire appelle elle-même cette fonction et lui passe le nombre d'octets reçus. On range la valeur dans une variable volatile et on lève simplement un drapeau "nouvelle donnée" ; le réglage de la LED et l'affichage dans le moniteur série se font dans loop(). Côté contrôleur, la valeur renvoyée par Wire.endTransmission() t'indique ce qu'est devenu le message :
| Valeur de endTransmission() | Signification | Que faire ? |
|---|---|---|
| 0 | Succès, la cible a acquitté chaque octet | - |
| 1 | Données trop longues pour le tampon (plus de 32 octets) | Découpe le message |
| 2 | Pas d'ACK sur l'adresse | Vérifie l'adresse, le câblage, la GND et que la cible est alimentée |
| 3 | Pas d'ACK sur un octet de données | La cible est occupée ou a reçu une longueur inattendue |
| 4 | Autre erreur | Bus parasité ou pull-up manquantes |
| 5 | Délai dépassé | Le bus est bloqué ; active la récupération avec setWireTimeout() |
onReceive et onRequest : les règles dans l'interruption
- Fais court : les deux fonctions s'exécutent dans l'interruption I2C. N'y utilise ni delay(), ni Serial.print(), ni de longs calculs ; range la donnée dans une variable et sors.
- Utilise volatile : déclare volatile les drapeaux modifiés dans l'interruption et lus dans loop() ; sinon le compilateur risque de ne pas voir le changement. Détails dans Les interruptions Arduino.
- Écris tout d'un coup dans onRequest : quand le contrôleur demande des données, place tous les octets dans le tampon avec un seul Wire.write(tableau, longueur). Prépare les données à l'avance ; lire un capteur dans onRequest fait attendre le contrôleur.
- La limite de 32 octets : le tampon de Wire fait 32 octets sur AVR. Découpe les données plus longues en plusieurs messages ou, si c'est vraiment nécessaire, utilise l'UART.
- Vérifie la longueur : compare le nombre d'octets reçus dans onReceive avec celui attendu ; s'il y en a trop ou pas assez, lis-les et jette-les.
- Prépare la réponse à l'avance : mets à jour les variables du rapport avant que la cible ne lance une tâche longue ; le contrôleur trouve ainsi toujours une réponse prête.
Exemple 2 : communication bidirectionnelle avec un struct
Dans les vrais projets, un octet ne suffit pas : le contrôleur envoie une commande et la cible renvoie un rapport contenant plusieurs valeurs. Plutôt que de découper les valeurs en octets à la main, il est plus lisible et plus rapide de définir un struct et de l'envoyer tel quel. Dans l'exemple ci-dessous, le contrôleur règle la LED et sa luminosité avec une commande de 2 octets, puis demande à la cible, avec Wire.requestFrom(), un rapport de 7 octets : la valeur du potentiomètre (uint16_t), l'état du bouton (uint8_t) et le temps de fonctionnement de la cible (uint32_t). Les structures doivent être identiques sur les deux cartes. Programme du contrôleur :
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}Programme de la carte cible ; les définitions des structures sont exactement les mêmes que sur le contrôleur :
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}Dans le programme de la cible, la fonction enregistrée avec Wire.onRequest() envoie la structure du rapport telle quelle dès que le contrôleur demande des données. Le rapport lui-même est mis à jour dans loop(). Pendant cette mise à jour, on suspend brièvement les interruptions avec noInterrupts() : si le contrôleur interroge pile à ce moment, il ne reçoit pas une valeur à moitié ancienne et à moitié nouvelle. La commande reçue est elle aussi copiée dans une variable locale sous la même protection. Côté contrôleur, la ligne Wire.setWireTimeout(25000, true) empêche le bus de rester bloqué indéfiniment si un fil se débranche ou si la cible plante : sans réponse en 25 ms, Wire se réinitialise tout seul.
Brancher plusieurs Arduino sur le même bus
Le grand avantage de l'I2C sur l'UART, c'est que de nombreuses cibles partagent les deux mêmes fils. Donne à chaque carte cible une adresse différente (par exemple 8, 9 et 10), relie toutes les SDA, toutes les SCL et toutes les GND, et n'utilise qu'une seule paire de résistances de pull-up pour tout le bus. Le contrôleur peut parcourir un tableau d'adresses pour envoyer une commande à chaque carte et lui demander son rapport. Plus le bus est long, plus sa capacité augmente ; garde les cartes proches, limite la longueur totale des fils à quelques dizaines de centimètres et, si besoin, reste à 100 kHz. Tu peux aussi placer sur le même bus des modules comme un écran LCD I2C ou un OLED ; tant que les adresses ne se chevauchent pas, tout fonctionne ensemble sans souci.
I2C entre Arduino et ESP32 : conversion de niveau
L'Arduino Uno fonctionne en 5 V et l'ESP32 en 3,3 V, et les broches de l'ESP32 ne tolèrent pas le 5 V. Comme Wire.begin() relie les pull-up internes de l'Uno au 5 V, une liaison directe tire les broches de l'ESP32 à 5 V. L'inverse pose aussi problème : si tu tires le bus seulement à 3,3 V, les entrées I2C de l'Uno demandent au moins 0,7 × 5 V = 3,5 V pour lire HIGH, et 3,3 V reste en dessous. La bonne solution est un convertisseur de niveau bidirectionnel BSS138 avec des pull-up de chaque côté : le côté HV va au 5V et à A4/A5 de l'Uno, le côté LV au 3V3 et aux GPIO 21/22 de l'ESP32, les GND sont communes. Pour le câblage détaillé, lis Convertisseur de niveau logique. L'ESP32 peut aussi servir de cible à partir de la version 2.0.1 du core, mais préparer les données pile au moment de onRequest y est plus délicat ; le montage le plus fiable reste donc l'ESP32 en contrôleur et l'Uno en cible. Le programme ci-dessous lit le même rapport que la cible Uno de l'exemple 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}Contrôleur I2C avec le Raspberry Pi Pico (MicroPython)
Le Raspberry Pi Pico fonctionne lui aussi en 3,3 V : il se relie donc à l'Uno de la même façon, via un convertisseur de niveau. MicroPython n'a pas de structs comme le C, mais le module struct fait le même travail : le format "<HBI" signifie un uint16_t, un uint8_t et un uint32_t en little-endian sans bourrage, ce qui correspond exactement au rapport de 7 octets de l'Uno. Le code scanne d'abord le bus et affiche les adresses trouvées, puis envoie une commande à la cible Uno et lit son rapport. Si tu débutes avec le Pico, commence par Qu'est-ce que le 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 ? Comparaison
| Caractéristique | I2C | UART |
|---|---|---|
| Fils | SDA, SCL et GND (directs) | TX, RX et GND (croisés) |
| Nombre d'appareils | Un contrôleur et jusqu'à 112 adresses | Deux appareils seulement |
| Qui lance l'échange ? | Le contrôleur uniquement | Les deux côtés, quand ils veulent |
| Vitesse typique | 100 kHz ou 400 kHz | 9600 à 115200 bauds |
| Distance | Sur la carte et fils courts (jusqu'à 1 m) | Quelques mètres ; bien plus avec le RS-485 |
| Accusé de réception | Oui (ACK et NACK) | Non ; à ajouter soi-même |
| Taille des messages (Wire) | Tampon de 32 octets | Flux continu d'octets |
| Matériel sur l'Arduino Uno | A4 et A5 | D0 et D1 (partagés avec l'USB) ou SoftwareSerial |
En résumé : choisis l'I2C quand les cartes sont dans le même boîtier, qu'une carte principale pilote plusieurs auxiliaires et que tu veux être sûr que chaque message arrive. Si les cartes sont à plusieurs mètres, si les deux côtés doivent pouvoir envoyer à tout moment ou s'il y a un long flux de données continu, l'UART convient mieux ; les détails sont dans Liaison série UART. Si tu as besoin de beaucoup de vitesse, la troisième option est le SPI.
Erreurs fréquentes et solutions
- endTransmission() renvoie 2 : la cible ne répond pas à cette adresse. Vérifie que l'adresse est la même dans les deux programmes, que SDA et SCL ne sont pas inversées, que la GND est reliée et que le programme de la cible est téléversé ; confirme l'adresse avec le scanner I2C.
- Croiser SDA et SCL comme en UART : en I2C, SDA va sur SDA et SCL sur SCL ; avec des fils croisés, aucun appareil n'est détecté.
- Le programme se fige dans onReceive : la fonction d'interruption utilise Serial.print() ou delay(), ou lance une nouvelle transmission Wire. Contente-toi d'y copier la donnée et fais le travail dans loop().
- Les valeurs arrivent mélangées ou décalées : les définitions du struct diffèrent entre les cartes, un type comme int dont la taille dépend de la carte a été utilisé, ou packed manque. Utilise des types de taille fixe et la même définition.
- Des erreurs aléatoires quand les fils s'allongent : les pull-up internes ne suffisent plus. Ajoute des résistances externes de 4,7 kΩ ou 2,2 kΩ, raccourcis les fils et reste à 100 kHz.
- Avec l'ESP32 le bus ne marche pas ou l'ESP32 chauffe : 5 V et 3,3 V ont été reliés directement. Intercale un convertisseur de niveau bidirectionnel.
Faire dialoguer deux Arduino en I2C est le moyen le plus simple de découper un gros projet en petites parties indépendantes : une carte gère l'écran et l'utilisateur pendant que les autres lisent des capteurs ou pilotent des moteurs. Vérifie d'abord la liaison avec l'exemple à un octet, puis passe à l'exemple bidirectionnel avec struct. Dans l'application BlueGrays, tu trouveras avec schéma et code pas à pas les projets de communication unidirectionnelle et bidirectionnelle entre 2 Arduino, l'écran LCD I2C, la calculatrice I2C, l'écran LCD I2C sur ESP32 et l'horloge avec RTC DS1307.
Questions fréquentes
Comment faire communiquer deux Arduino en I2C ?
Relie directement les broches A4 (SDA), A5 (SCL) et GND des deux cartes. L'une démarre comme contrôleur avec Wire.begin(), l'autre comme cible avec une adresse, par exemple Wire.begin(8). Le contrôleur envoie avec beginTransmission, write et endTransmission et demande des données avec requestFrom ; la cible répond par ses fonctions onReceive et onRequest.
Faut-il des résistances de pull-up pour l'I2C entre deux Arduino ?
Oui ; les lignes I2C sont à drain ouvert, c'est donc la pull-up qui fournit le niveau HIGH. Les pull-up internes de l'Arduino fonctionnent souvent avec deux cartes et des fils courts, mais pour un bus fiable on conseille d'ajouter 4,7 kΩ de SDA et de SCL vers 5V.
Combien d'Arduino peut-on brancher sur un bus I2C ?
Avec l'adressage 7 bits, 112 adresses de 0x08 à 0x77 sont utilisables : en théorie, 112 cibles. En pratique, la limite vient de la capacité totale du bus et de la longueur des fils ; avec quelques cartes et des fils courts, tu n'auras aucun problème.
Un Arduino esclave peut-il envoyer des données au maître de lui-même ?
Non. En I2C, c'est toujours le contrôleur qui lance la communication ; la cible ne répond via onRequest que lorsqu'on l'interroge. Si la cible doit signaler une nouvelle donnée, le contrôleur l'interroge régulièrement, ou la cible met à LOW une broche d'interruption séparée pour le prévenir.
Peut-on relier directement un Arduino et un ESP32 en I2C ?
C'est déconseillé. L'Uno fonctionne en 5 V et l'ESP32 en 3,3 V, et les pull-up internes de l'Uno tirent les broches de l'ESP32 à 5 V. Utilise un convertisseur de niveau bidirectionnel comme le BSS138 et fais de l'ESP32 le contrôleur et de l'Uno la cible.
Quelle différence entre I2C et UART sur Arduino ?
L'I2C réunit de nombreux appareils sur un même bus avec deux fils et des adresses, et confirme par un ACK l'arrivée de chaque octet, mais seul le contrôleur peut lancer un échange. L'UART ne relie que deux appareils, ses fils sont croisés, et chaque côté peut envoyer quand il veut. L'I2C convient à plusieurs cartes proches, l'UART aux longs câbles et aux flux de données continus.
Projets à réaliser après cet article
Voir tous les projets
Communication unidirectionnelle entre 2 Arduino
Tu fais discuter deux Arduino par un seul fil : appuie sur le bouton de l'un et la LED de l'autre s'allume, appuie encore et elle s'éteint.

Communication bidirectionnelle entre 2 Arduino
Deux Arduino reliés par des fils se parlent : appuie sur le bouton de l'un et la lumière de l'autre s'allume, appuie encore et elle s'éteint.

Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

Calculatrice Arduino I2C
Il s'agit d'un projet de calculatrice basé sur Arduino qui effectue des opérations d'addition, de soustraction, de multiplication et de division à l'aide d'un clavier à membrane 4x4 et d'un écran LCD I2C 16x2. Grâce à l'I2C, la connexion de l'écran n'est assurée que par deux câbles, ce qui réduit l'encombrement des câbles et permet d'utiliser plus de broches. L'entrée de nombres décimaux et la prise en charge des nombres négatifs sont également disponibles.

Écran LCD I2C ESP32 (16x2)
Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

Horloge numérique avec ESP32 et RTC DS1307 (I2C + LCD)
Dans ce projet, nous affichons l'heure et la date sur un écran LCD 16x2 I2C à l'aide du module d'horloge en temps réel (RTC) DS1307. Le DS1307 est une RTC avec batterie de secours qui conserve l'heure même si l'ESP32 s'éteint. Les deux modules partagent la même ligne I2C (SDA/SCL), ce qui nous permet d'apprendre à contrôler plusieurs appareils avec seulement deux fils de signal. Vous decouvrirez ainsi le protocole I2C et le fonctionnement des modules RTC en pratique.

Jeu de Raquettes - SSD1306
Une balle, deux raquettes et toi : tu joues au tennis de table, l'un des tout premiers jeux vidéo, sur un petit écran OLED.

Horloge et calendrier matriciel (MAX7219, DS1307)
Un panneau lumineux pour ton bureau ou ton mur, qui affiche l'heure et la date en texte défilant.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

