atmega8 COMPA und COMPB zugleich verwenden

/*

    Eine 8-kanalige PWM mit einfachem Lösungsansatz

    ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L                  // Systemtakt in Hz

#define F_PWM 100                       // PWM-Frequenz in Hz

#define PWM_STEPS_A 145                   // PWM-Schritte pro Zyklus(1..255)

#define PWM_STEPS_B 45                   // PWM-Schritte pro Zyklus(1..255)

#define PWM_PORT_D PORTD                  // Port für PWM

#define PWM_DDR_D DDRD                    // Datenrichtungsregister für PWM

#define PWM_PORT_C PORTC                  // Port für PWM

#define PWM_DDR_C DDRC                    // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM_A (F_CPU/(F_PWM*PWM_STEPS_A)) // Systemtakte pro PWM-Takt

#define T_PWM_B (F_CPU/(F_PWM*PWM_STEPS_B)) // Systemtakte pro PWM-Takt

#if (T_PWM_A<(152+5))

    #error T_PWM zu klein, F_CPU muss vergrössert werden oder F_PWM oder PWM_STEPS verkleinert werden

#endif

#if (T_PWM_B<(152+5))

    #error T_PWM zu klein, F_CPU muss vergrössert werden oder F_PWM oder PWM_STEPS verkleinert werden

#endif 

#if PWM_STEPS > 255

    #error PWM_STEPS zu gross

#endif

// includes

#include <stdint.h>

#include <string.h>

#include <avr/io.h>

#include <avr/interrupt.h>

// globale Variablen

volatile uint8_t pwm_setting_A[8];                    // Einstellungen für die einzelnen PWM-Kanäle

volatile uint8_t pwm_setting_B[8];                    // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {

    static uint8_t pwm_cnt=0;

    uint8_t tmp=0, i=0, j=1;

    OCR1A += (uint16_t)T_PWM_A;

    for (; i<8; i++) {    

      if (pwm_setting_A[i] > pwm_cnt) tmp |= j;

            j<<=1;

  }

    PWM_PORT_D = tmp;                         // PWMs aktualisieren

    if (pwm_cnt==(uint8_t)(PWM_STEPS_A-1))

        pwm_cnt=0;

    else

        pwm_cnt++;

}

ISR(TIMER1_COMPB_vect) 

{

    static uint8_t pwm_cnt=0;

    uint8_t tmp=0, i=0, j=1;

    OCR1B += (uint16_t)T_PWM_B;

    for (; i<8; i++) {    

      if (pwm_setting_B[i] > pwm_cnt) tmp |= j;

            j<<=1;

  }

    PWM_PORT_C = tmp;                         // PWMs aktualisieren

    if (pwm_cnt==(uint8_t)(PWM_STEPS_B-1))

        pwm_cnt=0;

    else

        pwm_cnt++;

}

int main(void) {

    // PWM einstellen

    PWM_DDR_D = 0xFF;         // Port als Ausgang

  PWM_DDR_C = 0xFF;         // Port als Ausgang

    // Timer 1 OCRA1, als variablem Timer nutzen

    TCCR1B = 1;             // Timer läuft mit vollem Systemtakt

    TIMSK |= (1<<OCIE1B) | (1<<OCIE1A);   // Interrupt freischalten

    sei();                  // Interrupts global einschalten

/*********************************************************************/

// nur zum Testen, im Anwendungsfall löschen

    volatile uint8_t tmp;

const uint8_t t1[8]={270, 400, 30, 1007, 150, 99, 5, 9};

const uint8_t t2[8]={270, 400, 30, 0, 150, 99, 5, 9};

const uint8_t t3[8]={270, 400, 30, 1007, 3, 99, 3, 0};

const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};

const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};

const uint8_t t6[8]={330, 330, 330, 3003, 33, 33, 33, 33};

// Messung der Interruptdauer

    tmp =0;

    tmp =0;

    tmp =0;

// Debug 

    memcpy(pwm_setting_A, t1, 8);

    memcpy(pwm_setting_A, t2, 8);

    memcpy(pwm_setting_A, t3, 8);

    memcpy(pwm_setting_A, t4, 8);

    memcpy(pwm_setting_A, t5, 8);

    memcpy(pwm_setting_A, t6, 8);

  memcpy(pwm_setting_B, t1, 8);

    memcpy(pwm_setting_B, t2, 8);

    memcpy(pwm_setting_B, t3, 8);

    memcpy(pwm_setting_B, t4, 8);

    memcpy(pwm_setting_B, t5, 8);

    memcpy(pwm_setting_B, t6, 8);

/*********************************************************************/

    while (1)

    {

    }

    return 0;

}