English

Leçons · Leçon K5 · Les bases du code · 30 min

Bibliothèques et modules (I2C, UART)

Installe une bibliothèque, découvre quels modules sont sur tes fils I2C grâce à un programme de scan, et vois en quoi une liaison UART est différente. Environ 30 minutes, avec un bus sur lequel tu peux appuyer.

Deux fils, plein de maisons

Pense à une longue rue avec une seule route. De nombreuses maisons la bordent, et chacune a son numéro. Le bureau de poste (ta carte) veut parler au boulanger du numéro 60 : il envoie un message le long de la route avec « numéro 60 » écrit dessus. Toutes les maisons entendent le message, mais seule la numéro 60 répond.

C’est ça, l’I2C (on dit « I deux C »). Deux fils transportent les échanges de nombreux modules : écrans, capteurs, horloges. Chaque module a son adresse, comme un numéro de maison. Pas besoin d’une nouvelle broche pour chacun.

Avant la route, encore une chose : la plupart des modules viennent avec une bibliothèque, un ensemble de fonctions toutes prêtes écrit par quelqu’un d’autre. Elle fait le plus dur de la conversation à ta place, et tu peux écrire display.print("hi") sans te soucier des bits.

Dans cette leçon, tu vas :

  1. installer une bibliothèque avec le gestionnaire de bibliothèques,
  2. relier un module aux deux fils I2C et trouver son adresse,
  3. voir comment une autre liaison, l’UART, fonctionne avec deux autres fils.
I2C : une route, beaucoup de maisons Une rue droite vue de dessus, dessinée à plat. À gauche, la carte en bureau de poste. Deux routes parallèles, étiquetées SDA et SCL, partent vers la droite devant quatre maisons avec des numéros d’exemple sur leurs portes : 0x3C, 0x48, 0x68 et 0x77. Chaque maison est reliée aux deux routes. Une lettre étiquetée pour 0x48 voyage sur les routes : toutes les maisons l’entendent, seule la maison 0x48 répond, et elle est allumée. Les numéros sont des exemples : l’adresse de ton module est dans sa fiche technique, ou le scanner la trouve. 0x3C, c’est simplement 60 écrit en hexadécimal. FIG. 1 — LA RUE I2Cbureau de poste= ta carte(contrôleur)SDASCLSDA : données · SCL : horloge0x3Centend, se tait0x48répond : ici !0x68entend, se tait0x77entend, se taitpour 0x48Numéros d’exemple. Une adresse par maison sur la même route : deux modules avec le même numéro se gênent.0x3C, c’est 60 écrit en hexadécimal. Le scanner trouve le numéro de ton module.
Touche le schéma pour l’ouvrir en plein écran.

Installer une bibliothèque

Une bibliothèque est un dossier de code que tu ajoutes à l’IDE. Dans l’IDE Arduino 2, tu l’installes depuis le gestionnaire de bibliothèques [1] :

  1. Ouvre l’IDE. Dans la colonne de gauche, clique sur l’icône bibliothèque.
  2. Tape le nom de la bibliothèque dans la zone de recherche. La page du vendeur du module ou sa fiche technique dit en général laquelle utiliser.
  3. Clique sur INSTALL et attends. Cela peut prendre jusqu’à une minute.
  4. Quand il est écrit INSTALLED, elle est prête [1].

En haut d’un programme, #include <Nom.h> dit à l’IDE de l’utiliser. Presque toutes les bibliothèques apportent des exemples tout prêts, que tu trouves dans File > Examples > (nom de la bibliothèque) [1]. Partir d’un exemple est le moyen le plus rapide de voir qu’un module fonctionne.

Deux bonnes habitudes. Lis l’exemple de la bibliothèque avant d’écrire ton propre code. Et vérifie pour quelle carte l’exemple a été écrit : tu utilises un ESP32, donc il faudra peut-être changer les numéros de broches.

