Arduino Grundlagen Teil 12: Softwareserial Library

Softwareserial Library Arduino-Grundlagen

SoftwareSerial Library

Die SoftwareSerial Library (Bibliothek) ermöglicht es uns, mehr serielle Schnittstellen an einem Arduino zu betreiben, als er hardwareseitig unterstützt. Dafür gibt es allerdings ein paar Einschränkungen.

ACHTUNG: Einschränkungen bei der SoftwareSerial Library

Uns bekannte Einschränkungen sind:

  • Werden mehrere Verbindungen über SoftwareSerial genutzt, kann immer nur eine Verbindung zu einem Zeitpunkt Daten empfangen.
  • Nur folgende Interrupt-Pins eines Arduino Mega und Mega 2560 können zum Empfangen von Daten (RX) genutzt werden: 10, 11, 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68) und A15 (69).
  • Nur folgende Interrupt-Pins eines Arduino Leonardo oder Micro können zum Empfangen von Daten (RX) genutzt werden: 8, 9, 10, 11, 14 (MISO), 15 (SCK) und 16 (MOSI).

Wir haben Glück, bei einem Arduino Nano können alle digitalen Pins zum Empfangen von Daten (RX) genutzt werden. 😉
Zum Senden von Daten (TX) sind uns bisher zu keinem Arduino Einschränkungen bekannt.

Natürlich wollen wir uns auch den Einsatz der SoftwareSerial Library anschauen. Dafür bauen wir uns als erstes eine kleine Testschaltung auf. Danach schreiben wir ein Testprogramm, welches Daten von der physischen seriellen Schnittstelle liest und an SoftwareSerial schreibt. Natürlich soll das auch in die andere Richtung funktionieren.

Komponenten-Liste

Für die Umsetzung brauchen wir folgende Komponenten:

Die Schaltung

Die Schaltung (siehe Abbildung 9) ist verhältnismäßig einfach. Eigentlich bräuchten wir dafür nicht mal ein Breadboard. Wichtig ist aber, dass die beiden Daten-Leitungen an die richtigen Ports angeschlossen werden:

  • USB-Serial RX an Pin D11
  • USB-Serial TX an Pin D10

TIPP: Andere Pins am Arduino
Möchtest Du andere Pins des Arduino nutzen, musst Du die Zuordnung im Programm in der Zeile
SoftwareSerial softSerial(10, 11);
ändern.

TIPP: 5V und Masse/GND
Der USB-Serial Adapter und der Arduino werden jeweils über USB versorgt. Sie müssen daher lediglich mit der Masse/GND Leitung verbunden sein. Die 5V Leitung wird nicht benötigt.
Falls Dein USB-Serial Adapter von 5V auf 3,3V umgeschaltet werden kann, achte darauf, dass er auf 5V eingestellt ist.

Abbildung 9a und 9b: Schaltung für das erste SoftwareSerial Beispiel mit USB-Serial Adapter:

Breadboard SoftwareSerial Steckplatine

Breadboard SoftwareSerial

Das war easy, also ab an das Programm!

Serial und SoftwareSerial Testprogramm

Wie üblich kannst Du den Sketch aus Listing 2 einfach komplett kopieren, in der Arduino IDE einfügen und hochladen.

#include <SoftwareSerial.h>        // Durch diesen Include können wir die Funktionen 
                                   // der SoftwareSerial Bibliothek nutzen.
SoftwareSerial softSerial(10, 11); // Pin D10 ist RX, Pin D11 ist TX.
                                   // Die Funktion softSerial() kann nun wie Serial() genutzt werden.

char c_inChar;   // Jedes empfangene Zeichen kommt kurzzeitig in diese Variable.
String s_input;  // In diesem String speichern wir dann unseren kompletten Text.

void setup()
{
  // Zuerst initialisieren wir die serielle Schnittstelle des Arduino.
  Serial.begin(57600);
  Serial.println("Nachrichten von PuTTY landen hier.");

  // Dann initialisieren wir die serielle Schnittstelle der SoftwareSerial Bibliothek.
  softSerial.begin(57600);
  softSerial.println("Nachrichten vom Arduino landen hier.");
}

void loop() 
{
  // In dieser Schleife warten wir auf einen Text von PuTTY.
  while(softSerial.available() > 0){        // So lange etwas empfangen wird, durchlaufe die Schleife.
    c_inChar = softSerial.read();           // Speichere das empfangene Zeichen in der Variablen c_inChar.
    s_input.concat(c_inChar);               // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten.
    if (c_inChar == '\r') {                 // War das letzte Zeichen ein CR (Carriage Return)?
      Serial.print("PuTTY hat gesagt: ");   // Dann schreibe einen Text auf den Serial Monitor.
      Serial.print(s_input);                // Füge in dieselbe Zeile den empfangenen Text ein
      Serial.print('\n');                   // und schicke noch ein NL (NewLine) für einen Zeilenumbruch hinterher.
      s_input="";                           // Lösche den String für die nächste Nachricht.
    }
  }
  
  // In dieser Schleife warten wir auf einen Text vom Arduino.
  while(Serial.available() > 0){            // So lange etwas empfangen wird, durchlaufe die Schleife.
    c_inChar = Serial.read();               // Speichere das empfangene Zeichen in der Variablen c_inChar.
    s_input.concat(c_inChar);               // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten.
    if (c_inChar == '\r') {                 // War das letzte Zeichen ein NL?
      softSerial.print("Arduino sagt: ");   // Dann schicke die Einleitung zu PuTTY.
      softSerial.print(s_input);            // Füge in dieselbe Zeile den empfangenen Text ein
      softSerial.print('\n');               // und schicke noch ein CR hinterher.
      s_input="";                           // Lösche den String wieder für die nächste Nachricht.
    }
  }
}

ACHTUNG: Änderung des COM-Ports
Wenn Du mehrere USB-Serial Controller (in diesem Fall also den zusätzlichen Adapter und den Arduino mit seinem integrierten Controller) anschließt, kann sich einer der beiden COM-Ports ändern.

Einstellungen anpassen

Bevor wir die Verbindung testen können, müssen wir noch ein paar kleine Einstellungen anpassen.

Arduino Serial Monitor

Im Serial Monitor der Arduino IDE brauchen wir jetzt als Zeilenende:

Zeilenumbruch (CR)

und als Baudrate:

57600Bd

Arduino Serial Monitor Einstellungen

Arduino Serial Monitor Einstellungen

PuTTY

PuTTY benötigt ebenfalls ein paar Anpassungen, die Du in den Abbildungen 10 und 11 findest.

Der COM-Port des USB-Serial Adapters ist bei uns COM8 geworden. Dann haben wir im Programm die Geschwindigkeit auf 57600Bd eingestellt, was PuTTY natürlich ebenfalls wissen muss.

PuTTY Configuration

Abb. 10: PuTTY Configuration 1

Dann fehlt noch im Menü-Punkt [Terminal] bei [Line discipline options] die Änderung auf:

  • Local echo: [Force on]
  • Local line editing: [Force on]
PuTTY Configuration

Abb. 11: PuTTY Configuration 2

Speichere die Einstellungen am besten wieder, damit Du sie beim nächsten Start von PuTTY nutzen kannst (siehe Abbildung 10 Eintrag USB_Serial).

Test

Das war wohl bisher die umfangreichste Aufgabe, aber wir haben es geschafft!

Starte den Serial Monitor der Arduino IDE und PuTTY, dann solltest Du folgende Meldungen erhalten (siehe Abbildung 12).

Abb. 12: Starten der zwei Terminals

Abb. 12: Starten der zwei Terminals

Wenn Du jetzt einen Text bei PuTTY eingibst und mit [Enter] bestätigst, wird er an den Serial Monitor gesendet (siehe Abbildung 13)

Abb. 13: Text von PuTTY an den Serial Monitor senden

Abb. 13: Text von PuTTY an den Serial Monitor senden

Wenn wir jetzt auch einen Text vom Serial Monitor an PuTTY senden können, ist unser Test erfolgreich bestanden!

Abb. 14: Test bestanden: Senden von Text vom Serial Monitor an PuTTY funktioniert

Abb. 14: Test bestanden: Senden von Text vom Serial Monitor an PuTTY funktioniert

In Abbildung 14 sehen wir das Ergebnis! Wir können vom Serial Monitor der Arduino IDE über den integrierten USB-Serial Controller des Arduino Nano eine Nachricht an den per SoftwareSerial Library eingebundenen zusätzlichen USB-Serial Adapter mit hinter geschaltetem PuTTY Terminal schicken und vice versa!!!

Fazit / Zusammenfassung

Wir haben nun mehrere Varianten kennen gelernt, wie wir mit unserem Arduino kommunizieren können. Dazu gehören:

  • Die serielle Schnittstelle des µC und ein integrierter USB-Serial Controller des Arduino.
  • Die SoftwareSerial Library zur Nutzung von „normalen“ digitalen Pins des Arduino für eine serielle Verbindung.
  • Einsatz eines zusätzlichen USB-Serial Adapters
  • Das PuTTY Terminal als Alternative zum Serial Monitor der Arduino IDE.

Gleichzeitig haben wir uns angeschaut, wie wir Daten von der seriellen Schnittstelle (Moment, wir kennen ja schon zwei) lesen und auf diese schreiben können.

Fast wäre unter den Tisch gefallen, dass wir durch die Abfrage:

while(Serial.available() > 0){
  // Jede Menge Befehle.
}

sogar so lange warten, bis die Übertragung über eine serielle Schnittstelle abgeschlossen ist. Dies dient der sauberen und fehlerfreien Kommunikation.

Dann haben wir das erste Mal Zeichen überprüft und verglichen. Das geschah durch die Abfrage:

