AVR sehr lange Integer Variablen

[Fragensteller (Gast)]

Hallo *,

ich habe 120 Bit (15 Byte) Integer Variablen mit denen ich mit 
selbstgebauten Assembler Routinen herumrechne.

Die Werte selbst stehen in 15 Byte Arrays:

unsigned char ul_number[15];

mit dem niederwertigsten Byte an Position 0.

Nun moechte ich das ganze als Zahl im Zehnersystem auf der Uart 
ausgeben.

Gibt es da einen geschickteren Ansatz als Stelle fuer Stelle durch 
subtrahieren von 10^x die auszugebenden Zahlen zu berechnen?

[Jörg G. (joergderxte)]

>Nun moechte ich das ganze als Zahl im Zehnersystem auf der Uart ausgeben.
Darf man fragen warum/wozu? (insbesondere: warum dezimal und nicht 
hexadezimal, das wäre nämlich sehr viel einfacher ?)
> Gibt es da einen geschickteren Ansatz als Stelle fuer Stelle durch
> subtrahieren von 10^x die auszugebenden Zahlen zu berechnen?
Da der AVR nicht dividieren kann, Nein.

hth, Jörg

[Johann L. (gjlayde)]

So ungeschickt ist das nicht.

Es ginge auch ne Art BCD-Arithmetik. Angenommen, du willst x=0b1101 
augeben. Dein Feld mit den Ziffern initialisiert du zu z=000...0 und 
gehst dann die Binärziffern von ober her durch nach folgendem Schema:

n := bitcount (z)
while n > 0
   n := n-1
   z := z+z            (1) 
   if (bit_n(z) == 1)
      z := z+1         (2)
end while

(1) z+z berechnest du ziffernweise, also

i := 0;
BASIS := 10
carry := 0

for (i)
    z[i] := 2 * z[i] + carry
    if (z[i] >= BASIS)
       z[i] := z[i] - BASIS;
       carry := 1
    else
       carry := 0
    i := i+1
end for

(2) ist einfach. Es gibt keine Übertrag, weil z[0] an der Stelle immer 
gerade ist: z+1 ergibt sich einfach durch z[0] := z[0]+1.

Ausgegeben wird dann der String ..., z[2]+'0', z[1]+'0', z[0]+'0'

Die Arithmetik ist zwar simpel, aber einfacher als dein Ansatz ist 
dieser auch nicht wirklich. Nur das eben zur Ausgabe die große Zahl nur 
bitweise getestet werden muss; Arithmetik darauf wird nich benötigt. 
Dafür braucht's die Zeichen- bzw. BCD-Arithmetik -- die zugegeben keine 
hohe Kunst ist.

Johann

[Fragensteller (Gast)]

Danke erst einmal.

Ich habe es auf die schnelle durch ein Feld von unsigned longs 
realisiert, bei denen der Uebertrag in die naechste Stelle bei 10^7 
stattfindet.
Das sind gerade etwas mehr als 23 Bit, so dass noch etwas mehr als 8 Bit 
fuer den Uebertrag bleiben.