Atmega8 Encoder + USB HID spinnt manchmal

[Kilo K. (kilo81)]

Aloha,

ich habe mal eine Frage:
Ich spiele die Flugsimulation Falcon 4.0 BMS, dort werden im Cockpit 
verschiedene Potis bewegt bezüglich Lautstärke Funk, etc.

Für meine Kippschalter benutze ich folgende Schaltung:
https://www.obdev.at/products/vusb/hidkeys-de.html

Nun habe ich für einen lautstärkeregler im Cockpit einen Encoder an 
diese USB HID Schaltung angeschlossen mit folgendem Code:
http://www.leniwiec.org/en/2014/04/28/rotary-shaft-encoder-how-to-connect-it-and-handle-it-with-avr-atmega8-16-32-168-328/

Letztes Beispiel, OHNE Verwendung von Timern!

So und jetzt mein problem. Bei einem Encoder klappt das wunderbar!! man 
sieht im Cockpit sogar das Poti bewegen.
habe ich 2 Encoder an meiner Schaltung, dann bewegt sich der eine Knopf 
im Cockpit nur manchmal und betätige ich den 2. Encoder, dann bewegt 
sich sogar ein anderer Knopf im Cockpit, obwohl die tastenkombination 
eine völlig andere ist. Bei 3 Encodern noch extremer...

Warum kommen die sich in die Quere? Encoder 1 sendet die Tastenkombi 
SHIFT+ALT+Ü und Encoder 2: SHIFT+ALT+CTRL+Ü. Also eine ganz andere, 
dennoch bewegt sich der eine Knopf manchmal mit.

Gruß
Dominik

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dominik Kristen schrieb:
> mit folgendem Code:
> http://www.leniwiec.org/...
> Letztes Beispiel
Dieser Code ist wegen des delay_ms() bestenfalls ein krudes 
Funktionsmodell. Zudem kann ich dort nicht sehen, wie du damit 3 Encoder 
einlesen willst.

Und nachdem der Code dort sogar funktionieren würde, dein Code aber 
Probleme macht, wäre es sinnvoll, wenn du den problembehafteten Code 
zeigen würdest...

[Dominik (Gast)]

ich habe einfach jeden Encoder für sich selber definert:

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;
}

und so weiter...

So, hier ist der code:

#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;
}

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

Wie gesagt: Im prinzip funktioniert es. Nur kommen sich die Encoder 
manchmal in die Quere. Der eine sendet sogar zusätzlich ein 
tastenkürzen, welches ich gar nicht definiert habe.

[Stefan F. (Gast)]

Bei der Schaltung würde ich nicht lange suchen.

Zum einen hast du da zwei Dioden in der Spannungsversorgung, die einen 
beträchtlichen Innenwiderstand haben. Zweitens sind die I/O Pins von AVR 
Mikrocontrollern nicht USB konform.

Das diese Schaltung unzuverlässig arbeitet, wundert mich gar nicht. Die 
ganzen billigen ISP Programmer, die auf dem selben Prinzip beruhen, sind 
ja auch unzuverlässig.

[Dominik (Gast)]

Aber warum funktioniert es mit Kippschaltern, Tastern und so weiter?
Die Encoder werden ja auch in der Schleife ständig abgefragt und sind 
unabhängig von einem Timer.

Hat also bei 3 Encodern die Übertragung per USB etwas damit zu tun?

[Vusb (Gast)]

Ich tippe eher auf ein Optimierungsproblem. VUSB ist empfindlich wenn 
das timing nicht stimmt und man sollte auf keinen fall delays benutzen. 
Das bringt die Usb-Verbindung durcheinander weil die hart an der Grenze 
ist für AVRs (ohne HW-Usb).

Änder dein code so dass er ohne delays auskommt oder wechsel auf ein Avr 
mit Usb. Mega32u4 zum beispiel. Gibts ein Arduino Micro oder Nano oder 
so der den hat. Damit ist ein Eigenbaucockpit kinderleicht gemacht...

[Dominik (Gast)]

Ich habe mir auch schon fast gedacht, dass es am Soft-USB liegen könnte.

ich werde mal die Encoder nicht in der Flugsim testen sondern mit dem 
Editor. Dann sehe ich wann, welche zeichen gesendet werden.
das _delay nehme ich danach mal raus.

[Kilo K. (kilo81)]

Achso: AVR wechseln wäre jetzt nicht meine 1. Priorität... :)

[Markus W. (Firma: guloshop.de) (m-w)]

