Serielles Echo mit Arduino: USART-Kommunikation lernen

Einleitung

Serielle Kommunikation ist eine der grundlegendsten Fähigkeiten in der eingebetteten Elektronik. Egal, ob du einen Sensor debuggen, mit einem GPS-Modul kommunizieren oder Daten an einen PC senden möchtest – der bescheidene USART (Universal Synchronous/Asynchronous Receiver/Transmitter) ist dein Werkzeug der Wahl. In diesem Tutorial bauen wir ein einfaches Serielles Echo-Projekt mit einem Arduino Uno im Velxio-Simulator. Jedes Zeichen, das du im Seriellen Monitor eingibst, wird zusammen mit seinem ASCII-Wert und einem laufenden Zähler zurückgesendet. Es ist das „Hallo Welt!“ der seriellen Kommunikation.

Schaltplan-Erklärung

Dieses Projekt ist bemerkenswert einfach – es verwendet nur das Arduino Uno-Board selbst. Es werden keine externen Komponenten benötigt, da die serielle Kommunikation über den im Uno integrierten USB-zu-Seriell-Wandler erfolgt. In Velxio ist der Serielle Monitor in die Editor-Symbolleiste integriert, sodass du sofort mit deinem Code interagieren kannst.

Komponenten

Das war’s! Die TX (Pin 1) und RX (Pin 0) des Arduino Uno sind intern mit der USB-Schnittstelle verbunden, die Velxio perfekt emuliert. Es ist keine Verkabelung erforderlich.

Code-Erklärung

Tauchen wir in den Code ein. Öffne den Velxio-Editor und du wirst den folgenden Sketch sehen:

// Serial Echo — USART Protocol Test
// Open the Serial Monitor to send and receive data.
// Everything you type is echoed back with extra info.

void setup() {
  Serial.begin(9600);
  Serial.println("=============================");
  Serial.println("  Serial Echo Test (USART)");
  Serial.println("=============================");
  Serial.println("Type something and press Send.");
  Serial.println();

  // Print system info
  Serial.print("CPU Clock: ");
  Serial.print(F_CPU / 1000000);
  Serial.println(" MHz");
  Serial.print("Baud rate: 9600");
  Serial.println();
  Serial.println();
}

unsigned long charCount = 0;

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();
    charCount++;

    Serial.print("[");
    Serial.print(charCount);
    Serial.print("] Received: '");
    Serial.print(c);
    Serial.print("' (ASCII ");
    Serial.print((int)c);
    Serial.println(")");
  }

  // Periodic heartbeat
  static unsigned long lastBeat = 0;
  if (millis() - lastBeat >= 5000) {
    lastBeat = millis();
    Serial.print("Uptime: ");
    Serial.print(millis() / 1000);
    Serial.print("s | Chars received: ");
    Serial.println(charCount);
  }
}

Wie es funktioniert

1. Setup: Wir initialisieren die serielle Kommunikation mit 9600 Baud über Serial.begin(9600). Dann geben wir einen Banner und Systeminformationen aus: die CPU-Taktgeschwindigkeit (F_CPU / 1000000 ergibt MHz) und die Baudrate.

2. Globale Variable: unsigned long charCount = 0; verfolgt, wie viele Zeichen wir empfangen haben.

3. Loop:

   • if (Serial.available() > 0) prüft, ob Daten im Empfangspuffer warten.
   • char c = Serial.read(); liest ein Zeichen.
   • Wir erhöhen charCount und geben eine formatierte Nachricht aus: [count] Received: 'c' (ASCII 99).
   • Alle 5 Sekunden geben wir einen Herzschlag mit der Betriebszeit und der Gesamtzahl der empfangenen Zeichen aus.

Wichtige Konzepte für Schüler

• Baudrate: Die Geschwindigkeit der seriellen Kommunikation. Beide Seiten müssen dieselbe Baudrate verwenden (hier 9600).
• Serial.available(): Gibt die Anzahl der Bytes zurück, die darauf warten, gelesen zu werden. Vor dem Lesen immer prüfen, um -1 zu vermeiden.
• Serial.read(): Liest ein einzelnes Byte (Zeichen) aus dem Puffer.
• ASCII: Jedes Zeichen hat einen numerischen Code. Zum Beispiel ist ‘A’ 65. Der Code castet c zu int, um dies anzuzeigen.
• millis(): Gibt die Millisekunden seit dem Programmstart zurück. Nützlich für nicht-blockierendes Timing.
• statische Variablen: static unsigned long lastBeat behält seinen Wert zwischen Loop-Durchläufen, im Gegensatz zu lokalen Variablen.

Häufige Fallstricke und Debugging-Tipps

• Serieller Monitor zeigt keine Ausgabe? Stelle sicher, dass du den Seriellen Monitor in Velxio geöffnet hast (klicke auf die Schaltfläche „Serial Monitor“ in der Symbolleiste). Überprüfe auch, ob die Baudrate im Monitor mit 9600 übereinstimmt.
• Müllzeichen? Eine falsche Baudrate ist die häufigste Ursache. Überprüfe Serial.begin(9600) und die Monitoreinstellung.
• Nichts passiert beim Tippen? Stelle sicher, dass du nach dem Tippen „Send“ oder die Eingabetaste drückst. Der Code liest jeweils ein Zeichen.
• Herzschlag wird nicht ausgegeben? Die Bedingung if (millis() - lastBeat >= 5000) verwendet >=, um das Intervall nicht zu verpassen. Wenn du keinen Herzschlag siehst, überprüfe, ob lastBeat korrekt aktualisiert wird.

Vorgeschlagene Erweiterungen

Sobald du das grundlegende Echo gemeistert hast, probiere diese Verbesserungen aus:

1. Ganze Zeilen echoen: Statt jedes Zeichen einzeln zu echoen, sammle Zeichen bis zum Zeilenumbruch und echo dann die gesamte Zeile.
2. Befehls-Parser: Interpretiere spezielle Befehle wie „LED ON“, um eine LED einzuschalten (füge eine LED zum Schaltplan hinzu).
3. Binäre Ausgabe: Gib das empfangene Zeichen im Binärformat aus.
4. Mehrere Baudraten: Lass den Benutzer die Baudrate über einen Befehl ändern.
5. In virtuelles EEPROM protokollieren: Speichere empfangene Daten im simulierten EEPROM.

Fazit

Du hast soeben dein erstes serielles Kommunikationsprojekt gebaut! Das Serielle Echo ist eine einfache, aber leistungsstarke Demonstration, wie Mikrocontroller mit der Außenwelt kommunizieren. Mit Velxio kannst du ohne Hardware experimentieren – öffne einfach den Simulator, schreibe Code und teste sofort.

Bereit, es selbst auszuprobieren? Öffne das Live-Beispiel in Velxio und beginne zu tippen: Serielles Echo auf Velxio. Viel Spaß beim Programmieren!