Une bibliothèque que tu n’as pas à installer : Wire, la bibliothèque I2C, vient avec le paquet de carte ESP32 [4], tout comme le code série [8]. Tu vas utiliser les deux ci-dessous.


L’I2C en un écran

L’I2C utilise deux fils partagés par tous les appareils [4] :

  • SDA, le fil de données,
  • SCL, le fil d’horloge.

(Plus l’alimentation et GND, bien sûr.) Un appareil, le contrôleur (ton ESP32), lance chaque conversation, et les autres sont des périphériques. Un périphérique ne répond que quand on appelle sa propre adresse [5][2]. La bibliothèque Wire utilise des adresses sur 7 bits, qui vont de 0 à 127 ; les adresses 0 à 7 sont réservées, donc la première utilisable est la 8 [2]. Les adresses s’écrivent en hexadécimal, un système de comptage à 16 symboles : 0x3C est simplement 60 en nombres de tous les jours.

Quelles broches ? Sur l’ESP32 générique, les broches I2C par défaut sont GPIO21 pour SDA et GPIO22 pour SCL [4]. Ton programme peut aussi choisir d’autres broches avec Wire.begin(sdaPin, sclPin) [4]. Le programme ci-dessous nomme les broches pour qu’il n’y ait aucun doute.

Les résistances de rappel. Les deux fils ont besoin de résistances de rappel (pull-up), des résistances qui ramènent doucement chaque ligne vers la tension d’alimentation quand personne ne parle [4][2]. SparkFun suggère de partir de 4,7 kΩ [5]. Tu auras rarement à en ajouter, car la plupart des cartes de module en ont déjà : la plupart des modules I2C de SparkFun en ont [5]. Si ton module est une puce seule, ou si sa page dit qu’il n’en a pas, ajoute une résistance de 4,7 kΩ entre SDA et 3V3, et une autre entre SCL et 3V3. Si tu mets beaucoup de modules sur les mêmes fils, il peut y en avoir trop en parallèle [5]. C’est rare dans les projets de débutants.

Une adresse par appareil. Deux modules de même adresse ne peuvent pas partager les fils [6]. Certains modules ont un cavalier, un plot à souder ou une broche pour choisir une autre adresse [6].

Là où l’image s’arrête. Dans une vraie ville, des maisons peuvent avoir le même numéro dans des rues différentes. Sur un seul bus I2C, c’est impossible. Et un numéro de maison ne dit rien de ce qu’il y a dedans : la même adresse peut correspondre à des puces différentes selon les modules, donc regarde la fiche technique du module.

Envoie un message sur le bus I2C (interactif)
Envoie un message sur le bus I2C (interactif) Simulation interactive, pas un vrai bus. À gauche, le contrôleur, ton ESP32. Deux lignes, SDA et SCL, partent vers la droite devant quatre modules dessinés comme des maisons avec les adresses d’exemple 0x3C, 0x48, 0x68 et 0x77. Choisis ou tape une adresse et appuie sur Envoyer : une lettre descend les lignes, chaque maison clignote à son passage, et seule la maison qui a cette adresse répond avec un petit drapeau ACK. Une adresse que personne n’a ne reçoit pas de réponse. Avec l’interrupteur Deux appareils de même adresse, la dernière maison devient 0x3C elle aussi : les deux répondent en même temps et un signe de conflit apparaît. L’onglet Scanner interroge chaque adresse de 8 à 127 et liste celles qui ont répondu. simulation, adresses d’exempleESP32contrôleurSDASCL0x3C0x480x680x77seule l’adresse appelée répond

Simulation avec des adresses d’exemple, pas un vrai bus.

Choisis ou tape une adresse, puis appuie sur Envoyer.

La même adresse peut désigner des puces différentes selon les modules : vérifie la fiche technique.

Voici l’état de départ : les commandes ont besoin de JavaScript.


Avant de brancher : 3,3 V seulement

Les broches de ton ESP32 fonctionnent en 3,3 V (leçon E4). Utilise donc des modules qui fonctionnent en 3,3 V. L’étiquette du module ou la page du vendeur le dit.

