encoder STEC12E08

[wolfgang (Gast)]

Hallo,
Ich nutze die Encoder-Funktion von Peter Dannegger zusammen mit einem
Drehencoder vo Reichelt,Aber leider zählt er nicht richtig,pro Rastung 
sind manchmal Sprünge von 100 drin.
Den Encoder-Wert gebe ich erstmal nur zum Terminal aus.
kann mir da einer Weiterhelfen
mfg

Leider kann ich das Datenblatt nicht Anhängen

/************************************************************************/
/*                                                                      */
/*                      Reading rotary encoder                     */
/*                      one, two and four step encoders supported  */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/
#include <avr\io.h>
#include <avr\interrupt.h>

        // target: ATmega16
//------------------------------------------------------------------------

#define  XTAL    8e6      // 8MHz

#define PHASE_A    (PINA & 1<<PA1)
#define PHASE_B    (PINA & 1<<PA3)




int8_t enc_delta;        // -128 ... 127
 uint8_t sec = 0;

void encode_init( void )
{
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;    // CTC, XTAL / 64
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);  // 1ms
  TIMSK |= 1<<OCIE0;
}


ISR( TIMER0_COMP_vect )        // 1ms for manual movement
{
  static int8_t last;
  int8_t new, diff;

  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;          // convert gray to binary
  diff = last - new;        // difference last - new
  if( diff & 1 ){        // bit 0 = value (1)
    last = new;          // store new as next last
    enc_delta += (diff & 2) - 1;    // bit 1 = direction (+/-)
  }
}


int8_t encode_read1( void )      // read single step encoders
{
  int8_t val;

  cli();
  val = enc_delta;
  enc_delta = 0;
  sei();
  return val;          // counts since last call
}


int8_t encode_read2( void )      // read two step encoders
{
  int8_t val;

  cli();
  val = enc_delta;
  enc_delta &= 1;
  sei();
  return val >> 1;
}


int8_t encode_read4( void )      // read four step encoders
{
  int8_t val;

  cli();
  val = enc_delta;
  enc_delta &= 3;
  sei();
  return val >> 2;
}


int main( void )
{
  int32_t val = 0;
  char encBuffer[10];
  encode_init();
  sei();

  for(;;){

   val += encode_read1();

  if(val > 0){
    val--;
    sec--;
  }else if(val < 0){
    val++;
    sec++;
   sprintf( encBuffer, "%3d", sec );
   uart_puts( encBuffer );    
  }
}

[Falk B. (falk)]

@wolfgang (Gast)

>Ich nutze die Encoder-Funktion von Peter Dannegger zusammen mit einem

Wirklich? Ich glaube da fehtl ein volatile.

volatile int8_t enc_delta;        // -128 ... 127

MFG
Falk

[Falk B. (falk)]

http://www.mikrocontroller.net/articles/Drehgeber#Solide_L.C3.B6sung:_Beispielcode_in_C

Selber schuld, wenn man den Code abtippt, anstatt ihr einfach 1:1 zu 
kopieren.

[Chris (Gast)]

Kopieren statt Kapieren ,und dann noch Falsch Kopiert ;)

[wolfgang (Gast)]

Falk Brunner schrieb:
> Ich glaube da fehtl ein volatile int8_t enc_delta;
steht bei mir im code drin.
aber Trotzdem zählt er in zu grossen schritten und auch nicht in jeder 
rastung.
mfg

[Falk B. (falk)]

@  wolfgang (Gast)

>> Ich glaube da fehtl ein volatile int8_t enc_delta;
>steht bei mir im code drin.

WAS? Und wieso nicht in dem geposteten Quelltext? Sowas kopiert man 
IMMER 1:1 und tippt NICHTS ab! Lies mal was über Netiquette!

MfG
Falk

[Jens (Gast)]

Na Falk, jetzt nicht mehr Bildformate sondern Netiquette? Ist das 
überhaupt ein Wort?

>>Selber schuld, wenn man den Code abtippt, anstatt ihr einfach 1:1 zu
>>kopieren.<<

Wer anderen eine Grube gräbt. Mann soll also nett sein und sich auch 
noch dumm belehren lassen - was ist hier nur los?
Komm mal langsam wieder runter - das kommt davon wenn man hier zu lange 
im Forum ist, das macht krank!

@Wolfgang
Wenn er teilweise springt oder 2 Schritte zählt, liegt das an den 
mechanischen Rastungen. Du solltest dann mal den code mit Tabelle 
nutzen. Steht auch im tutotrial.

