Timmer Interrupt zu langsam.

static char code graytab[] = { 0,1,-1,0, -1,0,0,1, 1,0,0,-1, 0,-1,1,0 };

unsigned char graycode = 0;

unsigned char = 0;

unsigned old = 0;

unsigned new = 0;

void high_isr (void)

{

    new = (KANALA<<1) | (KANALB);         // Kanal A + B einlesen

    graycode = ((old<<2) | (new));                     // Gray- Code bilden (2 Zustände)

    counter += graytab[graycode];                          // Graycode Auswertung

    old = new;                                      // Neuen Zustand als Alten Zustand speichern

    INTCONbits.TMR0IF = 0;          // Interrupt zurücksetzen

}

/** I N C L U D E S ************************************************************************************************************************************************************************************/

#include "p18f2550.h"                            // PIC- Header

#include "delays.h"                               // für Warteschleifen

#include "usart.h"                              // für RS232- Schnittstelle

#include "timers.h"                              // für Timerinterrupt

#include "stdlib.h"                              // für Standardbibliothek

#include "stdio.h"                              // Für Standardein- und ausgabe

/** Configuration Fuses*********************************************************************************************************************************************************************************/

#pragma config FOSC = HS                          // Quarz HS 20 MHZ an OSC1- OSC2

#pragma config PWRT = ON                          // PowerOnTimer AN   

#pragma config BOR = OFF                          // BOR AUS

#pragma config WDT = OFF                          // Watchdog Timer AUS

#pragma config LVP = OFF                          // Low Voltage ICSP AUS

#pragma config PBADEN = OFF                          // PORTA Analogeingänge AUS

#pragma config VREGEN = OFF                          // VREGEN AUS

#pragma config MCLRE = ON                          // Master Reset AN

#pragma config PLLDIV = 1                          // PLLTeiler = 1 => 20 MHz

#pragma config CPUDIV = OSC1_PLL2                      // OSCTeiler = 1 => 20 MHz

#pragma config USBDIV = 1                          // CPUTeiler = 1 => 20 MHz

/** Globale Variablendeklarationen und Definierungen****************************************************************************************************************************************************/

signed long volatile int counter = 0;                    // Zähler -2.147.483.648 bis 2.147.483.647                  

signed long int counter_state1   = 0;                    // Counter Zustand 1

unsigned char ch0, ch1, ch2, ch3, ch4, ch5;                  // Sendevariablen                      

unsigned char new = 0;                            // Neuer Zustand der Kanaele A und B

unsigned char old = 0;                            // Alter Zustand der Kanaele A und B

unsigned char graycode = 0;                          // Graycode

signed static int graytab[] = { 0,1,-1,0, -1,0,0,1, 1,0,0,-1, 0,-1,1,0 };  // Array mit allen 16 Drehgeberzuständen (Graycode)

#define KANALSENSEVCC (PORTBbits.RB0)                    // Kanal SenseVCC  liegt an Bit 0 des Port B

#define KANALSENSEGND (PORTBbits.RB1)                    // Kanal SenseGND  liegt an Bit 1 des Port B

#define KANALNN       (PORTBbits.RB2)                    // Kanal N_Negiert liegt an Bit 2 des Port B

#define KANALN      (PORTBbits.RB3)                    // Kanal N         liegt an Bit 3 des Port B 

#define KANALNA     (PORTBbits.RB4)                    // Kanal A_Negiert liegt an Bit 4 des Port B

#define KANALNB     (PORTBbits.RB5)                    // Kanal B_Negiert liegt an Bit 5 des Port B

#define KANALA      (PORTBbits.RB6)                    // Kanal A         liegt an Bit 6 des Port B 

#define KANALB      (PORTBbits.RB7)                    // Kanal B         liegt an Bit 7 des Port B

/** Interrupt ******************************************************************************************************************************************************************************************/

void high_isr(void);                            // High Interrupt bekannt machen

#pragma code high_vector=0x08                        // Speicherbereich Interrupt definieren

void interrupt_at_high_vector(void)                      // Interrupt (High) Funktion

{

  _asm goto high_isr _endasm                        // Assembler Funktion high_isr = Interrupt Service Routine

}

#pragma code                                // Compilerbefehl Beginn Code

#pragma interrupt high_isr                          // Compilerbefehl Beginn InterruptCode

void high_isr (void)                            // Interrupt Routine

{

    new = (KANALA<<1) | (KANALB);                     // Kanal A + B einlesen                      

    graycode = ((old<<2) | (new));                             // Gray- Code bilden (2 Zustände)                

    counter += graytab[graycode];                                // Graycode Auswertung

    old = new;                                              // Neuen Zustand als Alten Zustand speichern

    TMR0L = 242;                            // Timer0 Register aufladen auf 242, Zähler zählt nur noch 13 Prozessorschritte => 2,6µs Auflösung für 10 Umdrehungen pro s

    INTCONbits.TMR0IF = 0;                        // Interrupt zurücksetzen

}

