Démo multi-protocole Pico : Serial, I2C, SPI et ADC sur RP2040

Introduction

Bienvenue dans la Démo multi-protocole Pico ! Dans ce tutoriel, nous allons explorer comment utiliser le Raspberry Pi Pico (RP2040) pour communiquer via plusieurs protocoles simultanément : Serial, I2C, SPI et ADC. Il s’agit d’un exemple avancé qui rassemble plusieurs compétences clés pour le développement embarqué. Nous allons construire le circuit dans le simulateur Velxio, écrire le code, et parcourir chaque étape en détail.

Schéma du circuit pico-multi-protocole sur le canevas du simulateur Velxio

Présentation du circuit

Examinons les composants et le câblage. Le circuit utilise un Raspberry Pi Pico (Nano RP2040 Connect) et plusieurs périphériques :

LED bleue (led-i2c) : Connectée à la broche D12 (GP12) via une résistance de limitation de courant. L’anode (A) se connecte à D12, la cathode (C) à GND.
LED jaune (led-spi) : Connectée à la broche D7 (GP7) de la même manière.
Potentiomètre (pot-adc) : La broche de signal (SIG) se connecte à A0 (GP26). VCC va au 3,3 V, GND à GND.
LED verte (led-gpio) : Connectée à la broche D2 (GP2).

Toutes les LEDs partagent une masse commune. Le potentiomètre est alimenté par le rail 3,3 V. Le câblage est simple, mais notez que nous utilisons les périphériques I2C et SPI intégrés du Pico (bien que non représentés explicitement dans le schéma, le code suppose qu’ils sont disponibles sur les broches par défaut).

Analyse du code

Le code est écrit en Arduino C++ et utilise les bibliothèques Wire et SPI. Détaillons-le section par section.

Configuration

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  delay(500);

  Serial.println("==============================");
  Serial.println(" Pico Multi-Protocol Demo");
  Serial.println("==============================");
  Serial.println();

Nous commençons par initialiser la LED intégrée et le Serial à 115200 bauds. Le délai laisse le temps au moniteur série de se connecter.

1. Scanner I2C

  Wire.begin();
  Serial.println("[I2C] Scanning bus...");
  int found = 0;
  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      found++;
      Serial.print("  Found device at 0x");
      if (addr < 16) Serial.print('0');
      Serial.println(addr, HEX);
    }
  }
  Serial.print("  Total devices: "); Serial.println(found);
  Serial.println();

Ceci scanne toutes les adresses I2C possibles (1-126) et signale celles qui accusent réception. Dans le simulateur, vous pouvez voir des périphériques virtuels aux adresses comme 0x50 (EEPROM) et 0x68 (RTC).

2. Lecture/Écriture EEPROM I2C

  Serial.println("[I2C] EEPROM test at 0x50...");
  Wire.beginTransmission(0x50);
  Wire.write(0x00); // register 0
  Wire.write(0x42); // data
  Wire.endTransmission();
  delay(5);

  Wire.beginTransmission(0x50);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(0x50, 1);
  if (Wire.available()) {
    byte val = Wire.read();
    Serial.print("  Wrote 0x42, Read 0x");
    Serial.print(val, HEX);
    Serial.println(val == 0x42 ? " — OK" : " — FAIL");
  }
  Serial.println();

Nous écrivons la valeur 0x42 dans le registre 0 de l’EEPROM à l’adresse 0x50, puis nous la relisons pour vérifier. Cela teste les opérations de base de lecture/écriture I2C.

3. RTC I2C

  Serial.println("[I2C] Reading DS1307 RTC at 0x68...");
  Wire.beginTransmission(0x68);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(0x68, 3);
  if (Wire.available() >= 3) {
    byte sec = ((Wire.read() & 0x7F) >> 4) * 10 + (Wire.read() & 0x0F);
    byte min2 = Wire.read();
    (void)sec; (void)min2;
    Serial.println("  RTC responded OK");
  }
  Serial.println();

