Festkommaarithmetik

Das Problem

Ein immer wiederkehrendes Problem ist die Anzeige von Messwerten per UART/RS232 oder LCD. Die Messwerte werden praktisch immer von AD-Wandlern oder anderen Sensoren in digitaler Form geliefert. Doch wie wandelt man diese in eine "normale" Anzeige wie z.B. 4,56V um?

Der einfachste Ansatz ist der Einsatz von Gleitkommazahlen. Dabei gilt nahezu immer die Formel

[math]\displaystyle{ Eingangsspannung = \frac{ADC \hbox{-} Wert \cdot Referenzspannung}{ 2^{Bitbreite_{ADC}}} }[/math]

Den so errechneten Wert der Eingangsspannung kann man einfach per C-Funktion

<c> sprintf(mein_string, "%2.4f", Eingangsspannung); </c>

in einen String umwandeln und dann auf ein LCD oder den UART ausgeben.

Soweit so gut. Das Problem ist "nur".

• Das Rechnen mit Gleitkommazahlen ist auf den meisten Mikrocontrollern mit recht viel Rechenzeit sowie Programmspeicher verbunden, da diese keine Befehle zur direkten Verarbeitung von Gleitkommazahlen haben. Alle Rechnungen werden mit Hilfe von Bibliotheksfunktionen nachgebildet.
• Die Ausgabe von Gleitkommazahlen per sprintf und Konsorten benötigt ebenfalls sehr viel Programmspeicher, da diese Funktionen sehr mächtig und damit umfangreich sind

Die Lösung

Die allerwenigsten Anwendungen benötigen die volle Leistung von Gleitkommazahlen (Dynamikbereich). Wesentlich sinnvoller ist die Anwendung von Festkommazahlen. Diese sind normale Integerzahlen (ganzzahlig ohne Kommastellen), allerdings mit "gedachten" Kommastellen. Wie geht das? Ganz einfach. Anstatt 10,45 kann man auch 1045 schreiben und die beiden letzten Stellen als Nachkommastellen betrachten. 1045 kann man in einer ganz normalen 16 Bit Integervariable speichern. Und auch damit rechnen!

Anstatt nun in Gleitkomma zu schreiben und zu rechnen

[math]\displaystyle{ U = \frac{756 \cdot 5,0}{1024} }[/math]

wird geschrieben

[math]\displaystyle{ U = \frac{756 \cdot 5000}{1024} }[/math]

Die Referenzspannung wird in 1/1000 V (mV) ausgedrückt und damit gerechnet. Das Ergebnis ist eine Spannung in mV.

Wichtig ist dabei, daß

• erst alle Multiplikationen und dann erst die Divisionen durchgeführt werden, um Rundungsfehler zu minimieren
• währendessen keine arithmetischen Überläufe auftreten, also genügend grosse Variablen benutzen (16/32/64 Bit Integer)

Doch wie wird nun diese Zahl in einen darstellbaren String umgewandelt? Im einfachsten Fall durch Verwendung der C-Funktion itoa (Integer to ASCII). Diese ist auf vielen Mikrocontrollern als C-Bibliothek verfügbar. Wenn dies jedoch nicht so sein sollte muss man sie selber schreiben. Und da wir hier etwas lernen wollen, werden wir das auch tun.

ITOA selbst gemacht

Wie funktioniert nun die Umwandlung einer Zahl in einen String? Ganz einfach. Für jede Stelle der Dezimalzahl muss ein ASCII-Zeichen erzeugt werden. Wenn z.B. die Zahl 28943 in einen String gewandelt werden soll muss am Ende der String die ASCII-Codes 0x32, 0x38, 0x39, 0x34, 0x33 und 0x00 (Stringabschlusszeichen, Stringterminator) enthalten. Wie man bei genauem Hinsehen sieht, besteht der ASCII-Code einer Zahl zwischen 0..9 immer aus 0x30 + Zahl. Das ist einfach. Und wie kommt man nun an die einzelnen Ziffern? Dazu wird eine MODULO Operation durchgeführt. Diese liefert den Rest einer ganzzahligen Division.

