Drehgeber auswerten - Zählproblem

[Wuhu W. (wuhuuu2)]

Hallo zusammen,

ich hab folgenden Code geschrieben, mit Hilfe der bekannten Threats von 
dem Thema.
Er funktioniert auch weitestgehenst....

Problem:
Beim Hochzählen pendelt er immer zwischen zwei Werten.
(Runterzählen funktioniert problemlos)

Falls mir jemand den Fehler sagen kann (oder sagen das kein Fehler 
drinnen ist und dieser woanders liegen muss) wäre ich sehr dankbar.


Randinformationen:
Atmega2560
KEY_PIN is PINL
Increment_A = 5
Increment_B = 3
F_CPU = 14745600

main-schleife

wert += enc_get()

wert an Uart senden


/***********************************************************************************/

// -128 .. +127
volatile  uint8_t  enc_last_state;  // "letzter Zustand"
volatile  uint8_t  enc_last_count;  // "Bitcombination beim letzten zählen"
volatile  uint8_t  enc_new_state;
volatile  int8_t  enc_delta;


void init_incremental_encoder()
{
  //Initializing 8-Bit Timer2 - incremental encoder

  TCCR2A = 0x00;    // normal mode
  TCCR2B = 0x04;  //prescaler 64 = 0x04
  TIMSK2 = 0x01;    // enable timer overflow Interrupt
  //TCNT2 = 0x00;    // count-parameter

enc_delta = 0;
enc_last_count = KEY_PIN & ((1<<Increment_A ) | (1<<Increment_B ));

return;
}





ISR( TIMER2_OVF_vect )
{

enc_new_state = KEY_PIN & ((1<<Increment_A ) | (1<<Increment_B ))  ;  // save state

// Change in State on both important positions?
if (  (enc_new_state ^ enc_last_count) == ((1<<Increment_A )|(1<<Increment_B))    ) 
  {
    // right or left turn?
    if(  (enc_new_state ^ enc_last_state) == (1<<Increment_B ) )
      {enc_delta += 1;}
    else
      {enc_delta -= 1;}

    enc_last_count = enc_new_state;    // save Bitcombination of last count
  }
enc_last_state = enc_new_state;        // save last state

}





int8_t enc_get()
{
  int8_t val;
  cli();
  val = enc_delta;
  enc_delta = 0;
  sei();
  return val;
}

[Wuhu W. (wuhuuu2)]

Es gibt einen unerwünschten zustand, der bei jeder 2. umdrehung 
auftritt.
dabei wird
new_stat ^ last_state = 11
(nicht 01 oder 10 was normalerweise vorkommen sollte)

[MaWin (Gast)]

Wuhu W. schrieb:
> (enc_new_state ^ enc_last_count) == ((1<<Increment_A )|(1<<Increment_B))

Eher

(enc_new_state ^ enc_last_count) & ((1<<Increment_A ) | (1<<Increment_B 
))

ist dann ungleich 0

Ganz allgemein würde ich
enc_new_state ^ enc_last_count)
weil es 2 mal benutzt wird in eine Variable tum

enc_change_state = (enc_new_state ^ enc_last_count)

denn es könnte sich (volatile) mittendrin ändern.

[Wuhu W. (wuhuuu2)]

Hallo MaWin,

ich frage new_state und last_count nur einmal ab, das andere ist 
new_state und last_state.

Ich hab das mal versucht, aber es hat nicht geholfen, eher 
verschlimmert.
Denn dann wird ja auch in die Schleife gesprungen wenn nur eins von den 
beiden gesuchten bits gesetzt ist.

Trotzdem danke (=

[Wuhu W. (wuhuuu2)]

Lösung gefunden.
Der Encoder hat folgenden "Graycode": 00-10-11-00-10-11-00
(ddm 427)

Lösungsweg:

Auswerten des vorherigen absoluten zustandes (o oder 1), um dann die 
Drehrichtung zu bestimmen

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Wuhu W. schrieb:
> Der Encoder hat folgenden "Graycode": 00-10-11-00-10-11-00

Das ist kein Gray, der sich dadurch auszeichnen würde, das bei jeder 
Zustandsänderung nur ein Bit wechselt. Entweder hat der Encoder einen 
Defekt (der Zustand 01 scheint ja nicht aufzutauchen), oder irgendwas 
anderes ist faul.

[Teo D. (teoderix)]

Pin am Encoder vertauscht!

[Walter (Gast)]

Teo Derix schrieb:
> Pin am Encoder vertauscht!

dann kommt nach 11 immer noch 00

[Teo D. (teoderix)]

Walter schrieb:
> Teo Derix schrieb:
>> Pin am Encoder vertauscht!
>
> dann kommt nach 11 immer noch 00

Wenn Du das sagst, glaub ich das mal :)
(kein Sarkasmus! bin zu faul das durch zu denken :)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Wuhu W. schrieb:
> Threats
=Bedrohungen...
Thread=Faden

Walter schrieb:
>> Teo Derix schrieb:
>> Pin am Encoder vertauscht!
> dann kommt nach 11 immer noch 00
Dann zeig doch mal ein paar Fotos von deinem Aufbau. Wenn der Encoder so 
zählt  wie du dad geschrieben hast, kommt mit der geposteten Routine 
nichts sinnvolles raus. Die erwartet nämlich richtigen Graycode:
00-01-11-10-00-...

[Wuhu W. (wuhuuu2)]

Sorry das es so lang gedauert hat, hier meine funktinierende Lösung:

Wenn es um 2 stellen springt, also 00->11 oder 11->00, dann ergibt sich 
aus meiner links/rechts abfrage für beides eine 1, ich gehe zum else. 
Dort wird die letzte Absolute Position überprüft.

(Wenn er dann nur zwischen 2 zahlen pendelt, muss ich pins tauschen/ bzw 
+- in dieser else routine vertauschen)

Ich hoffe ihr versteht was ich mein

@Lothar Miller,  danke ;)

  
  // Change in State on both important positions?
  if (  (enc_1.buffer_new_state ^ enc_1.last_count) == ((1<<Increment_1_A )|(1<<Increment_1_B))    )
    {
      enc_1.time2 ++;    // for fast counting

      // right or left turn?
      if    (  (enc_1.buffer_new_state ^ enc_1.last_state) == (1<<Increment_1_B ) )
        {enc_1.delta += enc_1.add;}

      else if  (  (enc_1.buffer_new_state ^ enc_1.last_state) == (1<<Increment_1_A ) )
        {enc_1.delta -= enc_1.add;}
      else
      /**/
      //  This Part is normaly not required.But the rotary encoder in use has this Graycode: 00-10-11-00-10-11-00
      //  Therefore it evaluetes the last position to determine the turn-direction
      //  In case of failure, change + and - in the following
      /**/
        {
          if(enc_1.last_state != 0)
          enc_1.delta += enc_1.add;
          else
          enc_1.delta -= enc_1.add;  
        }

      enc_1.last_count = enc_1.buffer_new_state;    // save Bitcombination of last count
    }//if

  enc_1.last_state = enc_1.buffer_new_state;        // save last state