wie 1/T bilden? (Atmel assembler)

[Werner Just (Gast)]

Hallo,

mittels Int0 und Timer1 wird die Zeit für eine Umdrehung gemessen.
Anschließend soll Anhand der Drehzahl in eine Tabelle mit 256 Werten
gesprungen werden.

Ich muß also Zählerstand (== Umdrehungzeit) in Drehzahl umrechenen und
das Ergebiss auf 0...255 skalieren.

Wie löse ich das möglichst elegant? (ohne 255 Abfragen oder eine 2.
Tabelle)

Ciao,
Werner

[André Kronfeldt (Gast)]

Warum springst Du nicht anhand des Zählerstandes in eine Tabelle?

Definitionsbereich sollte der gleiche sein. Von den Werten ist dann nur
vorher der Kehrwert zu bilden.

Oder seh ich da was falsch?

[Werner Just (Gast)]

Hallo André,

weil ich eine äquidistante Teilung des Drehzahlbereichs brauche.

Würde ich anhand des Zählerstandes springen, sähe das so aus:
Tab.Wert 1: z,t= 51-150 == 1000 U/t
Tab.Wert 2: z,t= 151-250 == 500 U/t
Tab.Wert 3: z,t= 251-350 == 333 U/t
Tab.Wert 4: z,t= 351-450 == 250 U/t
...

Was ich brauche ist aber
Tab.Wert 1: = 1000 U/t
Tab.Wert 2: = 900 U/t
Tab.Wert 3: = 800 U/t
...

Ciao,
werner

[OliverK (Gast)]

Hallo Werner,

y = a*x+b, wobei x der Zählerstand Deines Timers ist. Zum Skalieren auf
[0...255] bedarf es dabei einen Minimalwert (0 nehme ich an) und einen
Maximalwert (volle 16 Bit von T1? = 65535?).

Dann würde es vermutlich so aussehen:

0 = a*0 +b
255 = a*65535 +b

Nach a und b auflösen, und Du hast die gewünschte Transformation.

Aber wie wird z.B. y = 0.123*x + 2.1 in Assembler berechnet??
Wenn die Vorgaben Deinem Ziel entsprechen, verrate ich Dir, wie es
weitergeht. Dann wird es etwas mathematisch, aber auch nocht soo
kompliziert.

Grüße
Oliver

[Werner Just (Gast)]

Hallo Oliver,

das alleine reicht leider nicht. Auch mit der Skallierung nach a*t+b
bleibt das Ergebnis proportional zu 1/U.

Verrate es mir trotzdem ;-),
denn wenn ich z.B. Y = 5.432 * x + 1.2 berechnen kann, dann komme ich
mit

U = T_max/T_mess * k - k weiter zum Ziel.

255 = T_max/T_min * k - k
0   = T_max/T_max * k - k

Ciao,
Werner

[OliverK (Gast)]

Hallo Werner,

also gut. War auf meine (schon ältere )Lösung so stolz wie ein
Flitzebogen ;-)

Du jagst jede 2er Potenz durch die Gleichung. Zum Beispiel mit einem
10-Bit Wert. Also 2^0, 2^2, ..., 2^9 und merkst Dir die Werte in einer
Tabelle.

5.432 * 2^0 + 1.2 = 6.638
5.432 * 2^1 + 1.2 = 12.064
5.432 * 2^2 + 1.2 = 22.982
usw.

Hier muß aber noch gerundet werden, da wir in Assembler nur mit
Ganzzahlen arbeiten können.
6.638 ==> 7
12.064 ==>12
22.982 == 23

Wichtig ist beim Runden, das die Summe aller vorhergehenden Werte
kleiner ist, als der aktuell betrachtete.
Also
7 < 12
7+12 = 19 < 23
Das ist gut! Ebenso muß dann 7+12+23 kleiner als der nächste sein usw.

Wenn die Tabelle mit den z.B. 10 Werten fertig ist, berechnest Du ein
beliebiges 10 Bit ganzahliges x nach dieser Vorschrift:

http://www.mikrocontroller.net/forum/read-1-14596.html#14661


Schreibs Dir hinter die Löffel ;-)

Grüße
Oliver

[edi (Gast)]

wenn ich z.B. Y = 5.432 * x + 1.2 berechnen kann, dann komme ich

                  5432 * x +1200.....................? komma !

[OliverK (Gast)]

Ja und?

Wenn Die lineare Transformation gerade aus so einem Problem hervorgeht,
wie z.B.
0 geht auf 0
...
1023 geht auf 255

Was machste denn mit Deinem riesigen Wert, um wieder auf 0 bis 255 zu
kommen? Ich vermute mal, Du wirst ihn wieder durch eine 10er Potenz
teilen wollen.

Meine Lösung besteht lediglich aus n Additionen bei einem n Bit Wert.