In diesem Beitrag möchte ich dir nun zeigen, wie du eine Ausgabe formatierter Strings / Zeichenketten mit dem Mikrocontroller der Arduino Familie erzeugen kannst.
Ich nutze hier wie so oft die Entwicklungsumgebung Arduino IDE.
Möchtest du einen Text auf der seriellen Schnittstelle ausgeben, so kannst du dieses mit den Methoden „print“ & „println“ am Objekt „Serial“ machen.
void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Ein Text. "); Serial.println("Und hier kommt ein weiterer Text mit einem Zeilenumbruch am Ende."); }
Der Aufruf mit
- „Serial.print“ gibt eine Zeile auf der seriellen Schnittstelle aus aber erzeugt KEINEN Zeilenumbruch am Ende
- „Serial.println“ gibt eine Zeile auf der seriellen Schnittstelle aus inkl. einem Zeilenumbruch am Ende
Dabei kann beiden Methoden als Parameter diverse Datentypen übergeben werden. Das macht diese Methoden sehr einfach in der Handhabung und man kann damit mit wenig Aufwand einen formatierten Text ausgeben.
Formatieren von Zahlen
Zunächst möchte ich dir zeigen wie du Zahlen formatiert ausgeben kannst. Diese Zahlenwerte können zum Beispiel von einem Temperatursensor gelesen werden und haben in der Regel mehrere Nachkommastellen (Datentyp float, double) welche jedoch durch die Ungenauigkeit des Sensors nicht so aussagekräftig sind.
Serial.print / Serial.println
Wie bereits erwähnt, können wir den Methoden print & println diverse Datentypen übergeben. Bei einem float bzw. double (also einer Gleitkommazahl) wird diese auf maximal 2 Nachkommastellen gekürzt.
void setup(){ Serial.begin(9600); } void loop(){ int ganzeZahl = 1; Serial.println(ganzeZahl); // liefert 1 float gleitkommaZahl = 3.143434 Serial.println(gleitkommaZahl); //liefert 3.14 }
Bei Zahlenwerte kannst du zusätzlich noch einen zusätzlichen Parameter für das Format übergeben.
void setup(){ Serial.begin(9600); } void loop(){ float gleitkommaZahl = 3.123456; Serial.println(gleitkommaZahl, 4); //liefert 3.1234 Serial.println(gleitkommaZahl, 6); //liefert 3.123456 }
Du kannst aber nicht nur die Zahlen formatieren, sondern auch Umwandeln. Nehmen wir die ganze Zahl 15, diese kannst du mit
Serial.println(15, BIN); //liefert den Wert 1111 Serial.println(15, HEX); //liefert den Wert f Serial.println(15, OCT); //liefert den Wert 17
umwandeln.
Um diesen Wert nicht gleich auf der seriellen Schnittstelle auszugeben, kannst du diese auch mit der Klasse String machen und dir somit diesen Wert zunächst in dem Speicher merken.
String bin = String(15, BIN); String hex = String(15, HEX); String oct = String(15, OCT); Serial.println(bin); Serial.println(hex); Serial.println(oct);
formatieren von Strings / Zeichenketten
Kommen wir nun zum eigentlichen Thema, dem „formatieren von Zeichenketten“.
Nehmen wir jetzt an, wir möchten eine Zeichenkette mit einem Datum-/ Zeitwert ausgeben. (Das Datum setzen wir für dieses Beispiel statisch in den Quellcode.)
Heute ist <TAG_LANG> der <TAG>.<MONAT>.<JAHR>, es ist <STUNDE>:<MINUTE>:<SEKUNDE>
Nun könnten wir mit der String Concatination die Zeile wie folgt aufbauen:
String wochentag = "Freitag"; int tag = 14; int monat = 8; int jahr = 2020; int stunde = 13; int minute = 37; int sekunde = 45; String zeile = "Heute ist " + wochentag + " der " + String(tag,DEC) + "." + String(monat,DEC) + "." + String(jahr,DEC) + " " + String(stunde,DEC) + ":" + String(minute,DEC) + ":" + String(sekunde,DEC); Serial.println(zeile);
Die Ausgabe auf dem seriellen Monitor der Arduino IDE sieht wiefolgt aus:
Funktion „sprintf“
Mit der Funktion sprintf kann man eine Zeichenkette in einem char Array formatiert ablegen. Zuvor muss man jedoch ein entsprechendes Array mit der maximalen Anzahl von Zeichen reservieren.
Ein kleines Beispiel
Wollen wir zunächst in einem kleinen Beispiel uns anschauen, wie man den Text „mein Name ist Stefan“ ausgeben kann.
//der Name String name = "Stefan"; //reservieren eines char Arrays mit maximal 20 Zeichen char buffer[20]; //formatieren des Textes und ablegen in dem Array sprintf(buffer, "mein Name ist %s", name); //ausgebn des Textes auf der seriellen Schnittstelle Serial.println(buffer);
Ausgabe auf dem seriellen Monitor der Arduino IDE:
Parameter für das Format
In dem Beispiel habe ich bereits einen Parameter gezeigt %s dient hier als Platzhalter für eine Zeichenkette, es gibt aber noch viele weitere.
Platzhalter | Beschreibung |
---|---|
%s | String |
%d, %i | Dezimale Zahl |
%o | Oktal Integer |
%x, %X | Hexadezimal Zahl |
Mit diesem Platzhalter kann man auch Zahlen umwandeln. Nehmen wir die ganze Zahl 65 und wandeln diese einmal mit der Funktion sprintf um.
int zahl = 65; char buffer[100]; sprintf(buffer, "Oktal %o \nDezimal %i \nHexadezimal %x \nCharacter %c", zahl, zahl , zahl, zahl); Serial.println(buffer);
Die Ausgabe auf dem seriellen Monitor ist:
Funktion „snprintf“
Der Funktion snprintf wird zusätzlich die Länge des Zielarrays übergeben, dieses sorgt für mehr Sicherheit beim Schreiben der Daten.
//der Name String name = "Stefan"; //reservieren eines char Arrays mit maximal 20 Zeichen char buffer[20]; //formatieren des Textes und ablegen in dem Array //und der maximalen Länge von 20 Zeichen snprintf(buffer, 20, "mein Name ist %s", name); //ausgebn des Textes auf der seriellen Schnittstelle Serial.println(buffer);
Ausgabe auf dem seriellen Monitor der Arduino IDE:
Besonderheiten beim Formatieren von Zahlenwerten
Wie Zahlen mit der Funktion sprintf umwandelst, habe ich dir bereits in diesem Beitrag gezeigt. Jedoch funktioniert dieses nur mit ganzen Zahlen. Wenn du jedoch Gleitkommazahlen umwandeln oder formatieren möchtest, so musst du auf die Funktion „dtostrf“ zurückgreifen.
Funktion dtostrf zum Formatieren von Gleitkommazahlen
Der Funktion dtostrf werden 4 Parameter übergeben
- der Zahlenwert vom Typ double
- die Breite des Zahlenwertes
- die Anzahl der Nachkommastellen
- ein char Array in welches dieser formatierte Text geschrieben werden soll
ein kleines Beispiel
Nehmen wir an wir haben einen Sensor DHT11 / DHT22, dieser liefert die Temperatur mit einer Genauigkeit von ±0,5 °C als float Wert. Es macht also Sinn diesen Wert auf maximal eine Nachkommastelle auszugeben.
float temperatur = 12.565; char buffer[10]; dtostrf(temperatur, 3,1,buffer); Serial.println(buffer);
Die Ausgabe der Umwandlung ist wie folgt:
Man erkennt in der Grafik, dass die Zahl mathematisch aufgerundet wurde und nicht einfach abgeschnitten ist.
Führende Nullen bei Zahlenwerten
Möchtest du zum Beispiel eine Uhrzeit auf einem Display im Format HH:MM:SS anzeigen lassen, so müsstest du ggf. zusätzlich prüfen, ob der Wert der Stunde, Minute, Sekunde zweistellig (also >= 10 ist) ansonsten müsstest du eine 0 davor schreiben. Dieses kannst du recht einfach mit der Funktion sprintf /snprintf machen.
Im nachfolgenden kleinen Beispiel durchlaufe ich die Zahlen von 0 bis 15 und formatiere diese auf 2 Stellen mit führender Null „0“.
char result[5]; for (int i=0;i<=15;i++){ sprintf(result, "%02d", i); Serial.println(result); delay(75); }
Fazit – Ausgabe formatierter Strings am Arduino
Da du in der Arduino IDE mit C bzw. C++ programmierst, kannst du Code aus diesen Sprachen wiederverwenden. Die Funktionen sind sehr gut dokumentiert und zur Not findest du auch dort viele Beispiele, welche du online ausprobieren kannst.
Im Beitrag Arduino UNO R4: LED Matrix Uhr mit NTP-Zeitsynchronisation verwende ich diese Funktion, um ein Datum zusammenzubauen und später auf der LED Matrix auszugeben.
Hallo,
danke, der Beitrag hat mir viel geholfen (sprintf)
Sehr gut, die Funktionen dtostrf() und snprintf_P habe ich neu gelernt.
Es wäre schön, wenn es Listen dieser Funktionen für Arduino bzw. ESP8266 gäbe
Hi,
eine gute Quelle an mögliche Funktionen ist die Referenz von Arduino welche du unter https://www.arduino.cc/reference/de/.
Ansonsten natürlich jedes C/C++ Tutorial da du eigentlich in einem Mix dieser Sprache programmierst.
Gruß
Stefan