Vusb schrieb:
> Ich tippe eher auf ein Optimierungsproblem.

Kann gut sein! Das hier zum Beispiel wird sehr wahrscheinlich 
wegoptimiert.

 j = 0;
  while(--j){     /* USB Reset by device only required on Watchdog Reset */
    i = 0;
    while(--i); /* delay >10ms for USB reset */
  }

Wenn ich mich recht erinnere, habe dieses Stück Code gleich 
rausgeworfen, als ich den USBasp für den guloprog (ATtiny85) angepasst 
habe.

> VUSB ist empfindlich wenn
> das timing nicht stimmt und man sollte auf keinen fall delays benutzen.
> Das bringt die Usb-Verbindung durcheinander weil die hart an der Grenze
> ist für AVRs (ohne HW-Usb).

Das sehe ich eher anders, weil VUSB mit Interrupts arbeitet. delay_ms() 
läuft meines Wissens im Vordergrund und wartet aktiv, kommt also mit den 
Interrupts nicht ins Gehege – was im Fall von VUSB eher ein Vorteil ist.

> Änder dein code so dass er ohne delays auskommt oder wechsel auf ein Avr
> mit Usb. Mega32u4 zum beispiel. Gibts ein Arduino Micro oder Nano oder
> so der den hat. Damit ist ein Eigenbaucockpit kinderleicht gemacht...

Der 32U4 ist sicher eine feine Sache, da läuft HW-USB sogar ohne Quarz. 
Für viele kleine Anwendungen ist er aber vielleicht doch eine Nummer zu 
groß.

[Vusb (Gast)]

Na bei 4-6€ für ein Pro-Micro Breakout Board ist mir der overkill nicht 
so wichtig. Ok, dauert Wochen aus China, aber ich hatte die eh mal im 
10er Pack bestellt, dann noch günstiger. Das schöne ist wenn man 
wirklich nur ein original F16-Stick aus den 80ern (Gameport und aus 
Metall und so!) wiederbeleben will dann ist das damit und mit der 
Arduino-IDE ein Nobrainer und man kann sich auf die mechanische 
Umsetzung konzentrieren.

Genauso einfach geht auch fast alles andere USB-HID-inputmässig.

Aber ich will niemand davon abbringen ein vorhandenes Vusb zum laufen zu 
bringen! Wollte nur eine mögliche Alternative aufzeigen die ich für 
etwas Ähnliches benutzt hab. Vusb ist toll, nicht ohne Grung hab ich 
damals für meine Bastelei von denen eine Lizenz mit meinen eigenen 
Vid/Pid geholt...

Mit an der Grenze meinte ich die Geschwindigkeit der 
USB-Lowspeed-Kommunikation, die den AVR im augenblich in dem über USB 
kommuniziert wird fast voll auslastet um die Signale zu samplen bzw. zu 
senden. Wenn da was dazwisvhen kommt oder man zu viel in die 
Hauptschleife packt (das hatte ich mal) dann kann Kauderwelsch 
rauskommen. Ich hab dann delays weggelassen und statt dessen eine 
statemachine gebaut die mit einem freizählenden Timer vergleicht um 
Zeiten zu bekommen.

Viel Erfolg!

[Kilo K. (kilo81)]

So, _delay rausgenommen und:

j = 0;
  while(--j){     /* USB Reset by device only required on Watchdog Reset */
    i = 0;
    while(--i); /* delay >10ms for USB reset */
  }

