Software

Hier eine Drehgeberauswertung, die auf der Basis von Peter Danneggers Code (auf www.mikrocontroller.net) zusätzlich eine dynamische Beschleunigung realisiert. Je schneller am Knopf gedreht wird, umso schneller ändert sich der Wert. Das ergibt ein gutes haptisches Gefühl, und man kann größere Bereiche einstellen, ohne dass umgegriffen werden muß.

---

volatile int16_t enc_pos;
#define PHASE_A  (PINA & 1<<PA1)   
#define PHASE_B  (PINA & 1<<PA2)

// ISR wird z.B. jede ms aufgerufen
ISR(SIG_OUTPUT_COMPARE1A)
{
    #define DYNAMIK 40  
    static uint8_t enc_ab = 0x01;   // speichert Encoderzustand 0..3     
    static uint8_t enc_accel = 0;   // speichert die aktuelle Beschleunigung
    int16_t   p;                    // (position) lokale Variable für Positionsberechnung    

    int8_t    m = 0;                // (moved) lokale Variable für Bewegungsberechnung
    if (PHASE_A) m = 1;             // Gray nach binär wandeln
    if (PHASE_B) m ^= 3;
    m -= enc_ab;                    // Differenz zeigt an, ob sich der Encoder bewegt hat
                                    // gültige Werte für Differenz (m): -1, 0, +1 
                                    // sonst ist die Abtastfrequenz zu niedrig!

    if (enc_accel) enc_accel--;     // solange >0: pro ms um 1 "entschleunigen" 

    if (m) {                        // wenn m ungleich 0 --> Positionsänderung am Encoder
        enc_ab += m;                // Bewegungsdifferenz auf alten Encoderzustand aufaddieren
        p = enc_pos;                // nicht auf globaler Variable (enc_pos) herumrechnen        
        if (enc_accel<255-DYNAMIK)  // neuen Beschleunigungswert berechnen:            
             enc_accel += DYNAMIK;  // solange <255 Beschleunigungswert aufaddieren
        else enc_accel = 255;       // sonst auf 255 begrenzen (diese Zeile kann weggelassen werden) 
        if (m&2)                    // Bit 1 = Vorzeichen = Richtung (+/-)            
            p += 1+(enc_accel>>6);  // Erst Beschleunigungswerte >64 (wegen >>6)          
        else                        // werden berücksichtigt.             
            p -= 1+(enc_accel>>6);  // Diese Division (Shift 6) evtl. anpassen...        
        enc_pos = p;                // lokale Variable auf globale Variable zurückkopieren
     }
    :
    // ab hier kommt sonstiger Code im Timerinterrupt   
}

---

Im Beispiel sind die beiden Spuren an den Portpins 1 und 2 vom Port A angeschlossen. In der Variablen m steht ein Wert für die Bewegung: -1, 0, +1 (11, 00 und 01). Ein Wert ungleich 0 bedeutet also: Bewegung. PeDa fragt das Bit 0 explizit ab (m&1), ich habe das reduziert auf m!=0. Im Bit 1 (m&2) steckt dann die Bewegungsrichtung, mit der die Position hoch- oder runtergezählt wird.

Mit dem #define DYNAMIK lässt sich der "Biss", also die Beschleunigung einstellen. Leider funktioniert das z.B. mit den billigen Pollin-Encodern nur eingeschränkt, weil die pro Raste zwei Schritte machen. Also ist da etwas Spielen und Ausprobieren mit dem Wert angesagt. Ich habe noch jedesmal einen brauchbaren Wert gefunden. Mit einem uint16_t für enc_accel kann der Dynamikbereich wesentlich ausgeweitet werden.

Die Umwandlung vom Gray- in den Binärcode erfolgt mit dem XOR Verfahren wie auf Software/Graycode im letzten Beispiel beschrieben.

Im PDF CY8CKIT-049-4xxx PSoC 4 Rotary Encoder für Cypress Mikrocontroller hat Reiner Wehner das Ganze ab Seite 37 fein säuberlich analysiert. Und im Forum dort wird das im Thread Quadrature decoder at PSoC 4 ausdiskutiert, dort sind dann auch Links zur Umsetzung in Software zu finden.

Eine Umwandlung von einer Zahl in ein Hex-ASCII-Zeichen ist recht einfach.
Man kann es ausrechnen:

if (i>9) then
   c = i-10+'a';
else
   c = i+'0';

Oder kürzer mit dem Fragezeichen-Operator:

c = i>9 ? i-10+'a' : i+'0';

Oder man kann die Zahl als Index auf eine Tabelle verwenden:

unsigned char i, t[]="0123456789ABCDEF";
c = t[i];

Die Kurzschreibweise dafür ist dann das hier:

c = "0123456789ABCDEF"[i];

Wenn man diese Indizierung eines Strings und die Verwendung des Strings als Tabelle mal verstanden hat, tun sich einige weitere Einsatzmöglichkeiten auf. So zum Beispiel wenn ein Byte bis zu einem angegebenen Bit mit 1-en aufgefüllt werden soll. Das kann man ausrechnen:

c = (1<<i)-1;

Oder man kann es über eine Tabelle machen:

#include<stdio.h>
int main()
{
   unsigned char i, t[8]={1,3,7,15,31,63,127,255};
   for (i=0; i<=7; i++) {
      printf("%c \t %d \t %d \t %d\n",
              "01234567"[i],
              t[i],
              (unsigned char)"\1\3\7\17\37\77\177\377"[i],       // Oktal-Zahlen!
              (unsigned char)"\x1\x3\x7\xf\x1f\x3f\x7f\xff"[i]); // Hex-Zahlen!
   }
   return 0;
}

ergibt das hier:

0 	 1 	 1 	 1
1 	 3 	 3 	 3
2 	 7 	 7 	 7
3 	 15 	 15 	 15
4 	 31 	 31 	 31
5 	 63 	 63 	 63
6 	 127 	 127 	 127
7 	 255 	 255 	 255

Mit einer kleinen Änderung der Tabelle kann dann ein gewünschtes Bits ausmaskiert werden:

unsigned char i, t[8]={1,2,4,8,16,32,64,128};
for (i=0; i<=7; i++) {
  printf("%c \t %d \t %d \t %d\n",
         "01234567"[i],
         t[i],
         (unsigned char)"\1\2\4\10\20\40\100\200"[i],       // Oktal-Zahlen!
         (unsigned char)"\x1\x2\x4\x8\x10\x20\x40\x80"[i]); // Hex-Zahlen!
}

ergibt das hier:

0 	 1 	 1 	 1
1 	 2 	 2 	 2
2 	 4 	 4 	 4
3 	 8 	 8 	 8
4 	 16 	 16 	 16
5 	 32 	 32 	 32
6 	 64 	 64 	 64
7 	 128 	 128 	 128

Und natürlich kann man in solche kleinen "Vor-Ort"-Tabellen noch einiges mehr packen. Z.B. ein Lauflichtmuster, eine Schritttabelle usw...

Hier finden sich C-Routinen zur Umwandlung von Graycode nach Binärcode und umgekehrt. Das Ganze basiert auf dem VHDL-Code hier: Graycode-Umwandlung in VHDL

---

/*
The purpose of this function is to convert an unsigned
binary number to reflected binary Gray code.
Binary 1-x-0-x-1-x-0-x-1
       |  `   `   `   ` 
       |   |   |   |   |       x = xor
       v   v   v   v   v       Abarbeitung MSB ... LSB 
Gray   1   1   0   0   1
*/
unsigned short BinaryToGray(unsigned short num)
{
   return (num>>1) ^ num;
}

/*
A tricky trick: for up to 2^n bits, you can convert Gray to binary by
performing (2^n) - 1 binary-to Gray conversions. All you need is the
function above and a 'for' loop.
*/
unsigned short GrayToBinary(unsigned short num)
{
  int i;
  unsigned short temp = num;
  for (i=0; i<15; i++) temp = BinaryToGray(temp);
  return temp;
}

/*
Gray   1   0   1   0   1
       |  /   /   /   / 
       | x   x   x   x     x = xor
       v/ `v/ `v/ `v/ `v   Abarbeitung MSB ... LSB 
Binary 1   1   0   0   1   
*/
unsigned short GrayToBinaryX(unsigned short num)
{
  int i;
  unsigned short temp = num;
  temp &= 0x8000;
  for (i=14; i>=0; i--) {
     if ( (!!(temp&(1<<(i+1)))) != (!!(num&(1<<i))) )
        temp |= (1<<i);
  }
  return temp;
}

/*
The purpose of this function is to convert a reflected binary
Gray code number to a binary number.
*/
unsigned short GrayToBinaryPow2(unsigned short num)
{
  unsigned short temp = num;
  temp ^= (temp>>8);
  temp ^= (temp>>4);
  temp ^= (temp>>2);
  temp ^= (temp>>1);
  return temp;
}

---

Die Grundlagen dieser Umwandlungsroutinen sind auf www.wisc-online.com schön erklärt.

Immer wieder braucht man einen Fifo, wenn zeitlich unabhängige Prozesse untereinander Daten austauschen müssen. Die Berechnung eines Wertes ist z.B. schnell erledigt, wenn dieser Wert aber über die serielle Schnittstelle verschickt werden (oder auch auf einem Display ausgegeben werden) muß, ist es unsinnig, auf das Übertragungsende jedes Zeichens zu warten.
Also wird der Wert von einer Routine berechnet und anschließend in einen Pufferspeicher abgelegt. Eine andere, zeit- oder interruptgesteuerte Routine holt dann ein Zeichen nach dem anderen aus dem Puffer und versendet das Zeichen.

Einfach und effizient zu implementieren ist ein Fifo, dessen Größe einer 2er-Potenz entspricht (8, 16, 32, 64...). Dann kann der Indexüberlauf einfach mit einer Bitmaske abgehandelt werden. Hier ist so eine Implementierung:

---

#define BLEN (16)          // z.B. 16
#define BMSK (BLEN-1)      // z.B. 16-1 = 15 = binär 1111
typedef struct {
   volatile unsigned char w;
   volatile unsigned char r;
   unsigned char d[BLEN];  // die Daten sind nicht volatil, sie können sich 
} fifotyp;                 // nur geändert haben, wenn der Index sich ändert
fifotyp fifo;
:
:
   // Fifo schreiben
   if ((fifo.w - fifo.r)&BMSK==BMSK) {
       // Fehlerbehandlung: Fifo ist voll
   }
   else {
      // Zeichen eintragen
      fifo.d[fifo.w&BMSK] = din;    
      fifo.w++;
   }
    
   // Fifo lesen
   if (fifo.w != fifo.r) { // Fifo belegt?
      // Zeichen auslesen
      dout = fifo.d[fifo.r&BMSK];
      fifo.r++;
   }

   // Fifo leeren
   fifo.w = fifo.r

---

Fifo leer: Wenn der Leseindex r gleich dem Schreibindex w ist, dann ist der Fifo leer.

Fifo belegt: Wenn der Leseindex r ungleich dem Schreibindex w ist, dann ist ein Zeichen im Puffer. Wichtig ist, dass zuerst das Zeichen in den Puffer geschrieben (bzw. gelesen) wird, und erst dann der Index erhöht wird. Denn sonst könnte nach der Indexmanipulation ein Interrupt kommen, und weil das Zeichen noch nicht eingetragen wurde, wird mit falschen Daten gearbeitet.

Fifo Reset: Das Rücksetzen des Fifos erfolgt einfach, indem der Leseindex gleich dem Schreibindex gesetzt wird. Allerdings sollte dieser Vorgang nur im Notfall angewendet werden, denn dabei gehen garantiert irgendwelche gespeicherte Informationen verloren.

