Dauerkalender

Der Kleine hat das Sagen

(Arduino Uno und Nano seriell verbinden)

Jedes Arduino Board verfügt über die Anschlüsse TX (Transmitter, Sender) und RX (Receiver, Empfänger). Manche von ihnen haben sogar mehrere. Über diese Anschlüsse ist es möglich, eine serielle Kommunikation mit anderen Geräten aufzubauen. Dabei kann Arduino mit einem anderen Arduino, mit einem PC oder mit einem anderen Mikrocontroller kommunizieren. In diesem Fall unterhalten sich über diese Anschlüsse Arduino Nano und Arduino Uno miteinander.
An Arduino Nano werden drei Potentiometer angeschlossen. Mit diesen drei Potis soll es möglich sein, drei Leuchtdioden zu dimmen. Das Problem dabei ist, die Leuchtdioden sind an Arduino Uno angeschlossen.
Damit die Aufgabe realisierbar ist, werden beide Arduinos seriell über die Pins Rx und Tx miteinander verbunden. Arduino Nano wird über diese Schnittstelle Ardinuo Uno mitteilen, auf welche Werte die drei Potis aktuell eingestellt sind. Daraufhin soll Arduino Uno die Helligkeit der drei LEDs entsprechend den Vorgaben einstellen.
Trotz, dass Arduino Nano der Kleinere und Schwächere des Duos ist, bestimmt er in dieser Runde, was gemacht wird.

Der Sender

Arduino Nano

Eine Kommunikation kann man in beiden Richtungen aufbauen. Dann sind beide Teilnehmer abwechselnd als Sender und Empfänger zu betrachten. In diesem Fall übernimmt Arduino Nano die Rolle des Senders, Arduino Uno die des Empfängers.
Die Aufgabe des Senders ist in dieser Schaltung äußerst simpel. Es werden in regelmäßigen Abständen drei analoge Eingänge, an die die drei Potentiometer angeschlossen sind, ausgelesen. Die Werte werden anschließend unverändert direkt über die serielle Schnittstelle zu Arduino Uno gesendet.
Damit der Empfänge weiß, welcher Wert welcher Leuchtdiode zuzuordnen ist, wird vor der Sendung ein Sendetelegramm gebildet. Es besteht aus einem String und einer Zahl, die mit einem Komma voneinander getrennt sind.
Der String enthält das Wort LED, an das die Nummer des jeweiligen Potemtiometers angehängt wird. Mit LED1 wird dann z.B. der erste Potentiometer und damit auch die erste Leuchtdiode gemeint. Die angehängte Zahl, die nach Komma kommt, ist der aktuell ausgelesener Dimmwert.
Ein vollständiges Telegramm für Leuchtdiode Nr2 mit dem ausgelesenen analogen Wert von 600 würde dann wie folgt aussehen:
LED2,600
Damit ist die Aufgabe des Senders erfüllt.
Die Daten werden mit der Funktion Serial.print an die serielle Schnittstelle übergeben.
Bevor das Programm hochgeladen wird, ist darauf zu achten, dass keine serielle Verbindung zwischen den beiden Kommunikationspartnern besteht. Die Pins Rx und TX bleiben bei der Übertragung des Programms frei.

Verdrahtung des Senders

Das Programm (Sender)

  int Eingang_Poti_1 = A1;                           // Analoger Eingang Potentiometer 1
  int Eingang_Poti_2 = A2;                           // Analoger Eingang Potentiometer 2
  int Eingang_Poti_3 = A3;                           // Analoger Eingang Potentiometer 3
  int Dimmwert_LED1;                                 // analoger Wert am A1 (0-1023)
  int Dimmwert_LED2;                                 // analoger Wert am A2 (0-1023)
  int Dimmwert_LED3;                                 // analoger Wert am A2 (0-1023)

  // ***********************************************************************************
  void setup() {
    
    Serial.begin (9600);
  }

  // ***********************************************************************************
  void loop() {

      Dimmwert_LED1 = analogRead(Eingang_Poti_1);    // Analoger Eingang A1 abfragen
      Dimmwert_LED2 = analogRead(Eingang_Poti_2);    // Analoger Eingang A2 abfragen
      Dimmwert_LED3 = analogRead(Eingang_Poti_3);    // Analoger Eingang A3 abfragen

      Serial.print ("LED1,");                        // String 'LED1,' senden
      Serial.print (Dimmwert_LED1);                  // Wert am Eingang A1 senden
      delay(10);                                     // Wartezeit
      
      Serial.print ("LED2,");                        // usw.
      Serial.print (Dimmwert_LED2);
      delay(10);
      
      Serial.print ("LED3,");
      Serial.print (Dimmwert_LED3);
      delay(10);
  }
  // ***********************************************************************************        

Der Empfänger

Arduino Uno

