[ATTiny24] Bitte um Blick auf Code

[Stefan H. (stefan_h16)]

Ich habe zwar schon ein paar größere und kleiner Programme mit dem 
Arduino fertiggestellt, dabei habe ich mir aber stark von der 
Arduino-eigenen Bibliothek helfen lassen. Deswegen bin ich mir noch 
unsicher was die ganz Systemnahen Sachen angeht, und hoffe das mir ein 
paar geschulte Augen noch Tipps geben können.
Das soll das Programm machen:
Es werden zwei einfache DC-Motoren über H-Brücken angeschlossen. Die 
Motoren beinhalten ausserdem jeweils optische Quadropol-Encoder.
Der vorliegende Programmprototyp soll die Encoder auslesen und jeweils 
die absolute Position und die aktuelle Geschwindigkeit über i2c (slave) 
ausgeben.
Um die Encoder auszulesen werden die PCINT 7,5,3,2 genutzt. Die 
gemeinsame ISR findet dann heraus welcher Pin verantwortlich ist für den 
Interrupt und behandelt diesen entsprechend.
Zur Bestimmung der Geschwindigkeit läuft ein Timer im CTC Modus als 
Zeitbasis der die tausendstel Sekunden seit Reset zählt.
Für i2c  nutze ich die Lib von Martin Junghans, da ich schon gute 
Erfahrungen damit gemacht habe.
Also meine Fragen:
- Sind sowohl Hardwareinterrupts als auch der Timer so konfiguriert wie 
ich das will
- Könnte die ISR Routine für die Hardware interrupts noch optimiert 
werden (sie scheint mir zu groß zu sein)
- Allgemeine Verbesserungsvorschläge, wo könnte das Programm haken ?

Zumindest compilieren lässt es sich mit gcc.

/*#################################################################################################
 Name  : i2c controlled Motordriver for Lego NXT Motors
 Version  : 0.1 alpha
 autor  : Stefan  page  :
 License  : GNU General Public License


 //################################################################################################*/
/*Structur of i2c Communication
 * txbuffer    (readable by master)
 * txbuffer[0] Motor A speed in ticks/sec high byte
 * txbuffer[1] Motor A speed in ticks/sec low byte
 * txbuffer[2] Motor A position count high byte
 * txbuffer[3] Motor A position count low byte
 * txbuffer[4] Motor B speed in ticks/sec high byte
 * txbuffer[5] Motor B speed in ticks/sec low byte
 * txbuffer[6] Motor B position count high byte
 * txbuffer[7] Motor B position count low byte
 */

/* Pinning of Attiny 24
 * VCC     -> VCC
 * PB0    -> Clkin (Quarzoszillator) or n.c.
 * PB1    -> PWM_MOTOR_A0
 * PB2    -> PWM_MOTOR_A1
 * PB3    -> RESET -> PULLUP-Resistor -> VCC
 * PA7    -> TACHO_MOTOR_A0
 * PA6    -> i2c SDA / ISP MOSI
 * PA5    -> TACHO_MOTOR_A1 / ISP MISO
 * PA4    -> i2c SCL / ISP SCK
 * PA3    -> TACHO_MOTOR_B1
 * PA2    -> TACHO_MOTOR_B0
 * PA1    -> PWM_MOTOR_B0
 * PA0    -> PWM_MOTOR_B1
 * GND    -> GND
 */
//################### Pinning
#define DDR_PWM_MOTOR_A DDRB
#define DDR_PWM_MOTOR_B DDRA
#define DDR_TACHO DDRA

#define PORT_PWM_MOTOR_A PORTB
#define PORT_PWM_MOTOR_B PORTA
#define PIN_TACHO PINA

#define PWM_MOTOR_A0 1
#define PWM_MOTOR_A1 2
#define PWM_MOTOR_B0 1
#define PWM_MOTOR_B1 0
#define TACHO_MOTOR_A0 7
#define TACHO_MOTOR_A1 5
#define TACHO_MOTOR_B0 2
#define TACHO_MOTOR_B1 3

//Additional constants
#define TIMEBASE 1000 //1/1000 s or 1 ms is the timebase for all calculations

#include   <stdlib.h>
#include   <avr/io.h>
#include   <avr/interrupt.h>
#include   <avr/pgmspace.h>
#include   <util/delay.h>

//###################### USI-TWI-I2C
#include   "usiTwiSlave.h"         
#define   SLAVE_ADR_ATTINY_1       0b00110100    // i2c slave address
#ifndef   F_CPU
#define   F_CPU 8000000UL
#endif
//###################### Global variables
volatile uint8_t pwm_settings[4]; //stores speeds for pwm
volatile uint16_t tacho_A = 0; // stores tacho count for motor a
volatile uint16_t tacho_B = 0; // stores tacho count for motor a

volatile uint32_t timebase = 0; //stores current time since reset

#define LOW_BYTE(x)          (x & 0xff)          // 16Bit   --> 8Bit
#define HIGH_BYTE(x)         ((x >> 8) & 0xff)      // 16Bit   --> 8Bit
//Interrupt vector that handles tacho interrups
ISR(PCINT1_vect)
{
  uint8_t current;
  uint8_t masked;
  static volatile uint8_t prev = 0;
  static volatile uint8_t dir_A;
  static volatile uint8_t dir_B;

  current = PIN_TACHO;
  masked = current ^ prev; //Calculate xor to find out which pins have  changed

  if (masked & (1 << TACHO_MOTOR_A0)) //PIN TACHO_A0 triggers interrupt
  {
    if ((prev & (1 << TACHO_MOTOR_A0)) == 0) //only interested in rising edge (prev = 0; current = 1);
    {
      if (dir_A)
        tacho_A--;
      else
        tacho_A++;
    }
  } else if (masked & (1 << TACHO_MOTOR_A1))
    dir_A = !dir_A;

  if (masked & (1 < TACHO_MOTOR_B0)) //PIN TACHO_A0 triggers interrupt
  {
    if ((prev & (1 << TACHO_MOTOR_B0)) == 0) //only interested in rising edge (prev = 0; current = 1);
    {
      if (dir_B)
        tacho_B--;
      else
        tacho_B++;
    }
  } else if (masked & (1 << TACHO_MOTOR_B1))
    dir_B = !dir_B;

  prev = current;
}

//the ISR is called every millisecond
ISR(TIM0_COMPA_vect)
{
  timebase++;
}

int main(void) {
  //Init I2C
  cli();
  //Set Motorports as outputs
  DDR_PWM_MOTOR_A |= (1 << PWM_MOTOR_A0) | (1 << PWM_MOTOR_A1);
  DDR_PWM_MOTOR_B |= (1 << PWM_MOTOR_B0) | (1 << PWM_MOTOR_B1);
  //Set Tachoports as inputs
  DDR_TACHO &= ~((1 << TACHO_MOTOR_A0) | (1 << TACHO_MOTOR_A1) | (1
      << TACHO_MOTOR_B0) | (1 << TACHO_MOTOR_B1));

  //Configure Interrupts for Tacho
  GIMSK = (1 << PCIE0); //Changes on PCINT 7:0 may cause interrupt
  PCMSK0 = (1 << TACHO_MOTOR_A0) | (1 << TACHO_MOTOR_A1) | (1
      << TACHO_MOTOR_B0) | (1 << TACHO_MOTOR_B1); //Enable Tachopins for Interrupt source


  //Configure Timer0 as time base for milliseconds
  TCCR0A = (1 << WGM01); //CTC Mode
  TCCR0B = (1 << CS01); //clock prescaler 8
  OCR0A = ((F_CPU / 8) / TIMEBASE) ; 
  TIMSK0 = (1 << OCIE0A); //Enable Compare interrupt

  //Init TWI Slave
  usiTwiSlaveInit(SLAVE_ADR_ATTINY_1);
  sei();

  uint32_t prev_time = 0;
  uint16_t prev_tachoA = 0;
  uint16_t prev_tachoB = 0;

  uint16_t speed_A = 0;
  uint16_t speed_B = 0;

  uint16_t delta_time;

  for (;;) {
    delta_time = (uint16_t) (timebase - prev_time);
    prev_time = timebase;

    if (delta_time > 0) //to prevent div by zero
    {
      speed_A = (tacho_A - prev_tachoA) * 1000 / delta_time;
      speed_B = (tacho_B - prev_tachoB) * 1000 / delta_time;
    }

    //Write everything into the txbuffer
    txbuffer[0] = HIGH_BYTE(speed_A);
    txbuffer[1] = LOW_BYTE(speed_A);
    txbuffer[2] = HIGH_BYTE(tacho_A);
    txbuffer[3] = LOW_BYTE(tacho_A);
    txbuffer[4] = HIGH_BYTE(speed_B);
    txbuffer[5] = LOW_BYTE(speed_B);
    txbuffer[6] = HIGH_BYTE(tacho_B);
    txbuffer[7] = LOW_BYTE(tacho_B);

  }

}

[Thomas E. (thomase)]

Stefan H. schrieb:

>static volatile uint8_t prev = 0;
>static volatile uint8_t dir_A;
>static volatile uint8_t dir_B;

Das hat in der ISR nichts zu verloren, sondern gehört global deklariert.


> speed_A = (tacho_A - prev_tachoA) * 1000 / delta_time;
> speed_B = (tacho_B - prev_tachoB) * 1000 / delta_time;

Das wird Probleme machen.

Wenn die Differenz (tacho_A - prev_tachoA) größer als 6 ist, ist das 
Ergebnis der folgenden Multiplikation min. 70000, unsigned int geht aber 
nur bis 65536.


mfg.

[Stefan H. (stefan_h16)]

Thomas Eckmann schrieb:
> Stefan H. schrieb:
>
>>static volatile uint8_t prev = 0;
>>static volatile uint8_t dir_A;
>>static volatile uint8_t dir_B;
>
> Das hat in der ISR nichts zu verloren, sondern gehört global deklariert.

Kannst du mir bitte sagen wieso ? Ich dachte, da ich die Variablen nur 
lokal brauche, sind sie als Static in der ISR am besten aufgehoben 
(gekapselt). Wo liegt der Unterschied ?


>> speed_A = (tacho_A - prev_tachoA) * 1000 / delta_time;
>> speed_B = (tacho_B - prev_tachoB) * 1000 / delta_time;
>
> Das wird Probleme machen.
>
> Wenn die Differenz (tacho_A - prev_tachoA) größer als 6 ist, ist das
> Ergebnis der folgenden Multiplikation min. 70000, unsigned int geht aber
> nur bis 65536.
>
An dem Teil arbeite ich zugegebener Maßen noch. Aber ich habe 
ausgerechnet das es nicht mehr als zwei Tachoticks pro Millisekunde 
geben kann (Motor ist nicht schneller), so dass die Variablen zumindest 
nicht überlaufen sollte.

Und der Rest, ist der richtig eingestellt ?

mfg
Stefan

[Helfer (Gast)]

>>>static volatile uint8_t prev = 0;
>>>static volatile uint8_t dir_A;
>>>static volatile uint8_t dir_B;
>>
>> Das hat in der ISR nichts zu verloren, sondern gehört global deklariert.
>
> Kannst du mir bitte sagen wieso ? Ich dachte, da ich die Variablen nur
> lokal brauche, sind sie als Static in der ISR am besten aufgehoben
> (gekapselt). Wo liegt der Unterschied ?

Du kannst die schon lokal in der ISR definieren (inkl. 
Initialisierung!), brauchst dann aber das volatile nicht.

Als "Nachteil" fällt mir nur ein, dass du eventuell schwieriger Debuggen 
kannst, weil die lokalen Variablen halt nur lokal sichtbar sind, d.h. 
wenn die ISR läuft. Mal eben einen Statusdump zu machen ist schwierig.

[Helfer (Gast)]

>    delta_time = (uint16_t) (timebase - prev_time);
>    prev_time = timebase;

Den Zugriff auf die gemeinsam benutzte Variable timebase musst du 
atomar machen. Siehe Artikel Interrupt

[Helfer (Gast)]

>      speed_A = (tacho_A - prev_tachoA) * 1000 / delta_time;
>      speed_B = (tacho_B - prev_tachoB) * 1000 / delta_time;

Ebenso den Zugriff auf die Variablen tacho_A und tacho_B

[Helfer (Gast)]

Es bietet sich an dafür einen eigenen Block zu Beginn des 
for-Anweisungsblocks zu machen, in dem die von der ISR gesetzten 
Variablen als "Schnappschuss" atomar in eine lokale Kopie kopiert werden