Hast du den code aus dem Tut oder aus dem Thread? Lies mal das tut.

Gruß,
JJ

PS.: wo das springen um 100 her kommt, kann ich nun aus dem stehgreif 
auch nicht sagen, bedenke dass der Zähler vorzeichenbehaftet ist!

[wolfgang (Gast)]

Ja da ist mir wohl ein Fehler unterlaufen,
Hab mir den code von hier 
http://www.mikrocontroller.net/articles/Drehgeber#...
nochmal geladen aber mein Encoder zählt immer noch Falsch
mfg

[Martin H. (martin_h85)]

Guten Morgen,

wenn du den Quelltext richtig kopiert hast und er funktioniert immer 
noch nicht wie erwartet guck dir doch mal deinen Hardware Aufbau an.
Bei Längeren Kabeln können Pullup Widerstände helfen.


Gruß Martin

[Jens (Gast)]

http://www.mikrocontroller.net/articles/Drehgeber

[wolfgang (Gast)]

Die Hardware Funktioniert,Pull-Ups habe ich aktiviert trozdem hauts 
nicht hin.

************************************************************************/
/*                                                                      */
/*                      Reading rotary encoder                      */
/*                      one, two and four step encoders supported   */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include "uart.h"
                // target: ATmega16
//------------------------------------------------------------------------
 
#define XTAL        8e6         // 8MHz
 
#define PHASE_A     (PINA & 1<<PA1)
#define PHASE_B     (PINA & 1<<PA3)
 
 
volatile uint8_t sec ;  
volatile int8_t enc_delta;          // -128 ... 127
static int8_t last;
 
 
void encode_init( void )
{
  int8_t new;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                   // convert gray to binary
  last = new;                   // power on state
  enc_delta = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;     // CTC, XTAL / 64
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);   // 1ms
  TIMSK |= 1<<OCIE0;
}
 
 
ISR( TIMER0_COMP_vect )             // 1ms for manual movement
{
  int8_t new, diff;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                   // convert gray to binary
  diff = last - new;                // difference last - new
  if( diff & 1 ){               // bit 0 = value (1)
    last = new;                 // store new as next last
    enc_delta += (diff & 2) - 1;        // bit 1 = direction (+/-)
  }
}
 
 
int8_t encode_read1( void )         // read single step encoders
{
  int8_t val;
 
  cli();
  val = enc_delta;
  enc_delta = 0;
  sei();
  return val;                   // counts since last call
}
 
 
int8_t encode_read2( void )         // read two step encoders
{
  int8_t val;
 
  cli();
  val = enc_delta;
  enc_delta = val & 1;
  sei();
  return val >> 1;
}
 
 
int8_t encode_read4( void )         // read four step encoders
{
  int8_t val;
 
  cli();
  val = enc_delta;
  enc_delta = val & 3;
  sei();
  return val >> 2;
}
 
 
int main( void )
{
  int32_t val = 0;
 char encBuffer[10];
 //Pull-Up einschalten
  DDRA  &= ~(1<<PHASE_A);  
  PORTA |= (1<<PHASE_A);   
  DDRA  &= ~(1<<PHASE_B);  
  PORTA |= (1<<PHASE_B);   
  encode_init();
  sei();
 
  for(;;){
  val += encode_read1();

  if(val > 0){
    val--;
    sec--;

  }  else if(val < 0){
     val++;
     sec++;

 }
 
  sprintf( encBuffer, "%3d", sec );
  uart_puts( encBuffer );  }
}

[Falk B. (falk)]

@  wolfgang (Gast)

>Die Hardware Funktioniert,Pull-Ups habe ich aktiviert

Nö.


>#define PHASE_A     (PINA & 1<<PA1)
>#define PHASE_B     (PINA & 1<<PA3)

> //Pull-Up einschalten
>  DDRA  &= ~(1<<PHASE_A);
>  PORTA |= (1<<PHASE_A);
>  DDRA  &= ~(1<<PHASE_B);
>  PORTA |= (1<<PHASE_B);

besser so.

  // Inputs
  DDRA  &= !((1<<PA1) | (1<<PA3));  
  PORTA |= (1<<PA1) | (1<<PA3);

Siehe auch Bitmanipulation. Hier ist leider eine Mischung aus den 
Bitdefinitionen drin.

http://www.mikrocontroller.net/articles/Bitmanipulation#Bitmanipulation_beim_MSP430

MFG
Falk

[Jens (Gast)]

aus dem Artikel:

Im wahren Leben gibt es immer wieder Dinge, welche der Theorie zwar 
widersprechen, dennoch weit verbreitet sind. Da machen Drehgeber keine 
Ausnahme. Gerade die heute so beliebten Drehgeber für manuelle Bedienung 
sind in großer Anzahl von verschiedenen Herstellern verfügbar. Umso 
merkwürdiger ist es, dass hier die Rastpunkte oft genau auf dem 
Pegelwechsel einer Spur liegen, meist Spur B. So zum Beispiel beim 
Drehgeber EC11E15244B2 von Alps, welcher u.a bei Pollin ehältlich ist.

Bei diesem Drehgeber kommt es bei der klassischen, eigentlich soliden 
Auswertung zu dem Effekt, dass der Drehgeber in Ruhelage auf einem 
Rastpunkt pendeln kann. Damit erhält das Programm sporadisch einen 
Schritt vor und zurück. Auch wenn sich die Auswertung daran nicht 
verschluckt, so ist dieses Pendeln doch ärgerlich, denn eine 
Menusteuerung würde dann komische Sachen machen.


Schau dir mal das zweite Codeposting mit dieser:

int8_t table[16] PROGMEM = {0,0,-1,0,0,0,0,1,1,0,0,0,0,-1,0,0};

Tabelle an.

Springt er um 100 oder vielleicht 127? Wie sieht deine Konvertierung von 
int8 auf die serielle ss aus?

JJ

[Peter D. (peda)]

Falk Brunner schrieb:
> besser so.
>
>   // Inputs
>   DDRA  &= !((1<<PA1) | (1<<PA3));
>   PORTA |= (1<<PA1) | (1<<PA3);

Warum sind 4 Bytes mehr Code besser?
Und außerdem ist das falsch.
Der ! Operator liefert nur 0 oder 1.


Peter

[Peter D. (peda)]

wolfgang schrieb:
> Aber leider zählt er nicht richtig,pro Rastung
> sind manchmal Sprünge von 100 drin.

Das glaube ich Dir nicht. Wo soll die 100 denn herkommen?
Vermutlich ein Ablesefehler, da Du die Ausgaben ohne einen Trenner 
aneinander reihst.
Versuch mal:

  sprintf( encBuffer, "%4d\n", sec );
  _delay_ms( 200 );

Rastende Enkoder machen 2 oder 4 Phasenwechsel, nimm also die dazu 
passende Auslesefunktion.


Peter

[Falk B. (falk)]

@  Peter Dannegger (peda)

>Warum sind 4 Bytes mehr Code besser?

Lies mal das Original vom OP. Dort wird doppelt gemoppelt Bits 
geschoben, nicht wirklich im Sin des Erfinders.

>Und außerdem ist das falsch.
>Der ! Operator liefert nur 0 oder 1.

Jaja, Flüchtigkeitsfehler.

   DDRA  &= ~((1<<PA1) | (1<<PA3));
   PORTA |= (1<<PA1) | (1<<PA3);

MFG
Falk

[Peter D. (peda)]

Falk Brunner schrieb:
> Lies mal das Original vom OP. Dort wird doppelt gemoppelt Bits
> geschoben, nicht wirklich im Sin des Erfinders.

Ja, der ist schlichtweg falsch.
Richtig:

 //Pull-Up einschalten
  DDRA  &= ~(1<<PA1);  
  PORTA |= (1<<PA1);   
  DDRA  &= ~(1<<PA3);  
  PORTA |= (1<<PA3);

Dann sinds 2 CBI und 2 SBI, also 2 Befehle gespart gegenüber IN+ORI+OUT, 
IN+ANDI+OUT.


Peter

[wolfgang (Gast)]

Guten Morgen
Vielen Dank für eure Hilfe und es lag bei mir doch am Aufbau.
Wenn ich 2Encoder auswerten will muss ich doch für den zweiten Encoder 
alle Routienen einen anderen Namen geben auch die im Interrupr, oder bin 
ich da jetz falsch.
mfg

[Falk B. (falk)]

@wolfgang (Gast)

>Wenn ich 2Encoder auswerten will muss ich doch für den zweiten Encoder
>alle Routienen einen anderen Namen geben auch die im Interrupr,

Ja.

MfG
Falk

[Jens (Gast)]

...au man...

JJ

[Jens (Gast)]

>>mit einem Drehencoder<<

so viel zum Thema, die Antworten können nur maximal so präzise sein, wie 
die Informationen der Problemstellung...

Na zumindest läufts dann ja jetzt...

JJ