Atmega8 Encoder + USB HID spinnt manchmal

uint8_t read_gray_code_from_encoder_1(void )

{ 

 uint8_t val1=0; 

  if(!bit_is_clear(PIND, PD2))

  val1 |= (1<<1); 

  if(!bit_is_clear(PIND, PD3))

  val1 |= (1<<0); 

  return val1;

} 

uint8_t read_gray_code_from_encoder_2(void )

{ 

 uint8_t val2=0; 

  if(!bit_is_clear(PIND, PD4))

  val2 |= (1<<1); 

  if(!bit_is_clear(PIND, PD5))

  val2 |= (1<<0); 

  return val2;

}

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <avr/wdt.h>

#include <util/delay.h>

#include "usbdrv.h"

#include "oddebug.h"

uint8_t val1=0, val_tmp1 =0;

uint8_t val2=0, val_tmp2 =0;

uint8_t val3=0, val_tmp3 =0;

uint8_t read_gray_code_from_encoder_1(void )

{ 

 uint8_t val1=0; 

  if(!bit_is_clear(PIND, PC0))

  val1 |= (1<<1); 

  if(!bit_is_clear(PIND, PC1))

  val1 |= (1<<0); 

  return val1;

} 

uint8_t read_gray_code_from_encoder_2(void )

{ 

 uint8_t val2=0; 

  if(!bit_is_clear(PIND, PC2))

  val2 |= (1<<1); 

  if(!bit_is_clear(PIND, PC3))

  val2 |= (1<<0); 

  return val2;

} 

uint8_t read_gray_code_from_encoder_3(void )

{ 

 uint8_t val3=0; 

  if(!bit_is_clear(PIND, PC4))

  val3 |= (1<<1); 

  if(!bit_is_clear(PIND, PC5))

  val3 |= (1<<0); 

  return val3;

} 

static void hardwareInit(void)

{

uchar  i, j;

    PORTB = 0xff;   /* activate all pull-ups */

    DDRB = 0;       /* all pins input */

    PORTC = 0xff;   /* activate all pull-ups */

    DDRC = 0;       /* all pins input */

    PORTD = 0xfa;   /* 1111 1010 bin: activate pull-ups except on USB lines */

    DDRD = 0x07;    /* 0000 0111 bin: all pins input except USB (-> USB reset) */

  j = 0;

  while(--j){     /* USB Reset by device only required on Watchdog Reset */

    i = 0;

    while(--i); /* delay >10ms for USB reset */

  }

    DDRD = 0x02;    /* 0000 0010 bin: remove USB reset condition */

    /* configure timer 0 for a rate of 12M/(1024 * 256) = 45.78 Hz (~22ms) */

    TCCR0 = 5;      /* timer 0 prescaler: 1024 */

  DDRD  = 0b00000000;

  DDRD |= _BV(PD7);

}

/* ------------------------------------------------------------------------- */

#define NUM_KEYS    17

/* The following function returns an index for the first key pressed. It

 * returns 0 if no key is pressed.

 */

static uchar    keyPressed(void)

