Cosinus Bereichsanpassung

[Tobias (Gast)]

Hallo Jungs,
ich habe ein kleines Problem und ich hoffe ihr könnt mir Helfen.
Also ich benutze eine Atmega 2561 von Atmel der einen Triac abhängig von 
einer Funktion Ansteuert. Soweit so gut.
Die Funktion habe ich durch diverse Test geprüft (Messungen, durch das 
gute alte Excel geprüft ect.)
In der Funktion kommt ein Cosinus bzw. ArcCosinus zum Einsatz, je nach 
dem wie groß das Argument des Cosinus wird, muss eine Bereichsanpassung 
für die ArcCosinus Funktion gemacht werden (2Pi +/- ArcCosinus). Und 
hier liegt mein Problem. Die Bereichsabfrage habe ich mit drei If 
schleifen durchgeführt, in meinem Testprogramm bekomme ich auch das 
Passende Ergebnis, nur im Realen Leben geht’s dann irgendwie doch nicht.
Vielleicht hat ja von Euch einer eine Idee.
Grüße Tobias

/************************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();
}

[Karl H. (kbuchegg)]

Was immer du da auch rechnest:
Wäre es nicht um 3 Wohnblöcke einfacher, ganz einfach mit dem ADC Wert 
in eine Tabelle zu gehen und sich dann von dort den auf dem PC 
vorgerechneten OCR Wert aus der Tabelle zu holen?

Da es sich um eine Lüftereteuerung handelt und ich mir ehrlich gesagt 
nicht wirklich vorstellen kann, dass es bei einem Lüfter sinnvoll ist 
bzw. unterscheidbar ist, ob der 256 'Schaltstufen' hat oder doch 1024, 
würde eine Tabelle mit 256 vorgerechneten Werten meines Erachtens 
komplett ausreichend sein.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Karl Heinz schrieb:
> Da es sich um eine Lüftereteuerung handelt

Wo liest du das raus? Ich les immer nur "Zündungen"

[Tobias (Gast)]

Es handelt sich nicht um eine Lüftersteuerung!
Die Platine auf der der mc Plaziert ist war aber mal für eine 
Lüftersteuerung gedacht. Jetzt hängt an der Platine ein Universalmotor

[Karl H. (kbuchegg)]

Michael Reinelt schrieb:
> Karl Heinz schrieb:
>> Da es sich um eine Lüftereteuerung handelt
>
> Wo liest du das raus? Ich les immer nur "Zündungen"

Kommentar im Code, ganz oben.
(ob der stimmt, weiß ich allerdings nicht)

[Michael R. (Firma: Brainit GmbH) (fisa)]

Karl Heinz schrieb:
>> Wo liest du das raus? Ich les immer nur "Zündungen"
>
> Kommentar im Code, ganz oben.
> (ob der stimmt, weiß ich allerdings nicht)

Meine Güte, ich blinde Nuß! Sogar beim zweiten Mal musste ich suchen...

Tobias schrieb:
> Jetzt hängt an der Platine ein Universalmotor

Und der wird gezündet? ich versteh nämlich den Mörder-Aufwand den du 
hier treibst, überhaupt nciht...

[Karl H. (kbuchegg)]

Michael Reinelt schrieb:

> Und der wird gezündet? ich versteh nämlich den Mörder-Aufwand den du
> hier treibst, überhaupt nciht...

Da bist du nicht alleine.

[Tobias (Gast)]

also Sinn des ganzen ist, dass die Ausgangsspannung bei belastung recht 
konstant bleibt.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Tobias schrieb:
> also Sinn des ganzen ist, dass die Ausgangsspannung bei belastung recht
> konstant bleibt.

ich hab zwar mittlerweile das Zünden verstanden (Triac), aber welche 
Ausgangsspannung?

Vielleicht wäre es hilfreich, wenn du mal einen Schritt zurückmachst, 
und beschreibst was du überhaupt machen willst.

[Tobias (Gast)]

Funktionieren soll das ganze so,
man habe z.B. einen Universalmotor (Bohrmaschine ect.) diese wird 
belastet. Bei Belastung geht der Universalmotor in die Knie man müsste 
mehr Gas geben. Das Gasgeben wird quasie durch die Formel ersetzt und 
die Ausgangsspannung bricht nicht mehr ein.
Der Vorteil wird dan sein, das die Anwendung eine deutlich bessere 
Dynamik hat.
In der Formel ist ein Cosinus bzw. ArcCosinus. Es ist also notwendig zu 
wissen in welchem Bereich sich das Argument des Cosinus befindet z.B. 
zwischen 270°-360°. Abhängig von dem Bereich muss die Formel etwas 
abgeändert werden (2Pi +/- ArcCosinus)
Und hier ist mein Probelm, die Bereiche frage ich mit den if/else if 
Bedingungen ab und da kommt der uc in's Straucheln

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;
        }

[Michael R. (Firma: Brainit GmbH) (fisa)]

Tobias schrieb:
> man habe z.B. einen Universalmotor (Bohrmaschine ect.) diese wird
> belastet. Bei Belastung geht der Universalmotor in die Knie man müsste
> mehr Gas geben. Das Gasgeben wird quasie durch die Formel ersetzt und
> die Ausgangsspannung bricht nicht mehr ein.

Erstmal würde ich davon ausgehen, dass bei einem 230V-Motor keine 
Spannung einbricht, dafür ist der Innenwiderstand des Netzes viel zu 
gering. Die Abnahme der Drehzahl hat andere Ursachen.

Was nimmt denn deine Formel als Input? Wie erkennst du die Belastung?

[Tobias (Gast)]

Also als Anwendung dient ein "Nackter" Motor.
Als Input bekommt die Formel die Leitdauer (wie lange liegt Strom am 
Triac) und das verhältnis von eingangsspannung und ausgangsspannung, das 
sich ind er Variable "u" niederschlägt, welches über die momentane 
stellung des Potis zur verfügung steht

[Tobias (Gast)]

Bie größerer Belastung wird die Leitdauer entsprechend länger

[Michael R. (Firma: Brainit GmbH) (fisa)]

Sorry, aber das ist alles etwas konfus...

ich geh mal davon aus du arbeitst mit 230V Wechselspannung, und machst 
mit dem Triac eine Phasenanschnitt-Steuerung.

Hier von "Spannungen" zu sprechen ist mMn etwas verwirrend...

Die "Leitdauer" wird bei belastung eher nicht länger, weil der Triac im 
Nulldurchgang verlöscht. Außer du machst sie länger, indem du früher 
zündest.

Das Poti steuert sowas wie die Soll-Drehzahl, oder?

Also woher erfährst du die momentane Belastung?

[Tobias (Gast)]

ja ist etwas schwierig zu erklären.
 ja 230V Stimmt.

nein der Triac bleibt bei belastung länger leitend, bis max zum 
Nulldurchgang aber der variirt zwischen quasie 0ms und 8ms.(Es wird jede 
Sinushalbwelle für sich betrachtet)
Die entsprechende länge der leitdauer steht dem uc in Takten zur 
Verfügung (Timer 4)

Es handelt sich nicht um eine Phasenanschnitt-Steuerung, das Poti gibt 
an wie viel der Netzspannung (Eingangsspannung) zur verfügung stehen 
soll. Dieser wert ist zwischen 0->1 1 bedeutet 230V

[spess53 (Gast)]

Hi

>nein der Triac bleibt bei belastung länger leitend, bis max zum
>Nulldurchgang

Wie schaltest du den TRiac ab?

MfG Spess

[Tobias (Gast)]

der Triac geht aus, wenn der Strom am Triac 0 wird. Denn kann man nicht 
selber ausschalten

[Michael R. (Firma: Brainit GmbH) (fisa)]

Jetzt verstehe ich wo du hin willst: du versuchst das Unterschreiten des 
Haltstroms schon vor dem nulldurchgang zu verwenden, um die Belastung zu 
erkennen.

ich fürchte nur, das wird bei induktiven lasten (und dein motor ist eine 
induktive last, sogar eine ekelhafte) nicht verläßlich funktionieren.

Außerdem dokterst du offensichtlich schon länger dran rum: 
Beitrag "AVR: Komischer Fehler nach dem Ein- / und Ausschalten"

> Und hier ist mein Probelm, die Bereiche frage ich mit den if/else if
> Bedingungen ab und da kommt der uc in's Straucheln

nein, das glaub ich nicht. DU kommst aufgrund mangelnder C-Erfahrung ins 
straucheln.

Ehrlich, dein Code ist so "eigenartig", da mag ich mich wirklich nicht 
reinlesen. ich glaub da hat sogar schon Karl-Heinz aufgegeben...

Formulier deine Berechnung mal mathematisch sauber (ohne C) und 
beschreibe sie so, dass ein Außernstehender das auch kapieren kann. Dann 
können wir dir vielleicht helfen, das in sauberes C zu übersetzen.

[Tobias (Gast)]

heheh
ja ich sitze da schon eine weile dran ;)
Formel in Mathematischer Form kommt morgen.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Was du vielleicht noch überdenken solltest: Vermutlich detektierst du 
den Nulldurchgang der Spannung. Der Triac (und der Motor) 
interessieren sich aber kaum für Spannungen, für die sind Ströme 
relevant. Und jetzt kommt wieder die ekelhafte induktive Last ins Spiel, 
die dir da eine Phasenverschiebung reinbringt. Vermutlich solltest du 
auch den Nulldurchgang des Stroms detektieren.

Außerdem zweifle ich deine 8msec von oben an. ich behaupte das können 
maximal 4msec sein.

Und zuallerletzt hoffe ich, dass du da sauber galvanisch getrennt 
arbeitst. Da ist doch mindestens ein Optokoppler drin, oder?

[Tobias (Gast)]

Eine etwas verspätete Antwort.
Hier ist die Formel, (falls es noch jemanden interessiert)

An  Michael,
ja klar es ist ein Optokoppler zur Galvanischen Trennung in meiner 
Schaltung enthalten.

Der Strom wird auch über eine Leitdauererfassung gemessen.
Das Läuft vom Ablauf her so, dass der Timer der im Nulldurchgang der 
Netzspannung anfängt zu zählen, bis eine Steigende Flanke (der 
Leitdauererfassung) anliegt, die Differenz ist dann die Leitdauer.

Das geht zwar, aber es geht ein Teil der Leitdauer verloren (die 
Phasenverschiebung). Besser währe wenn der Timer Quasi bei der Fallenden 
Flanke (der Leitdauererfassung) losrennen würde bis die steigende Flanke 
(der Leitdauererfassung) erkannt wird, also unabhängig von der 
Netzspannung.

Warum habe ich das so gemacht.
Es ist ja möglich auf die Fallende und die steigende Flanke zu 
reagieren, aber dann kommt das Programm immer durcheinander. Mann misst 
dann immer von der Fallenden bis zur Steigenden und dann wieder bis zur 
Fallenden Flanke.

[Georg G. (df2au)]

Tobias schrieb:
> if ((z)>1 & (z)<30000)

meinst du vielleicht if ((z < 1) && (z < 30000)) ?

[Tobias (Gast)]

ich "meinte" größer als 1 und kleiner als 30.000 ob mit einem & oder && 
beides ausprobiert aber keinen unterschied festgestellt.

[DomeG (Gast)]

Tobias schrieb:
> ich "meinte" größer als 1 und kleiner als 30.000
Ich denke das war ein Tippfehler
> ob mit einem & oder && beides ausprobiert aber keinen unterschied festgestellt.
Einzig && ist hier sinnvoll ;-)

also

if (z>1 && z<30000)

Gruß