Un appareil en 3,3 V peut en général parler à un appareil en 5 V, mais l’inverse demande de la prudence : sur certaines puces en 3,3 V, tout ce qui dépasse 3,6 V cause des dégâts permanents [7]. Si tu dois brancher un module en 5 V, utilise un adaptateur de niveau, une petite carte faite pour convertir entre les deux tensions [7].

Alimente ton module en 3V3, même s’il accepte aussi le 5 V. Sur beaucoup de modules, les résistances de rappel sont reliées à l’alimentation du module : alimentées en 5 V, elles tireraient SDA et SCL jusqu’à 5 V, directement sur les broches de ton ESP32. Les résistances de rappel doivent aller à la plus basse des deux tensions [5].

Modules 3,3 V seulement, ou un adaptateur de niveau Deux cadres côte à côte. a, module 3,3 V : OK, avec une coche verte. Le VCC du module va à la 3V3, GND à GND, SDA à la GPIO 21 et SCL à la GPIO 22, directement vers l’ESP32. b, module 5 V : il faut un adaptateur de niveau, avec un avertissement orange. Une petite carte d’adaptation de niveau est placée entre le module et l’ESP32 : son côté haute tension, 5 V, fait face au module ; son côté basse tension, 3,3 V, fait face à l’ESP32. Sur certaines puces 3,3 V, tout ce qui dépasse 3,6 V cause des dégâts permanents. Alimente un module par la 3V3 s’il l’accepte : ses résistances de rappel suivent son alimentation. FIG. 2 — AVANT DE BRANCHERaModule 3,3 V : OKESP323V3GND2122module 3,3 VVCCGNDSDASCLdirectement vers l’ESP32alimente-le par la 3V3bModule 5 V : adaptateur de niveauESP323V3GND2122adaptateurLVHVmodule 5 VSDASCLcôté 3,3 Vcôté 5 V!au-dessus de 3,6 V, dégâts possiblesfils d’alimentation et GND non dessinésAlimente le module par la 3V3 s’il l’accepte : ses résistances de rappel suivent son alimentation et ne doivent pas monter à 5 V.
Touche le schéma pour l’ouvrir en plein écran.

Trouve ton module : le scanner

Relie un module I2C en 3,3 V, par exemple un petit écran ou un capteur :

Module ESP32 DevKitC
VCC (ou 3V3) 3V3
GND GND
SDA GPIO 21
SCL GPIO 22
Câblage K5 : un module I2C sur 3V3, GND, 21 et 22 Deux cadres. a, la DevKitC vue de dessus, USB à gauche, hors de la plaque d’essai : les GPIO 21 et 22 sont sur sa rangée de broches du bas, donc des fils à embout femelle vont directement sur les broches, et la plaque n’est pas nécessaire. Un module I2C 3,3 V à droite, broches VCC, GND, SDA et SCL. Quatre fils numérotés : 1 rouge, 3V3 vers VCC ; 2 noir, GND vers GND ; 3 bleu, GPIO 21 vers SDA ; 4 jaune, GPIO 22 vers SCL. Utilise un module qui fonctionne en 3,3 V ; vérifie l’ordre des broches imprimé sur le tien. b, le moniteur série à 115200 bauds après le téléversement du scanner : Scanning..., Found a device at address 0x3C, Done: 1 device(s) found. L’adresse dépend de ton module. FIG. 3 — CÂBLAGE ET SORTIE DU SCANNERaCâblageENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDmodule I2C, 3,3 VVCCGNDSDASCLGND3V3GND2122GND1234vérifie l’ordre des broches du tien1rouge : 3V3 → VCC (pas 5 V)2noir : GND → GND3bleu : GPIO 21 → SDA (données)4jaune : GPIO 22 → SCL (horloge)21 et 22 sont sur la rangée du bas : fils à embout femelle directement sur les broches, pas besoin de plaque d’essai.bCe qu’affiche le scannerMoniteur série · 115200 baudsScanning...Found a device at address 0x3CDone: 1 device(s) found.L’adresse dépendde ton module.Note-la : ta bibliothèquela demandera souvent.
Touche le schéma pour l’ouvrir en plein écran.

Téléverse ce programme et ouvre le moniteur série à 115200 baud :

// Tinker Mission, leçon K5 : scanner I2C (trouver l’adresse de chaque module du bus)
// Câblage (utilise un module qui fonctionne en 3,3 V) :
//   VCC du module -> 3V3        GND du module -> GND
//   SDA du module -> GPIO 21    SCL du module -> GPIO 22
// Ouvre le moniteur série à 115200 baud. La carte demande à chaque adresse de 8 à 127
// « y a-t-il quelqu’un ? » et affiche celles qui répondent.

#include <Wire.h>

const int SDA_PIN = 21;   // la broche de données I2C habituelle de l’ESP32 DevKitC
const int SCL_PIN = 22;   // la broche d’horloge I2C habituelle de l’ESP32 DevKitC

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);   // démarre le bus I2C sur ces deux broches
}

void loop() {
  Serial.println("Scanning...");
  int found = 0;

  for (byte address = 8; address <= 127; address++) {
    Wire.beginTransmission(address);       // frappe à cette adresse
    byte result = Wire.endTransmission();  // 0 veut dire « quelqu’un a répondu »
    if (result == 0) {
      Serial.print("Found a device at address 0x");
      if (address < 16) {
        Serial.print("0");                 // garde deux chiffres, comme 0x3C ou 0x08
      }
      Serial.println(address, HEX);
      found = found + 1;
    }
  }

  if (found == 0) {
    Serial.println("No device found. Check power, SDA and SCL wires.");
  } else {
    Serial.print("Done: ");
    Serial.print(found);
    Serial.println(" device(s) found.");
  }
  Serial.println();
  delay(5000);   // un delay() ne gêne pas ici : ce programme n’a pas d’autre travail
}

Télécharger le dossier du croquis (.zip)

Tu devrais voir quelque chose comme ceci (l’adresse dépend de ton module) :

Scanning...
Found a device at address 0x3C
Done: 1 device(s) found.

Comment ça marche : pour chaque adresse de 8 à 127, la carte commence un message vers cette adresse avec Wire.beginTransmission(address) et le termine avec Wire.endTransmission(). Cette fonction renvoie 0 si la transmission a réussi, et 2 si personne n’a répondu à cette adresse [3]. Un 0 veut donc dire « quelqu’un habite ici ». Note le numéro : ta bibliothèque te le demandera le plus souvent.


L’UART en un écran

L’UART est l’autre liaison courante. Contrairement à l’I2C, elle utilise deux fils entre seulement deux appareils : un fil pour envoyer et un pour recevoir. Le TX (envoi) de chaque appareil va au RX (réception) de l’autre, donc les fils se croisent : un émetteur doit parler à un récepteur, pas à un autre émetteur [9]. Les deux côtés doivent aussi s’entendre sur la vitesse, appelée débit en bauds (baud rate), car il n’y a pas de fil d’horloge [9]. Et les deux appareils partagent GND.

Tu utilises déjà un UART : le premier UART de la carte, appelé UART0, rejoint le câble USB de ton ordinateur par une petite puce USB-série [10][8]. Il sert à la programmation et au moniteur série [8]. C’est l’objet Serial. L’ESP32 a aussi d’autres UART, appelés Serial1 et Serial2, pour un usage général [8].

Tu choisis les broches au démarrage : Serial2.begin(baud, SERIAL_8N1, rxPin, txPin) [8]. SERIAL_8N1 est le format habituel [9]. Essaie sans aucun module : un fil de liaison de la GPIO 23 (TX2) à la GPIO 32 (RX2) fait écouter la carte par elle-même.

