Hilfe bei Programmierung

[Fridolin (Gast)]

Hallo Forum,

ich habe für den µc folgendes als Programmvorlage.

LCDdata3[6] =  (cm  % 1000) / 100 + '0';     // Hunderterstelle
LCDdata3[7] =  (cm   % 100) / 10 + '0';     // Zehnerstelle
LCDdata3[8] =  cm  % 10 + '0';         // Einnerstelle

Wie müsste ich die Stellen

Tausend
Zehntausend
Hunderttausend
1Mio
10 Mio.
100. Mio
1. Mrd. im code fortführen?

Danke.

[Stefan F. (Gast)]

Einfach weitere Nullen anhängen
> LCDdata3[7] =  (cm  % 10000) / 1000 + '0';     // Tausender-Stelle

Den Rest der Hausaufgabe schaffst du alleine, nehme ich an.

Falls noch jemand fragt, wie man das im echten Leben üblicherweise 
macht: man verwendet sprintf()

[Thilo L. (bc107)]

LCDdata3[6] =  (cm  % 1000) / 100 + '0';     // Hunderterstelle
LCDdata3[7] =  (cm  %  100) /  10 + '0';     // Zehnerstelle
LCDdata3[8] =  (cm  %   10) /   1 + '0';     // Einnerstelle


Hmmm... vielleicht hilft Dir die Einrückung Deines Codes, um hier evtl. 
eine gewisse Systematik zu erkennen?

[Stefan F. (Gast)]

Stefan ⛄ F. schrieb:
> LCDdata3[7] =  (cm  % 10000) / 1000 + '0';     // Tausender-Stelle

Misst in die eckigen Klammern gehört eine 5!

[Hmmm (Gast)]

Stefan ⛄ F. schrieb:
> Falls noch jemand fragt, wie man das im echten Leben üblicherweise
> macht: man verwendet sprintf()

Wenn man genug Speicher hat, kann man das machen, *printf() ist nicht 
gerade schlank.

[Stefan F. (Gast)]

Fridolin schrieb:
> Wie müsste ich die Stellen
> 1. Mrd. im code fortführen?

Dieser letzte Schritt passt nicht mehr in den reservierten Platz des 
Displays (Position -1 gibt es nicht). Dazu müsstest du alles um eine 
Position nach rechts verschieben.

[W.S. (Gast)]

Fridolin schrieb:
> Wie müsste ich die Stellen...
> ... im code fortführen?

Ich sehe, daß du dir Gedanken darüber machst, wie man Integerzahlen in 
lesbare Zeichen konvertieren kann - und zwar selber. Der Ratschlag mit 
printf ist dagegen etwa so wie "nehmen sie sich ein Ingenieurbüro zum 
Lösen ihrer Aufgabe".

Aber dein Ansatz ist recht verschwenderisch, denn er beinhaltet gleich 
zwei Divisionen, eine für das Modulo und dann noch eine explizite.

man mach sowas anders: Zunächst solltest du mal nachlesen, was die 
Funktion

ldiv_t T;
T = ldiv(zahl,10);

macht.
Damit kannst du dann das Ganze in eine Schleife packen. Beim 1. 
Durchlauf kommt als Rest die Einerstelle herus, beim 2. Durchlauf dann 
die Zehnerstelle und so weiter. Im Prinzip teilst du mehrfach durch 10 
und der jeweilige Rest ist die Stelle (natürlich dann aus 0..9 noch 
ASCII machen, also 30h..39h)

Das spart nicht nur Code, sondern in deinem Falle auch Rechenzeit und du 
brauchst dich nicht mehr zu fragen, wie man "die Stellen...im Code 
fortführt".

Und damit kannst du dir deine eigene Ausgabekonvertierung schreiben, die 
dramatisch kleiner und schneller ist als alles was nach printf riecht 
bzw. stinkt. Und du weißt ab jetzt, wie man sowas selber anpackt.

W.S.

[Fridolin (Gast)]

Hallo an alle und Danke,

dachte ich auch, mehr Nullen aber mit

LCDdata3[0] = cm  /1000000+'0';     // 1.000.000
LCDdata3[1] = cm  /100000+'0';       // 100.000
LCDdata3[2] = cm  /10000+'0';       // 10.00
LCDdata3[3] = cm  /1000+'0';       // 1.000
LCDdata3[4] =  (cm  % 1000) / 100 + '0';   // Hunderterstelle
LCDdata3[5] =  (cm   % 100) / 10 + '0';   // Zehnerstelle
LCDdata3[6] =  cm  % 10 + '0';       // Einnerstelle