#include <util/atomic.h>
...

  for(;;) {
    uint32_t akt_timebase;
    uint16_t akt_tacho_A;
    uint16_t akt_tacho_B; 

    ATOMIC_BLOCK(ATOMIC_FORCEON)
    {
      akt_timebase = timebase;
      akt_tacho_A = tacho_A;
      akt_tacho_B = tacho_B; 
    }

    delta_time = (uint16_t) (akt_timebase - prev_time);
    prev_time = akt_timebase;

    if (delta_time > 0) //to prevent div by zero
    {
      speed_A = ((akt_tacho_A - prev_tachoA) * 1000) / delta_time;
      speed_B = ((akt_tacho_B - prev_tachoB) * 1000) / delta_time;
    }

    //Write everything into the txbuffer
    txbuffer[0] = HIGH_BYTE(speed_A);
    txbuffer[1] = LOW_BYTE(speed_A);
    txbuffer[2] = HIGH_BYTE(akt_tacho_A);
    txbuffer[3] = LOW_BYTE(akt_tacho_A);
    txbuffer[4] = HIGH_BYTE(speed_B);
    txbuffer[5] = LOW_BYTE(speed_B);
    txbuffer[6] = HIGH_BYTE(akt_tacho_B);
    txbuffer[7] = LOW_BYTE(akt_tacho_B);
  }

[Helfer (Gast)]

In deinem Code (und meinem Vorschlag) fehlt IMHO noch, das regelmäßige 
Update von prev_tachoA und prev_tachoB ähnlich wie bei prev_time.

Anschliessend stellt sich die Frage, wann die so stetig weitergezählten 
Variablen irgendwann überlaufen...

[Stefan H. (stefan_h16)]

Helfer schrieb:
> In deinem Code (und meinem Vorschlag) fehlt IMHO noch, das regelmäßige
> Update von prev_tachoA und prev_tachoB ähnlich wie bei prev_time.
>
> Anschliessend stellt sich die Frage, wann die so stetig weitergezählten
> Variablen irgendwann überlaufen...

Vielen Dank für deine umfangreiche Hilfe. Insbesondere die Sache mit dem 
atomaren Kopien hatte ich völlig übersehen. Der Vollständigkeit halber 
muss ich aber anmerken das ich die drei akt_ Variablen wohl Global 
deklarieren muss damit innerhalb des Atomblocks sichtbar sind.

Ich habe jetzt eine neue korrigierte Version meines Codes angehängt. 
Ausserdem habe ich jetzt das Software-PWM ergänzt. Es ist eine 
hoffentlich richtig angepasste Version des C-Software-PWM das hier 
http://www.mikrocontroller.net/articles/Soft-PWM erklärt wird.

Ich erwarte, grob überschlagen 3900 Interruptereignisse von meinen 
Encodern pro Sekunde bei maximaler Geschwindigkeit der Motoren. Reichen 
da für das Programm 8 MHZ Takt oder sollte ich eine schnellere 
Taktquelle anschließen.

/*#################################################################################################
 Name  : i2c controlled Motordriver for Lego NXT Motors
 Version  : 0.1 alpha
 autor  : Stefan Huber
 page  :
 License  : GNU General Public License


 //################################################################################################*/
/*Structur of i2c Communication
 * txbuffer    (readable by master)
 * txbuffer[0] Motor A speed in ticks/sec high byte
 * txbuffer[1] Motor A speed in ticks/sec low byte
 * txbuffer[2] Motor A position count high byte
 * txbuffer[3] Motor A position count low byte
 * txbuffer[4] Motor B speed in ticks/sec high byte
 * txbuffer[5] Motor B speed in ticks/sec low byte
 * txbuffer[6] Motor B position count high byte
 * txbuffer[7] Motor B position count low byte
 */

/* Pinning of Attiny 24
 * VCC     -> VCC
 * PB0    -> Clkin (Quarzoszillator) or n.c.
 * PB1    -> PWM_MOTOR_A0
 * PB2    -> PWM_MOTOR_A1
 * PB3    -> RESET -> PULLUP-Resistor -> VCC
 * PA7    -> TACHO_MOTOR_A0
 * PA6    -> i2c SDA / ISP MOSI
 * PA5    -> TACHO_MOTOR_A1 / ISP MISO
 * PA4    -> i2c SCL / ISP SCK
 * PA3    -> TACHO_MOTOR_B1
 * PA2    -> TACHO_MOTOR_B0
 * PA1    -> PWM_MOTOR_B0
 * PA0    -> PWM_MOTOR_B1
 * GND    -> GND
 */
//################### Pinning
#define DDR_PWM_MOTOR_A DDRB
#define DDR_PWM_MOTOR_B DDRA
#define DDR_TACHO DDRA

#define PORT_PWM_MOTOR_A PORTB
#define PORT_PWM_MOTOR_B PORTA
#define PIN_TACHO PINA

#define PWM_MOTOR_A0 1
#define PWM_MOTOR_A1 2
#define PWM_MOTOR_B0 1
#define PWM_MOTOR_B1 0
#define TACHO_MOTOR_A0 7
#define TACHO_MOTOR_A1 5
#define TACHO_MOTOR_B0 2
#define TACHO_MOTOR_B1 3

