AVR Assembler Ganzzahl durch Kommazahl

Hi

Multiplikation mit 1/0,8789. Multiplikationsroutinen findest du bei 
AppNotes von Atmel.

MfG Spess

Such dir nen Bruch der möglichst nahe an deiner Zahl liegt.
Dann multiplizierst du ganzzahlig deine Zahl mit dem Zähler (auf 
Überlaufe achten -> Zahlenbereich), und dann dividerst du durch den 
Nenner.

Ideal wäre ein Bruch, der im Nenner eine 2er-Potenz hat, dann kann man 
das Dividieren durch Schieben ersetzen.

Viel dank für die schnellen und zahlreichen Antworten.

1800*289/254= 2048

Das kommt dem ganzen noch am nächsten denke ich.

Was mich aber stört sind die 3 Bytes (1800*289).

Aber das bekomme ich wohl hin.

Da ich kleine kompakte Umrechnungen öfter brauche, habe ich mal
mein Verfahren als Code-Schnipsel angefügt.
Die Multiplikationsroutine kann man immer brauchen,
das Ergebnis ist nicht exakt, aber optimal genau.

1

; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

2

3

.def Tmp0  = R16

4

.def Tmp1  = R17     

5

.def Tmp2  = R18     

6

.def Tmp3  = R19     

7

.def Tmp4  = R20     

8

.def Tmp5  = R21     

9

.def Tmp6  = R22     

10

.def Tmp7  = R23     

11

.def Tmp8  = R24     

12

.def Tmp9  = R25 

13

14

; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

15

16

; K = 1 / 0,8789

17

;

18

; Konstante muss < 1 sein, also:

19

;

20

; A / 0,8789 = A * 1,137786

21

: = A * 2 * 0,568893    

22

; = A * 2 * (0,568893 * 65536) / 65536

23

; = A * 2 * 37283 / 65536

24

25

26

  ldi Tmp0,  low(1800)

27

  ldi Tmp1, high(1800)  ; A

28

29

  lsl Tmp0

30

  rol Tmp1    ; A = 2 * A

31

32

  push Tmp2

33

  push Tmp3    ; Register sichern

34

35

  ldi Tmp2,  low(37283)

36

  ldi Tmp3, high(37283)

37

  rcall mult_01_23  ; A = A * 2 * 37283

38

39

  mov Tmp0, Tmp2

40

  mov Tmp1, Tmp3  ; A = A * 2 * 37283 / 65536 = A / 0,8789

41

42

  pop Tmp3

43

  pop Tmp2    ; Register wiederherstellen

44

45

46

; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

47

48

mult_01_23:      ; IN: Tmp1-0 = A, Tmp3-2 = B

49

  push  Tmp4    ; OUT: Tmp3-2-1-0 = A x B

50

  push  Tmp5

51

  push  Tmp6

52

  push  Tmp7

53

  push  Tmp8

54

  push  Tmp9

55

  clr  Tmp4

56

  clr  Tmp5

57

  clr  Tmp6

58

  clr  Tmp7

59

  clr  Tmp8

60

  clr  Tmp9

61

62

mult0:

63

  lsr  Tmp1

64

  ror  Tmp0

65

  brcc  mult1

66

  add  Tmp6, Tmp2

67

  adc  Tmp7, Tmp3

68

  adc  Tmp8, Tmp4

69

  adc  Tmp9, Tmp5

70

mult1:

71

  lsl  Tmp2

72

  rol  Tmp3

73

  rol  Tmp4

74

  rol  Tmp5

75

76

  tst  Tmp0

77

  brne  mult0

78

  tst  Tmp1

79

  brne  mult0

80

81

  mov  Tmp3, Tmp9

82

  mov  Tmp2, Tmp8

83

  mov  Tmp1, Tmp7

84

  mov  Tmp0, Tmp6

85

86

  pop  Tmp9

87

  pop  Tmp8

88

  pop  Tmp7

