Einschaltverzögerung Bodenstrahler mit BM

/*

    Eine 8-kanalige PWM mit intelligentem Lösungsansatz

    ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU         12000000L          // Systemtakt in Hz

#define F_PWM         100L               // PWM-Frequenz in Hz

#define PWM_PRESCALER 8                  // Vorteiler für den Timer

#define PWM_STEPS     256                // PWM-Schritte pro Zyklus(1..256)

#define PWM_PORT_1    PORTD              // Port für PWM

#define PWM_DDR_1     DDRD               // Datenrichtungsregister für PWM

#define PWM_PORT_2    PORTC              // Port für PWM

#define PWM_DDR_2     DDRC               // Datenrichtungsregister für PWM

#define PWM_CHANNELS  11                 // Anzahl der PWM-Kanäle

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

//#define T_PWM 1   //TEST

#if ((T_PWM*PWM_PRESCALER)<(111+5))

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

#endif

#if ((T_PWM*PWM_STEPS)>65535)

    #error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.   

#endif

// includes

#include <stdint.h>

#include <string.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

// globale Variablen

uint16_t PINFreigabe = 0;

uint8_t DelayBetweenPINs = 50;          // verzögerung zwischen den ausgängen

uint16_t pwm_timing[PWM_CHANNELS+1];          // Zeitdifferenzen der PWM Werte

uint16_t pwm_timing_tmp[PWM_CHANNELS+1];      

uint16_t  pwm_mask[PWM_CHANNELS+1];            // Bitmaske für PWM Bits, welche gelöscht werden sollen

uint16_t  pwm_mask_tmp[PWM_CHANNELS+1];        // ändern uint16_t oder uint32_t für mehr Kanäle

uint8_t  pwm_setting[PWM_CHANNELS];           // Einstellungen für die einzelnen PWM-Kanäle

uint8_t  pwm_setting_tmp[PWM_CHANNELS+1];     // Einstellungen der PWM Werte, sortiert

                                              // ändern auf uint16_t für mehr als 8 Bit Auflösung  

volatile uint8_t pwm_cnt_max=1;               // Zählergrenze, Initialisierung mit 1 ist wichtig!

volatile uint8_t pwm_sync;                    // Update jetzt möglich

// Pointer für wechselseitigen Datenzugriff

uint16_t *isr_ptr_time  = pwm_timing;

uint16_t *main_ptr_time = pwm_timing_tmp;

uint16_t *isr_ptr_mask  = pwm_mask;              // Bitmasken fuer PWM-Kanäle

uint16_t *main_ptr_mask = pwm_mask_tmp;          // ändern uint16_t oder uint32_t für mehr Kanäle

// Zeiger austauschen

// das muss in einem Unterprogramm erfolgen,

// um eine Zwischenspeicherung durch den Compiler zu verhindern

void tausche_zeiger(void) {

    uint16_t *tmp_ptr16;

    uint16_t *tmp_ptr8;                          // ändern uint16_t oder uint32_t für mehr Kanäle

    tmp_ptr16 = isr_ptr_time;

    isr_ptr_time = main_ptr_time;

    main_ptr_time = tmp_ptr16;

    tmp_ptr8 = isr_ptr_mask;

    isr_ptr_mask = main_ptr_mask;

    main_ptr_mask = tmp_ptr8;

}

// PWM Update, berechnet aus den PWM Einstellungen

// die neuen Werte für die Interruptroutine

void pwm_update(void) {

    uint8_t i, j, k;

    uint16_t m1, m2, tmp_mask;                   // ändern uint16_t oder uint32_t für mehr Kanäle    

    uint8_t min, tmp_set;                       // ändern auf uint16_t für mehr als 8 Bit Auflösung

    // PWM Maske für Start berechnen

    // gleichzeitig die Bitmasken generieren und PWM Werte kopieren

    m1 = 1;

    m2 = 0;

    for(i=1; i<=(PWM_CHANNELS); i++) {

        main_ptr_mask[i]=~m1;                       // Maske zum Löschen der PWM Ausgänge

        pwm_setting_tmp[i] = pwm_setting[i-1];

        if (pwm_setting_tmp[i]!=0) m2 |= m1;        // Maske zum setzen der IOs am PWM Start

        m1 <<= 1;

    }

    main_ptr_mask[0]=m2;                            // PWM Start Daten 

    // PWM settings sortieren; Einfügesortieren

    for(i=1; i<=PWM_CHANNELS; i++) {

        min=PWM_STEPS-1;

        k=i;

        for(j=i; j<=PWM_CHANNELS; j++) {

            if (pwm_setting_tmp[j]<min) {

                k=j;                                // Index und PWM-setting merken

                min = pwm_setting_tmp[j];

            }

        }

        if (k!=i) {

            // ermitteltes Minimum mit aktueller Sortiertstelle tauschen

            tmp_set = pwm_setting_tmp[k];

            pwm_setting_tmp[k] = pwm_setting_tmp[i];

            pwm_setting_tmp[i] = tmp_set;

            tmp_mask = main_ptr_mask[k];

            main_ptr_mask[k] = main_ptr_mask[i];

            main_ptr_mask[i] = tmp_mask;

        }

    }

    // Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden

    k=PWM_CHANNELS;             // PWM_CHANNELS Datensätze

    i=1;                        // Startindex

    while(k>i) {

        while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0))  && (k>i) ) {

            // aufeinanderfolgende Werte sind gleich und können vereinigt werden

            // oder PWM Wert ist Null

            if (pwm_setting_tmp[i]!=0)

                main_ptr_mask[i+1] &= main_ptr_mask[i];        // Masken vereinigen

            // Datensatz entfernen,

            // Nachfolger alle eine Stufe hochschieben

            for(j=i; j<k; j++) {

                pwm_setting_tmp[j] = pwm_setting_tmp[j+1];

                main_ptr_mask[j] = main_ptr_mask[j+1];

            }

            k--;

        }

        i++;

    }

    // letzten Datensatz extra behandeln

    // Vergleich mit dem Nachfolger nicht möglich, nur löschen

    // gilt nur im Sonderfall, wenn alle Kanäle 0 sind

    if (pwm_setting_tmp[i]==0) k--;

    // Zeitdifferenzen berechnen

    if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind

        main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;

        main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;

        k=1;

    }

    else {

        i=k;

        main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);

        tmp_set=pwm_setting_tmp[i];

        i--;

        for (; i>0; i--) {

            main_ptr_time[i]=(uint16_t)T_PWM*(tmp_set-pwm_setting_tmp[i]);

            tmp_set=pwm_setting_tmp[i];

        }

        main_ptr_time[0]=(uint16_t)T_PWM*tmp_set;

    }

    // auf Sync warten

    pwm_sync=0;             // Sync wird im Interrupt gesetzt

    while(pwm_sync==0);

    // Zeiger tauschen

    cli();

    tausche_zeiger();

    pwm_cnt_max = k;

    sei();

}

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {

    static uint8_t pwm_cnt;        // ändern auf uint16_t für mehr als 8 Bit Auflösung

    uint16_t tmp;            // ändern uint16_t oder uint32_t für mehr Kanäle

    OCR1A += isr_ptr_time[pwm_cnt];

    tmp    = isr_ptr_mask[pwm_cnt];

    if (pwm_cnt == 0) {

    tmp &= PINFreigabe;

        PWM_PORT_1 = tmp;               // Ports setzen zu Begin der PWM

        PWM_PORT_2 = tmp >> 8;      // zusätzliche PWM-Ports hier setzen

        pwm_cnt++;

    }

    else {

    tmp &= PINFreigabe;

        PWM_PORT_1 &= tmp;              // Ports löschen

        PWM_PORT_2 &= tmp >> 8;      // zusätzliche PWM-Ports hier setzen

        if (pwm_cnt == pwm_cnt_max) {

            pwm_sync = 1;        // Update jetzt möglich

            pwm_cnt  = 0;

        }

        else pwm_cnt++;

    }

}

int main(void) {

  // Helligkeit für jeden PIN einstellen

  //                CN14 CN12 CN11 CN10 CN9  CN8  CN7  CN6  CN5  CN3  CN1

  uint8_t timing[PWM_CHANNELS]={243, 243, 244, 245, 246, 249, 249, 250, 253, 254, 255};

  uint8_t Anzahl = 9;

  uint8_t cnt;

  int i;

    // PWM Port einstellen

    PWM_DDR_1 = 0xFF;       // Port als Ausgang

    PWM_DDR_2 = 0x07;    // zusätzliche PWM-Ports hier setzen

  DDRB = 0x00;      // Port B als Input

  PORTB = 0x03;      // Pull Up auf PB0 und PB1 aktivieren

    // Timer 1 OCRA1, als variablen Timer nutzen

    TCCR1B = 2;             // Timer läuft mit Prescaler 8

    TIMSK1 |= (1<<OCIE1A);   // Interrupt freischalten

    sei();                  // Interrupts global einschalten

  // Abfrage ob 9 oder 11 Pins benutzt werden sollen

  if ((PINB & (1<<PINB1)) == 0)

    Anzahl = 11;

    memcpy(pwm_setting, timing, PWM_CHANNELS);

    pwm_update();

  // Abfrage in welche Richtung gezählt werden soll  

  if ((PINB & (1<<PINB0)) == 0)

  {

    for (i=0; i<Anzahl; i++)

    {

      PINFreigabe |= (1 << i);

      for (cnt=0;cnt<DelayBetweenPINs;cnt++)

      {

        _delay_ms(1);

      }

    }    

  }

  else

  {

    for (i=Anzahl-1; i>=0; i--)

    {

      PINFreigabe |= (1 << i);

      for (cnt=0;cnt<DelayBetweenPINs;cnt++)

      {

        _delay_ms(1);

      }      

    }    

  }

while(1);

}