IIR Besselfilter in Attiny85 - 32 Bit Berechnung möglich?

#include <avr/io.h>

#include <avr/interrupt.h>

#include <inttypes.h> 

//PB2: ADC1 ist der Eingang für die Fotodiode.

//PB0: ist der Ausgang für den Motor.

//PB4: PCINT4 ist der Steuerausgang für die Fotodioden-Beleuchtung

// Wenn der Motor dreht, ziehen abwechselnd schwarze und weiße Streifen an

// der Fotodiode vorbei. Bei sieben gezählten Streifen soll er wieder anhalten.

#define ANZAHL_STREIFEN 7

char schwarze_streifen; //Zähler für die schwarzen Streifen

char wirdsHeller; //wird es heller oder dunkler?

// Wenn der Motor steht, soll das Teil 5 Minuten Pause machen bis er wieder anfängt

// zu drehen.

#define PAUSENLAENGE 600 // halbe Sekunden

unsigned int pausenzeit; //zähler für die halben Sekunden

// generelle Statemachine im Hauptprogramm

#define WARTEN_AUF_MESSUNG  0

#define MESSEN_STARTEN  2

#define MESSEN_FERTIG  3

#define PAUSE_EINLAEUTEN 6

#define PAUSE 4

#define WEITERDREHEN 5

char cSREG;

//Filtervariablen

uint32_t mess_hilf, mess_0, mess_1, mess_2, mess_3, mess_4;

uint32_t ergebnis_4, ergebnis_3, ergebnis_2, ergebnis_1, ergebnis_0;

uint32_t A, B; // Filter zwischenergebnisse

char communication; //Statemachine Steuervariable

ISR(TIM1_COMPA_vect) // Timer 1 meldet einen OCR1A Vergleich

{

    cSREG = SREG;

    // Interrupt Code 

  if (communication == PAUSE)

  {

    pausenzeit = pausenzeit + 1;

    if (pausenzeit >= PAUSENLAENGE)

    {

      communication = WEITERDREHEN;

    }

  }

  else

  {

    communication = MESSEN_STARTEN; //Messintervall vorüber

  }

  SREG = cSREG;

  //TIFR = 0x7E;

  sei();

}

//Der ADC meldet sich hier, wenn die Messung fertig ist.

ISR (ADC_vect)

{

  communication = MESSEN_FERTIG;

  sei();

}

void adc_einstellen(void);

void messwert_filtern(void);

void timer1_einstellen(unsigned char); // umstellen von Pause zur Messen und andersherum

void motor_ein(void); // ein

void motor_aus(void); // aus

int main(void)

