Division mit Nachkomastelle - Assembler - Atmega32

[Stef (Gast)]

Hallo zusammen,

ich beschäftige mich seit kurzem mit Mikrocontrollern. In der Schule 
habe ich zwar das Programmieren mit Assembler gelernt, aber leider alles 
nur Theorie und mit Simulationssoftware. Hochsprache wie C kann ich noch 
nicht, deshalb möchte ich gerne ein paar Projekte in Asm realisieren.
Ich benutze Atmel Studio 5, eine Entwicklungsboard von Pollin mit einem 
Atmel Atmega32.

Ich habe die Suchfunktion schon gelöchert und konnte nichts passendes 
finden, vielleicht könnt ihr mir ein paar Tipps geben.

Ich möchte mit den INT0 und INT1 jeweils zwei Register hochzählen und 
über einen Timerinterrupt jede Sekunde die beiden Register dividieren 
und auf einem LCD ausgeben.
Mein Problem ist der Rest bei der Division. Ich möchte das Ergebnis 2 
Stellen nach dem Koma darstellen, finde aber keine Lösung den Rest 
"umzuwandeln".

Würde mich über eine Antwort freuen!

Gruß Stephan

[Karl H. (kbuchegg)]

Am einfachsten erhöhst du dein 'erstes Register' nicht einfach nur um 1, 
sondern um 100. Nachdem du durchdividiert hast, setzt du einen 
Kommapunkt zwischen der Hunderter- und der Zehnerstelle deines 
Ergebnisses.

(Natürlich nur, wenn deine Zahlenbereiche das zulassen)

[Karl H. (kbuchegg)]

> finde aber keine Lösung den Rest "umzuwandeln".

Wenn du das rechnen willst, dann erinnere dich daran, wie du in der 
Schule dividieren gelernt hast

Du sollst zb rechnen   122 durch 14


   122       : 14  =

14 ist in 122 8 mal enthalten


   122       : 14  = 8

denn 8 * 14 ergibt 112

   122       : 14  = 8
  -112
  ----
    10

die 10 hier, die sind der Rest den du auch bei deiner bisherigen 
Rechnung rausbekommen hast.
WIe ist es in der Grundschule weiter gegangen?
(ok, ich weiß nicht wie es bei dir gelautet hat, bei mir hies es noch:
-> nächste Stelle 0 herunter!
(was dasselbe ist, wie eine Multiplikation des Restes mit 10)

   122       : 14  = 8
  -112
  ----
    100

14 ist in 100 7 mal enthalten

   122       : 14  = 8.7
  -112
  ----
    100

denn 7 mal 14 ergibt 98

   122       : 14  = 8.7
  -112
  ----
    100
   - 98
   ----
      2

(und dann bleiben in diesem Fall dann 2 Rest)

-> nächste Stelle 0 herunter (den Rest wieder mit 10 multiplizieren)

   122       : 14  = 8.7
  -112
  ----
    100
   - 98
   ----
      20

14 ist in 20 1 mal enthalten


   122       : 14  = 8.71
  -112
  ----
    100
   - 98
   ----
      20

denn 1 mal 14 macht 14

   122       : 14  = 8.71
  -112
  ----
    100
   - 98
   ----
      20
     -14

und somit bleiben 6 Rest

   122       : 14  = 8.71
  -112
  ----
    100
   - 98
   ----
      20
     -14
     ---
       6

-> nächste Stelle 0 herunter (Rest mal 10 nehmen)

   122       : 14  = 8.71
  -112
  ----
    100
   - 98
   ----
      20
     -14
     ---
       60


14 ist in 60 4 mal enthalten

   122       : 14  = 8.714
  -112
  ----
    100
   - 98
   ----
      20
     -14
     ---
       60

usw. usw.

Und genau das kannst du natürlich auch in Software nachbilden. Einfach 
den Rest mal 10 nehmen, erneut durchdividieren und du hast die nächste 
Stelle. Mit dem Rest dieser Division gehts dann wieder weiter. Bis du so 
viele Nachkommastellen hast, wie du haben willst.

Jetzt kann man das ganze auch natürlich vereinfachen.
Anstatt sukzessive immer mit 10 zu multiplizeren, kannst du auch 2 
Stufen zusammenfassen und statt dessen mit 100 multiplizeren.

Wieder  122 : 14

122 durch 14 ergibt erst mal 8, Rest 10
10 (der Rest von oben) mal 100 macht 1000
1000 durch 14 ergibt 71

d.h. dein Ergbenis lautet 8.71

(aber vorsicht, bei der Aufarbeitung des Restes darfst du führende 0-en 
nicht einfach unter den Tisch fallen lassen. 8.09 ist was anderes als 
8.9)


> Ich habe die Suchfunktion schon gelöchert

Das geile ist, dass du all diese Dinge vor Jahren alle schon mal gelernt 
hast. Nur über die Jahre hinweg hast du vergessen, was du damals 
eigentlich alles an Techniken und Algorithmen gelernt hast, bzw. das ist 
alles automatisiert worden. Und jetzt gilt es das eben alles neu zu 
entdecken, was du eigentlich alles bereits weißt und kannst. Das wird 
dir in vielen Bereichen in der Programmierung immer wieder passieren: 
Das du nach einer Lösung für ein Problem suchst, welches du eigentlich 
schon laaange lösen kannst. Du weißt nur noch nicht, dass du es kannst.