Poti an ADC und in 20 Schritten runter rechnen

[Sebastian I. (sebisr)]

Hallo liebe ATMHallo liebe ATMEL Gemeinde,

ich betreibe an einen ATTINY24/44/84 ein Poti an einen ADC. Dabei wird 
das ADCH Register (die oberen 8Bit des 10Bit Wortes) ausgelesen. Das 
funktioniert so weit alles einwandfrei. Ich benötige das Poti für das 
Einstellen einer Blinkfrequenz. Leider ist das ganze so recht grob 
einzustellen und entspricht nicht meinen Wünschen. Deshalb habe ich das 
ganze in 20 Schritten unterteilt.
00-12 -> 1. Schritt
13-25 -> 2. Schritt
26-38 -> 3. Schritt
etc.

Hinter jeden Schritt soll sich später eine Blinkfrequenz verbergen.
Da ich in Assembler programmiere (ich weiß, ich bin ein Dino:-)) müsste 
ich jetzt recht viele Vergleiche und Sprünge tätigen, um den Inhalt des 
ADCH Registers in meinen gesetzten Grenzen zu identifizieren. Nach 
einigen Überlegen bin ich zu folgende Lösung gekommen.
Ich subtrahiere den Inhalt des ADCH-Register immer mit -13 und frage 
nach jeder Subtraktion das Carry Flag nach einen Unterlauf ab und zähle 
dabei die Subtraktionen. Somit könnte ich Problemlos den Inhalt des ADCH 
Registers identifizieren, ohne viele unnötige Vergleiche und Sprünge. 
Ich verspreche mir hiervon einen effizienteren Code oder überdies auch 
noch besser zu lesen ist.

Beispiel

ADCH Register 26

26
-13  1.Schritt
13
-13  2.Schritt
0
-13  3.Schritt
___
-13    ergibt drei Schritte

Meine Frage ist nun, funktioniert dies Prinzipiell oder ist irgendwo 
noch ein Denkfehler enthalten.
Bisher wurde noch nichts ins Quellcode gegossen, es geht nur um den 
Lösungsweg des Problems.

Mit freundlichen Grüßen
sebisr

[Kai S. (kai1986)]

Hallo,

mir fällt kein Grund ein, wieso es nicht funktionieren sollte. Falls es 
nicht unbedingt 20 Teile sind müssen, sondern vielleicht auch 16 oder 32 
ausreichend sind könntest du deinen Wert mit der entsprechenden Anzahl 
an Shifts einfach runterteilen, dann wäre es noch einfacher.
Würde dann z.B. für 16 Schritte so aussehen (angenommen, du willst damit 
einen 16 Bit Wert auswählen)

- Zahl = Zahl 4 mal Rechtsshift (Zahl/16)
- Relativsprung 2 * Zahl (einmal Linksshift)

- 2 Byte Wert für 0
- Zum Ende Springen
- 2 Byte Wert für 1
- Zum Ende Springen
...
- 2 Byte Wert für 15
- Zum Ende Springen

- Ende

Gruß Kai

[John (Gast)]

Hallo Sebastian,
Mein Vorschag:
Bau einen Vorwiderstand vor das Poti, so dass der ADC-Wert auf max 159 
begrenzt wird.
Dann einfach drei mal Shift-Right (geteilt durch 8) das ergibt einen 
Wert von 0...19, und dann noch +1 -> 1...20.

Gruß
John

[Anja (Gast)]

John schrieb:
> Bau einen Vorwiderstand vor das Poti, so dass der ADC-Wert auf max 159
> begrenzt wird.

Das steht so aber nicht in den Hausaufgaben.

Sebastian Isr schrieb:
> Ich verspreche mir hiervon einen effizienteren Code oder überdies auch
> noch besser zu lesen ist.

Dann Würdest Du aber wie im richtigen Leben auch Divisions oder 
Multiplikationsroutinen verwenden.
also entweder / 13 oder
*20/256 rechnen.

und dann direkt die Periodendauer über einen Table-Read aus einer 
Tabelle holen.

Gruß Anja

[Praktiker (Gast)]

Anja schrieb:
> Dann Würdest Du aber wie im richtigen Leben auch Divisions oder
> Multiplikationsroutinen verwenden.

Wenn es dann noch besonders schnell gehen soll, beschränkt man sich auf 
Multiplikation mit rationalen Zahlen, bei denen der Nennen eine Potenz 
von 2 ist.