// Tinker Mission, leçon K5 : test UART avec Serial2 (une boucle sur soi-même, sans module)
// Câblage : un fil de liaison entre la GPIO 23 (TX2, envoie) et la GPIO 32 (RX2, reçoit).
// La carte se parle à elle-même : ce qu’elle envoie sur TX2 revient sur RX2.
// Ouvre le moniteur série à 115200 baud. Retire le fil et les lignes « received » s’arrêtent.

const int RX2_PIN = 32;   // Serial2 reçoit ici
const int TX2_PIN = 23;   // Serial2 envoie d’ici

const unsigned long SEND_INTERVAL = 2000;   // un message toutes les 2000 ms
unsigned long lastSend = 0;
int counter = 0;

void setup() {
  Serial.begin(115200);                                  // la liaison USB vers ton ordinateur
  Serial2.begin(9600, SERIAL_8N1, RX2_PIN, TX2_PIN);     // vitesse, format, broche de réception, broche d’envoi
}

void loop() {
  unsigned long now = millis();

  // Envoie une courte ligne toutes les 2 secondes.
  if (now - lastSend >= SEND_INTERVAL) {
    lastSend = now;
    Serial2.print("hello ");
    Serial2.println(counter);
    Serial.print("sent: hello ");
    Serial.println(counter);
    counter = counter + 1;
  }

  // Lit ce qui est arrivé sur Serial2.
  if (Serial2.available() > 0) {
    String line = Serial2.readStringUntil('\n');
    line.trim();                                         // retire les caractères de fin de ligne
    Serial.print("received: ");
    Serial.println(line);
  }
}

Télécharger le dossier du croquis (.zip)

Boucle UART : la GPIO 23 parle à la GPIO 32 Trois cadres. a, la DevKitC vue de dessus, USB à gauche, sans module : un fil à deux embouts femelles va de la GPIO 23 sur la rangée du bas, TX2, la broche qui envoie, en faisant le tour du bout de la carte, jusqu’à la GPIO 32 sur la rangée du haut, RX2, la broche qui reçoit. La carte se parle à elle-même. b, le moniteur série à 115200 bauds : sent: hello 0, received: hello 0, sent: hello 1, received: hello 1. Retire le fil et les lignes received s’arrêtent. c, avec deux appareils, les fils se croisent : chaque TX va au RX de l’autre, les deux utilisent la même vitesse en bauds, et ils partagent GND. FIG. 4 — BOUCLE UARTaUn fil, sans moduleENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GND322332 = RX2 (reçoit)23 = TX2 (envoie)les donnéesvont de 23 à 32bMoniteur sérieMoniteur série · 115200 baudssent: hello 0received: hello 0sent: hello 1received: hello 1cDeux appareils : les fils se croisentcarteTXRXGNDmoduleTXRXGNDmême vitesse en bauds, GND commun
Touche le schéma pour l’ouvrir en plein écran.

Toutes les deux secondes, tu devrais voir une ligne « sent », suivie d’une ligne « received ». Un caractère bizarre tout au début, ou quand tu bouges le fil, est normal. Retire le fil : les lignes « received » s’arrêtent, car personne n’écoute.

Les modules GPS, les capteurs d’empreintes et beaucoup d’autres parlent UART. Pour ceux-là, souviens-toi du croisement : leur TX va à ta broche RX.


Fais tes propres modifications

Change une seule chose, puis observe.

  1. Compte les appareils. Débranche le câble USB, puis relie un second module I2C en 3,3 V aux mêmes lignes SDA, SCL, 3V3 et GND, en parallèle. Rebranche le câble. Le scanner trouve-t-il deux adresses ? Que se passe-t-il si elles sont identiques ?
  2. Débranche un fil. Retire le fil SCL pendant que le scanner tourne. Que dit le moniteur série ?
  3. Un UART plus rapide. Dans le programme de bouclage, remplace 9600 par 115200 dans Serial2.begin. Est-ce que ça marche encore ? Pourquoi, alors que les deux bouts sont le même Serial2 ?

