Cosinus Bereichsanpassung

/************************LÜFTERSTEUERUNG*****************************

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

#include <avr/io.h>

#include <avr/interrupt.h>

//#include <util/delay.h>

#include "TrigonometrischeFunktionen.h"

/*****************************Variablen-Deklaration****************/

int ALPHA = 17900;

//int ALPHAnutz = 17900;

volatile int ALPHAnutz = 17900;

volatile int ausschaltsicherung = 0;

volatile int netzErkannt = 0;

volatile int drehrichtung = 0;

volatile int frequenz = 0;

int fallendeFlanke = 1; //W1

int steigendeFlanke =1;

volatile int zweiteHalbwelle = 0;

volatile int weiterZuenden = 0;

volatile int leitdauerErkennung = 0;

volatile int LAMBDA = 0;

int LAMBDAmess =0;

float u = 0;

const float uMin = 0;

const float uMax = 1024;

const float pi = 20000;

/****************************Funktionen-Deklaration****************/

void PortInit(void);

void Timer1Init(void);  //Zündverzögerung

void Timer3Init(void);  //Leitdauererfassung

void Timer4Init(void);  //Ermittlung der Periodendauer

void AdcInit(void);

void Init(void);

float Linearisierung(volatile int LAMBDA,  float u);

int ADC_Lesen (void);

/****************************Port W1 Initialisierung*****************/

void PortInit(void) {

  DDRD=0x00;  //Eingang LDE;NDG

  DDRC=0xFF;  //Ausgang W1-Zündung

  PORTC=0xFF; //Anfangszustand; lowactic

  DDRF=0x00;  //Eingang AD-Konverter

  DDRB=0xFF;  //Ausgang 

  PORTB=0x00;

}

/****************************TIMER1-Initialisierung*****************/

void Timer1Init(void)  //Zündverzögerung

{

  TCCR1B = 0x00;          //stop Timer

  TCCR1A = 0x00;          //normaler Modus = inkrementale Aufzählung

  TIMSK1 |= (1<<OCIE1A) | (1<<OCIE1B);// | (1<<OCIE1C); //Interrupts aktivieren für: compare Register A B C

  EIMSK |= (1<<INT0);        //aktiviere INT0

//  EICRA |= (1<<ISC01);       //INT0 reagiert auf fallende Flanke

  EICRA |= (0<<ISC01) | (1<<ISC00);       //INT0 reagiert auf fallende und steigende Flanke

  TCCR1B = 0x02;          //Vorteiler 8; start Timer1 bei 0

}

/****************************TIMER4-Initialisierung*****************/

void Timer4Init(void)  //Ermittlung der Periodendauer

{

  TCCR4B = 0x00;          //stop Timer

  TCCR4A = 0x00;          //normaler Modus = inkrementale Aufzählung

  TCCR4B = 0x02;          //Vorteiler 8; start Timer4 bei 0

  EICRA |= (1<<ISC11)| (1<<ISC10);      //Reagiert auf Steigende Flanke

  EIMSK |= (1<<INT1);

}

/****************************Hauptprogramm*****************/

int main() 

{

  int linearisierungsBeschraenkung = 20;

  cli();  //disable Interrupts

  Init();

  sei();  //alles initialisiert

      //enable Interrupts  

  while(1)

  {

    u = (((uMax - uMin) / (1023)) * (ADC_Lesen()) + uMin);

    if(linearisierungsBeschraenkung >= 20)    //alle 20 main-Durchläufe wird hier rein gesprungen

    {

      linearisierungsBeschraenkung = 0;

      ALPHA = Linearisierung(LAMBDA, u);// - 480;  //ACHTUNG! Dieser Korrekturfaktor ist nur für die ALTE Schaltung!

    }

    linearisierungsBeschraenkung++;  

  }

}    

/******************************EXTERNER Interrupt*****************/

/*Netzsynchronisierung*/

ISR (INT0_vect)        //NDG; 240us Verzögerung

{

  TCNT1=0;

  TCNT4=0;

  //OCR1A = ALPHA;

  steigendeFlanke=1;

  ALPHAnutz = ALPHA;

  OCR1A = ALPHAnutz;

}

ISR (INT1_vect)

{

  LAMBDAmess =TCNT4;

    if ((LAMBDAmess >=1000) && (LAMBDAmess <19000))

    {

      LAMBDA=LAMBDAmess;

    }

}