Ici, nous tentons de lire les registres de temps d’un RTC DS1307 à l’adresse 0x68. Le code lit trois octets (secondes, minutes, heures) mais vérifie seulement si le périphérique a répondu.

4. Boucle de retour SPI

  Serial.println("[SPI] Loopback test...");
  SPI.begin();
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  byte tx = 0xAB;
  byte rx = SPI.transfer(tx);
  Serial.print("  TX: 0x"); Serial.print(tx, HEX);
  Serial.print("  RX: 0x"); Serial.println(rx, HEX);
  SPI.endTransaction();
  Serial.println();

Ceci effectue une simple boucle de retour SPI : il envoie 0xAB et lit ce qui est reçu. Dans le simulateur, MISO et MOSI ne sont pas connectés en externe, donc la valeur reçue peut être 0xFF ou autre chose. Cela teste le matériel SPI.

5. ADC

  Serial.println("[ADC] Reading analog channels...");
  analogReadResolution(12);
  int a0 = analogRead(A0);
  Serial.print("  A0 (GP26): "); Serial.println(a0);
  Serial.println();

Nous réglons la résolution de l’ADC sur 12 bits et lisons la valeur de A0 (GP26). La tension du curseur du potentiomètre est lue, donnant une valeur entre 0 et 4095.

6. Clignotement GPIO

  Serial.println("[GPIO] Blinking LED...");
  for (int i = 0; i < 3; i++) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
    delay(200);
  }
  Serial.println("  3 blinks done");
  Serial.println();

  Serial.println("=== All protocol tests complete ===");
}

Enfin, nous faisons clignoter la LED intégrée trois fois pour indiquer que la configuration est terminée.

Boucle principale

void loop() {
  // Heartbeat
  static unsigned long last = 0;
  if (millis() - last >= 3000) {
    last = millis();
    Serial.print("[Heartbeat] ");
    Serial.print(millis() / 1000);
    Serial.println("s");
  }
}

La boucle affiche un message de pulsation toutes les 3 secondes pour montrer que le programme est toujours en cours d’exécution.

Concepts clés

Intégration multi-protocole : Combiner Serial, I2C, SPI et ADC dans un seul sketch vous apprend à gérer plusieurs périphériques sans conflits.
Adressage I2C : Comprendre comment scanner et communiquer avec des périphériques à des adresses spécifiques.
Configuration SPI : Régler la vitesse d’horloge, l’ordre des bits et le mode.
Résolution ADC : Utiliser analogReadResolution() pour obtenir une précision plus élevée.
Débogage série : Utiliser le moniteur série pour afficher des données en temps réel.

Pièges courants et conseils de débogage

Résistances de tirage I2C : Le Pico a des résistances de tirage internes, mais des résistances externes peuvent être nécessaires pour des fils plus longs. Dans le simulateur, cela est géré automatiquement.
Boucle de retour SPI : Sans boucle de retour physique, les données reçues peuvent être erronées. Utilisez un fil de cavalier entre MOSI et MISO pour un véritable test de boucle de retour.
Bruit ADC : Les potentiomètres peuvent être bruyants ; l’ajout d’un condensateur entre le curseur et la masse aide.
Décalage de débit en bauds série : Assurez-vous que votre moniteur série est réglé sur 115200 bauds.

Extensions suggérées

Ajoutez un capteur I2C externe (par exemple, température/humidité) et affichez ses lectures.
Utilisez SPI pour contrôler un écran OLED.
Implémentez un enregistreur de données simple qui lit l’ADC et stocke les valeurs dans l’EEPROM.
Ajoutez un bouton pour déclencher différents modes de test.

Essayez par vous-même !

Prêt à expérimenter ? Ouvrez l’exemple en direct dans Velxio et lancez la simulation. Vous pouvez modifier le code, ajouter des composants et voir les résultats instantanément.

Lancer la Démo multi-protocole Pico sur Velxio

Barre d'outils de l'éditeur Velxio avec les commandes de compilation et d'exécution