Arduino Programmierung: Ausgabe formatierter Strings / Zeichenketten

In diesem Beitrag möchte ich dir nun zeigen wie du eine Ausgabe formatierter Strings / Zeichenketten mit dem Microcontroller 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 zbps. 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 nun 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 wiefolgt 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	Dezimal Zahl
%o	Oktal Integer
%x, %X	Hexadezimal Zahl

Mit diesen 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 Ziel Arrays ü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 das die Zahl mathematisch aufgerundet wurde und nicht einfach abgeschnitten ist.

führende Nullen bei Zahlenwerten

Möchtest du zbsp. 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üsstes 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);
}