//Additional constants
#define TIMEBASE 1000 //1/1000 s or 1 ms is the timebase for all calculations
#include   <stdlib.h>
#include   <avr/io.h>
#include   <avr/interrupt.h>
#include   <avr/pgmspace.h>
#include   <util/delay.h>
#include <util/atomic.h>

//###################### USI-TWI-I2C
#include   "usiTwiSlave.h"         
#define   SLAVE_ADR_ATTINY_1       0b00110100    // i2c slave address
#ifndef   F_CPU
#define   F_CPU 8000000UL
#endif
//###################### Global Macros

#define LOW_BYTE(x)          (x & 0xff)          // 16Bit   --> 8Bit
#define HIGH_BYTE(x)         ((x >> 8) & 0xff)      // 16Bit   --> 8Bit
//###################### PWM configuration
#define F_PWM 50                       // PWM-Frequenz in Hz
#define PWM_STEPS 256                   // PWM-Schritte pro Zyklus(1..256)
// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
#if (T_PWM<(93+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif
//###################### Global variables
volatile uint8_t pwm_settings[4]; //stores speeds for pwm
volatile uint16_t tacho_A = 0; // stores tacho count for motor a
volatile uint16_t tacho_B = 0; // stores tacho count for motor a
volatile uint32_t akt_timebase = 0;
volatile uint16_t akt_tachoA = 0;
volatile uint16_t akt_tachoB = 0;
volatile uint32_t timebase = 0; //stores current time since reset


//Interrupt vector that handles tacho interrups
ISR(PCINT1_vect)
{
  uint8_t current;
  uint8_t masked;
  static  uint8_t prev = 0;
  static  uint8_t dir_A = 0;
  static  uint8_t dir_B = 0;

  current = PIN_TACHO;
  masked = current ^ prev; //Calculate xor to find out which pins have  changed

  if (masked & (1 << TACHO_MOTOR_A0)) //PIN TACHO_A0 triggers interrupt
  {
    if ((prev & (1 << TACHO_MOTOR_A0)) == 0) //only interested in rising edge (prev = 0; current = 1);
    {
      if (dir_A)
        tacho_A--;
      else
        tacho_A++;
    }
  } else if (masked & (1 << TACHO_MOTOR_A1))
    dir_A = !dir_A;

  if (masked & (1 < TACHO_MOTOR_B0)) //PIN TACHO_B0 triggers interrupt
  {
    if ((prev & (1 << TACHO_MOTOR_B0)) == 0) //only interested in rising edge (prev = 0; current = 1);
    {
      if (dir_B)
        tacho_B--;
      else
        tacho_B++;
    }
  } else if (masked & (1 << TACHO_MOTOR_B1))
    dir_B = !dir_B;

  prev = current;
}

//the ISR is called every millisecond
ISR(TIM0_COMPA_vect)
{
  timebase++;
}

ISR(TIM1_COMPA_vect)
{
  static uint8_t pwm_cnt = 0;

  OCR1A += (uint16_t) T_PWM;

  if(pwm_settings[0] > pwm_cnt)
    PORT_PWM_MOTOR_A |= (1<<PWM_MOTOR_A0);
  else
    PORT_PWM_MOTOR_A &= ~(1<<PWM_MOTOR_A0);

  if(pwm_settings[1] > pwm_cnt)
    PORT_PWM_MOTOR_A |= (1<<PWM_MOTOR_A1);
  else
    PORT_PWM_MOTOR_A &= ~(1<<PWM_MOTOR_A1);

  if(pwm_settings[2] > pwm_cnt)
    PORT_PWM_MOTOR_B |= (1<<PWM_MOTOR_B0);
  else
    PORT_PWM_MOTOR_B &= ~(1<<PWM_MOTOR_B0);

  if(pwm_settings[3] > pwm_cnt)
    PORT_PWM_MOTOR_B |= (1<<PWM_MOTOR_B1);
  else
    PORT_PWM_MOTOR_B &= ~(1<<PWM_MOTOR_B1);

  if (pwm_cnt == (uint8_t) (PWM_STEPS - 1))
    pwm_cnt = 0;
  else
    pwm_cnt++;
}

