Pico Multi-Protocol Demo: Serielle, I2C-, SPI- und ADC-Kommunikation auf dem RP2040

Einleitung

Willkommen zur Pico Multi-Protocol Demo! In diesem Tutorial erkunden wir, wie man den Raspberry Pi Pico (RP2040) nutzt, um gleichzeitig über mehrere Protokolle zu kommunizieren: Serielle Schnittstelle, I2C, SPI und ADC. Dies ist ein fortgeschrittenes Beispiel, das mehrere wichtige Fähigkeiten für die eingebettete Entwicklung zusammenbringt. Wir bauen die Schaltung im Velxio-Simulator auf, schreiben den Code und gehen jeden Schritt im Detail durch.

Schaltplan der Pico-Multi-Protocol-Demo auf der Velxio-Simulator-Leinwand

Schaltungsaufbau

Schauen wir uns die Komponenten und die Verdrahtung an. Die Schaltung verwendet einen Raspberry Pi Pico (Nano RP2040 Connect) und mehrere Peripheriegeräte:

Blaue LED (led-i2c): Angeschlossen an Pin D12 (GP12) über einen Strombegrenzungswiderstand. Die Anode (A) verbindet sich mit D12, die Kathode (C) mit GND.
Gelbe LED (led-spi): Angeschlossen an Pin D7 (GP7) auf ähnliche Weise.
Potentiometer (pot-adc): Der Signalpin (SIG) verbindet sich mit A0 (GP26). VCC geht an 3,3V, GND an GND.
Grüne LED (led-gpio): Angeschlossen an Pin D2 (GP2).

Alle LEDs teilen sich eine gemeinsame Masse. Das Potentiometer wird von der 3,3V-Schiene versorgt. Die Verdrahtung ist unkompliziert, aber beachten Sie, dass wir die integrierten I2C- und SPI-Peripheriegeräte des Pico verwenden (obwohl sie im Schaltplan nicht explizit gezeigt werden, geht der Code davon aus, dass sie auf den Standard-Pins verfügbar sind).

Code-Analyse

Der Code ist in Arduino C++ geschrieben und verwendet die Bibliotheken Wire und SPI. Lassen Sie uns ihn Abschnitt für Abschnitt aufschlüsseln.

Setup

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

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

Wir beginnen mit der Initialisierung der eingebauten LED und der seriellen Schnittstelle mit 115200 Baud. Die Verzögerung gibt dem seriellen Monitor Zeit, sich zu verbinden.

1. I2C-Scanner

  Wire.begin();
  Serial.println("[I2C] Scanne Bus...");
  int found = 0;
  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      found++;
      Serial.print("  Gerät gefunden bei 0x");
      if (addr < 16) Serial.print('0');
      Serial.println(addr, HEX);
    }
  }
  Serial.print("  Gesamtgeräte: "); Serial.println(found);
  Serial.println();

Dies scannt alle möglichen I2C-Adressen (1-126) und meldet alle, die quittieren. Im Simulator sehen Sie möglicherweise virtuelle Geräte an Adressen wie 0x50 (EEPROM) und 0x68 (RTC).

2. I2C-EEPROM-Lesen/Schreiben

  Serial.println("[I2C] EEPROM-Test bei 0x50...");
  Wire.beginTransmission(0x50);
  Wire.write(0x00); // Register 0
  Wire.write(0x42); // Daten
  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("  Geschrieben 0x42, Gelesen 0x");
    Serial.print(val, HEX);
    Serial.println(val == 0x42 ? " — OK" : " — FEHLGESCHLAGEN");
  }
  Serial.println();

Wir schreiben den Wert 0x42 in Register 0 des EEPROMs an Adresse 0x50 und lesen ihn dann zurück, um dies zu überprüfen. Dies testet das grundlegende I2C-Lesen/Schreiben.

3. I2C-RTC

  Serial.println("[I2C] Lese DS1307 RTC bei 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 hat geantwortet OK");
  }
  Serial.println();