{

val_tmp1 = read_gray_code_from_encoder_1(); 

val_tmp2 = read_gray_code_from_encoder_2(); 

val_tmp3 = read_gray_code_from_encoder_3(); 

     if(val1 != val_tmp1)

     { 

       if( /*(val==2 && val_tmp==3) ||*/

         (val1==3 && val_tmp1==1) || 

         /*(val==1 && val_tmp==0) ||*/

         (val1==0 && val_tmp1==2) 

       ) 

       { 

        return 1;

       } 

       else if( /*(val==3 && val_tmp==2) ||*/

         (val1==2 && val_tmp1==0) || 

         /*(val==0 && val_tmp==1) ||*/

         (val1==1 && val_tmp1==3) 

       ) 

       { 

        return 2;

       } 

       val1 = val_tmp1; 

     } 

     if(val2 != val_tmp2)

     { 

       if( /*(val==2 && val_tmp==3) ||*/

         (val2==3 && val_tmp2==1) || 

         /*(val==1 && val_tmp==0) ||*/

         (val2==0 && val_tmp2==2) 

       ) 

       { 

        return 3;

       } 

       else if( /*(val==3 && val_tmp==2) ||*/

         (val2==2 && val_tmp2==0) || 

         /*(val==0 && val_tmp==1) ||*/

         (val2==1 && val_tmp2==3) 

       ) 

       { 

        return 4;

       } 

       val2 = val_tmp2; 

     } 

     if(val3 != val_tmp3)

     { 

       if( /*(val==2 && val_tmp==3) ||*/

         (val3==3 && val_tmp3==1) || 

         /*(val==1 && val_tmp==0) ||*/

         (val3==0 && val_tmp3==2) 

       ) 

       { 

        return 5;

       } 

       else if( /*(val==3 && val_tmp==2) ||*/

         (val3==2 && val_tmp3==0) || 

         /*(val==0 && val_tmp==1) ||*/

         (val3==1 && val_tmp3==3) 

       ) 

       { 

        return 6;

       } 

       val3 = val_tmp3; 

     } 

_delay_ms(1); 

}

/* ------------------------------------------------------------------------- */

/* ----------------------------- USB interface ----------------------------- */

/* ------------------------------------------------------------------------- */

static uchar    reportBuffer[2];    /* buffer for HID reports */

static uchar    idleRate;           /* in 4 ms units */

const PROGMEM char usbHidReportDescriptor[35] = {   /* USB report descriptor */

    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)

    0x09, 0x06,                    // USAGE (Keyboard)

    0xa1, 0x01,                    // COLLECTION (Application)

    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)

    0x19, 0xe0,                    //   USAGE_MINIMUM (Keyboard LeftControl)

    0x29, 0xe7,                    //   USAGE_MAXIMUM (Keyboard Right GUI)

    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)

    0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)

    0x75, 0x01,                    //   REPORT_SIZE (1)

    0x95, 0x08,                    //   REPORT_COUNT (8)

    0x81, 0x02,                    //   INPUT (Data,Var,Abs)

    0x95, 0x01,                    //   REPORT_COUNT (1)

    0x75, 0x08,                    //   REPORT_SIZE (8)

    0x25, 0x65,                    //   LOGICAL_MAXIMUM (101)

    0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))

    0x29, 0x65,                    //   USAGE_MAXIMUM (Keyboard Application)

    0x81, 0x00,                    //   INPUT (Data,Ary,Abs)

    0xc0                           // END_COLLECTION

};

#define MOD_CONTROL_LEFT    (1<<0)

#define MOD_SHIFT_LEFT      (1<<1)

#define MOD_ALT_LEFT        (1<<2)

#define MOD_GUI_LEFT        (1<<3)

#define MOD_CONTROL_RIGHT   (1<<4)

#define MOD_SHIFT_RIGHT     (1<<5)

#define MOD_ALT_RIGHT       (1<<6)

#define MOD_GUI_RIGHT       (1<<7)

#define KEY_A       4

#define KEY_B       5

#define KEY_C       6

#define KEY_D       7

#define KEY_E       8

#define KEY_F       9

#define KEY_G       10

#define KEY_H       11

#define KEY_I       12

#define KEY_J       13

#define KEY_K       14

#define KEY_L       15

#define KEY_M       16

#define KEY_N       17

#define KEY_O       18

#define KEY_P       19

#define KEY_Q       20

#define KEY_R       21

#define KEY_S       22

#define KEY_T       23

#define KEY_U       24

#define KEY_V       25

#define KEY_W       26

#define KEY_X       27

#define KEY_Y       28

#define KEY_Z       29

#define KEY_1       30

#define KEY_2       31

#define KEY_3       32

#define KEY_4       33

#define KEY_5       34

