Erkennen ob eine Variable hochzählt bzw runterzählt

[MB (Gast)]

Hallo erstmal,

ich habe folgende Problemstellung:
mit einem Drehgeber (Datenblatt: 
http://www.pollin.de/shop/downloads/D240313D.PDF) sollte ich eine Zahl 
abspeichern jede Drehung wird dabei die Variable um 1 erhöht. Bei einer 
Richtungsänderung soll der Wert dieser Variable dann in ein Array 
abgespeichert werden und anschließend der neue Wert gezählt und bei 
einer Weiteren Richtungsänderung wieder in das Array abgespeichert 
werden. Mein Problem dabei ist, dass ich nicht weis wie ich erkenne das 
der Drehgeber die Richtung geändert und dabei den Wert abspeichern kann.

Danke schon mal im Voraus.

Mit freundlichen Grüßen,
MB

[Tilo (Gast)]

Wenn du einfach nur hoch oder runter zählst geht das gar nicht.
Wenn du den Zahlenstrahl anschaust wirst du merken, dass die 
Richtungsinformation nicht abgespeichert wird. Entweder du nimmst eine 
2. Variable oder verwendest eine Kodierung, über welche die Richtung 
bekannt ist.

[Tilo (Gast)]

Falls du aber nur wissen willst, ob du die Variable hoch oder 
runterzählen musst:
Signal B low und:
fallende Flanke A: incrementieren
steigende Flanke A: decrementieren.
Signal B high und:
steigende Flanke A: incrementieren
fallende Flanke A: decrementieren.

[MB (Gast)]

Aber wenn ich die Variable nur Hochzählen lasse, weis ich ja nicht wann 
eine Richtungsänderung ist und dann zählt es hoch und dann wieder 
runter.

[Tilo (Gast)]

Verstehe ich nicht. Warum willst du eine Variable nur hochzählen lassen?
Warum soll sich plötzlich die Zählrichtung ändern?

[Alex R. (itaxel)]

Schau dir mal den Link an. Der sollte dir dabei helfen:

http://www.hobbytronics.co.uk/arduino-tutorial6-rotary-encoder

[MB (Gast)]

Das Ziel ist es einen Code über den Drehgeber eingeben zu können, dieser 
besteht aus vier Zahlen (diese werden in ein Array abgespeichert) und um 
dies zu ermöglichen wird bei z.B. einer Drehung nach rechts der in das 
Array abzuspeichernde Wert um eines erhöht, sobald nun nach links 
gedreht wird, wird der Wert in das Array abgespeichert (dabei kann der 
Wert von 0-9 gehen und der Wert wird nach der Richtungsänderung auf 0 
gesetzt) und nun wird beim links drehen runtergezählt  und der 
abzuspeichernde Wert hat einen Wert von 0- -9 und dies folgt dann 
weitere 2 Mal und am Ende sollten im Array vier Variablen stehen die ich 
wieder auslesen kann.

[npn (Gast)]

Die meisten Encoder haben einen Taster integriert. Wenn man nicht dreht, 
sondern auf die Achse drückt, wird der Taster betätigt und du kannst den 
Wert übernehmen. Auch der von dir verlinkte Encoder hat so einen Taster.
Also drehen, um den Anzeigewert zu ändern (hoch und runter) und wenn die 
richtige Ziffer in der Anzeige steht, drückst du auf den Encoder und der 
angezeigte Wert wird übernommen.
So wie du es vorhast, ist es (vornehm ausgedrückt) etwas unüblich.

[MB (Gast)]

Problem ist dabei, dass es ein Schulprojekt ist und mein Lehrer auf die 
unüblichen Varianten steht und ich daher gezwungener Maßen es so machen 
muss.

[Alex R. (itaxel)]

Kurz gesagt, du musst Signal A und B permanent abfragen und mit der 
vergangenen Zeit (in ms) des letzten drehens (Step) vergleichen.
So kannst du dann beim rechts und links drehen zeitunterschiede 
feststellen.

[Tilo (Gast)]

MB schrieb:
> Das Ziel ist es einen Code über den Drehgeber eingeben zu können,
> dieser
> besteht aus vier Zahlen (diese werden in ein Array abgespeichert) und um
> dies zu ermöglichen wird bei z.B. einer Drehung nach rechts der in das
> Array abzuspeichernde Wert um eines erhöht, sobald nun nach links
> gedreht wird, wird der Wert in das Array abgespeichert (dabei kann der
> Wert von 0-9 gehen und der Wert wird nach der Richtungsänderung auf 0
> gesetzt) und nun wird beim links drehen runtergezählt  und der
> abzuspeichernde Wert hat einen Wert von 0- -9 und dies folgt dann
> weitere 2 Mal und am Ende sollten im Array vier Variablen stehen die ich
> wieder auslesen kann.

Ist doch alles kein Problem. Du musst einfach nur die Flanken auswerten. 
Dafür gibts mehere Lösungen, z.B. direkt mit IRQs. Die können aber bei 
Jitter blöde Sachen machen.
Einfacher wäre es, z.B. alle 50ms die beiden Werte auszulesen und dann 
mit den vorherigen Werten zu vergleichen.
Daraus ergibt sich die Drehrichtung. Davon abhängig kannst du entweder 
den Arraywert ändern oder zum nächsten Element springen.

Es scheint nicht gefordert zu sein, dass du keine zusätzlichen Variablen 
verwenden darfst.