{

   // Initialisierungen: globale Variablen

  //Vor-Initialisierung, damit der Filter schneller auf Stand kommt

  ergebnis_4 = 32768;  

  ergebnis_3 = 32768;

  ergebnis_2 = 32768;

  ergebnis_1 = 32768;

  ergebnis_0 = 32768;

  //Statemachine initialisieren; mit "drehen" starten.

  communication = WEITERDREHEN;

  wirdsHeller = 2; //wird es heller oder dunkler?

  schwarze_streifen = 0; //wie viele Streifen sind am Sensor vorbeigezogen?

  pausenzeit = 0; //Aktuell verstrichene Pausenzeit

  // Initialisierungen: Clock, Ports, Timer, ADC, Interrupts

  // Clock

  // Der interne Takt ist eingestellt auf 8 MHz 

  // Watchdog deaktivieren

  //  WDTCR = 0x00;

  // Portpin

  DIDR0 = 0x00;

  MCUCR = 0x00; // Pull Up Widerstände aktivieren

  DDRB  = 0x3F; // Data Direction Register, vorerst komplett als Ausgang

  PORTB = 0x00; // Alle Pins auf Low

  //PINB      // Eingangsregister -> will ich nicht -> weggelassen

// nötige Peripherals einstellen

  timer1_einstellen(WEITERDREHEN); 

  adc_einstellen();

  pwm_einstellen();

// LED einstellen

  DDRB |= (1 << PB4); // Pin für LED auf "Ausgang" schalten

// Timer-Interrupts aktivieren

  TIMSK = 0x40; // Timer 1 OCR1A Compare Match Interrupt enabled

  SREG |= 0x80;

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

   while(1) { 

     // Statemachine              

    switch (communication)

    {

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

    case PAUSE: { 

    // Warte auf nächsten Zyklusstart; 

    // State wird im Interrupt verändert

      break;

    }

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

    case WEITERDREHEN: { // Start eines neuen Zyklus

      // Sensorbeleuchtung starten

      PORTB |= (1 << PB4); // LED für den Sensor einschalten

      // Timer 1 umstellen für Sensor Interrupts

      timer1_einstellen(WEITERDREHEN);

      // Motor starten

      motor_ein();

      // Messung starten

      communication = MESSEN_STARTEN;

      break;

    }

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

    case MESSEN_STARTEN: { //Messung starten

      ADCSRA |= (1<<ADSC); // ADSC auf 1 setzen startet den ADC

      communication = WARTEN_AUF_MESSUNG;

      break;

    }

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

    case WARTEN_AUF_MESSUNG: { 

    // Wartet auf nächstes Messwert-Timer-Intervall oder auf

    // die Fertigstellung der Messung. Beide States werden 

    // in den Interrupt Handlern gesetzt

      break;

    }

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

    case MESSEN_FERTIG: //Messwert fertig gemessen

    {

      mess_0 = ADCL; 

      mess_hilf = ADCH;

      mess_hilf = mess_hilf * 256;

      mess_0 = mess_0 + mess_hilf;

      messwert_filtern();

      if (ergebnis_0 > ergebnis_4)

      {

        wirdsHeller = wirdsHeller + 1;

        if (wirdsHeller == 4) //einige Male in Folge heller geworden?

        {  //-> Ein schwarzer Streifen ist vorbeigezogen. Zählen!

          schwarze_streifen = schwarze_streifen + 1;

        }

        if (wirdsHeller > 5)

        {

          wirdsHeller = 5;

        }

      }

      if (ergebnis_0 < ergebnis_4)

      {  // Es wird dunkler

        wirdsHeller = 0;

      }

      if (schwarze_streifen >= ANZAHL_STREIFEN)

      {

        communication = PAUSE_EINLAEUTEN;

      }

      else communication = WARTEN_AUF_MESSUNG;

      break;

    }

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

    case PAUSE_EINLAEUTEN:

    {

      // Motor stoppen

      motor_aus();

      // LED ausschalten

      PORTB &= ~(1 << PB4); // LED für den Sensor ausschalten

      // Pause machen bis zum nächsten Mal

      communication = PAUSE;

      // Timer 1 umstellen auf Pausenmodus

      timer1_einstellen(PAUSE);

      communication = PAUSE;

      break;

    }

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

    default : {

      communication = PAUSE_EINLAEUTEN;

      // Im Fehlerfall lieber den Motor stoppen und in sichere States gehen

      break;

      }

    }

  }                        

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

   return 0;    

}

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

Ausgelagerte ADC-Einstellen-Funktion für die Übersichtlichkeit

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

void adc_einstellen(void)

{

  /*

      #define ADMUX   _SFR_IO8(0x07)

      #define REFS1   7

      #define REFS0   6

      #define ADLAR   5

      #define REFS2   4

      #define MUX3    3

      #define MUX2    2

      #define MUX1    1

      #define MUX0    0

      */  

  ADMUX = 0xE1; //Interne 1.1V Referenz, ADLAR = 1 für linksbündige Ergebnisse, Pin PB2 (ADC1D) als ADC-Eingang

  /*

    ADCSRB

    Bit 7: Bei 1 wird bipolar gemessen. 0.

    Bit 5: Bei 1 wird der Eingang negativ gemessen. 0.

    Bits 2:0 : Auto Trigger Source. Brauche ich nicht, weil ADATE = 0 ist.

  */

  ADCSRB = 0x00;

  // ADC1 Pin als Eingang schalten

  DIDR0 |= (1<<ADC1D);   // Digital Input Disable Register;  Bit 5 auf 1, damit der AD-Pin nicht digital verwendet wird.

  DDRB  &= ~(1<<ADC1D); //Pin ADC1D als Eingang

  /* 

    ADCSRA

    Bit 7, ADEN: ADC Enable. Auf 1.

    Bit 6, ADSC: ADC Start Converstion. Auf 1 zum Initialisieren vom AD

    Bit 5, ADATE: ADC Auto trigger enable: Bei bestimmten Ereignissen automatisch starten. 0 für Aus.

    Bit 4, ADIF: ADC Interrupt Flag, wird automatisch beschrieben wenn der ADC fertig ist

    Bit 3, ADIE: ADC Interrupt Enable, auf 1 wenn ein Interrupt nach der Wandlung ausgeführt werden soll. 1.

    Bit 2:0, ADPS2:0, ADC Prescaler Bits für System Clock. 110 für 8MHz geteilt durch 64 = 125kHz

  */

  ADCSRA = 0xCE; //führt auch gleich die erste Konversion für die Initialisierung mit durch

}

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

