Mehrere Drehencoder gleichzeitig abfragen

[Lokus P. (derschatten)]

Ich möchte gerne mittels einem ATMEGA8-16PU jeweils 5 Drehencoder 
gleichzeitig abfragen.

Für einen gibt es ja bereits dieses schöne Beispiel hier: 
http://www.mikrocontroller.net/articles/Drehgeber

Wie muß ich das ganze jedoch erweitern für 5 Stück?

[Bastler (Gast)]

PeDa Lösung einfach 5-mal hintereinander in ISR.
Bei akuter Speichernot die 2-Bit Status je Encoder packen (4 in ein 
Byte).
Oder die 4-fach-parallel-Lösung à la PeDa Entprellung (er)finden.

[Lokus P. (derschatten)]

Also am einfachsten in einer Wurst hintereinander setzen:

void encode_init( void )
{
  int8_t new1, new2, new3, new4, new5;
 
  new1 = 0;
  if( PHASE_A1 )
    new1 = 3;
  if( PHASE_B1 )
    new1 ^= 1;
  last1 = new1;
  enc_delta1 = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;

  new2 = 0;
  if( PHASE_A2 )
    new2 = 3;
  if( PHASE_B2 )
    new2 ^= 1;
  last2 = new2;
  enc_delta2 = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;

  new3 = 0;
  if( PHASE_A3 )
    new3 = 3;
  if( PHASE_B3 )
    new3 ^= 1;
  last3 = new3;
  enc_delta3 = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;

  new4 = 0;
  if( PHASE_A4 )
    new1 = 3;
  if( PHASE_B4 )
    new4 ^= 1;
  last4 = new4;
  enc_delta4 = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;

  new5 = 0;
  if( PHASE_A5 )
    new5 = 3;
  if( PHASE_B5 )
    new5 ^= 1;
  last5 = new5;
  enc_delta5 = 0;
  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;
}
 
 
ISR( TIMER0_COMP_vect )
{
  int8_t new1, diff1, new2, diff2, new3, diff3, new4, diff4, new5, diff5, 
 
  new1 = 0;
  if( PHASE_A1 )
    new1 = 3;
  if( PHASE_B1 )
    new1 ^= 1;
  diff1 = last1 - new1;
  if( diff1 & 1 ){
    last1 = new1;
    enc_delta1 += (diff1 & 2) - 1;
  }

  new2 = 0;
  if( PHASE_A2 )
    new2 = 3;
  if( PHASE_B2 )
    new2 ^= 1;
  diff2 = last2 - new2;
  if( diff2 & 1 ){
    last2 = new2;
    enc_delta2 += (diff2 & 2) - 1;
  }

  new3 = 0;
  if( PHASE_A3 )
    new3 = 3;
  if( PHASE_B3 )
    new3 ^= 1;
  diff3 = last3 - new3;
  if( diff3 & 1 ){
    last3 = new3;
    enc_delta3 += (diff3 & 2) - 1;
  }

  new4 = 0;
  if( PHASE_A4 )
    new4 = 3;
  if( PHASE_B4 )
    new4 ^= 1;
  diff4 = last4 - new4;
  if( diff4 & 1 ){
    last4 = new4;
    enc_delta4 += (diff4 & 2) - 1;
  }

  new5 = 0;
  if( PHASE_A5 )
    new5 = 3;
  if( PHASE_B5 )
    new5 ^= 1;
  diff5 = last5 - new5;
  if( diff5 & 1 ){
    last5 = new5;
    enc_delta5 += (diff5 & 2) - 1;
  }
}

int8_t encode_read1( void )
{
  int8_t val1;
 
  cli();
  val1 = enc_delta1;
  enc_delta1 = val1 & 1;
  sei();
  return val1 >> 1;
}

int8_t encode_read2( void )
{
  int8_t val2;
 
  cli();
  val2 = enc_delta2;
  enc_delta2 = val2 & 1;
  sei();
  return val2 >> 1;
}

int8_t encode_read3( void )
{
  int8_t val3;
 
  cli();
  val3 = enc_delta3;
  enc_delta3 = val3 & 1;
  sei();
  return val3 >> 1;
}

int8_t encode_read4( void )
{
  int8_t val4;
 
  cli();
  val4 = enc_delta4;
  enc_delta4 = val4 & 1;
  sei();
  return val4 >> 1;
}

int8_t encode_read5( void )
{
  int8_t val5;
 
  cli();
  val5 = enc_delta5;
  enc_delta5 = val5 & 1;
  sei();
  return val5 >> 1;
}

[Karl H. (kbuchegg)]

Aber ein bischen mitdenken ist schon auch erlaubt
Den Teil

  TCCR0 = 1<<WGM01^1<<CS01^1<<CS00;
  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
  TIMSK |= 1<<OCIE0;

brauchst du nicht 5 mal. Einmal den Timer auf den Vorteiler und CTC 
Modus einstellen, den Compare Wert setzen und den Interrupt freigeben 
reicht völlig aus.

Wenn man schon Code kopiert, sollte man sich zumindest ansehen, was man 
da kopiert.

[Falk B. (falk)]

Es wäre auch eine gute Übung för den Schööööler, das Ganze auf eine 
mehrkanalige Auswertung mit einem Array zu erweitern, ohne den Code 
X-fach zu kopieren. Oder auf Macrobasis. Oder, oder, oder. Copy & Paste 
ist bäh.

[Lokus P. (derschatten)]

stimmt, der Teil genügt natürlich ein mal.
Hab jetzt einfach nur munter drauflos kopiert :)

[Falk B. (falk)]

Hier mal ein Ansatz, ist aber praktisch nicht getestet.

[Lokus P. (derschatten)]

Ich habe mir das Beispiel mal angesehen und würde es gerne als 
alternative zu meinem anderen Versuch ausprobieren und habe es 
entsprechend angepasst:

/************************************************************************/
/*                                                                      */
/* Reading rotary encoder, multi channel version                        */
/* one, two and four step encoders supported                            */
/*                                                                      */
/* based on Peter Dannegger's example code                              */
/*                                                                      */
/*  example for ATmega664, 8 MHz internal clock                         */
/*                                                                      */
/************************************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include "encoder.h"
  
#define XTAL        8e6             // 8MHz
 
#define ENCODER_COUNT 2
 
encoder_t   encoder_array[ENCODER_COUNT] = {
//    PINx of phase A
//    |         bitmask of phase A
//    |         |      PINx of phase B
//    |         |      |         bitmask of phase B
//    |         |      |         |       high nibble: encoder step size, low nibble internal
//    |         |      |         |       |   internal postion
//    |         |      |         |       |   |  
//    |         |      |         |       |   |  
    {&PINC, (1<<PC0), &PINC, (1<<PC1), 0x20 ,0 },
    {&PINC, (1<<PC3), &PINC, (1<<PC4), 0x20 ,0 },
};

// positions of encoders for normal use in main loop and functions
int16_t encoder_position[ENCODER_COUNT];        
 
// 1ms timer ISR, sufficient for manual movement

ISR( TIMER0_COMPA_vect ) {            

    encoder_process(encoder_array, ENCODER_COUNT);
}

int main( void ) {

    // init a timer

  TCCR0A = (1<<WGM01);
  OCR0A = (uint8_t)(F_CPU / 64.0 * 1e-3 - 0.5);
  TCCR0B = (1<<CS01 | 1<<CS00);
  TIMSK0 = (1<<OCIE0A);

    DDRA  = 0xFF;        // init test port, diplay valu with LEDs
    PORTC = 0xFF;        // init test port, pull Ups on

    encoder_init(encoder_array, ENCODER_COUNT);
    sei();
 
    while(1){
        encoder_read_all(encoder_array, ENCODER_COUNT, encoder_position); // read all encoders
        PORTA = encoder_position[0];
        PORTA = encoder_position[1];
    }
}

Das funktioniert auch soweit.
Allerdings habe ich bei mir die Situation, das ich pro Port 
unterschiedliche LED's von mehreren Encoder anzeigen möchte.
Also die ersten 4 PIN's vom ersten Encoder, die nächsten 2 PIN's vom 
zweiten Encoder, usw.

Ich muß die Ports also unterteilen.
Wie macht ich das am besten?

[Falk B. (falk)]

>Ich muß die Ports also unterteilen.
>Wie macht ich das am besten?

Exakt genau so, wie es dieses Beispiel macht, nur mit dem Unterschied, 
dass du Ports schreibst anstatt zu lesen. Siehe Bitmanipulation.