28943 MOD 10 =       3

Nun gehts an die nächste Stelle. Dazu wird die Zahl einfach durch 10 dividiert

228943 / 10 = 2894

Und nun das Spiel von vorn.

2894 MOD 10 =        4
2894 / 10   = 289
289 MOD 10  =        9
289 / 10    = 28
28 MOD 10   =        8
28 / 10     = 2
2 MOD 10    =        2

Das wars eigentlich schon. Beachtet werden muss nur, dass bei dieser Methode die einzelnen Stellen in umgekehrter Reihenfolge entstehen: Die höchstwertigen Stellen kommen erst zum Schluss.

Hier ist nun unsere erste einfache Funktion, um eine vorzeichenlose 32 Bit Zahl in einen String umzuwandeln. Diese kann maximal 10 Dezimalstellen haben (0..4294967295), also wird ein Speicher für 11 Bytes benötigt (letztes Byte für den Stringterminator). Bei dem Verfahren wird die Zahl rückwärts berechnet. Das muss bei der Ablage im Speicher berücksichtigt werden. Im Sinne der Verständlichkeit wurde bewusst auf Optimierungen und kompakt/kryptische Schreibweisen verzichtet. Der Syntax ist Standard-C und somit auf jedem Compiler nutzbar.

<c>

1. include <stdint.h>