wird ab 10.000 beginnend für die tausender ein ":" ausgegeben über "A" 
..."D" usw. ausgegeben. Ab 90.000 ist die zehntausender dann leer. Ab 
100.000 wird die 1 der 100.000 richtig angezeigt aber die zehntausender 
beginnt wieder mit ":" und die zehntausender Zelle ist leer.

char LCDdata3[40];        //
unsigned long int cm = 0;     // 0 bis 4294967295

Danke.

[Stefan F. (Gast)]

Warum sehen deine oberen 4 hinzugefügten Zeilen ganzn anders aus, als 
die darunter? Was hast du dir dabei gedacht?

Vergleiche das doch mal mit dem Beispiel, dass ich dir gegeben habe. Du 
musst nur die Anzahl der Nullen ändern, nicht eine neue Formel erfinden.

Offenbar hast du nicht verstanden, was die Formel macht.

Einer:
> cm  % 10 + '0'

Hier wird cm zuerst durch 10 geteilt und der Rest (Modulus) davon 
verwendet.
Bei 129cm wäre das Ergebnis die 9. Dann wird '0' addiert, um aus der 
Zahl 9 das Zeichen '9' zu machen. Das hat mit den ASCII Codes zu tun.

Die Zeichen '0' bis '9' haben den ASCII-Code 48 bis 57. Um eine '9' auf 
das Display auszugeben musst du den ASCII-Code 57 an das Display senden. 
Wie kommt man von der Zahl 9 auf 57? -> Indem man 48 oder '0' addiert. 
Denn '0' ist 48.

0 + '0' =     0 + 48 =    48     = '0'
1 + '0' =     1 + 48 =    49     = '1'
2 + '0' =     2 + 48 =    50     = '2'
...
9 + '0' =     9 + 48 =    57     = '9'

Zehner:
> (cm   % 100) / 10 + '0';

Bleiben wir beim Beispiel 129cm. 129 % 100 ergibt 29. Du willst aber nur 
die 2 (die Zehner) ausgeben. Also werden die 29 nochmal durch 10 geteilt 
-> ergibt 2,9. Aber weil es eine Integer-Division ist, entfallen die 
Nachkommastellen. Bleibt die 2 übrig.
2 + '0' ergibt '2'.

Hunderter:
> (cm  % 1000) / 100 + '0';

129cm % 1000 ergibt 129. Das durch 100 geteilt ergibt 1.
1 + '0' ergibt '1'.

Und genau so geht das Spiel mit größeren Zahlen weiter. Das einzige, was 
sich ändert ist die Anzahl der Nullen in der Formel.

[Looper (Gast)]

Es gibt bestimmt noch mehr Routinen in der Codesammlung.
Beitrag "schnelle Wandlung long -> ASCII"

[Fridolin (Gast)]

Hallo an alle,

hab es nun so gemacht:

LCDdata3[0] =  (cm  % 10000000) / 1000000 + '0';   // 1. Mio
LCDdata3[1] =  (cm  % 1000000) / 100000 + '0';     // 100.Tausend
LCDdata3[2] =  (cm  % 100000) / 10000 + '0';     // 10 Tausend
LCDdata3[3] =  (cm  % 10000) / 1000 + '0';     // Tausend
LCDdata3[4] =  (cm  % 1000) / 100 + '0';     // Hunderterstelle
LCDdata3[5] =  (cm   % 100) / 10 + '0';     // Zehnerstelle

es läuft alles. Suppi !

Danke an alle.

[A. S. (Gast)]

Du kannst das / und % auch umdrehen, ist dann vielleicht verständlicher:

LCDdata3[0] = (cm/1000000) %10 + '0'; // 1. Mio
LCDdata3[1] = (cm/ 100000) %10 + '0'; // 100.Tausend
LCDdata3[2] = (cm/  10000) %10 + '0'; // 10 Tausend
LCDdata3[3] = (cm/   1000) %10 + '0'; // Tausend
LCDdata3[4] = (cm/    100) %10 + '0'; // Hunderterstelle
LCDdata3[5] = (cm/     10) %10 + '0'; // Zehnerstelle

[A. S. (Gast)]

Schleife ist dann auch einfacher:

int i;
long c=cm/10; /* weil nur bis zehner, nicht einer. Und damit cm erhalten bleibt */
   
    for(i=5; i>=0; i--)
    {  
        LCDdata3[i] = c%10 + '0';
        c/=10;
    }

Oder vorwärts

long 1000000;
int i; 
   
    for(i=0; i<=5; i++)
    {  
        LCDdata3[i] = (cm/d)%10 + '0';
        d/=10;         
    }

[overflow (Gast)]

Fridolin schrieb:
> LCDdata3[2] =  (cm  % 100000) / 10000 + '0';     // 10 Tausend

Kannst du einmal die Deklaration von cm zeigen und das Zielsystem 
benennen?