Arduino Programmierung: Ausgabe formatierter Strings / Zeichenketten

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.