rechnen in Assembler mit AVR

http://elm-chan.org/cc_e.html

Joe

Beitrag "Re: Temp.Sensor TSIC 306 - Temperaturwert"

> kuck mal hier ;)
> http://elm-chan.org/cc_e.html
> gruß jonas


Den 2.Beitrag zu diesem Thread schon gelesen??


Joe

Tipp, falls es in den Links nicht schon erwähnt wurde: Dividieren und 
multiplizieren durch 2er-Potenzen macht man mit einem Shift! Divisonen 
durch Konstanten kann man auch als Fixkommamultiplikation mit dem 
Kehrwert implementieren!

>Tipp, falls es in den Links nicht schon erwähnt wurde: Dividieren und
>multiplizieren durch 2er-Potenzen macht man mit einem Shift! Divisonen
>durch Konstanten kann man auch als Fixkommamultiplikation mit dem
>Kehrwert implementieren!

Gibt es dafür Beispiele?

Ich hab leider keins, aber Google und die Stichwörter werden dir sicher 
weiterhelfen ;-)

Matze0001 schrieb:

> umrechnen:
> (Wert / 2047 * 200) - 50

> das Ergebnis soll dann in 3 Registern stehen:
> z.B.:
> Register 16    (Wert für 10er)
> Register 17    (Wert für 1er)
> Register 18    (Wert für Nachkommastelle)

Die einfachste Möglichkeit: bastle in Excel o.ä. eine Lookup-Tabelle und 
binde sie ins Programm ein.
In der Tabelle stehen für jeden der möglichen Werte (ich nehme an: 
0...2047) die zugehörigen Zehntel, Einer und Zehner. Mit etwas 
Nachdenken reicht für die Tabelle ein Byte je Eintrag (Zehntel und 
Einer), für Zehner und Vorzeichen musst Du dann eine zweite spendieren. 
Oder Du nimmst zwei Byte je Eintrag, dann ist es ganz einfach.

Die zweiteinfachste Möglichkeit: Du probierst einfach alle Werte für die 
Anzeige vom kleinsten zum größten durch, so viele sind es ja nicht (2000 
Stück, wenn ich mich nicht irre). Sobald der Anzeigewert größer ist als 
der gemessene, hast Du den richtigen Wert gefunden. Anders formuliert 
(Pseudocode):
var zehner, einer, zehntel
zehner = -5; einer = 0; zehntel = 0;
loop:
  wenn (200 * messwert - 50 < 20470*zehner + 2047*einer + 205*zehntel)
    dann breche Schleife ab, Wert gefunden
  zehntel = zehntel + 1
  einer = einer + 1
  zehner = zehner + 1
end loop
(Du musst natürlich drei Schleifen verschachteln und noch ein bisschen 
Aufwand für die negativen Zahlen treiben).
Die Rechnerei dauert ein paar Millisekunden, aber das ist ja egal, so 
schnell kannst Du das Display eh nicht ablesen.

Die komplizierteste Möglichkeit: vorwärts rechnen, wie von Dir 
vorgeschlagen.
(Wert / 2047) zu rechnen ist diffizil, einfach ist: (Wert / 2048) = 
(Wert >> 11). >> ist der Rechtsshiftoperator, guck mal in Deinem 
C-Handbuch nach. In Assembler geht das natürlich auch.
Bitte erst multiplizieren, dann den Rechtsshift machen, vorher 
überlegen, welche Wortbreite Du brauchst. Mit ((Wert * 25) >> 8) - 50 
geht es übrigens auch. Wenn Du es andersherum machst, verlierst Du 
Genauigkeit.
Anschließend musst Du das Ergebnis noch in Zehner, Einer und Zehntel 
zerlegen, das ist tendenziell die schwierigere Aufgabe.

Hallo,

1

2

;11Bit Rohwert des TSic in Temperatur umrechnen

3

;Originalformel aus dem Datenblatt T= (Digital_signal/2047*(HT-LT)+LT) [°C]

4

;LT = -50,  HT = 150 als Standardwert für die Temperatur-Berechnung

5

;

6

;Umgestellt für ASM

7

;t=TSic_Wert*200 /2048-50   (die 2047 um 1 erhöht um besser rechnen zu können)

8

;t=TSic_Wert*25/256-50  (gekürzt /8)

9

;Da eine Stelle hinter dem Komma angezeigt wird, rechne ich die Temperatur*10 und setze

10

;vor die letzte Stelle den Dezimalpunkt (Festkomma).

11

;Temperatur*10=(TSic_Wert*250)/256-500 

12

  clr    temp1

13

  mov    temp2,tsicwert_low

14

  mov    temp3,tsicwert_high  

15

  lsl    tsicwert_low      ;*2

16

  rol    tsicwert_high

17

  add    tsicwert_low,temp2  ;*3

18

  adc    tsicwert_high,temp3

19

  lsl    tsicwert_low      ;*6

20

  rol    tsicwert_high

21

  sub    temp1,tsicwert_low  ;*256 - *6 = *250

22

  sbc    temp2,tsicwert_high  ;TSic_Wert*250 steht jetzt in temp1/temp2/temp3

23

  sbci  temp3,0      ;Durch verwerfen des LSB (temp1) wird durch 256 geteilt  

24

  subi  temp2,low(500)  ;500 (50.0) abziehen

25

  sbci  temp3,high(500)

26

27

; Nach ASCii wandeln

