Lothar Miller - Software

Drehgeberauswertung mit Beschleunigung

nospam@example.com (Lothar Miller) — Fri, 12 Mar 2010 12:56:02 +0100

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;   // 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( enc_accel ) enc_accel--;    // solange >0: pro ms um 1 "entschleunigen" 

    if( PHASE_A ) m = 1;            // Gray nach binär wandeln
    if( PHASE_B ) m ^= 3;

    m -= enc_ab;                     // berechnen, ob sich der Encoder bewegt hat
                                     // gültige Werte für Differenz (m): -1, 0, +1 
                                     // sonst ist die Abtastfrequenz zu niedrig!

    if( moved ) {                    // Positionsänderung am Encoder?
        enc_ab += m;                 // Encoderzustand speichern
        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                         // sonst             
            enc_accel = 255;         // auf 255 begrenzen  
        if (i&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. 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.

Graycode Umwandlung

nospam@example.com (Lothar Miller) — Sun, 17 Jan 2010 19:07:00 +0100

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.

FIFO

nospam@example.com (Lothar Miller) — Sat, 12 Dec 2009 14:05:30 +0100

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 Rotuine berechnet und anschliessend in einen Pufferspeicher abgelegt. Eine andere, zeit- und 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)
#define BMSK (BLEN-1)
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
   if (cleanupfifo=1) {
      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.

Timer+Zeiten

nospam@example.com (Lothar Miller) — Mon, 01 Dec 2008 10:43:52 +0100

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 Start;
  uint32_t Stop;
  uint32_t Event;
  // 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;
   //...
   cli();           // Interupts deaktivieren
   ti.Akt = gtiAkt; // Zeit atomar abholen
   sei();           // Ints wieder aktivieren

   if(ti.Akt&0xC0000000) {      // Zeitstempel laufen an die Obergrenze
       tiptr = (uint_32t*)(ti); // von jedem Zeitstempel Offset abziehen
       for(char i=0; i<sizeof(ti)/sizeof(uint32_t); tiptr++)   
          *tiptr-=0x80000000;
   }

   // 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;
   }
   
   // Zeit für Port-Pin low
   if (PortPin)  ti.Event = ti.Akt;
   lowtime = ti.Akt-ti.Event; // zählt hoch, solange Portpin low
 
//...
}

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.

Filter in C

nospam@example.com (Lothar Miller) — Mon, 01 Dec 2008 09:57:32 +0100

Ein Filter in der Art eines RC-Filters (PT1-Glied) kann in einem uC relativ leicht implementiert werden. Dazu bedarf es, wie beim RC-Glied eines "Summenspeichers" (der Kondensator) und einer Gewichtung (Widerstand bzw. Zeitkonstante).

unsigned long mittelwert(unsigned long newval) 
{
   static unsigned long avgsum = 0;
   // Filterlängen in 2er-Potenzen --> Compiler optimiert 
   avgsum -= avgsum/128;
   avgsum += newval;
   return avgsum/128;
}

Etwas spannender wird es, wenn die Initialisierung des Startwertes nicht so lange dauern soll. Wenn ich beispielsweise nach dem 1. Messwert diesen Wert und ab dem 2. Messwert bis zur Filterbreite den Mittelwert aus allen Messungen haben möchte, dann ist eine andere Behandlung der Initialisierung nötig.

unsigned long mittelwert(unsigned long newval) 
{
   static short n = 0;
   static unsigned long avgsum = 0;
   if (n<100) {
      n++;
      avgsum += newval;
      return avgsum/n;
   }
   else {
      // Konstanten kann der Compiler besser optimieren
      avgsum -= avgsum/100;
      avgsum += newval;
      return avgsum/100;
   }
}

Der Aufruf erfolgt z.B. anhand eines Timer-Flags:

int main(int argc, char* argv[])
{
   :
   while(1) {
      if(ti.Akt>ti.Calc) {
         avgwert = mittelwert(value[i]);
         printf("i: %3d --> Wert: %d --> Mittelwert: %d\n",i, value[i], mw);
      }
   }
}