auskommentiert....
Problem besteht weiterhin. :(
Encoder 3 funzt super!
Encoder 1 nur manchmal
Encoder 2 bewegt die anderen Knöpfe gleich mit :(

[Kilo K. (kilo81)]

Noch eine Anmerkung.
hab mir mal Buchstaben senden lassen an den Texteditor.
Encoder 2 und 3 senden bei einem "Klick" 2 Impulse. 1 Impuls kommt 
bereits, bevor ein Klick zu hören ist!!! Dreht man also langsam, bevor 
es klick macht, dann funktioniert alles wi es soll. Aber das kann ja 
nicht sein :(


Encoder 1 funktioniert einwandfrei und ist übrigens von eine, anderen 
Hersteller. Weiß aber nicht welcher.
Encoder 2 und 3 sehen aus wie Potis von Alps. Keine Ahnung ob es diese 
Marke ist.

Mir scheint, es liegt also nicht an der Schaltung sondern an den 
Encodern?!

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Deine Encoderabfrage ist auch sehr empfindlich gegen prellende 
Drehgeber. Du solltest dir mal die Encoder Routine von PeDa anschauen:
https://www.mikrocontroller.net/articles/Drehgeber

Die kommt selbst mit völlig abgenudelten Teilen klar, wenn man den Timer 
ein wenig anpasst.

[Kilo K. (kilo81)]

Hm.. ich probiere das mal!
Muss da nur den Timer1 nehmen, weil der andere ja schon für USB ist...
hatte da anfangs auch Probleme mit dem Timer1 :(

[Kilo K. (kilo81)]

Also mit dem Code von Peter Dannegger tut sich gar nichts bei mir :(

Was soll denn eigentlich als 'val' rauskommen? 0 und 1?
Kann mir mal einer sagen ob ich den Timer1 falsch initialisiere?

void encode_init( void )
{
  int8_t new;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                   // convert gray to binary
  last = new;                   // power on state
  enc_delta = 0;
  TCCR1A = (1<<COM1A0);                // CTC mode, toggle OC1A on compare match
  TCCR1B = (1<<CS12)|(1<<CS10)         // Start Timer1 with prescaler 1024
              |(1<<WGM12);
  OCR1A = (uint8_t)(8 / 64.0 * 1e-3 - 0.5);   // 1ms
  TIMSK |= 1<<OCIE1A;
}
 
 
ISR( TIMER1_COMP_vect )             // 1ms for manual movement
{
  int8_t new, diff;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                   // convert gray to binary
  diff = last - new;                // difference last - new
  if( diff & 1 ){               // bit 0 = value (1)
    last = new;                 // store new as next last
    enc_delta += (diff & 2) - 1;        // bit 1 = direction (+/-)
  }
}

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Du hast die Abfrage des Encoders vergessen:

int8_t encode_read2( void )         // read two step encoders
{
  int8_t val; 
  cli();
  val = enc_delta;
  enc_delta = val & 1;
  sei();
  return val >> 1;
}
// Das Beispiel aus dem Artikel:
int main( void )
{
  int32_t val = 0;
 
  LEDS_DDR = 0xFF;
  encode_init();
  sei();
 
  for(;;){
    val += encode_read2();          // read a 2 step encoder
    LEDS = val;
  }
}

[Kilo K. (kilo81)]

ja die hatte ich auch drinnen... mir gings jetzt nur um den Timer1.
Denn mit dem lief gar nichts :(

Ich weiß auch gar nichts was 'val' für einen Wert ausgibt.
Bei meinem Beispiel, konnte ich nämlich auch auswählen, welcher Wert 
zurückgegeben werden soll:

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;
       }

Encoder 1 soll 1 und 2 zurückgeben als zahl
Encoder 2 => 3 und 4
und so weiter...

Das Beispiel von PeDa läuft bei mir nicht.. Also ich kriege das mit dem 
Timer anscheinend nicht hin.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Dominik Kristen schrieb:
> Das Beispiel von PeDa läuft bei mir nicht.. Also ich kriege das mit dem
> Timer anscheinend nicht hin.

Je nach verwendetem AVR löst der CTC Interrupt verschiedene ISR aus. Bei 
manchen (z.B. der Tiny26) ist es der Timer Overflow, bei manchen der OC 
Interrupt. Ich habe schon länger nichts mehr mit dem Mega8 gemacht, 
glaube aber, das es im CTC der OC1 Interrupt ist, wäre also bei dir 
richtig.

> TCCR1A = (1<<COM1A0);                // CTC mode, toggle OC1A on
> compare match

Das solltest du nicht tun, denn du willst ja gar kein Signal am Pin, 
sondern nur den Interrupt. Kann aber zum Testen nützlich sein, wenn der 
Pin frei ist.
Achte auf die Prioritäten: Der USB Interrupt muss höhere Priorität als 
der Timer sein, evtl. musst du die Timer ISR als 'non-blocking' 
erklären:

ISR( TIMER1_COMPA_vect,ISR_NOBLOCK )

Beachte ausserdem deinen Schreibfehler - das Dings heisst 
ISR(TIMER1_COMPA_vect), steht so in der avr_libc Referenz.

> Ich weiß auch gar nichts was 'val' für einen Wert ausgibt.

In PeDas Beispiel wird val hoch und runtergezählt, je nachdem, ob du 
rechts oder links drehst. Fängt bei 0 an und ist dann eine 
vorzeichenbehaftete Variable:

  int32_t val = 0;

[Kilo K. (kilo81)]

Hallo Matthias,

danke schön. Ja ich habs nicht so mit Timern! :(
Meinen Schreibfehler hab ich auch schon bemerkt. Vielleicht lag es auch 
daran. Muss ich später nochmal testen.

[Kilo K. (kilo81)]

Mal ne andere Frage:
Wie könnte man denn ein Poti an den ADC hängen, bzw. es programmieren, 
dass es sich wie ein Encoder verhält?
Sprich, bei einer 8bit Auflösung soll es alle, sagen wir mal, 20 
Schritte eine Variable hochzählen. Bzw. runterzählen wenn ich wieder 
zurückdrehe.
Das müsste doch auch irgendwie gehen oder?

[Karl M. (Gast)]

Dominik,

wie machst Du das mit dem Anschlägen am Poti ? 360° kann es halt nicht.

Sonst kann man das Poti auch direkt zur Eingabe von Werten verwenden.

[Ulrich F. (Gast)]

> wie machst Du das mit dem Anschlägen am Poti ? 360° kann es halt nicht.
Es gibt 360° Potis ohne Anschläge

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Dominik Kristen schrieb:
> Sprich, bei einer 8bit Auflösung soll es alle, sagen wir mal, 20
> Schritte eine Variable hochzählen. Bzw. runterzählen wenn ich wieder
> zurückdrehe.

Das macht der ADC alleine, er liefert grössere Werte, wenn mehr Spannung 
am Eingang liegt und kleinere Werte, wenn weniger Spannung da ist.
Die AVR haben im Allgemeinen 10 Bit Wandler, so das eine Spannung nahe 
AREF Werte um die 1023 liefert, null Volt am Eingang bringen etwa Werte 
nahe 0.
Für 8 bit Werte reicht es aus, nur ADCH zu lesen, sofern ADLAR gesetzt 
ist. Steht aber alles im Datenblatt.
Nur mitteln solltest du kräftig, sonst zappelt der Wert. Für einen 
Joystick ist es evtl. auch sinnvoll, erst dann neue Werte zu liefern, 
wenn eine gewisse Schwelle zum vorherigen Wert überschritten wird.

[Kilo K. (kilo81)]

Ne es muss nicht 360° können.. das ist egal!
Wenn ich das Poti "aufdrehe", will ich alle 20 ADC-Schritte eine 
variable hochzählen.
Genauso umgekehrt, wenn ich wieder zurückdrehe.
ich frage mich nur, wie lege ich die Schwelle fest.

[Kilo K. (kilo81)]

Matthias Sch. schrieb:
> Dominik Kristen schrieb:
>> Sprich, bei einer 8bit Auflösung soll es alle, sagen wir mal, 20
>> Schritte eine Variable hochzählen. Bzw. runterzählen wenn ich wieder
>> zurückdrehe.
>
> Das macht der ADC alleine, er liefert grössere Werte, wenn mehr Spannung
> am Eingang liegt und kleinere Werte, wenn weniger Spannung da ist.
> Die AVR haben im Allgemeinen 10 Bit Wandler, so das eine Spannung nahe
> AREF Werte um die 1023 liefert, null Volt am Eingang bringen etwa Werte
> nahe 0.
> Für 8 bit Werte reicht es aus, nur ADCH zu lesen, sofern ADLAR gesetzt
> ist. Steht aber alles im Datenblatt.
> Nur mitteln solltest du kräftig, sonst zappelt der Wert. Für einen
> Joystick ist es evtl. auch sinnvoll, erst dann neue Werte zu liefern,
> wenn eine gewisse Schwelle zum vorherigen Wert überschritten wird.

ja das stimmt schon. Aber ich will meine eigenen Werte definieren 
können.
hm... Dann müsste ich den ADC Wert teilen, so dass ich auf zahlen von 
1-20 komme.

Ein Joystick wird es nicht. Es soll weiterhin als tastaturcontroller Key 
commands senden.
Also um das mal zu erklären:

Ein lautstärkepoti im Cockpit der Simulation kann mit '+' aufgedreht 
werden und mit 'ü' wieder leiser gedreht werden.

jetzt könnte man einen Joystick anschließen und das Signal einer 
analogen Achse zuweisen. Das will ich aber aus einigen Gründen nicht!
D.h. ich verwende weiterhin den Tastaturcontroller und schicke mein 'ü' 
und mein '+' per USB raus. Bei einem Encoder ist das ja leicht. Da kann 
ich pro Klick nach rechts die Taste senden.
Bei einem Poti wird es da aber schon schwieriger.