/******************************SOFTWARE Interrupts****************/

ISR (TIMER1_COMPA_vect)          //Zündung erste Halbwelle

{  

      PORTC &= ~(1<<PC0);    //T1 AN W1 Low Aktiv       

      OCR1B = ALPHAnutz + 400;  //ALPHAnutz + Zuendimpulsbreite;

}

ISR (TIMER1_COMPB_vect)          //Löschen aller gezündeten Pins

{

      PORTC |= (1<<PC0);    //T1 aus W1 Low Aktiv  

      //OCR1A = ALPHA;                           

} 

/****************************Funktionen************************/

/*Linearisierung*/

float Linearisierung(volatile int LAMBDA, volatile float u)  

{

  int result =0;  

  float Pi = 3.14159;

  float lambda =LAMBDA *0.009*Pi/180; //Takte in RAD

  float SINUSVonMinusLAMBDA = (-Sinus(LAMBDA));

  float relativ_u = u/uMax;

  float relativ_uQuadrat = relativ_u*relativ_u;

  float Term1 = relativ_uQuadrat*Pi;

  float Term2 = Term1-lambda;  

  float Term3 = SINUSVonMinusLAMBDA/10000; //der Wert aus der inustabelle muss durch 10.000 geteilt werden

  float Bruch = (Term2/Term3)*10000; //Argument für den Arccos //Arccosinus nimmt nur Takte entgegen

  float ArcCosinusVonBruch = 0;

  ArcCosinusVonBruch = (float)ArcCosinus((float)Bruch);

  float Term4 =ArcCosinusVonBruch/10000; //Von Takte in Radiant Zurückrechnen

  float Term5=2*Pi-Term4;

  float Term6 = Term5 - lambda;

  float Term7 = Term6/2; //ergebnis in Rad

  float Term8 = Term7*180/Pi;

  float Term9 = Term8*111.11; //Alpha in Takten

  float z = (Term9*2)+LAMBDA;//Sinus Argument

//Bereichsabfrage des Sinus Argumentes  

    if ((z)>1 & (z)<30000)

    {

      float Term_5=0;

      Term_5 = Pi+Term4;

      float Term_6 = 0;

      Term_6 =  Term_5 - lambda;

      float Term_7 = 0;

      Term_7= Term_6/2; //ergebnis in Rad

      float Term_8 = 0;

      Term_8=Term_7*180/Pi;

      float Term_9 = 0;

      Term_9=Term_8*111.11; //Alpha ;

      result = Term_9;

      return result;

    }

      else if ((z)>=30000 & (z) <=40000)

      {

      result = Term9;    

      return result;

      }

      else if ((z)>40000 & (z) <=50000)

        {

        float Term_52=0;

        Term_52 = 2*Pi+Term4;

        float Term_62 = 0;

        Term_62 =  Term_52 - lambda;

        float Term_72 = 0;

        Term_72= Term_62/2; //ergebnis in Rad

        float Term_82 = 0;

        Term_82=Term_72*180/Pi;

        float Term_92 = 0;

        Term_92=Term_82*111.11; //Alpha ;

        result = Term_92;

              return result;      

        }

}

/***************************************ADC W1**********************/

void AdcInit (void)

{

   ADMUX |= (0<<MUX0) | (0<<MUX1) | (0<<MUX2); //ADC0  

   ADMUX |= (1<<REFS0); //externe Referenzspannung nutzen 5 V

  ADCSRA |=(1<<ADEN); //ADC überhaupt zu aktivieren.

   ADMUX |= (0<< ADLAR);   // Die 8 bit kommen in das Low-Register 

  ADCSRA |=(1<<ADSC); //Messvorgang startet.

   ADCSRA |=(1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);//Vorteiler 128

}

int ADC_Lesen (void)

{

  ADCSRA |=(1<<ADEN);         //ADC aktivieren.

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

  while (ADCSRA & (1<<ADSC) );    // auf Abschluss der Konvertierung warten

  ADCSRA &= ~(1<<ADEN);        // ADC wieder deaktivieren

  return ADCW;

} 

//********************************INITIALISIERUNG*******************

void Init() 

{

  PortInit();

  Timer1Init();

//  Timer3Init();

  Timer4Init();

  PORTB |= (1<<PINB3);  //rote LED aus

  PORTB |=(1<<PINB3);  //rote LED aus

  AdcInit();

}