16 bit / 10

Wie wäre es z.B. mit einer sukzessiven Subtraktion? Immer 10 abziehen,
bis weniger als 10 übrig bleibt, und dabei immer die Anzahl der
Subtraktionsschritte zählen. Das ist dann das Ergebnis, das was übrig
bleibt der Rest...

"Die Rechenroutinen vom Hersteller sind aber alle 16/16 Routinen was
für ich ja überdimensioniert wäre."

Wenn Du fertige Routinen hast, nimm sie doch. Das geht schneller als
alles andere.

Ach, Moment... Du willst eine 16-Bit-Zahl durch 10 Bit teilen? Das ist
aber ein kleiner Unterschied!

Dann kann ich mich Karl nur anschließen. Eine CPU rechnet eh immer mit
vielfachen von 8 Bit. Da ist nix überdimensioniert.

Nein du hast es schon richtig verstanden.
Ich möchte eine 16 Bit Zahl durch die Konstante 10 teilen.

Also wäre eine 16/8 Routine nett....aber gibt es sowas?

Oder besser eine 16/16 Routine nehmen und High Byte mit 0 laden?!

Hallo,

hmm, wenn ich dich recht verstehe willst du eine 16bit lange zahl durch
eine konstande dezimalzahl Teilen d10!?

also:

xxxx xxxx xxxx xxxx durch
0000 0000 0000 1010 !?

ist das so richtig!?

maddin

...deinen letzteren post verstehe ich nicht, der steht bei meinem
verständnisstand deines problems im konflikt zu dem vorangeganenen..

Ich habe die 16 Bit /10 Divisionsroutine aus dem Trampert-Buch zum AVR
hier, die braucht man immer wenn man eine binär vorliegende Zahl als
ASCII-Ziffern ausgeben will. Für jede Stelle wird die Routine einmal
aufgerufen, anschließend ist die ursprüngliche Zahl in TempH/TempL
durch 10 geteilt, die Ziffer steht in Temp1. Die Ziffern kommen von
rechts nach links, das muß man bei der Ausgabe berücksichtigen:

;*********************************************************************** 
**
;* subroutine: divide 16bit word in TempH/TempL by 10,
;* results: quotient in TempH/TempL, remainder in Temp1 = decimal
digit
;* taken from "Trampert, AVR-RISC-Mikrocontroller"
;* Franzis-Verlag www.franzis.de ISBN 3772354742 pg. 327
;*********************************************************************** 
**
Div10:
  push  Cnt    ;
  clr  Temp1    ;
  lsl  TempL    ; input word is shifted out to the left
  rol  TempH    ; filled up with zeroes from the right
  rol  Temp1    ;
  lsl  TempL    ;
  rol  TempH    ; most significant 3 bits are always < 10
  rol  Temp1    ; so just shift out and in via Cy 3 times
  lsl  TempL    ;
  rol  TempH    ;
  rol  Temp1    ;
  ldi  Cnt,13    ; start loop for next 13 bits
Div10a:
  lsl  TempL    ;
  rol  TempH    ;
  rol  Temp1    ;
  subi  Temp1,10  ; remainder >10 ? -> subtract 10
  brlo  Div10b    ; was <10, LSB of output word = 0
  inc  TempL    ; LSB of output word = 1
  rjmp  Div10c
Div10b:
  subi  Temp1,-10  ; back to old value <10
Div10c:
  dec  Cnt    ; next bit
  brne  Div10a    ;
  pop  Cnt    ;
  ret      ;