/*

Funktion zur Umwandlung einer vorzeichenlosen 32 Bit Zahl in einen String

• /

void my_uitoa(uint32_t zahl, char* string) {

 int8_t i;                             // schleifenzähler

 string[10]='\0';                       // String Terminator
 for(i=9; i>=0; i--) {
   string[i]=(zahl % 10) +'0';         // Modulo rechnen, dann den ASCII-Code von '0' addieren
   zahl /= 10;
 }

} </c>

Diese Funktion gibt auch führende Nullen aus. Das ist erstmal OK, denn so wissen wir immer wo unser gedachtes Komma ist. Bei der Ausgabe können die führenden Nullen unterdrückt werden. Wie das geht, wird weiter unten beschrieben.

Benötigt man neben der Ausgabe für vorzeichenlose (unsigned) Werte auch noch eine Funktion für vorzeichenbehaftete Werte, so ist auch dieses keine Hexerei. Dazu verwenden wir ein zusätzliches Byte im String um das Vorzeichen zu speichern. Der String muss nun also mindestens 12 Bytes Speicherplatz zur Verfügung stellen.

<c>

1. include <stdint.h>

/*

Funktion zur Umwandlung einer vorzeichenbehafteten 32 Bit Zahl in einen String

• /

void my_itoa(int32_t zahl, char* string) {

 uint8_t i;

 string[11]='\0';                  // String Terminator
 if( zahl < 0 ) {                  // ist die Zahl negativ?
   string[0] = '-';              
   zahl = -zahl;
 }
 else string[0] = ' ';             // Zahl ist positiv

 for(i=10; i>=1; i--) {
   string[i]=(zahl % 10) +'0';     // Modulo rechnen, dann den ASCII-Code von '0' addieren
   zahl /= 10;
 }

} </c>

Beispiele

Digitaler Temperatursensor

Anstatt eines ADC-Wertes werden oft auch Digitalwerte von Temperatursensoren verarbeitet. Der Weg ist hier identisch. Allerdings hat man keine Referenzspannung oder Referenztemperatur. Das ist aber kein Beinbruch. Z.B. der LM74 hat eine Auflösung von 1/16°C = 0,0625°C. Um das Messergebnis ohne Verlust von Auflösung auszugeben könnte man als erstes den Digitalwert auf 1/100 °C umrechnen. Das geschieht mit der Multiplikation mit 6,25. Doch Stop, das ist ja schon wieder ne Gleitkommazahl. Doch kein Problem, wir wissen ja wie wir das Problem lösen. Wir schieben das Komma um zwei Stellen nach rechts und multiplizieren mit 625 und wissen, dass das Ergbniss nun in 1/10000°C vorliegt. Über den physikalischen Sinn dieser Auflösung müssen wir nicht nachdenken, wichtig ist für uns nur, dass jetzt die Zahl einfach per itoa() umwandelbar ist. Allgemein kann man folgenden Ablauf zur Berechnung des Korrekturfaktors angeben

• Den Korrekturfaktur K mit vollen Kommastellen berechnen, dabei ist die neue Auflösung sinnvollerweise eine Dezimalzahl ( 0,1; 0,001 etc.) und kleiner als die alte Auflösung.

[math]\displaystyle{ K = \frac{alte~Aufloesung}{neue~Aufloesung} }[/math]

• Den berechneten Korrekturfaktor solange mit 10 multiplizieren bis alle Nachkommastellen verschwunden sind bzw. durch Rundung ein akzeptabler Fehler entsteht. Für jede Multiplikation des Faktors mit 10 muss die neue Auflösung durch 10 dividiert werden.

[math]\displaystyle{ Temperatur = Sensorwert \cdot K }[/math]

Beispiel:

Alte Auflösung: 1/32°C
Neue Auflösung: 1/100°C

[math]\displaystyle{ K = \frac{\frac{1}{32}}{\frac{1}{100}} = 3,125 }[/math]

Der Korrekturfaktor 3,125 kann zweimal mit 10 multipliziert werden und dann auf 312 gerundet werden, das entspricht einem Rundungsfehler von gerade mal 1/624 = 0,16% ! Die neue Auflösung beträgt 1/10000°C. Wenn der Sensor nur 7 Bit Werte liefert kann das Ergebnis in einer 16 Bit Variablen gespeichert werden, darüber hinaus ist eine 32 Bit Variable notwendig.

ADC allgemein

Wenn man das obige ADC-Beispiel allgemein beschreiben will, dann gilt folgender Ablauf

• Korrekturfaktor mit vollen Kommastellen berechnen

[math]\displaystyle{ alte Aufloesung = \frac{Referenzspannung}{2^{Bitbreite_{ADC}}} }[/math]

[math]\displaystyle{ K = \frac{alte~Aufloesung}{neue~Aufloesung} }[/math]

• Den berechneten Korrekturfaktor K solange mit 10 multiplizieren bis alle Nachkommastellen verschwunden sind bzw. durch Rundung ein akzeptabler Fehler entsteht. Für jede Multiplikation des Faktors mit 10 muss die neue Auflösung durch 10 dividiert werden.

[math]\displaystyle{ Eingangsspannung = ADC \hbox{-} Wert \cdot K }[/math]

Beispiel:

Referenzspannung : 5V
ADC Bitbreite : 10

[math]\displaystyle{ alte Aufloesung = \frac{5V}{2^{10}} = \frac{5}{1024} = 0,0048828125\,V }[/math]

neue Auflösung: 0,001 V = 1mV

[math]\displaystyle{ K = \frac{0,0048828125 V}{0,001V} = 4,8828125 }[/math]

Der Korrekturfaktor 4,8828125 wird zweimal mit 10 multipliziert und dann auf 488 gerundet, das entspricht einem Rundungsfehler von gerade mal 0,05% ! Die neue Auflösung ist 0,00001 V = 10uV. Das Ergebnis muss in einer 32 Bit Variablen gespeichert werden, denn der grösste Messwert ergibt 1023*488 = 499224. Der Vorteil dieses allgemeinen Ansatzes ist vor allem, daß nur eine Multiplikation benötigt wird, im Gegensatz zu unserem allerersten Beispiel, welches eine Multiplikation und eine Division benötigt. Das spart einiges an Rechenzeit und Programmspeicherplatz.

Ergebnis runden

Nach der Umrechung des ADC/Sensor-Wertes und dem Aufruf von my_uitoa() kann man sehr einfach eine Rundung durchführen. Dazu muss nur die erste Stelle, welche durch Rundung wegfallen soll, geprüft werden. Ist sie kleiner als der ASCII-Code von '5' (0x35) dann muss abgerundet werden, sprich alles bleibt wie es ist. Im anderen Fall muss aufgerundet werden, was bedeutet dass die letzte angezeigte Dezimalstelle um eins erhöht werden muss. Doch aufgepasst! Wenn z.B. in unserem String die Zahl 1995 steht und die letzte Stelle durch Rundung wegfallen soll, kommte es zum Übertrag. Die letzte 9 wird zur 0 + Übertrag. Die nächste linksstehende Stelle muss erhöht werden. Das ist "dummerweise" auch eine 9, also wieder ein Übertrag. Die letzte Ziffer ist 1, die wird nur auf zwei erhöht und der Übertrag endet.

Basierend auf unserer Funktion my_uitoa() soll hier eine einfache Rundungsfunktion gezeigt werden. Auch diese arbeitet mit einem 11 Byte String, welcher vorher durch my_uitoa erzeugt wurde.

<c>

1. include <stdint.h>

/*

Funktion zur Rundung einer vorzeichenlosen 32 Bit Zahl im Stringformat

Parameter:

char* string: Zeiger auf String, welcher mit my_uitoa() erzeugt wurde uint8_t digit: Offset im String, zeigt auf die Stelle welche zur Rundung ausgewertet werden soll

              gültiger Wertebereich ist 1..9 !
              Der Offset von 1 zeigt auf die zweite Stelle von links
              Der Offset von 9 zeigt auf die letzte Stelle von links

• /

void my_round(char* string, uint8_t digit) {

 uint8_t i;

 if (string[digit]>='5') {         // Aufrunden?
   for(i=(digit-1); i>=0; i--) {
     string[i] += 1;               // Aufrunden
     if (string[i]<='9')
       break;                      // kein Übertrag, schleife verlassen
     else
       string[i]='0';              // Übertrag und Überlauf
   }
 }

 for(i=digit; i<10; i++) string[i] ='0';   // gerundete Stellen auf Null setzen

} </c>

Die Funktion ist auch auf einen String anwendbar, welcher mit my_itoa() erzeugt wurde (also vorzeichenbehaftete Zahlen). Allerdings muss der Funktion ein Pointer auf das zweite Byte (char) übergeben werden, da im ersten das Vorzeichen gespeichert ist. Das geschieht am einfachsten so.

<c> my_round(my_sting+1, 5); </c>

Ergebnis ausgeben

Ausgabe auf LCD (HD44780 & CO)

Nun haben wir unseren Messwert in eine Zahl mit der richtigen Einheit umgewandelt und gerundet. Jetzt folgt der letzte Schritt, die Ausgabe auf einen UART oder LCD. Dazu ist es meist wünschenswert führende Nullen nicht anzuzeigen. Also anstatt 0095,89 will man 95,89 ausgeben. Bei negativen Zahlen kommt noch das Vorzeichen hinzu. Zunächst wollen wir unsere Zahl auf einem LCD ausgeben. Dazu braucht man die entsprechende Funktion lcd_data(), wie sie z.B. im AVR-Tutorial: LCD zu finden ist.

<c>

1. include <stdint.h>

/*

Funktion zur Anzeige einer vorzeichenbehafteten 32 Bit Zahl im Stringformat auf einem LCD mit HD44780 Controller

Parameter:

char* string  : Zeiger auf String, welcher mit my_itoa() erzeugt wurde uint8_t start : Offset im String, ab der die Zahl ausgegeben werden soll,

               das ist notwenig wenn nur Zahlen mit begrenztem Zahlenbereich
               ausgegeben werden sollen 

uint8_t komma : Offset im String, zeigt auf die Stelle an welcher das virtuelle

               Komma steht (erste Nachkommastelle)
               komma muss immer grösser oder gleich start sein !

uint8_t frac  : Anzahl der Nachkommastellen

• /

void my_print_LCD(char* string, uint8_t, start, uint8_t komma, uint8_t frac) {

 uint8_t i;            // Zähler
 uint8_t flag=0;       // Merker für führende Nullen

 // Vorzeichen ausgeben  
 if (string[0]=='-') lcd_data('-'); else lcd_data(' ');

 // Vorkommastellen ohne führende Nullen ausgeben
 for(i=start; i<komma; i++) {
   if (flag==1 || string[i]!='0') {
     lcd_data(string[i]);
     flag = 1;
   }
   else lcd_data(' ');         // Leerzeichen
 }

 lcd_data(',');                // Komma ausgeben

 // Nachkommastellen ausgeben
 for(; i<(komma+frac); i++) lcd_data(string[i]);

} </c>

Die Funktion gibt zunächst das Vorzeichen aus, das ist einfach. Danach werden die Vorkommastellen ausgegeben. Aber es wird nur dann ein Zeichen ausgegeben, wenn vorher schon mal eins ausgegeben wurde (flag ==1) oder das aktuelle Zeichen keine '0' ist. Danach werden ganz normal die Nachkommastellen ausgegeben, hier ist eine Unterdrückung führender Nullen sogar mathematisch falsch!

Genutzt wird die Funktion beispielsweise so, um dreistellige Zahlen bis 999 mit zwei Nachkommastellen auszugeben. Die Zahl selber hat sechs Nachkommastellen.

<c> char my_string[12]="-0034567891\0"; my_print_LCD(my_string, 2, 5, 2); </c>

Auf dem LCD erscheint dann

- 34.56

Ausgabe auf UART

Die Ausgabe auf einen UART ist nahezu identisch. Auch hier braucht man eine Funktion putc(), welche ein einzelnes Zeichen auf den UART schreiben kann wie z.B. im AVR-Tutorial:UART:GCC beschrieben ist. Der Unterschied zur LCD-Ausgabe besteht darin, dass zwischen dem Vorzeichen und der Zahl keinerlei Leerzeichen eingefügt werden.

<c>

1. include <stdint.h>

/*

Funktion zur Anzeige einer 32 Bit Zahl im Stringformat auf den UART

Parameter:

char* string  : Zeiger auf String, welcher mit my_itoa() erzeugt wurde uint8_t start : Offset im String, ab der die Zahl ausgegeben werden soll,

               das ist notwenig wenn nur Zahlen mit begrenztem Zahlenbereich
               ausgegeben werden sollen
               Vorzeichenlose Zahlen      : 0..10
               Vorzeichenbehaftete zahlen : 1..11

uint8_t komma : Offset im String, zeigt auf die Stelle an welcher das virtuelle

               Komma steht (erste Nachkommastelle);
               komma muss immer grösser oder gleich start sein !

uint8_t frac  : Anzahl der Nachkommastellen

• /

void my_print_UART(char* string, uint8_t, start, uint8_t komma, uint8_t frac) {

 uint8_t i;            // Zähler
 uint8_t flag=0;       // Merker für führende Nullen

 // Vorkommastellen ohne führende Nullen ausgeben
 for(i=start; i<komma; i++) {
   if (flag==1 || string[i]!='0') {
     if (flag==0 && string[0]=='-') putc('-');     // negatives Vorzeichen ausgeben
     putc(string[i]);
     flag = 1;
   }
 }

 putc(',');                // Komma ausgeben

 // Nachkommastellen ausgeben
 for(; i<(komma+frac); i++) putc(string[i]);

} </c>

Diese Funktion kann auch verwendet werden, um vorzeichenlose Strings auszugeben, welche mit my_uitoa() erzeugt wurden. Da an der ersten Stelle nie ein '-' steht, wird auch nie ein '-' ausgegeben.