Mikrocontroller.net - Benutzerbeiträge [de]

Avr-akku-kapazitaet-messen

2007-12-28T21:59:53Z

84.167.184.249: Meine Erfahrungen

== Messen der Akkukapazität mit einem AVR ==

Entstehen soll ein sehr einfaches Gerät, das die Kapazität der Akkus anzeigt.

Um das Projekt zu starten, sollten erst einmal die grundlegenden Spezifikationen festgelegt werden:

* Die Schaltung soll einfach sein (Leichter Nahbau)
* Es werden nur Lade- / Entladespannungen bis 2.56 Volt unterstützt. Das reicht für AAA / AA / B / C / D - Zellen. Es werden nur einzelne NiCD / NiMH -zellen getestet
* Stromsenke (LM317, MOS-FET)
* 2-zeiliges LC-Display
* Entladestrom fest eingestellt durch einen 6 Ohm Entladdewiderstand
* Stromversorgung: Netzteil
* Entladen / Laden von bis zu 4 Akkus gleichzeitig. Jeder für sich, unabhängig voneinander.
* Verwendung eines einfachen unzuverlässigen Batteriehalters. Wenn die Spannung vom Akku für eine kurze Zeit (< 5Sec) ausfällt, soll das ignoriert werden
* Messen der Entladespannung, während der Entladestrom fließt, und Abschalten des Entladestroms, um die Leerlaufspannung messen zu können.
* Abschätzen (berechnen) des Entladestromes, ohne den Strom zu messen. Stattdessen wird die Entladespannung über dem bekannten Entladewiederstand gemessen und der Strom und der integrierte Strom berechnet.
* Bedienung über die serielle Schnittstelle.
* Abfragen des Entladezustandes (Warten auf Akku, Entladen, Warten bis Akku entfernt) über die serielle Schnittstelle.
* Möglichkeit den Akku zu laden (Befehl über die serielle Schnittstelle)
* Abschätzen (berechnen) des Ladestroms aus der Akkuspannung, der Versorgungsspannung und des bekannten ladesstrombestimmenden Festwiderstandes.
* Begrenzung der Ladung durch Vorgabe der maximalen Ladespannung
* Begrenzung der Ladung durch Vorgabe des maximales Ladestromintegrals.
* Bilden eine Tabelle der Entladespannungen (alle Minuten eine Abfrage) durch Excel. (Excel benutzt porl.dll um die Entladespannung abzufragen.)
* Bilden einer Entladegrafik durch Excel.

Die größte Problematik eines Akku - Testers sind die Übergangswiderstände zwischen der AA / AAA - Zelle und dem (billigen, China-) Batteriehalter.