#define KEY_6       35

#define KEY_7       36

#define KEY_8       37

#define KEY_9       38

#define KEY_0       39

#define KEY_UE      47

#define KEY_PLUS    48

#define KEY_F1      58

#define KEY_F2      59

#define KEY_F3      60

#define KEY_F4      61

#define KEY_F5      62

#define KEY_F6      63

#define KEY_F7      64

#define KEY_F8      65

#define KEY_F9      66

#define KEY_F10     67

#define KEY_F11     68

#define KEY_F12     69

static const uchar  keyReport[NUM_KEYS + 1][2] PROGMEM = {

/* none */  {0, 0},                     /* no key pressed */

/*  1 */    {MOD_CONTROL_LEFT | MOD_SHIFT_LEFT, KEY_UE},  

/*  2 */    {MOD_CONTROL_LEFT | MOD_SHIFT_LEFT, KEY_PLUS},  

/*  3 */    {MOD_ALT_LEFT | MOD_CONTROL_LEFT | MOD_SHIFT_LEFT, KEY_UE},             

/*  4 */    {MOD_ALT_LEFT | MOD_CONTROL_LEFT | MOD_SHIFT_LEFT, KEY_PLUS},          

/*  5 */    {MOD_ALT_LEFT | MOD_CONTROL_LEFT, KEY_UE},

/*  6 */    {MOD_ALT_LEFT | MOD_CONTROL_LEFT, KEY_PLUS},

/*  7 */    {0, KEY_G},

/*  8 */    {0, KEY_H},

/*  9 */    {0, KEY_I},

/* 10 */    {0, KEY_J},

/* 11 */    {0, KEY_K},

/* 12 */    {0, KEY_L},

/* 13 */    {0, KEY_M},

/* 14 */    {0, KEY_N},

/* 15 */    {0, KEY_O},

/* 16 */    {0, KEY_P},

/* 17 */    {0, KEY_Q},

};

static void buildReport(uchar key)

{

/* This (not so elegant) cast saves us 10 bytes of program memory */

    *(int *)reportBuffer = pgm_read_word(keyReport[key]);

}

uchar  usbFunctionSetup(uchar data[8])

{

usbRequest_t    *rq = (void *)data;

    usbMsgPtr = reportBuffer;

    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* class request type */

        if(rq->bRequest == USBRQ_HID_GET_REPORT){  /* wValue: ReportType (highbyte), ReportID (lowbyte) */

            /* we only have one report type, so don't look at wValue */

            buildReport(keyPressed());

            return sizeof(reportBuffer);

        }else if(rq->bRequest == USBRQ_HID_GET_IDLE){

            usbMsgPtr = &idleRate;

            return 1;

        }else if(rq->bRequest == USBRQ_HID_SET_IDLE){

            idleRate = rq->wValue.bytes[1];

        }

    }else{

        /* no vendor specific requests implemented */

    }

  return 0;

}

/* ------------------------------------------------------------------------- */

int  main(void)

{

val1 = read_gray_code_from_encoder_1(); 

val2 = read_gray_code_from_encoder_2(); 

val3 = read_gray_code_from_encoder_3(); 

    uchar   key, lastKey = 0, keyDidChange = 0;

    hardwareInit();

  usbInit();

  sei();

  for(;;)

  {

    usbPoll();

        key = keyPressed();

        if(lastKey != key){

            lastKey = key;

            keyDidChange = 1;

        }

        if((keyDidChange == 1) && usbInterruptIsReady()){

            keyDidChange = 2;

            buildReport(lastKey);

            usbSetInterrupt(reportBuffer, sizeof(reportBuffer));

        }

    if((keyDidChange == 2) && usbInterruptIsReady())

    {

      keyDidChange = 0;

            buildReport(0);

            usbSetInterrupt(reportBuffer, sizeof(reportBuffer));

    }

  }

  return 0;

}

/* ------------------------------------------------------------------------- */