Routine läuft so einwandfrei bei mir

Grüsse

Na dann mal viel Spass ;-)

Bei 3 Bytes pro Tabelleneintrag sind das 6144 Bytes (6kb), Hoffentlich 
hast du dann noch genügend Platz für den Code.

Was gefällt dir an meinem Code nicht ? Sind gerade mal 14 Befehle.

Matze0001 schrieb:
> hab den code schon mal ausprobiert... nur was kommt da genau raus? Was
> sind das dann für Werte?


In temp3 das Highbyte des Ergebnisses, in temp2 das Lowbyte.
Wobei der Wert das 10-fache der Temperatur ist.

Bei 22 Grad kriegst du also 220 als Ergebnis, bei 38.7 Grad 
dementsprechend 387. Auf die Art hat man 1 'Kommastelle', obwohl man gar 
nicht mit Kommazahlen rechnet. Einfach während der Ausgabe auf einem LCD 
vor die letzte Stelle ein Komma 'einschmuggeln' und schon sieht es so 
aus als ob. Bei deinen 7-Segment LED-Anzeigen steht das Komma ja schon 
dort (auf der Frontplatte), da brauchst du also gar nichts tun :_)

@Matze0001

und wenn du jetzt 3 Werte einzel brauchst, dann musst du das Ergebnis 
noch mal durch 10 teilen, der Rest ist dann die Komma-Stelle. Das 
ganzzahlige Ergebnis teilst du wieder durch 10, womit der Rest dann die 
Einer-Stelle und das ganzzahlige Ergebnis die Zehner-Stelle ergibt.

Sascha

Matze0001 schrieb:
> ahh, jetzt klickts langsam! Vielen lieben dank euch!
>
> Wie kann ich euch ein Bier ausgeben? :)
>
> Ok und wenn ichs jetzt sozusagen durch 2047 teilen will damits genauer
> wird, dann wirds wieder zu kompliziert oder? (wär aber jetzt auch ned so
> wichtig bin froh das es jetzt so funktioniert)

Ja wird es.
Allerdings solltest du dir mal ausrechnen, wieviel denn dieses 'genauer' 
überhaupt ist.

> Und wie teil ich das jetzt noch durch 10? Und dann nochmal?
> damit ich die Zehner, Einer und die Nachkommastelle in einzelnen
> Registern hab?

zb indem man in einer Schleife 10 abzieht, solange bis die Zahl negativ 
wird. Gleichzeitig zählt man mit wie oft man abgezogen hat.

Bei dir sind das natürlich erst mal die Hunderter. Du ziehst also in 
einer Schleife jeweils 100 ab und zählst mit oft das gut ging. Die 
Anzahl ist die Anzahl der Hunderter in der Zahl oder eben vulgo: das 
Ergebnis von Zahl dividiert durch 100.

Zum Ergebnis (das ja jetzt negativ ist, schnell wieder 100 dazu, und das 
ganze Spielchen mit 10. Wie oft kann man 10 abziehen, ehe die Zahl 
negativ wird. Damit hast du die Zehner. Und das was übrig bleibt (10 
dazu zählen um wieder positiv zu werden), sind dann die Einer.


  387
  +++

                                    0
  387 - 100  = 287                  1
  287 - 100  = 187                  2
  187 - 100  =  87                  3
   87 - 100  = -13   Ooops          |
                                    +------>  3 Hunderter

  -13 + 100 = 87
                                    0
   87 - 10  = 77                    1
   77 - 10  = 67                    2
   67 - 10  = 57                    3
   57 - 10  = 47                    4
   47 - 10  = 37                    5
   37 - 10  = 27                    6
   27 - 10  = 17                    7
   17 - 10  =  7                    8
    7 - 10  = -3   Oops             |
                                    +------> 8 Zehner

   -3 + 10 = 7                      -------> und 7 Einer


das geht bei Zahlen in dieser Größenordnung schneller als richtige 
Divisionen. Und ist auch leichter implementiert.

Matze0001 schrieb:
> ok, das bekomm ich hin! Vielen dank!
> Jetzt musst ich dann nur noch eins wissen... Wie kann ich jetzt die
> beiden Register mit 100 subtrahieren
> also 16bit - 8bit? :)

Falsch

16 Bit - 16 Bit

und das hast du im Code von Jürgen schon gesehen.
Ich zitiere

1

  subi  temp2,low(500)  ;500 (50.0) abziehen

2

  sbci  temp3,high(500)

:-) Code studieren! In jedem Code verbergen sich Schätze. Und nirgends 
ist das extensive Codestudium so wertvoll wie in Assembler. Bis man die 
Feinheiten von 5 oder 6 Anweisungen komplett in allen Details verstanden 
hat, das kann auch schon mal Stunden dauern. Aber dann lehnt man sich 
zurück und sagt: "Genial! Das hat was."

Spätestens jetzt ist es Zeit auf das
AVR-Tutorial
zu verweisen

es gibt ein Bit im Statusregister für negative Ergebnisse oder man 
vergleicht ob 87 größer als 100 ist.

dann sorry für die Fehlinformation, musst es dann eben doch über einen 
vergleich lösen.

ja genau so wars, wusste noch das ich das mal über die Statusbits nach 
dem Abziehen gemacht habe.

Matze001: Ansonsten einfach mal in der Befehlsübersicht nachschauen was 
nach dem subtrahieren passiert.