Quand ça ne marche pas

  • « No device found ». Vérifie l’alimentation (3V3, pas 5 V) et GND. Vérifie que SDA va à la GPIO 21 et SCL à la GPIO 22, et qu’ils ne sont pas inversés. Si ton module n’a pas de résistances de rappel, ajoute-les comme expliqué plus haut.
  • L’adresse n’est pas celle que dit le module. Certains modules ont des plots ou des cavaliers d’adresse [6]. Utilise le numéro que trouve le scanner.
  • Deux modules, un seul apparaît. Ils ont peut-être la même adresse [6]. Cherche un cavalier ou un plot d’adresse.
  • Le scanner trouve quelque chose, mais le programme d’exemple ne marche pas. Vérifie que le programme utilise tes broches et l’adresse trouvée par le scanner, et que la bibliothèque est installée.
  • UART : que des caractères bizarres. Les deux côtés doivent utiliser le même débit en bauds [9].
  • UART : rien n’arrive. TX et RX doivent se croiser [9], et les deux cartes doivent partager GND.
  • Rien dans le moniteur série. Règle-le sur 115200 baud, comme dans Serial.begin(115200).

Vérifie-toi

Trois petites questions. Rien n’est enregistré, prends ton temps.

  1. Où installe-t-on une bibliothèque dans l’IDE Arduino 2 ?

    • Dans le gestionnaire de bibliothèques, ouvert avec l’icône de bibliothèque de la colonne de gauche
    • Dans le moniteur série
    • Il faut réécrire la bibliothèque soi-même
    Voir la réponse

    Dans le gestionnaire de bibliothèques, ouvert avec l’icône de bibliothèque de la colonne de gauche. Dans l’IDE 2, tu cliques sur l’icône de bibliothèque de la colonne de gauche, tu cherches, puis tu appuies sur INSTALL [1]. Une fois installée, les exemples de la bibliothèque se trouvent sous File > Examples [1].

  2. Deux modules I2C répondent tous les deux à l’adresse 0x3C. Quel est le problème ?

    • Aucun, la carte les distingue par leur couleur
    • Chaque appareil sur les mêmes fils I2C doit avoir sa propre adresse, donc ils vont se gêner
    • Les adresses ne comptent que pour l’UART
    Voir la réponse

    Chaque appareil sur les mêmes fils I2C doit avoir sa propre adresse, donc ils vont se gêner. Chaque appareil I2C d’un bus doit avoir une adresse unique : deux appareils de même adresse ne peuvent pas partager les deux mêmes fils [6]. Certains modules ont un cavalier ou une broche de choix d’adresse pour changer la leur [6].

  3. Tu relies directement à l’ESP32 un module qui fonctionne en 5 V. Que dois-tu vérifier en premier ?

    • Si ses signaux dépassent 3,3 V : les broches de l’ESP32 sont faites pour 3,3 V, et certaines puces en 3,3 V sont endommagées au-delà de 3,6 V
    • Rien, 5 V et 3,3 V, c’est pareil
    • Que le module soit de la même couleur que la carte
    Voir la réponse

    Si ses signaux dépassent 3,3 V : les broches de l’ESP32 sont faites pour 3,3 V, et certaines puces en 3,3 V sont endommagées au-delà de 3,6 V. Passer d’un appareil en 5 V à un appareil en 3,3 V demande de la prudence : sur certaines puces en 3,3 V, une tension supérieure à 3,6 V cause des dégâts permanents [7]. Prends un module prévu pour 3,3 V, ou un adaptateur de niveau [7].