Fifo Overrun: Ob noch ein Zeichen in den Fifo passt oder dieser voll ist, kann durch die Subtraktion des Schreibindex w vom Leseindex r überprüft werden. Ist das Ergebnis dieser Operation -1, dann kann kein weiteres Zeichen gespeichert werden. Aber aufpassen: weil beide Indexe unsigned sind, muss auf  (BLEN-1 = BMSK = alle Bits auf 1) abgefragt werden.

Die Softwarestruktur eines uC-Programms sollte so aussehen, dass alle "üblichen" Arbeiten in einer Hauptschleife ausgeführt werden. Interrupt-Rotuinen setzen "nur" Flags oder verwalten FIFOs.

Zeiten können elegant über eine Struktur (ti) verwaltet werden, die eine Systemzeit (ti.Akt) und andere Aktionszeiten bzw. Triggerzeiten enthält.

---

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
//...
volatile uint32_t gtiAkt;
typedef {
  uint32_t Akt; // Systemzeit in ms  
  uint32_t Toggle;  
  uint32_t Start;
  uint32_t Stop;
  uint32_t Rise;
  uint32_t Duration;
  // usw...
} tiStruct;
tiStruct ti;

// Timer-Compare Interrupt ISR, wird z.B. alle 10ms ausgefuehrt
ISR(TIMER1_COMPA_vect)
{
   gtiAkt+=10;
}
 
int main(void)
{
   uint_32t *tiptr;

   while (1) { // die HAUPTSCHLEIFE

      cli();           // Interupts (eigentlich nur Timerinterrupt) deaktivieren
      ti.Akt = gtiAkt; // Zeit atomar abholen
      if(ti.Akt&0xC0000000) {      // Zeitstempel laufen an die Obergrenze
         gtiAkt-=0x80000000;       // aktuelle Zeit und          tiptr = (uint_32t*)(ti);  // jeden Zeitstempel nach unten korrigieren
         sei();                    // Timerinterrupt kann hier schon wieder aktiviert werden
         for(char i=0; i<sizeof(ti)/sizeof(uint32_t); tiptr++) {  
           if(*tiptr>0x80000000) *tiptr-=0x80000000;
           else                  *tiptr=0;
         }
      }
      sei();           // Wenn nichts zu korrigieren gibt: hier Ints wieder aktivieren

      // LED blinken 
      if(ti.Akt>ti.Toggle) {
         LedPin = !LedPin;
         ti.Toggle = ti.Toggle+500; // Blinkfrequenz 1 Hz = 500ms an, 500ms aus
      }

      // Start-Zeitpunkt erreicht
      if(ti.Akt>ti.Start) {
         run = 1;
         ti.Start = ti.Akt + 100000;
         ti.Stop  = ti.Akt + 1000;
      }

      // Stop-Zeitpunkt erreicht
      if(ti.Akt>ti.Stop) {
         run = 0;
         ti.Start = ti.Akt + 2000;
         ti.Stop  = ti.Akt + 100000;
      }
   
      // Beispiel: Zeit ermitteln für Port-Pin high
      PortPinAkt = Portpin_Einlesen():
      if (PortPinAkt!=PortPinAlt) {       // Flanke am Portpin?
         if (PortPinAkt)                  // steigende Flanke
            ti.Rise = ti.Akt;             // --> Zeit merken
         else                             // fallende Flanke
            ti.Duration = ti.Akt-ti.Rise; // --> Betätigungsdauer ausrechnen
      }
      PortPinAlt = PortPinAkt;            // Pegel merken für Flankenerkennung

   } // Ende HAUPTSCHLEIFE
}

---

Hier wird in einer Interruptroutine ein Millisekunden-Zähler hochgezählt und als Zeitbasis auf eine globale Struktur abgebildet. Auf diese systemweit einmalige Zeit werden dann alle lokalen Zeiten bezogen. Bei einem drohenden Überlauf wird von allen Zeiten in der ti-Struktur ein Offset abgezogen.