Zahlen auf LCD ausgeben

[The F. (frotzzi)]

Hallo zusammen, ich bin ein einsteiger in C und versuche grade auf einem 
LCD_Display zahlen auszugeben.

Auf der FAQ Seite habe ich mir schon "Wie kann ich Zahlen auf LCD/UART 
ausgeben?" durchgelesen aber nicht zu 100% verstanden.
Link 
https://www.mikrocontroller.net/articles/FAQ#Wie_kann_ich_Zahlen_auf_LCD.2FUART_ausgeben.3F

Ich habe mal Spaßes weise den Code einfach kopiert und ausprobiert und 
es funktioniert. Aber was habe ich davon wenn ich es einfach nur 
einfüge. Kann man den Code vereinfachen so das es auch ein Anfänger 
versteht?

Mein Ziel ist es den Code zu verstehen und daraus eine neue Funktion zu 
machen FtoA

u = ( (unsigned)-(z+1) ) + 1; //ich weiß das hier unsigned für posetive Zahlen steht aber was hat es mit z+1 zu tun und warum?

Buffer[i++] = '0' + u % 10; // hier verstehe ich den "u % 10" Teil nicht, kann man das einfacher schreiben?

u /= 10; //Vereinfacht wäre es ja dann "u = u / 10;" oder?

 
// Ich verstehe zwar was es macht das die Zahlen sich spiegeln sollen
// aber ich verstehe nicht wie
// bei der for-schleife verstehe ich das i/ 2 nicht warum man es tut.

      for( j = 0; j < i / 2; ++j ) {
      tmp = Buffer[j];
      Buffer[j] = Buffer[i-j-1];
      Buffer[i-j-1] = tmp;
    }
    Buffer[i] = '\0';

Original Code

void ItoA( int z, char* Buffer )
{
  int i = 0;
  int j;
  char tmp;
  unsigned u;    // In u bearbeiten wir den Absolutbetrag von z.
  
    // ist die Zahl negativ?
    // gleich mal ein - hinterlassen und die Zahl positiv machen
    if( z < 0 ) {
      Buffer[0] = '-';
      Buffer++;
      // -INT_MIN ist idR. größer als INT_MAX und nicht mehr 
      // als int darstellbar! Man muss daher bei der Bildung 
      // des Absolutbetrages aufpassen.
      u = ( (unsigned)-(z+1) ) + 1; 
    }
    else { 
      u = (unsigned)z;
    }
    // die einzelnen Stellen der Zahl berechnen
    do {
      Buffer[i++] = '0' + u % 10;
      u /= 10;
    } while( u > 0 );

    // den String in sich spiegeln
    for( j = 0; j < i / 2; ++j ) {
      tmp = Buffer[j];
      Buffer[j] = Buffer[i-j-1];
      Buffer[i-j-1] = tmp;
    }
    Buffer[i] = '\0';
}

[zyxw (Gast)]

Es reicht, i/2 Stellen zu spiegeln, d.h. zu vertauschen.

Das beschriebene ist aber ein recht rechenaufwendiges Verfahren.

Suche nach Peters Danneggers Add-Sub-Methode, die braucht keine "teuren" 
%- und /-Operationen.
% ist die Modulo-Funktion, d.h. der Rest der Division. Damit werden die 
einzelnen Ziffern berechnet.

>    u = ( (unsigned)-(z+1) ) + 1;
Die Zeile und deren Original-Kommentar sind ziemlich sinnlos.
Gemeint ist, dass bei z.B. bei int16_t  es zwar -32768, aber nur +32767 
gibt.

Der Autor meint, dass er das mit dem +1 irgendwie umschiffen kann 
(-32768+1=-32767), das geht aber nicht, weil sich in der int_t 32768 
immer noch nicht darstellen lässt.
Er müsste es schon in eine neue unsigned-Variable berechnen.
I.d.R braucht man aber diese Fallunterscheidung gar nicht, der Compiler 
/ Prozessor macht es irgendwie richtig.

[W.S. (Gast)]

The F. schrieb:
> Auf der FAQ Seite habe ich mir schon "Wie kann ich Zahlen auf LCD/UART
> ausgeben?" durchgelesen aber nicht zu 100% verstanden.

Das ist im Prinzip doch ganz einfach. Laß dich aber nicht von den gern 
und oft benutzten C-typischen Abkürzungen und Sonderzeichen verwirren.

So, jetzt mal in "symbolischer" Sprache:

1. Methode, wenn man mit Rechenkraft nur so um sich schmeißen kann:

if Zahl ist 0 then Ergebnis = "0" und raus.
Ergebnis = "";
while Zahl ist nicht 0 do
begin
  Ziffer = (Zahl modulo 10) + '0';
  Zahl = Zahl durch 10;
  Ergebnis = Ziffer + Ergebnis;
end

Eine Variante davon ist das Verwenden von ldiv_t, womit man modulo und 
durch in einem Ruck hat.



2. Methode, so wie im Schulbuch 1. oder 2. Klasse:
(größte glatte Zahl sei hier mal 10000, weil ein 16 Bit Integer nicht 
die 100000 erreichen kann)
Ergebnis = "";
for Stelle=10000, dann 1000, dann 100 dann 10 to 1 do
begin
  Ziffer = '0';
  while Zahl >= Stelle do
  begin
    Zahl = Zahl - Stelle;
    Ziffer = Ziffer + 1;
  end
  Ergebnis = Ergebnis + Ziffer;
end

Noch ein Tip: In der steinalten Lernbetty (hier im Forum zu saugen) ist 
ein Modul conv.c, wo du solche Konvertierungen mal nachlesen kannst, so 
du magst.

W.S.