int main(void) {
  //Init I2C
  cli();
  //Set Motorports as outputs
  DDR_PWM_MOTOR_A |= (1 << PWM_MOTOR_A0) | (1 << PWM_MOTOR_A1);
  DDR_PWM_MOTOR_B |= (1 << PWM_MOTOR_B0) | (1 << PWM_MOTOR_B1);
  //Set Tachoports as inputs
  DDR_TACHO &= ~((1 << TACHO_MOTOR_A0) | (1 << TACHO_MOTOR_A1) | (1
      << TACHO_MOTOR_B0) | (1 << TACHO_MOTOR_B1));

  //Configure Interrupts for Tacho
  GIMSK = (1 << PCIE0); //Changes on PCINT 7:0 may cause interrupt
  PCMSK0 = (1 << TACHO_MOTOR_A0) | (1 << TACHO_MOTOR_A1) | (1
      << TACHO_MOTOR_B0) | (1 << TACHO_MOTOR_B1); //Enable Tachopins for Interrupt source


  //Configure Timer0 as time base for milliseconds
  TCCR0A = (1 << WGM01); //CTC Mode
  TCCR0B = (1 << CS01); //clock prescaler 8
  OCR0A = ((F_CPU / 8) / TIMEBASE) - 1; //-1 because interrupt is performed in the next cycle
  TIMSK0 |= (1 << OCIE0A); //Enable Compare interrupt

  //Configure Timer 1 for Software PWM
  TCCR1B |= (1 << WGM12); //CTC Mode
  TCCR1B |= (1 << CS10); //no prescaling
  TIMSK1 |= (1 << OCIE1A); //Activate Interrupt


  //Init TWI Slave
  usiTwiSlaveInit(SLAVE_ADR_ATTINY_1);
  sei();

  uint32_t prev_time = 0;
  uint16_t prev_tachoA = 0;
  uint16_t prev_tachoB = 0;


  uint16_t speed_A = 0;
  uint16_t speed_B = 0;

  uint16_t delta_time;

  for (;;) {
      ATOMIC_BLOCK(ATOMIC_FORCEON)
      {
        akt_timebase = timebase;
        akt_tachoA = tacho_A;
        akt_tachoB = tacho_B;
      }
    delta_time = (uint16_t) (akt_timebase - prev_time);
    prev_time = akt_timebase;

    if (delta_time > 0) //to prevent div by zero
    {
      speed_A = (akt_tachoA - prev_tachoA) * 1000 / delta_time;
      speed_B = (akt_tachoB - prev_tachoB) * 1000 / delta_time;
    }
    prev_tachoA = akt_tachoA;
    prev_tachoB = akt_tachoB;

    //Write everything into the txbuffer
    txbuffer[0] = HIGH_BYTE(speed_A);
    txbuffer[1] = LOW_BYTE(speed_A);
    txbuffer[2] = HIGH_BYTE(tacho_A);
    txbuffer[3] = LOW_BYTE(tacho_A);
    txbuffer[4] = HIGH_BYTE(speed_B);
    txbuffer[5] = LOW_BYTE(speed_B);
    txbuffer[6] = HIGH_BYTE(tacho_B);
    txbuffer[7] = LOW_BYTE(tacho_B);

    //Read speed settings rxbuffer -
    //TODO: change to access PID controller
    pwm_settings[0] = rxbuffer[0];
    pwm_settings[1] = rxbuffer[1];
    pwm_settings[2] = rxbuffer[2];
    pwm_settings[3] = rxbuffer[3];

  }

}

[Helfer (Gast)]

> Der Vollständigkeit halber muss ich aber anmerken das ich die drei
> akt_ Variablen wohl Global deklarieren muss damit innerhalb des
> Atomblocks sichtbar sind.

Musst du nicht.

[Helfer (Gast)]

> Ich erwarte, grob überschlagen 3900 Interruptereignisse von meinen
> Encodern pro Sekunde bei maximaler Geschwindigkeit der Motoren. Reichen
> da für das Programm 8 MHZ Takt oder sollte ich eine schnellere
> Taktquelle anschließen.

8000000/3900 = 2051 Takte zwischen den IRQs. Deine drei ISRs zusammen 
sehen nicht so mächtig aus. Kannst du aber im Simulator ausmessen.

[Stefan H. (stefan_h16)]

Helfer schrieb:
>> Der Vollständigkeit halber muss ich aber anmerken das ich die drei
>> akt_ Variablen wohl Global deklarieren muss damit innerhalb des
>> Atomblocks sichtbar sind.
>
> Musst du nicht.

Ja war mein Fehler, da haben sich andere Fehler im Quelltext zu einer 
missverstandenen Compilermeldung vermischt :)