if (c_inChar == ‘\r’) {
  // Wieder jede Menge Befehle.
}

in der wir das empfangene Zeichen auf ein Carriage Return (CR) kontrolliert haben.

Wie geht es jetzt weiter?

Probier doch einfach mal aus, ob Du die bisherigen Beispiele und Anleitungen kombinieren kannst.

  • Sende eine Nachricht, wenn Du einen Taster drückst.
  • Schalte die LED 1 an, wenn das Zeichen „1“ empfangen wird.
    Tipp: if (c_inChar == ‘1’) { … }
  • Schalte die LED 1 über das Zeichen “1” an, wenn es über die integrierte serielle Schnittstelle empfangen wird und schalte die LED 1 aus, wenn das Zeichen “1” über den USB-Serial Adapter empfangen wird.
  • Natürlich geht das auch mit 2, 3 oder 4 LEDs.

Das ist aber natürlich nicht alles, es wird noch einiges kommen. Dazu gehört beispielsweise das Bearbeiten von den empfangenen Zeichen und die Umwandlung in verschiedene Datentypen. Dadurch können wir die gesendeten/empfangenen Daten später für komplexere Aufgaben nutzen. Auch die Einbindung analoger Eingänge kann durch die seriellen Verbindungen optimiert werden. Warum die Nutzung analoger Eingänge vorher nicht viel Sinn macht, werden wir dann sehen. Unsere Programme werden also mit der Zeit auch immer komplexer, weswegen es dann langsam Sinn macht, dass wir uns auch das Debuggen über die serielle Schnittstelle anschauen.


Arduino Grundlagen Kurs im Überblick:

>> Teil 1: Der Arduino im Detail
>> Teil 2: Die Bauteile des Arduino
>>Teil 3: Ein Programm auf einen Arduino laden
>> Teil 4: Eine LED blinken lassen!
>> Teil 5: Eine externe LED blinken lassen
>> Teil 6: Die LED Schaltung im Detail
>> Teil 7: Mehrere LEDs ansteuern & blinken lassen
>> Teil 8: Eine LED dimmen
>> Teil 9: Mehrere LEDs dimmen
>> Teil 10: Taster an Arduino anschließen
>> Teil 11: Serielle Schnittstelle
>> Teil 12: Softwareserial Library

4 Kommentare zu "Arduino Grundlagen Teil 12: Softwareserial Library"

  1. Anton Englisch | 19. Januar 2017 um 16:02 | Antworten

    Ich befasse mich seit geraumer Zeit mit dem Arduino. Ich habe schon etliche Tutorials gelesen. Ich finde Ihre 12 Teile didaktisch sehr gut aufgebaut und gut verständlich. Der Text ist sehr leserfreundlich verfasst. Er liest sich wie ein gutes Buch. Es blieben mir kaum offene Fragen. Ich habe die 12 Teile allerdings nur quergelesen, was mir leicht fiel. Ich befasse mich seit einem halben Jahr mit Automatisierungen im Haus. Mittlerweile habe ich etliche Adruinos (Mini, Nano u. Uno)aus Fernost gekauft.Alles i.O.

    • Hallo Anton, vielen Dank für Dein Feedback! Das freut uns sehr 🙂
      Genau, so sollte es auch sein: 12 Teile, die aufeinander aufbauen – für den Einsteiger genauso verständlich wie auch für den ‘fortgeschrittenen’ Arduino-Interessierten.
      Das Thema Hausautomatisierung wollen wir auch unbedingt einmal in Angriff nehmen!
      Beste Grüße, Micha

  2. Claus Schröder | 25. März 2017 um 16:16 | Antworten

    Hallo Micha,
    auch ich finde deine Tuts sehr verständlich, gut leserlich!
    Ich habe nur zwei Fragen: Wann geht es weiter? Wann kommen weitere Tuts den Arduino bereffend ?
    Noch eine kliene Kritik:
    Die Links zu den einzelnen Tuts auf der Webseite springen mal zum Copter, mal zum Arduino …
    CS

    • Hallo Claus,
      vielen Dank für Deine positive Rückmeldung zu unseren Arduino-Tutorials!
      Unsere Planung ist, dass wir schon sehr bald weitere Arduino-Anleitungen veröffentlichen. Leider hatten wir in der letzten Zeit zu wenig Kapazitäten frei für solche Art Beiträge (…die doch sehr, sehr zeitintensiv sind). Schau einfach immer mal wieder rein – es wird sich bald was tun! 😉
      P.S.: Zu den Links: ja, genau, diese Funktion springt von Blog-Artikel zu Blog-Artikel (in der Reihenfolge der zeitlichen Veröffentlichung) und nicht innerhalb der ‘geschlossenen Arduino-Reihe’.
      Beste Grüße,
      Micha

Hinterlasse einen Kommentar

E-Mail Adresse wird nicht veröffentlicht.


*


*