Ausgelagerte Motor-Steuern-Funktion für die Übersichtlichkeit

Benötigt OCR0A als PWM Ausgang vor-eingestellt

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

void motor_ein(void)

{

  PORTB |= (1 << PB0); //Eins auf den Motorpin

}

void motor_aus(void)

{

  PORTB &= ~(1 << PB0);//Null auf den Motorpin

}

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

Ausgelagerte Pausentimer-Einstellen-Funktion für die Übersichtlichkeit

Der Pausentimer soll messen, wann die Pause vorbei ist.

Er soll außerdem den ADC Takt vorgeben wenn keine Pause ist.

Die Funktion soll nur aufgerufen werden um den Timer-Modus umzustellen!

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

void timer1_einstellen(unsigned char state)

{

  if (state == PAUSE)

  {

    GTCCR = 0x80; // Stoppen vom Timer via setzen von 1 im TSM Bit

    TCCR1 = 0x8F; // Clear on compare match mit OCR1C; Sysclock/16384 ist die Timer Clock (488 Hz)

    OCR1A = 0x0A; // 0x0A = 10; an dieser Zählmarke wird der OCR1A-Interrupt aktiviert.

    OCR1C = 244;  // Nach 244 Zählern wird der Timer rückgesetzt -> 2 Interrupts / sec

    GTCCR = 0x00; // kein PWM B, kein Output force, kein löschen von TCCR1, 0 ins TSM Bit -> restart

  }

  else

  {  

    GTCCR = 0x80; // Stoppen vom Timer via setzen von 1 im TSM Bit

    TCCR1 = 0x8A; // Clear on compare match mit OCR1C; Sysclock/512 ist die Timer Clock (15625 Hz)

    OCR1A = 0x0A; // 0x0A = 10; an dieser Zählmarke wird der OCR1A-Interrupt aktiviert.

    OCR1C = 31;   // Nach 31 Zählern wird der Timer rückgesetzt -> 504 Interrupts / sec

    GTCCR = 0x00; // kein PWM B, kein Output force, kein löschen von TCCR1, 0 ins TSM Bit -> restart

  }    

}

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

Messwerte filtern

Benötigt:

- 5 Ergebnisvariablen mit uint32_t

- 5 Messwertvariablen mit uint32_t

- Messwerte 16 Bit breit linksbündig (sorry)

- Abtastfrequenz 500Hz

- Filtervariablen 32 Bit breit

 Die Filterkoeffizienten wurden mit dem Excel aus dem Projektordner bestimmt.

 Es handelt sich um ein IIR Filter mit einer Grenzfrequenz von 12,5Hz

 und 4 Filterstufen nach Butterworth

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

void messwert_filtern(void)

{

  A =   12 * mess_0; //TAP 0

  A = A + 50 * mess_1; //TAP 1

  A = A + 75 * mess_2; //TAP 2

  A = A + 50 * mess_3; //TAP 3

  A = A + 12 * mess_4; //TAP 4

  A = A + 50; // Faktor entfernen I: die Hälfte vom Faktor drauflegen gegen Rundungsfehler

  A = (int)(A/100); //Faktor entfernen II: Teilen und abrunden

  B =   14359 * ergebnis_1; //TAP 1

  B = B - 19405 * ergebnis_2; //TAP 2

  B = B + 11696 * ergebnis_3; //TAP 3

  B = B - 2652  * ergebnis_4; //TAP 4

  ergebnis_0 = A + B + 2000;// Faktor entfernen I: die Hälfte vom Faktor drauflegen gegen Rundungsfehler

  ergebnis_0 = (int)(ergebnis_0 / 4000); //Faktor entfernen II: Teilen und abrunden

  //Messwerte durch die TAPs schieben

  mess_4 = mess_3;

  mess_3 = mess_2;

  mess_2 = mess_1;

  mess_1 = mess_0; //mess0 wird vom ADC gefüllt

  //Ergebnisse durch die TAPs schieben

  ergebnis_4 = ergebnis_3;

  ergebnis_3 = ergebnis_2;

  ergebnis_2 = ergebnis_1;

  ergebnis_1 = ergebnis_0; //ergebnis_0 wird weiter oben berechnet.

}

//Der ADC meldet sich hier, wenn die Messung fertig ist.

ISR (ADC_vect)

{

  communication = MESSEN_FERTIG;

  sei();

}