wie 1/T bilden? (Atmel assembler)

Gast #52121
Lesenswert?

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
Gast #52122
Lesenswert?

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?
Gast #52123
Lesenswert?

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
Gast #52124
Lesenswert?

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
Gast #52125
Lesenswert?

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
Gast #52126
Lesenswert?

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
Gast #52128
Lesenswert?

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.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren