Scanner I2C avec Arduino : Trouver chaque périphérique sur le bus

Introduction

Avez-vous déjà connecté un nouveau capteur ou écran I2C à votre Arduino en vous demandant : « Quelle adresse cet appareil utilise-t-il ? » Vous n’êtes pas seul ! Le protocole I2C est un moyen puissant de communiquer avec plusieurs périphériques en utilisant seulement deux fils, mais chaque appareil a une adresse unique — et parfois cette adresse n’est pas évidente dans la fiche technique. C’est là qu’un scanner I2C entre en jeu. C’est un sketch simple qui sonde toutes les adresses possibles et rapporte lesquelles répondent.

Dans ce tutoriel, nous allons construire un scanner I2C en utilisant un Arduino Uno et un écran OLED SSD1306 (qui sert également de périphérique connu sur le bus). Nous exécuterons le tout dans le simulateur en ligne Velxio, vous n’avez donc besoin d’aucun matériel pour suivre. À la fin, vous comprendrez comment fonctionne le bus I2C, comment câbler des périphériques et comment écrire du code pour les scanner.

C’est parti !

Présentation du circuit

Le circuit est d’une simplicité rafraîchissante. Nous n’avons besoin que de deux composants :

• Arduino Uno – le cerveau de l’opération.
• Écran OLED SSD1306 – un écran monochrome de 128x64 pixels qui utilise l’I2C pour communiquer. Son adresse par défaut est 0x3C.

Détails du câblage

Connectez l’OLED à l’Arduino en utilisant quatre fils :

• SDA (A4) est la ligne de données. Elle transporte les données réelles entre le maître (Arduino) et l’esclave (OLED).
• SCL (A5) est la ligne d’horloge. Elle synchronise le transfert de données.
• GND et 5V fournissent l’alimentation à l’OLED.

Remarque : Sur l’Arduino Uno, A4 et A5 sont les broches I2C dédiées. D’autres cartes peuvent utiliser des broches différentes (par exemple, SDA/SCL sur un ESP32).

Dans le simulateur Velxio, vous pouvez ajouter l’OLED depuis le sélecteur de composants et le câbler en cliquant sur les broches. La barre d’outils du canevas vous aide à zoomer et à vous déplacer pour faciliter les connexions.

Explication du code

Regardons maintenant le code. Ouvrez l’éditeur de code dans Velxio (vous verrez l’éditeur Monaco avec coloration syntaxique). Le sketch est écrit en Arduino C++ et utilise la bibliothèque intégrée Wire.

Inclusion de la bibliothèque

#include <Wire.h>

La bibliothèque Wire gère toute la communication I2C de bas niveau. Elle est incluse avec l’IDE Arduino, donc aucune installation supplémentaire n’est nécessaire.

Fonction Setup

void setup() {
  Wire.begin();
  Serial.begin(9600);

  Serial.println("===========================");
  Serial.println("  Scanner de bus I2C (TWI)");
  Serial.println("===========================");
  Serial.println("Scan en cours...");
  Serial.println();

  int devicesFound = 0;

  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    byte error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("  Périphérique trouvé à 0x");
      if (addr < 16) Serial.print("0");
      Serial.print(addr, HEX);

      // Identification des adresses connues
      switch (addr) {
        case 0x27: Serial.print("  (Backpack LCD PCF8574)"); break;
        case 0x3C: Serial.print("  (OLED SSD1306)"); break;
        case 0x48: Serial.print("  (Capteur de température)"); break;
        case 0x50: Serial.print("  (EEPROM)"); break;
        case 0x68: Serial.print("  (RTC DS1307)"); break;
        case 0x76: Serial.print("  (Capteur BME280)"); break;
        case 0x77: Serial.print("  (BMP180/BMP280)"); break;
      }
      Serial.println();
      devicesFound++;
    }
  }

  Serial.println();
  Serial.print("Scan terminé. ");
  Serial.print(devicesFound);
  Serial.println(" périphérique(s) trouvé(s).");

  if (devicesFound == 0) {
    Serial.println("Aucun périphérique I2C trouvé. Vérifiez les connexions.");
  }
}

Détaillons-le :

1. Wire.begin() – Initialise l’Arduino en tant que maître I2C.
2. Serial.begin(9600) – Démarre la communication série à 9600 bauds pour voir les résultats dans le Moniteur Série.
3. La boucle parcourt les adresses de 1 à 126 (0x01 à 0x7E). L’adresse 0 est réservée pour l’appel général, et 127 est réservée à des fins spéciales.
4. Wire.beginTransmission(addr) – Démarre une transmission vers l’adresse donnée.
5. Wire.endTransmission() – Termine la transmission et renvoie un code d’erreur. Si l’erreur est 0, cela signifie que le périphérique a accusé réception (ACK) — nous avons trouvé un appareil !
6. Affichage de l’adresse – Nous l’affichons en format hexadécimal avec un zéro non significatif pour la lisibilité.
7. Instruction switch – Identifie les périphériques courants par leurs adresses connues. C’est facultatif mais utile.
8. Comptage des périphériques – Nous incrémentons devicesFound pour chaque ACK.
9. Rapport final – Affiche le nombre total de périphériques trouvés.