Hier versuchen wir, die Zeitregister von einer DS1307 RTC an Adresse 0x68 zu lesen. Der Code liest drei Bytes (Sekunden, Minuten, Stunden), überprüft aber nur, ob das Gerät geantwortet hat.

4. SPI-Loopback

  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();

Dies führt einen einfachen SPI-Loopback durch: Es sendet 0xAB und liest zurück, was empfangen wird. Im Simulator sind MISO und MOSI nicht extern verbunden, daher kann der empfangene Wert 0xFF oder etwas anderes sein. Dies testet die SPI-Hardware.

5. ADC

  Serial.println("[ADC] Lese analoge Kanäle...");
  analogReadResolution(12);
  int a0 = analogRead(A0);
  Serial.print("  A0 (GP26): "); Serial.println(a0);
  Serial.println();

Wir setzen die ADC-Auflösung auf 12 Bit und lesen den Wert von A0 (GP26). Die Schleiferspannung des Potentiometers wird gelesen, was einen Wert zwischen 0 und 4095 ergibt.

6. GPIO-Blinken

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

  Serial.println("=== Alle Protokolltests abgeschlossen ===");
}

Schließlich lassen wir die eingebaute LED dreimal blinken, um anzuzeigen, dass das Setup abgeschlossen ist.

Loop

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

Die Schleife gibt alle 3 Sekunden eine Heartbeat-Nachricht aus, um zu zeigen, dass das Programm noch läuft.

Wichtige Konzepte

Multi-Protokoll-Integration: Die Kombination von serieller, I2C-, SPI- und ADC-Kommunikation in einem Sketch lehrt, wie man mehrere Peripheriegeräte ohne Konflikte verwaltet.
I2C-Adressierung: Verstehen, wie man Geräte an bestimmten Adressen scannt und mit ihnen kommuniziert.
SPI-Konfiguration: Einstellen von Taktgeschwindigkeit, Bit-Reihenfolge und Modus.
ADC-Auflösung: Verwendung von analogReadResolution(), um eine höhere Präzision zu erzielen.
Serielles Debugging: Verwendung des seriellen Monitors zur Ausgabe von Echtzeitdaten.

Häufige Fallstricke & Debugging-Tipps

I2C-Pull-up-Widerstände: Der Pico hat interne Pull-ups, aber für längere Leitungen können externe erforderlich sein. Im Simulator wird dies automatisch gehandhabt.
SPI-Loopback: Ohne physischen Loopback können die empfangenen Daten Müll sein. Verwenden Sie eine Jumper-Leitung zwischen MOSI und MISO für einen echten Loopback-Test.
ADC-Rauschen: Potentiometer können verrauscht sein; das Hinzufügen eines Kondensators zwischen Schleifer und Masse hilft.
Fehlende Übereinstimmung der seriellen Baudrate: Stellen Sie sicher, dass Ihr serieller Monitor auf 115200 Baud eingestellt ist.

Vorgeschlagene Erweiterungen

Fügen Sie einen externen I2C-Sensor (z. B. Temperatur/Luftfeuchtigkeit) hinzu und zeigen Sie dessen Messwerte an.
Verwenden Sie SPI, um ein OLED-Display anzusteuern.
Implementieren Sie einen einfachen Datenlogger, der den ADC ausliest und Werte im EEPROM speichert.
Fügen Sie einen Taster hinzu, um verschiedene Testmodi auszulösen.

Probieren Sie es selbst aus!

Bereit zum Experimentieren? Öffnen Sie das Live-Beispiel in Velxio und führen Sie die Simulation aus. Sie können den Code ändern, Komponenten hinzufügen und die Ergebnisse sofort sehen.

Starten Sie die Pico Multi-Protocol Demo auf Velxio

Velxio-Editor-Symbolleiste mit Kompilieren- und Ausführen-Steuerelementen