/** Programm *******************************************************************************************************************************************************************************************/

void InitUsart(void)                                        // Funktion USART Konfiguration            

{

  SPBRG = 20;                                // Baudrate 57600 Baud  SPBRG- Berechnung  59524 = 20000000/(16*(20+1)) = Fehlerquote unter 5% ; 1 BIT = 1,74 µs ; 57600 Baud

  SPBRGH =  0;                              // 8 Bit Übertragung      

  TRISCbits.TRISC6 = 1;                          // Aktivierung Senden TXD

  TRISCbits.TRISC7 = 1;                          // Aktivierung Empfangen RXD

  RCSTA = 0b10000100;                            // Empfangsregister konfigurieren

  TXSTA = 0b00100100;                            // Senderegister konfigurieren

}

void PICConfig(void)                                             // Funktion PIC Konfiguration

{

  // PORTA => Ausgänge

  TRISA = 0x00;                              // PORT A Ausgänge deklarieren

  PORTA = 0x00;                              // PORT A auf Null setzen

  LATA  = 0x00;                              // PORT A Latchregister auf Null setzen

  // PORTB  => Eingänge Inkrementalgeber

  TRISB = 0xFF;                              // PORT B Ausgänge deklarieren

  PORTB = 0x00;                              // PORT B auf Null setzen

  LATB  = 0x00;                              // PORT B Latchregister auf Null setzen

  // PORTC => Ausgänge 

  TRISC = 0x00;                               // PORT C Ausgänge deklarieren

  PORTC = 0x00;                              // PORT C auf Null setzen

  LATC  = 0x00;                               // PORT C Latchregister auf Null setzen

  // TIMER-INTERRUPT konfigurieren

  INTCON  = 0b11100000;                          // Interruptregister setzen

  INTCON2 = 0b00000000;                          // Interruptregister setzen

  T0CON =   0b11000000;                          // Timer 0 Konfiguration + Starten

}

char InttoChar(signed long int counter_state)                       // Funktion zur Umwandlung von INT in CHAR 

{

   int s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0;              // Variablen, die die einzelnen Stellen des Counter darstellen

    ch0 = '+';                                                // Positives Vorzeichen als Default                

     if (counter_state < 0)                                         // Falls Zähler negativ...

     {

         ch0 = '-';                                             // ...Minus als Vorzeichen

         counter_state = (-counter_state);                          // Vorzeichen entfernen                          

     }            

    for(;counter_state > 9999;counter_state -= 10000)            // Zehntausenderstelle

    {s1++;}

    for(;counter_state > 999;counter_state -= 1000)                     // Tausenderstelle

    {s2++;}

    for(;counter_state > 99;counter_state -= 100)                       // Hunderterstelle

    {s3++;}

    for(;counter_state > 9;counter_state -= 10)                         // Zehnerstelle

    {s4++;}

    for(;counter_state > 0;counter_state -= 1)                         // Einerstelle

    {s5++;}

                                      // Konvertierung

                                      // "Verschiebung" nach ASCII-Tabelle um Zeichen aus Zahlen zu erhalten

  ch1 = s1 + 0x30;                                            // Zehntausenderstelle

    ch2 = s2 + 0x30;                                             // Tausenderstelle 

    ch3 = s3 + 0x30;                                                    // Hunderterstelle

    ch4 = s4 + 0x30;                                                  // Zehnerstelle 

    ch5 = s5 + 0x30;                                              // Einerstelle 

  return ch0, ch1, ch2, ch3, ch4, ch5;                  // Rückgabe der zu sendenden Zeichen

}

void main(void)                                                  

{

  PICConfig();                              // Konfiguration der Ports

  InitUsart();                              // Start der USART-Schnittstelle

  Delay10KTCYx(10);                            // Wartezeit

  printf("#CONNECTED#\n");                        // Anfangsintialiserung senden

  while(1)                                  // Hauptschleife

  {

    INTCONbits.TMR0IE = 0;                        // Interrupts ausschalten für Variablenübergabe

    counter_state1 = counter/4;                      // Vergleichsvariable1 zwischenspeichern und Auflösung reduzieren 5000 Schritte pro Umdrehung

    INTCONbits.TMR0IE = 1;                        // Interrupts wieder aktivieren

    InttoChar(counter_state1);                      // Zähler in chars zum Senden umwandeln

    printf("%c%c%c%c%c%c\n",ch0, ch1, ch2, ch3, ch4, ch5);        // Senden des Counters  

  }                                    // Ende Endlosschleife

 }                                      /* Ende Mainfunktion */