89

  pop  Tmp6

90

  pop  Tmp5

91

  pop  Tmp4

92

  ret

93

94

; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Guten Morgen

@Ralli

das läuft optimal mit dein Vorschlag!

Hätte nie gedacht, dass man das so hinbekommt!

Hi

>; K = 1 / 0,8789
>;
>; Konstante muss < 1 sein, also:
>;
>; A / 0,8789 = A * 1,137786
>: = A  2  0,568893
>; = A  2  (0,568893 * 65536) / 65536
>; = A  2  37283 / 65536

Die Berechnung kann der Assembler2 auch allein:

1

ldi r18,Low(Q15(FRAC(1/0.8789))+1)

2

ldi r19,High(Q15(FRAC(1/0.8789))+1)+$80

MfG Spess

0,8789r*65536=74565,93469109113  hex 1.2345  binär 1.0010001101000101

das genaue Ergebnis für 4000 ist
4000/0,8789=4551,1434747

d.h. Du kopierst die Zahl in ein Summierregister (alles 
16bit-Operationen)
shiftest die Zahl um 3 nach rechts und addierst ins Summierregister
shiftest die Zahl um weitere 4 nach rechts und addierst ins Register
shiftest die Zahl um weitere 1 nach rechts und addierst ins Register
shiftest die Zahl um weitere 2 nach rechts und addierst ins Register
shiftest die Zahl um weitere 4 nach rechts und addierst ins Register *)
fertig - Ergebnis steht im Summierregister

das sind 2*(1+4+5+2+3)=30 Befehle

*) diese Zeile bringt nur etwas, wenn wie unten beschrieben vorher nach 
links geschoben wurde
dann sind es 2*(1+4+5+2+3+5)=40 Befehle

Wenn's etwas schneller, dafür ungenauer sein darf
(/0,8767123287 entspricht *1,140625):
d.h. Du kopierst die Zahl in ein Summierregister (alles 
16bit-Operationen)
shiftest die Zahl um 3 nach rechts und addierst ins Summierregister
shiftest die Zahl um 3 nach rechts und addierst ins Summierregister
4000 wird so zu 4000+500+62=4562
so sind es 2*(1+4+4)=18 Befehle


Wenns genauer sein soll: Der Wert 4000 passt in 12 Bit, also zuerst um 
1-4 Bits nach links schieben, dann wie oben beschrieben rechnen und 
Ergebnis wieder um 1-4 Bits nach rechts schieben.

Das kann man noch optimieren:
Zahl ins Register kopieren
Zahl um 3 nach links schieben und ins Register addieren
Originalzahl um 4 nach rechts schieben und ins Register addieren
weiter wie oben
zum Schluss Ergebnis wieder um 3 nach rechts

Das Runden bringt auch mehr Genauigkeit:
Einfach das "Nachkommabit" auf das Ergebnis addieren.
also beim letzten Beispiel nur noch das Carry addieren (adc #0), da sich 
das Nachkommabit nach dem letzten shr  im Carry  befindet.

Falls noch Fragen, bitte fragen!
Mich würde interessieren, wie Du es gelöst hast.

Nein, ich meine schon nach rechts schieben. Zum Schluss soll ja nichts 
mehr übrigbleiben.
Nochmal zur Verdeutlichung ein Beispiel:
1.   0    0    1   0   0   0  1  1  0 1 0 0 0 1 0 1
4000 2000 1000 500 250 125 62 31 15 7 3 1
4000+          500+           31+15+  3              =4549

Und das Beispiel mit erhöhter Genauigkeit durch "shl 3":
1.    0     0    1    0    0    0   1   1   0  1  0  0 0 1 0 1
32000 16000 8000 4000 2000 1000 500 250 125 62 31 15 7 3 1
32000+           4000+              250+125+   31+       1=36407
36407/8=4550,875   Runden ergibt 4551, da das Nachkommabit 1 ist.


Wieso hättest Du auf Linksschieben getippt?