Fonction Loop

void loop() {
  // Rescan toutes les 10 secondes
  delay(10000);
  Serial.println("\nNouveau scan...");
  setup();
}

La fonction loop() attend simplement 10 secondes puis appelle setup() à nouveau pour rescanner. Cela est utile si vous ajoutez ou retirez des périphériques pendant que le système fonctionne.

Concepts clés pour les étudiants

Qu’est-ce que l’I2C ?

L’I2C (Inter-Integrated Circuit), également appelé TWI (Two-Wire Interface), est un protocole de communication série synchrone. Il utilise deux lignes bidirectionnelles à drain ouvert : SDA (données) et SCL (horloge). Chaque périphérique sur le bus a une adresse unique de 7 bits (bien que des adresses de 10 bits existent). Le maître (Arduino) initie la communication et génère le signal d’horloge.

Comment fonctionne le scanner

Le scanner envoie une condition de départ suivie de l’octet d’adresse (adresse 7 bits + bit de lecture/écriture). Si un périphérique avec cette adresse existe, il répond par un ACK (accusé de réception) en tirant SDA à l’état bas pendant la neuvième impulsion d’horloge. Si aucun périphérique ne répond, un NACK (non-accusé de réception) est reçu, et endTransmission() renvoie un code d’erreur non nul.

Pourquoi utiliser un scanner ?

• Trouver des adresses inconnues – De nombreux périphériques I2C ont des adresses configurables (par exemple, en soudant des pads). Un scanner vous indique l’adresse réelle.
• Déboguer le câblage – Si un périphérique ne répond pas, le scanner peut confirmer s’il est correctement connecté.
• Vérifier les conflits – Deux périphériques avec la même adresse provoqueront des erreurs de communication. Le scanner peut aider à identifier les doublons.

Pièges courants et astuces de débogage

1. Mauvais câblage – Vérifiez que SDA et SCL sont correctement connectés. Les inverser ne fonctionnera pas.
2. Résistances de tirage manquantes – Les lignes I2C ont besoin de résistances de tirage (généralement 4,7 kΩ) vers VCC. De nombreuses cartes d’extension les incluent, mais si vous construisez à partir de zéro, ne les oubliez pas.
3. Conflits d’adresses – Si deux périphériques partagent la même adresse, aucun ne fonctionnera de manière fiable. Utilisez le scanner pour détecter les conflits.
4. Débit en bauds inadapté – Le scanner utilise la valeur par défaut de 100 kHz (mode standard). Certains périphériques peuvent nécessiter des vitesses plus lentes. Vous pouvez la changer avec Wire.setClock(400000) pour le mode rapide.
5. Le Moniteur Série n’affiche rien – Assurez-vous que le débit en bauds dans le Moniteur Série correspond à 9600.

Dans Velxio, vous pouvez ouvrir le Moniteur Série depuis la barre d’outils de l’éditeur. Si vous ne voyez pas de sortie, vérifiez que le code a bien été compilé (cherchez des erreurs dans la console).

Extensions suggérées

Une fois que vous avez le scanner de base fonctionnel, essayez ces améliorations :

• Afficher les résultats sur l’OLED – Au lieu d’imprimer sur le port série, affichez la liste des adresses sur l’écran SSD1306. Vous aurez besoin des bibliothèques Adafruit_SSD1306 et Adafruit_GFX.
• Ajouter un bouton pour déclencher le scan – Connectez un bouton poussoir à une broche Arduino et scannez uniquement lorsqu’il est pressé.
• Scanner des périphériques spécifiques – Modifiez le code pour ne chercher qu’une plage d’adresses particulière (par exemple, 0x20-0x2F pour le PCF8574).
• Utiliser un LCD – Remplacez l’OLED par un LCD I2C 16x2 (adresse 0x27 ou 0x3F).
• Enregistrer sur carte SD – Si vous avez un module carte SD, enregistrez les résultats du scan pour une analyse ultérieure.

Pour ajouter des bibliothèques dans Velxio, utilisez le Gestionnaire de bibliothèques.

Conclusion

Vous venez de construire un scanner I2C universel qui fonctionne avec n’importe quelle carte compatible Arduino. Cet outil est inestimable pour déboguer et explorer de nouveaux modules I2C. Le meilleur dans tout ça ? Vous pouvez l’exécuter dès maintenant dans votre navigateur sur Velxio sans aucun matériel.

Prêt à essayer par vous-même ? Ouvrez l’exemple en direct et commencez à scanner :

👉 Lancer le Scanner I2C sur Velxio

Bon bricolage !