Diese sind Abhängig von der Lage des Akkus (Einfaches Drehen des Akkus verändert die angezeigte Entladespannung eines AA - Akkus mal geschwind um 60 mV

Hier mal eine Beispielschaltung aus dem Forum:
[http://www.mikrocontroller.net/forum/read-1-199581.html Akku-Kapazitätsmessung mit AVR]

[[Bild:1AStromsenke.jpg|1A Stromsenke mit LM317.jpg]]

Muluwuw

2007-12-28T16:26:52Z

84.167.184.249: Erstellt

= Multiplikation von 2 16-bit-Zahlen =

Wenn wir schriftlich zwei Zahlen multiplizieren, kommen immer größere Zahlen heraus, als jeder der beiden Faktoren.

Beispiel: 999 * 99999 = 99899001

Weil hier eine dreistellige Zahl mit einer fünfstelligen Zahl multipliziert wurde, kann das Ergebnis achtstellig sein.

Das ist bei Binärzahlen genauso:

Wenn eine 8-Bit-Zahl mit einer 8-Bit-Zahl multipliziert wird, wird ein 16-bit-Ergebnis herauskommen.

== Der Programmcode 16 bit mal 16 bit ergibt 32 bit ==
<pre>
// This routine multiplies two 16 bit integers,
// The return value is a 32 bit integer
//
// See also mulswsw.cpp : Signed 16 bit * signed 16 bit

#include <heport.h>
#include <heimath.h> // definition of mul_uw_uw
#ifdef AVR
#include <avr/io.h>
#endif

#ifndef AVR
// Other processors do not need speed up
FUNCT ulong mul_uw_uw( uword x , uword y )
{
ulong res ;

res = (ulong)x * (ulong)y ;
return res ;
}

#else

#if 0 /* Software- Multiply */
// input:
// r23_r22 = x.h_x.l
// r25_r24 = y.h_y.l
// may destroy r18 r19 r20 r21 r22 r23 r24* r25* r26* r27*
// may not destroy r14 r15 r16 r17 r28=YL r29=YH
// return r25_r24_r23_r22

FUNCT ulong dummy_mul_uw_uw( uword x , uword y )
{

// asm(" .text " "\n");
asm(" ; " "\n");
asm(" .global mul_uw_uw" "\n");
asm(" ; See as well mul_uc_uc : 8 bit by 8 bit, result 16 bits " "\n");
asm(" ; " "\n");
asm(" ; Function mul_uw_uw " "\n");
asm(" ; multiply unsigned 16 bit by 16 bit " "\n");
asm(" ; " "\n");
asm(" ; Input: " "\n");
asm(" ; r23:r22 : The factor " "\n");
asm(" ; r25:r24 : The factor " "\n");
asm(" ; Results " "\n");
asm(" ; r25:r24:r23:r22 : result " "\n");
asm(" ; Destroyed registers " "\n");
asm(" ; r18 r19 r20 r21 r26 r27" "\n");
asm(" ; This program is verified by qqarith.asm " "\n");
asm(" ; " "\n");
//asm(" _Z9mul_uw_uwtt: " "\n");
asm("mul_uw_uw: " "\n");
asm(" push r16 ; " "\n");
asm(" ; Clear start values " "\n");
asm(" mov r26,r22 ; factor x to interim storage " "\n");
asm(" mov r27,r23 " "\n");
asm(" mov r18,r24 ; factor y to interim storage " "\n");
asm(" mov r19,r25 " "\n");
asm(" clr r20 " "\n");
asm(" clr r21 " "\n");
asm(" ; Clear result r25:r24;r23;r22 " "\n");
asm(" clr r22 " "\n");
asm(" clr r23 " "\n");
asm(" clr r24 " "\n");
asm(" clr r25 " "\n");
asm(" ; " "\n");
asm(" mul_uw_uw_3: " "\n");
asm(" lsr r27 " "\n");
asm(" ror r26 ; next binary digit of right factor to carry " "\n");
asm(" brcc mul_uw_uw_4 " "\n");
asm(" ; Add the (shifted) left factor into result " "\n");
asm(" add r22,r18 " "\n");
asm(" adc r23,r19 " "\n");
asm(" adc r24,r20 ; add 0" "\n");
asm(" adc r25,r21 ; add 0" "\n");
asm(" mul_uw_uw_4: " "\n");
asm(" ; shift the factor y by 1 bit to left" "\n");
asm(" add r18,r18 " "\n");
asm(" adc r19,r19 " "\n");
asm(" adc r20,r20 " "\n");
asm(" adc r21,r21 " "\n");
asm(" mov r16,r26 ; no more of right factor left " "\n");
asm(" or r16,r27 " "\n");
asm(" brne mul_uw_uw_3 " "\n");
asm(" ; result is 32 bits in r25:r24:r23:r22 " "\n");
asm(" pop r16 " "\n");
asm(" ret " "\n");

return 0 ;
}

#else

// Hardware multiply MUL
// input:
// r23_r22 = x.h_x.l
// r25_r24 = y.h_y.l
// may destroy r18 r19 r20 r21 r22 r23 r24* r25* r26* r27*
// may not destroy r14 r15 r16 r17 r28=YL r29=YH
// return r25_r24_r23_r22

FUNCT slong dummy_mul_uw_uw( sword x , sword y )
{
//asm(" .text " "\n");
asm(" .global mul_uw_uw" "\n");
asm(" ; See as well mul_uc_uc : 8 bit by 8 bit, result 16 bits " "\n");
asm(" ; " "\n");
asm(" ; Function mul_uw_uw " "\n");
asm(" ; multiply unsigned 16 bit by 16 bit " "\n");
asm(" ; " "\n");
asm(" ; Input: " "\n");
asm(" ; r23:r22 : The factor " "\n");
asm(" ; r25:r24 : The factor " "\n");
asm(" ; Results " "\n");
asm(" ; r25:r24:r23:r22 : result" "\n");
asm(" ; Destroyed registers " "\n");
asm(" ; r18 " "\n");
asm(" ; This program is verified by qqarith.asm " "\n");
asm(" ; " "\n");
//asm(" _Z9mul_uw_uwtt: " "\n");
asm("mul_uw_uw: " "\n");
asm(" push r0 ; " "\n");
asm(" push r1 ; " "\n");
asm(" push r16 ; " "\n");
asm(" ; Clear start values " "\n");
asm(" clr r16 " "\n" );
asm(" mov r20,r22 ; factor x to interim storage " "\n");
asm(" mov r21,r23 " "\n");
asm(" mov r18,r24 ; factor y to interim storage " "\n");
asm(" mov r19,r25 " "\n");

asm(" mul r20,r18 ; low byte * low byte" "\n" );
asm(" mov r22,r0 ; low byte of low result word" "\n" );
asm(" mov r23,r1 ; high byte of low result word" "\n" );
asm(" mul r21,r19 ; high byte * high byte" "\n" );
asm(" mov r24,r0 ; high result word" "\n" );
asm(" mov r25,r1 ; high result word" "\n" );
asm(" mul r20,r19 ; low byte * high byte" "\n" );
asm(" add r23,r0 ; medium result word" "\n" );
asm(" adc r24,r1 ; medium result word" "\n" );
asm(" adc r25,r16 ; carry to highest byte" "\n" );
asm(" mul r21,r18 ; low byte * high byte" "\n" );
asm(" add r23,r0 ; medium result word" "\n" );
asm(" adc r24,r1 ; medium result word" "\n" );
asm(" adc r25,r16 ; carry to highest byte" "\n" );
asm(" ; result is 32 bits in r25:r24:r23:r22 " "\n");
asm(" pop r16 " "\n");
asm(" pop r1 " "\n");
asm(" pop r0 " "\n");
asm(" ret " "\n");

return 0 ;
}

#endif

#endif

</pre>

Hinweis: Register r1 braucht nicht gerettet werden, muss dann vor der Rückkehr auf 0 gesetzt werden.

Festkommaarithmetik

2007-12-28T16:11:58Z

84.167.184.249: /* ADC allgemein */ Umwandlung, Rundung und Ausgabe in Einem

== Das Problem ==

Ein immer wiederkehrendes Problem ist die Anzeige von Messwerten per UART/RS232 oder LCD. Die Messwerte werden praktisch immer von [[AD-Wandler]]n 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>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>U = \frac{756 \cdot 5,0}{1024}</math>

wird geschrieben

<math>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
* in sämtlichen Zwischenergebnissen 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.

<pre>
28943 MOD 10 = 3
</pre>

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

<pre>
28943 / 10 = 2894
</pre>

Und nun das Spiel von vorn.

<pre>
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
</pre>

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>
#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>
#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>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>Temperatur = Sensorwert \cdot K</math>

Beispiel:

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

<math>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>alte Aufloesung = \frac{Referenzspannung}{2^{Bitbreite_{ADC}}}</math>

<math>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>Eingangsspannung = ADC \hbox{-} Wert \cdot K</math>

Beispiel:

Referenzspannung : 5V 
ADC Bitbreite : 10

<math>alte Aufloesung = \frac{5V}{2^{10}} = \frac{5}{1024} = 0,0048828125\,V</math>

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

<math>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.

Für die Ausgabe der ADC-Spannung eignet sich folgendes Unterprogramm nach [[User:HJHerbert]]:

ulong round[5] =
{
65536L/2/1 ,
65536L/2/10 ,
65536L/2/100 ,
65536L/2/1000 ,
65536L/2/10000
} ;

void out_uwfx(
uword w, // Der ADC-Wert, linksbuendig
// 0xffff = 0.999999, 0x8000 = 0.500
uword prec, // Anzahl der Nachkommastellen
uword n ) // Der Wert, den w=(0xffff+1) repräsentiert
{
ulong ul ;
uword teil ;
uword x ;
uchar i ;

ul = mul_uw_uw(w, n);
if ( prec < 5 )
{
ul += round[prec] ;
}
x = (uword)(ul >> 16) ;
teil = (uword)ul ;
out_uint16( x ); // Anzeige des ganzzahligen Teils
out_char( '.' );
for ( i = 0 ; i < prec ; ++i )
{
ul = mul_uw_uw(teil, 10);
x = (uword)(ul >> 16) ;
teil = (uword)ul ; // Der Ueberlauf wurde schon angezeigt
out_char( x + '0' ); // noch eine Nachkommastelle
}
}

Dieses Ausgabeprogramm kann dann so aufgerufen werden:

out_puts( " B=" );
out_uwfx( 756<<6, 4, 1 ); // with rounding 756/1024 = 0.73828125
out_puts( " C=" );
out_uwfx( 756<<6, 4, 5 ); // output unsigned fixed point number 756*5/1024 = 3.69140625
out_nl();

Damit wird angezeigt: B=0.7383 C=3.6914

Hinweis: Um 6 Bits nach links wird geschoben, weil der maximale ADC-Wert 1023 ist und 10 Bits hat. Nach dem Linksschieben ist der code in den oberen 10 Bits des 16-Bit-Wortes.

Die hierbei verwendeten Unterprogramme sind:
* out_uint16( uword x ) // Ausgabe einer ganzen Zahl
* mul_uw_uw( uword a, uword b) // 32-Bit-Ergebnis einer 16bit x 16bit Multiplikation, siehe [[muluwuw]]

== 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>
#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 ==

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.

=== Ausgabe auf LCD (HD44780 & CO) ===

Zunächst wollen wir unsere Zahl auf einem LCD ausgeben. Dazu braucht man die entsprechende Funktion lcd_data(), wie sie z.B. im [[AVR-GCC-Tutorial#LCD_Ansteuerung]] zu finden ist.

<c>
#include <stdint.h>
/*

Funktion zur Anzeige einer 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 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_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
<pre>
- 34.56
</pre>

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

=== 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>
#include <stdint.h>
/*

Funktion zur Ausgabe 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 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.