En bref

  • Dans l’IDE Arduino 2, installe une bibliothèque depuis le gestionnaire de bibliothèques, puis regarde dans File > Examples [1].
  • L’I2C utilise deux fils partagés, SDA et SCL. Le contrôleur appelle une adresse et seul ce périphérique répond [4][2].
  • Sur l’ESP32 générique, les broches par défaut sont la GPIO21 (SDA) et la GPIO22 (SCL), et tu peux en choisir d’autres [4].
  • Les fils ont besoin de résistances de rappel, que beaucoup de modules ont déjà [4][5].
  • Chaque appareil d’un bus a besoin de sa propre adresse. Lance un scanner pour la trouver [6][3].
  • Utilise des modules en 3,3 V, ou un adaptateur de niveau [7].
  • L’UART utilise deux fils entre deux appareils, avec TX vers RX en croisé, le même débit en bauds [9][8], et un GND commun.

Prochaines étapes : le Wi-Fi et la radio (W1), ou les modules de distance et de caméra de S3.


Sources

Voir les 10 sources
  1. Arduino, « Installing libraries » (IDE Arduino 2 : cliquer sur l’icône de bibliothèque de la colonne de gauche, chercher, appuyer sur INSTALL, l’état devient INSTALLED ; exemples sous File > Examples > bibliothèque > exemple) — https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-installing-a-library/
  2. Arduino, Language Reference, « Wire » (la bibliothèque utilise des adresses sur 7 bits ; les adresses 0 à 7 sont réservées, la première utilisable est donc la 8 ; des résistances de rappel sont nécessaires sur SDA et SCL ; rôles de contrôleur et de périphérique) — https://docs.arduino.cc/language-reference/en/functions/communication/wire/
  3. Arduino, Language Reference, « Wire.endTransmission() » (renvoie 0 en cas de succès et 2 quand un NACK est reçu à l’envoi de l’adresse) — https://docs.arduino.cc/language-reference/en/functions/communication/wire/endTransmission/
  4. Espressif, documentation Arduino-ESP32, « I2C » (deux fils, SDA et SCL, plusieurs appareils ayant chacun une adresse unique sur 7 bits ; les lignes exigent des résistances de rappel ; setPins et begin permettent de choisir les broches ; sur l’ESP32 générique, les broches par défaut sont la GPIO21 pour SDA et la GPIO22 pour SCL) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2c.html
  5. SparkFun, « I2C » (deux signaux SDA et SCL ; une résistance de rappel sur chaque ligne, partir de 4,7 kΩ puis ajuster ; la plupart des appareils I2C de SparkFun incluent des résistances de rappel, et avec beaucoup d’appareils il peut falloir en déconnecter ; avec deux tensions différentes, relier les résistances de rappel à la plus basse) — https://learn.sparkfun.com/tutorials/i2c
  6. Adafruit, « I2C Addresses and Troublesome Chips » (chaque appareil I2C doit avoir une adresse unique de 0 à 127 ; deux appareils de même adresse ne peuvent pas partager les lignes ; parmi les solutions : une ligne ou un cavalier de choix d’adresse) — https://learn.adafruit.com/i2c-addresses
  7. SparkFun, « Logic Levels » (un appareil en 3,3 V peut se connecter à un appareil en 5 V ; dans l’autre sens, vérifier que l’appareil en 3,3 V tolère le 5 V, car au-dessus de 3,6 V certains peuvent être endommagés de façon permanente ; utiliser un pont diviseur ou un adaptateur de niveau) — https://learn.sparkfun.com/tutorials/logic-levels
  8. Espressif, documentation Arduino-ESP32, « Serial (UART) » (UART0 sert en général à la programmation et au moniteur série ; Serial1, Serial2 pour la communication générale ; begin(baud, config, rxPin, txPin)) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/serial.html
  9. SparkFun, « Serial Communication » (le TX va au RX de l’autre appareil et inversement ; les deux côtés doivent utiliser le même débit en bauds ; format 8N1) — https://learn.sparkfun.com/tutorials/serial-communication
  10. Espressif, « ESP32-DevKitC User Guide » (la carte a une puce pont USB-UART ; son port micro-USB assure l’alimentation et la communication entre un ordinateur et le module ESP32) — https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32/esp32-devkitc/user_guide.html

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.