Arduino Uno muss als Empfänger die Schnittstelle überwachen, die Daten auslesen (falls vorhanden) und die entsprechenden Leuchtdioden mit den neuen Werten dimmen.
Die Überwachung der Schnittstelle übernimmt die Funktion Serial.available(). Sobald sie feststellt, dass Daten vorhanden sind, wird das erste Zeichen ausgelesen.
Das Lesen der Daten erfolgt mit der Funktion Serial.read(). Damit das Lesen zum Erfolg führen kann, muss das erste Zeichen der Buchstabe L sein. Der Buchstabe markiert den Anfang des Sendetelegramms. Wenn das der Fall ist, werden weitere Zeichen ausgelesen. Sie werden summiert und bilden einen String, der in der Variable LED gespeichert wird. Das Lesen findet statt, bis das Zeichen , (Komma) ausgelesen wird. Das anschließende Byte wird mit der Funktion Serial.parseInt() als Zahl interpretiert und in der Variable Dimmwert gespeichert. Damit ist das Telegrammempfang abgeschlossen.
Der Dimmwert, der als eine 10-Bit Zahl ankommt (0-1023) muss vor der Anwendung skaliert werden. Die PWM-Ausgänge erwarten 8-Bit Werte (0-255). Die Anpassung erreicht man einfach mit der Division durch 4.
Zum Schluss kann die jeweilige Leuchtdiode mit analogWrite(Ausgang, Dimmwert) auf den vorgegebenen Wert gedimmt werden.

Verdrahtung des Empfängers

Das Programm (Empfänger)

        
  int Ausgang_LED_1 = 9;                                // Leuchtdiode 1 /PWM-Ausgang 9
  int Ausgang_LED_2 = 10;                               // Leuchtdiode 2 /PWM-Ausgang 10
  int Ausgang_LED_3 = 11;                               // Leuchtdiode 1 /PWM-Ausgang 11
  int Ausgang_LED_Stoerung = 12;                        // LED rot, digitaler Ausgang 12
  unsigned long Millis_Alt;                             // Variable für Zeitüberwachun
  int Max_Wartezeit = 5000;                             // Zeit-Grenze 5 sek
  char InChar;                                          
  int Dimmwert;      
  String LED = "";

  // ***********************************************************************************
  void setup() {
     pinMode (Ausgang_LED_1, OUTPUT);                    // LED 1
     pinMode (Ausgang_LED_2, OUTPUT);                    // LED 2
     pinMode (Ausgang_LED_3, OUTPUT);                    // LED 3
     pinMode (Ausgang_LED_Stoerung, OUTPUT);             // LED ROT
     Millis_Alt = millis();
     Serial.begin (9600);                                // Initialisierung 
  }

  // ***********************************************************************************
  void loop() {

      if ((millis() - Millis_Alt) > Max_Wartezeit) {     // LED rot an
          digitalWrite (Ausgang_LED_Stoerung, HIGH);
      }


      if ((Serial.available () > 0) and (Serial.read() == 'L')) {   // Telegramm Anfang?
          LED = "L";                                                // ja
          while (InChar != ',') {                                   // Lesen bis Komma
              if ((millis() - Millis_Alt) > Max_Wartezeit) { break; }
              if (Serial.available () > 0) {
                  InChar = Serial.read();                           // Zeichen lesen
                  if ( InChar != ',') {
                      LED = LED + InChar;                           // String LED bilden
                  }
              }
          }
      }

      if (InChar == ',') {                                          // Nach Komma Dimmwert
          Dimmwert = Serial.parseInt();
          Dimmwert = Dimmwert / 4;                                  // Wert Anpassung
          InChar = "";                                              // InChar zurücksetzen
      }

      if (LED == "LED1") {                              // LED 1 auf aktuellen Wert setzen
          analogWrite (Ausgang_LED_1, Dimmwert);
          LED = "";
          Millis_Alt = millis();
      }
      if (LED == "LED2") {
         analogWrite (Ausgang_LED_2, Dimmwert);         // LED 2 auf aktuellen Wert setzen
         LED = "";
         Millis_Alt = millis();
      }    
      if (LED == "LED3") {
          analogWrite (Ausgang_LED_3, Dimmwert);        // LED 3 auf aktuellen Wert setzen
          LED = "";
          Millis_Alt = millis();
      }
  }
  // ***********************************************************************************        

Rote Leuchtdiode

Neben den drei dimmbaren Leuchtdioden, kommt in der Schaltung noch eine weitere, rote, hinzu. Das ist die Störung-Leuchte. Sobald an der seriellen Schnittstelle fünf Sekunden lang keine Daten empfangen werden, geht diese Leuchtdiode an. Auf diese Weise bekommt man eine Information, dass die Datenübertragung gestört ist.

Der Schaltplan

Schaltplan

Die Testschaltung

Testschaltung (komplett)

Kurzvideo

Kurzvideo

Kommunikation