AVR: Komischer Fehler nach dem Ein- / und Ausschalten

[Tobias (Gast)]

Hallo zusammen,

ich habe ein Problem, das ich mir so langsam gar nicht mehr Erklären 
kann. Also ich verwende einen Mikrocontroller der Familie ATmega 2561, 
der eine Linearisierungsfunktion für ein W1 Stellglied berechnet. Soweit 
so gut, er macht „eigentlich“ was er soll.
Mein Problem ist, das es gelegentlich zu Fehlern kommt.

Beispiel: alles Funktioniert, Spannungsversorgung wird abgeschaltet und 
nach einer Zeit wieder eingeschaltet und siehe da, der Mikrocontroller 
berechnet die Funktion falsch. Nach einem hin und her aus Aus-/ und 
Einschalten geht’s dann wieder, wie durch Zauberhand.
Hat jemand schonmahl Ähnliche Probleme gehabt?

Viele Grüße und schonmahl Danke im Voraus für Anregungen und Tipps
Tobias

[Karl H. (kbuchegg)]

> und siehe da, der Mikrocontroller berechnet die Funktion falsch.
> Nach einem hin und her aus Aus-/ und Einschalten geht’s dann wieder,
> wie durch Zauberhand.

Klingt nach nicht initialisierten Variablen, die mit zufälligen Werten 
lostraben. Ein paar mal ist der Zufall dann eben auch gerade richtig, so 
dass sich das Problem von selbst regelt. Ein ander mal dann eben wieder 
nicht.

[Tobias (Gast)]

Hallo Karl Heinz,
besten Dank für den Tipp. Ich hatte in meiner Funktion Variablen gleich 
mit einem Ergebniss Initialisiert.
z.B. float Bruch = a / b;

jetzt habe ich das so gemacht

float Bruch = 0;
Bruch = a/b;

Es hat denn anschein, als würde es jetzt besser laufen :-)

grüße Tobias

[Karl H. (kbuchegg)]

Zeig mal. Das ist entweder unlogisch oder ein schwerer Compilerfehler.

[Tobias (Gast)]

tja so ganz wars das wohl doch nicht....jetzt ist der fehler wieder da

hier ist der quellcode

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


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

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "TrigonometrischeFunktionen.h"



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

int ALPHA = 17900;
volatile int ALPHAnutz = 17900;

volatile int gezuendet_A = 0;
volatile int gezuendet_B = 0;
volatile int ausschaltsicherung = 0;
volatile int netzErkannt = 0;
volatile int drehrichtung = 0;
volatile int frequenz = 0;

volatile int fallendeFlanke = 1; //W1
volatile int zweiteHalbwelle = 0;
volatile int weiterZuenden = 0;
volatile int leitdauerErkennung = 0;

volatile int LAMBDA = 0;

float u = 0;
const float uMin = 1;
const float uMax = 1023;
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);
int ADC_Lesen(void);

int Linearisierung(volatile int LAMBDA, volatile float u);


/****************************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

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

/****************************TIMER3-Initialisierung*****************/

void Timer3Init(void)  //Leitdauererfassung
{
  TCCR3B = 0x00;          //stop Timer
  TCCR3A = 0x00;          //normaler Modus = inkrementale Aufzählung

  EIMSK |= (1<<INT1);        //aktiviere INT1
  EICRA |= (1<<ISC10);       //INT1 reagiert auf fallende und steigende Flanke

  TCCR3B = 0x02;          //Vorteiler 8; start Timer3 bei 0
}



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

/*Netzsynchronisierung*/
ISR (INT0_vect)        //NDG; 240us Verzögerung
{
  leitdauerErkennung = 1;
  

  TCNT1 = 0;
  ALPHAnutz = ALPHA;
  OCR1A = ALPHAnutz;
  gezuendet_A=1;
  gezuendet_B=0;

  
}


ISR (INT1_vect)        //Leitdauer; 304us Verzögerung
{

    static int LAMBDAmess = 4000;

      if(fallendeFlanke)
      {
        fallendeFlanke = 0;
        TCNT3 = 0;
      }
        else //(fallendeFlanke) 
        {
          fallendeFlanke = 1;
          LAMBDAmess=TCNT3;
        }

          if(LAMBDAmess >= 1000)      //mindestens >= 1000 um den fehlerhaften Zündimpuls nicht zu berücksichtigen!!!
          {
            LAMBDA = LAMBDAmess;
          }
      
}

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

/*Timer1 Zünden des Thyristorsn*/
ISR (TIMER1_COMPA_vect)          //Zündung erste Halbwelle
{

  if (gezuendet_A=1)
  {      
    
      PORTC &= ~(1<<PC0);    //T1 AN W1 Low Aktiv 
      OCR1B = ALPHAnutz + 400;  //ALPHAnutz + LAMBDA;

      zweiteHalbwelle = 1;
      weiterZuenden = 1;

  }
}

ISR (TIMER1_COMPB_vect)          //Löschen aller gezündeten Pins
{
  if(gezuendet_A=1)
  {
    if(weiterZuenden)
    {

      PORTC |= (1<<PC0);    //T1 aus W1 Low Aktiv
      gezuendet_A=0;
      gezuendet_B=1;
        
    
      if(zweiteHalbwelle)
      {
        //gezuendet=1;
        zweiteHalbwelle = 0;
        OCR1C = ALPHAnutz + 20000;
      }
      else
      {
        gezuendet_A=0;
        weiterZuenden = 0;
      }
    }
  }                    
}
ISR (TIMER1_COMPC_vect)          //Zündung zweite Halbwelle
{
  
  if(gezuendet_B=1)
  {
    if(weiterZuenden)
    {

          PORTC &= ~(1<<PINC0);    //T1 an W1 Low Aktiv
        
          OCR1B = ALPHAnutz + 20400;

          gezuendet_B=0;
          gezuendet_A=1;
    }

  }

}  

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

/*Linearisierung*/
int Linearisierung(volatile int LAMBDA, volatile float u)  
{
int bruch = 0;
int zaehler =0;
int nenner = 0;
int result = 0;
float K = 0;
float Ua = 0;
int Ul = 0;
int Pi = 20000;
float UaDurchUl = 0;
float UaDurchUlQuadrat =0;
int UaDurchUlQuadratMalPi = 0;

int  sinusVonLambda = 0;

int arcCosVonBruch = 0;

int arcCosVonBruchInTakte = 0;
int arcCosVonBruchInTakteminusLAMBDA = 0;

K = 1023/230;
Ua = u/K; 
Ul = 230;
UaDurchUl = Ua/Ul;
UaDurchUlQuadrat = UaDurchUl*UaDurchUl;
UaDurchUlQuadratMalPi = UaDurchUlQuadrat*Pi;



 zaehler = (UaDurchUlQuadratMalPi) - LAMBDA;
 nenner = (-(float)sinusVonLambda);

 bruch = zaehler / nenner;


arcCosVonBruch = ((float)ArcCosinus(bruch)/10000);

arcCosVonBruchInTakte = (float)ArcCosinus(bruch)/10000*(180/3.14/0.009) ;

arcCosVonBruchInTakteminusLAMBDA = arcCosVonBruchInTakte - LAMBDA;
  
result =13000 - (arcCosVonBruchInTakteminusLAMBDA /2);


if(result > 17900)      //maximaler ALPHA = 161,1° (17900 Takte)
  {
    result = 17900;
  }

  if(result < 5000)      //minimaler ALPHA = 58,5° (6500 Takte)
  {
    result = 5000;
  } 


  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;                  // ADC auslesen und zurückgeben
}




//********************************INITIALISIERUNG*******************
void Init() {
  
  PortInit();

  Timer1Init();
  Timer3Init();
  PORTB |= (1<<PINB3);  //rote LED aus
  PORTB |=(1<<PINB3);  //rote LED aus
  AdcInit();
}


//*****************************HAUPT-PROGRAMM********************/
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);//+13000;// - 480;  //ACHTUNG! Dieser Korrekturfaktor ist nur für die ALTE Schaltung!
    }
    
    linearisierungsBeschraenkung++;  
  }    
}

[Karl H. (kbuchegg)]

if(gezuendet_A=1)

sieht schon mal seltsam aus.
Beim gcc gibt es doch da eine Warnung! Hast du dir ignoriert?

Ditto:
  if(gezuendet_B=1)

[Karl H. (kbuchegg)]

Dir ist klar, dass hier

K = 1023/230;

das >Ergebnis NICHT 4.447 lautet, selbst wenn K ein float ist?

[Tobias (Gast)]

hallo karl Heinz,

ähmm ist mir nicht klar. warum sollte den 1023/230 nicht 4.447 sein?

[Karl H. (kbuchegg)]

Kann mal jemand meine Mathe kontrollieren?

Im Code steht

K = 1023/230;
Ua = u/K; 
Ul = 230;
UaDurchUl = Ua/Ul;

da wird ziemlich viel rumgerechnet. Aber was wird (sollte) eigentlich 
gerechnet werden.

Da steht

  UaDurchUL = Ua / Ul

Ul einsetzen

  UaDurchUL = Ua / 230

Ua einsetzen

  UaDurchUl = ( u / k ) / 230

Auf Doppelbruch erweitern

  UaDurchUl = ( u / k ) / ( 230 / 1 )

Doppelbruch auflösen

  UaDurchUL = u / ( k * 230 )

k einsetzen

  UaDurchUL = u / ( 1023 / 230 * 230 )

kürzen

  UaDurchUL = u / 1023


Da wird als eine Menge rumgerechnet, nur um u durch 1023 zu dividieren. 
Bei jeder Floating Point Operation hat man aber entsprechende Rundungs 
bzw. Darstellungsfehler. Die 'einfachere Version'

 UaDurchUL = u / 1023.0;

ist also nicht nur schneller, sondern auch höchst wahrscheinlich näher 
an der Wahrheit.

[Karl H. (kbuchegg)]

Tobias schrieb:
> hallo karl Heinz,
>
> ähmm ist mir nicht klar.


Was mir nicht klar ist: Wwarum du das nicht weißt, wie sich die Sache 
mit den Datentypen in C (bzw. in den meisten Programmiersprachen) 
verhält?

> warum sollte den 1023/230 nicht 4.447 sein?

weil 1023 ein int ist und 230 ein int ist.
Damit ist das eine Integer Division. Und die erzeugt nun mal keine 
Nachkommastellen.

Das du das Divisionsergebnis einem float zuweist, ist zwar nett, aber 
völlig irrelevant. Entscheidend sind die Datentypen der beteilgten 
Operanden. Und die sind nun mal beide int.

[Peter II (Gast)]

Karl Heinz schrieb:
> Kann mal jemand meine Mathe kontrollieren?
>
> Im Code steht
>

> K = 1023/230;
> Ua = u/K;
> Ul = 230;
> UaDurchUl = Ua/Ul;
>

sollte man nicht erst mal die 1023 in frage stellen? Ein 1024 ist doch 
viel schöner

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Das verwirrt mich ein wenig:

      if(fallendeFlanke)
      {
        fallendeFlanke = 0;
        TCNT3 = 0;
      }
        else //(fallendeFlanke) 
        {
          fallendeFlanke = 1;

Seltsamer Name, der sich selber nicht verdient.

Ich vermute übrigens, dass du genau an dieser Stelle ein Problem mit der 
Flankenerkennung hast. Denn dich interessiert das, was tatsächlich am 
Pin ist keinen Deut, sondern du fabulierst dir selber eine Flanke her...

Was, wenn nach dem Einschalten der Eingangspin nicht den Pegel hat, 
den deine Software erwartet?

[Tobias (Gast)]

Also bis jetzt hat das alles keinen großen Einfluss. Abgesehen das die 
Version von

UaDurchUL = u / 1023

natürlich die weitaus schönere ist.

[Tobias (Gast)]

Hallo  Lothar,

das kommt daher, das ich um meine Funktion durchführen zu können, die 
Leitdauer an meinem Triac messen muss. Da die Leitdauererfassung aber 
immer im Nulldurchgang der Wechselspannung eine kurze Leitdauer misst, 
obwohl keine vorhanden ist, habe ich das so abgestellt.

[Tobias (Gast)]

Was halt komisch ist, ist das ich ein anderes Verhalten habe, wenn ich 
im Betrieb den Programmer rausziehe oder reinstecke, das hat doch 
eigentlich nichts mit der Funktion zu tun, oder?

[Karl H. (kbuchegg)]

Tobias schrieb:
> Also bis jetzt hat das alles keinen großen Einfluss.

Noch sind wir ja nicht fertig.
Bis jetzt hat mich ja die Logik noch überhaupt nicht interessiert, 
sondern ich such erst mal den Code nach formalen Dingen ab, die seltsam 
aussehen und mehr verwirren, als sie zum Verständnis des Codes 
beitragen. Zb das hier

ISR (TIMER1_COMPB_vect)          //Löschen aller gezündeten Pins
{
  if(gezuendet_A=1)
  {
    if(weiterZuenden)
    {

      PORTC |= (1<<PC0);    //T1 aus W1 Low Aktiv
      gezuendet_A=0;
      gezuendet_B=1;
        
    
      if(zweiteHalbwelle)
      {
        //gezuendet=1;
        zweiteHalbwelle = 0;
        OCR1C = ALPHAnutz + 20000;
      }
      else
      {
        gezuendet_A=0;
        weiterZuenden = 0;
      }
    }
  }                    
}

nach der Erkennung von weiterZuenden wird gezuendet_A auf jeden Fall 
erst mal auf 0 gesetzt. D.h. das innere if suggeriert hier

      if(zweiteHalbwelle)
      {
        //gezuendet=1;
        zweiteHalbwelle = 0;
        OCR1C = ALPHAnutz + 20000;
      }
      else
      {
        gezuendet_A=0;
        weiterZuenden = 0;
      }

dass dies nur im Falle einer zweiten Halbwelle der Fall wäre. 
Tatsächlich stimmt das aber gar nicht. gezuendet_A ist auf jeden Fall 0, 
egal wie dieser if ausgeht. Betrachtet man nur das if, kommt man also zu 
falschen Schlussfolgerungen, bzw. in weiterem Kontext dann eben zu: was 
stimmt denn jetzt eigentlich? Immer 0, oder nur im Falle 
zweiteHalbwelle.

Das sind so die Dinge, die einem bei rein formaler Durchsicht schon mal 
auffallen. Genauso wie du für meinen Geschmack im Programm da ein wenig 
sehr freizügig rumrechnest. Hast du die Funktion 'Linearisierung' schon 
mal in einem PC Programm getestet, indem du sie systematisch in einer 
Schleife mit variierenden Werten durchgejagt und das Ergebnis 
kontrolliert hast?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Tobias schrieb:
> habe ich das so abgestellt.
Die Flankenerkennung funktioniert nicht, wenn du nicht mit der 
Aussenschaltung garantiert immmer mit dem selben Pegel am Pin beginnst.

Nur mal angenommen, du erwartest zuerst ein "low" am Eingang, der ist 
aber gerade "high": dann erkennst du immer dort eine fallende Flanke, wo 
in der Realität eine steigende Flanke ist...

> Was halt komisch ist, ist das ich ein anderes Verhalten habe, wenn ich
> im Betrieb den Programmer rausziehe oder reinstecke, das hat doch
> eigentlich nichts mit der Funktion zu tun, oder?
Hast du zusätzlich noch EMV-Sauereien auf dem Interrupt-Pin?

[Joachim D. (Firma: JDCC) (scheppertreiber)]

if(gezuendet_A=1)

ist eigentlich immer wahr. Sicher, daß nicht if(gezuendet_A == 1)
gemint ist ? Das wäre ein Vergleich ...

[Karl H. (kbuchegg)]

Tobias schrieb:
> Hallo  Lothar,
>
> das kommt daher, das ich um meine Funktion durchführen zu können, die
> Leitdauer an meinem Triac messen muss. Da die Leitdauererfassung aber
> immer im Nulldurchgang der Wechselspannung eine kurze Leitdauer misst,
> obwohl keine vorhanden ist, habe ich das so abgestellt.

Dann ist aber 'fallendeFlanke' ein ganz schlechter Name.
Der suggeriert nämlich etwas, was offensichtlich nicht stimmt bzw. auch 
gar nicht erwartet war.

Sieht trotzdem seltsam aus, der ganze Interrupt. Offenbar wird da 
abwechselnd TCNT auf 0 gesetzt bzw. der TCNT geholt. Da wird also was 
ausgemessen.
Der Interrupt ist eingestellt auf

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

ergo, wird die Zeitdauer von einer fallenden Flanke zur nächsten 
ausgemessen, aber nur bei jedem 2.ten mal.

Was das mit deiner Erklärung über die Leitdauer zu tun hat, ist mir 
allerdings nicht klar. Eine irgendwie erkennbare Erkennung eines 
'Fehlerzustands' (Zitat: "obwohl keine vorhanden ist") kann ich keine 
erkennen. Da wird sich halt drauf verlassen, dass der jeweils erste 
Interrupt schon passen wird.

[Tobias (Gast)]

Ok, also da das mit dem if(gezuendet_A=1) habe ich rausgeschmissen.
Funktion funktioniert immer noch. Mittlerweile auch so, dass ich 
Spannung An- und Aus machen kann und es geht dann auch immer noch

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Der Interrupt ist eingestellt auf
>

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

Ach entschuldigung. Das ist ja gar nicht der INT0, über dessen ISR wir 
reden.
Dessen initialisierung ist ja hier

  EIMSK |= (1<<INT1);        //aktiviere INT1
  EICRA |= (1<<ISC10);       //INT1 reagiert auf fallende und steigende Flanke

ok. Selbes Problem - wie von Lothar schon angemerkt. Da wird drauf 
vertraut, dass die erste Flanke, die einen Interrupt auslöst, schon eine 
fallende sein wird.
GUt.
Aber: was wenn dem nicht so ist?

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Ach entschuldigung.

Übrigens:
Das ist besonders schlau, die Initialisierung der externen Interrupts in 
2 getrennte Funktionen zu stecken, die dann auch noch "TimerxInit" 
heißen.

[Karl H. (kbuchegg)]

Tobias schrieb:
> Ok, also da das mit dem if(gezuendet_A=1) habe ich rausgeschmissen.

Na wenn das mal gut geht.

Da war offenbar eine Verriegelung der einzelnen Compare Interrupts 
vorgesehen, so dass der ganze COmpare-Interrupt Tanz nur dann zu 
Veränderungen am Pin führt, wenn hier

ISR (INT0_vect)        //NDG; 240us Verzögerung
{
  leitdauerErkennung = 1;
  

  TCNT1 = 0;
  ALPHAnutz = ALPHA;
  OCR1A = ALPHAnutz;
  gezuendet_A=1;
  gezuendet_B=0;

  
}

der ganze Vorgang angestossen wird. Sprich: bleiben die INT0 Interrupts 
aus, dann laufen die Compare-Interrupts ins Leere und der Pin PC0 wird 
nicht mehr angesteuert.

Ist dieses Verhalten jetzt noch gewährleistet (ich habs nicht 
durchdacht, was dann passiert)

[Tobias (Gast)]

Ok, nach einigem nachdenken und einer kleineren Überarbeitung des 
Quellcodes, (Dank eurer Anregungen) ist der momentane Stand, das es beim 
Einschalten erst gar nicht funktioniert, dann falsch und zu guter Letzt 
richtig. Neu ist, dass das Verhalten jetzt immer gleich ist.

Neu hin zu gekommen ist, das wenn ich am Potentiometer
drehe (also einen anderen ADC Wert „u“ vorgebe) es scheinbar keinen 
Einfluss auf meine Funktion hat. Die Funktion spielt also die ganze Zeit 
mit dem gleichen wert rum.

[Tobias (Gast)]

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


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

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "TrigonometrischeFunktionen.h"



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

int ALPHA = 17900;
volatile int ALPHAnutz = 17900;

int gezuendet = 0;
 int gezuendet_A = 0;
  int gezuendet_B = 0;

volatile int ausschaltsicherung = 0;
volatile int netzErkannt = 0;
volatile int drehrichtung = 0;
volatile int frequenz = 0;

volatile int fallendeFlanke = 1; //W1
volatile int zweiteHalbwelle = 0;
volatile int weiterZuenden = 0;
volatile int leitdauerErkennung = 0;

volatile int LAMBDA = 0;

float u = 0;
const float uMin = 1;
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);
int ADC_Lesen(void);

int Linearisierung(volatile int LAMBDA, volatile float u);


/****************************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

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

/****************************TIMER3-Initialisierung*****************/

void Timer3Init(void)  //Leitdauererfassung
{
  TCCR3B = 0x00;          //stop Timer
  TCCR3A = 0x00;          //normaler Modus = inkrementale Aufzählung

  EIMSK |= (1<<INT1);        //aktiviere INT1
  EICRA |= (1<<ISC10);       //INT1 reagiert auf fallende und steigende Flanke

  TCCR3B = 0x02;          //Vorteiler 8; start Timer3 bei 0
}

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

void Timer4Init(void)  //Ermittlung der Periodendauer
{
  TCCR4B = 0x00;          //stop Timer
  TCCR4A = 0x00;          //normaler Modus = inkrementale Aufzählung
  TIMSK4 |= (1<<OCIE4A) | (1<<OCIE4B) | (1<<OCIE4C); //Interrupt aktivieren für: compare Register A B C
  OCR4A = 20000;          //Vergleichswert für die Zulassung der Leitdauererfassung in der zweiten Halbwelle
  TCCR4B = 0x02;          //Vorteiler 8; start Timer4 bei 0
}

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

/*Netzsynchronisierung*/
ISR (INT0_vect)        //NDG; 240us Verzögerung
{
  leitdauerErkennung = 1;
  TCNT1 = 0;
  TCNT4 = 0;
  ALPHAnutz = ALPHA;
  OCR1A = ALPHAnutz;
  gezuendet_A =1;  
  gezuendet_B =0;  
}


ISR (INT1_vect)        //Leitdauer; 304us Verzögerung
{

    static int LAMBDAmess = 4000;
    if(leitdauerErkennung)
    {
      if(fallendeFlanke)
      {
        fallendeFlanke = 0;
        TCNT3 = 0;
      }
        else //(fallendeFlanke) 
        {
          fallendeFlanke = 1;
          LAMBDAmess=TCNT3;
          leitdauerErkennung = 0;
        

          if((LAMBDAmess >= 2000)  & (LAMBDAmess < 12000))    //mindestens >= 1000 um den fehlerhaften Zündimpuls nicht zu berücksichtigen!!!
          {
            LAMBDA = (20000 - LAMBDAmess);
          }
        }
    }    
}

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


/*Timer1 Zünden des Thyristors*/
ISR (TIMER1_COMPA_vect)          //Zündung erste Halbwelle
{
  if(gezuendet_A==1)
  {
      PORTC &= ~(1<<PC0);    //T1 AN W1 Low Aktiv 
      OCR1B = ALPHAnutz + 400;  //ALPHAnutz + LAMBDA;

      zweiteHalbwelle = 1;
      weiterZuenden = 1;
    //  gezuendet=1;
      gezuendet_A=1;
      gezuendet_B=0;
  }
}

ISR (TIMER1_COMPB_vect)          //Löschen aller gezündeten Pins
{
  if(gezuendet_A==1)
  {
    if(weiterZuenden)
    {

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

      gezuendet_B=1;
      gezuendet_A=0;

      if(zweiteHalbwelle)
      {
        //gezuendet=1;
        zweiteHalbwelle = 0;
        OCR1C = ALPHAnutz + 20000;
        gezuendet_B=1;
        gezuendet_A=0;
        
      }
      else
      {
        weiterZuenden = 0;
        
      }
    }
  }
                      
}
ISR (TIMER1_COMPC_vect)          //Zündung zweite Halbwelle
{
  if(gezuendet_B==1)
  {
    if(weiterZuenden)
    {

      PORTC &= ~(1<<PINC0);    //T1 an W1 Low Aktiv
      OCR1B = ALPHAnutz + 20400;
      gezuendet_B=0;
      gezuendet_A=1;

      
    }
  }
}  
/*******************************Timer4 : Leitdauer in der zweiten Haklbwelle**************/
ISR (TIMER4_COMPA_vect)    //lässt die Leitdauererkennung einmal in der zweiten Halbwelle zu!
{
  leitdauerErkennung = 1;
}
/****************************Funktionen************************/

/*Linearisierung*/
int Linearisierung(volatile int LAMBDA, volatile float u)  
{
  float relativU = 0;
  int bruch = 0;
  int zaehler =0;
  int nenner = 0;
  int result = 0;
  float K = 0;
  float Ua = 0;
  float Ul = 0;
  float Pi = 20000;
  float UaDurchUl = 0;
  float UaDurchUlQuadrat =0;
  int UaDurchUlQuadratMalPi = 0;

  int  sinusVonLambda = 0;

  int arcCosVonBruch = 0;

  int arcCosVonBruchInTakte = 0;
  int arcCosVonBruchInTakteminusLAMBDA = 0;

  relativU = u / uMax;

  //K = 5/230;
  K = uMax / 230;
  Ua = u/K; 
  Ul = 230; 
  UaDurchUl = Ua / Ul;
  //UaDurchUl = u / 1024;
  UaDurchUlQuadrat = UaDurchUl*UaDurchUl;
  UaDurchUlQuadratMalPi = UaDurchUlQuadrat*Pi;



 zaehler = (UaDurchUlQuadratMalPi) - LAMBDA;
 nenner = (-(float)sinusVonLambda);

 bruch = zaehler / nenner;


  arcCosVonBruch = ((float)ArcCosinus(bruch)/10000);

  arcCosVonBruchInTakte = (float)ArcCosinus(bruch)/10000*(180/3.14/0.009) ;

  arcCosVonBruchInTakteminusLAMBDA = arcCosVonBruchInTakte - LAMBDA;
  
  result =13000 - (arcCosVonBruchInTakteminusLAMBDA /2);


  if(result > 17900)      //maximaler ALPHA = 161,1° (17900 Takte)
    {
      result = 17900;
    }

    if(result < 5000)      //minimaler ALPHA = 58,5° (6500 Takte)
    {
      result = 5000;
    } 


    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;                  // ADC auslesen und zurückgeben
}




//********************************INITIALISIERUNG*******************
void Init() 
{
  
  PortInit();

  Timer1Init();
  Timer3Init();
  Timer4Init();
  PORTB |= (1<<PINB3);  //rote LED aus
  PORTB |=(1<<PINB3);  //rote LED aus
  AdcInit();
}


//*****************************HAUPT-PROGRAMM********************/
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);//+13000;// - 480;  //ACHTUNG! Dieser Korrekturfaktor ist nur für die ALTE Schaltung!
    

    }
    linearisierungsBeschraenkung++;  
  }
}

[Karl H. (kbuchegg)]

In deinem Programm taucht jetzt plötzlich ein Timer 4 auf.
Von dem gibst du 3 Compare Interrupts frei, hast aber nur für einen 
davon eine ISR -> Prozessorreset.

Dein Programm fängt dauernd wieder von vorne an.


Es ist keine gute Idee, an einem Programm zu viel auf einmal zu 
verändern (bzw. dann auch gleich noch Erweiterungen einzubauen). Eine 
Änderung, testen was sich verändert hat. Dann die nächste Änderung.

[Tobias (Gast)]

Mir ist nicht ganz klar, warum mein Programm wieder von vorne anfängt? 
Es würde aber erklären, warum das poti quasie keinen einfluss hat

[Dietrich L. (dietrichl)]

Tobias schrieb:
> Mir ist nicht ganz klar, warum mein Programm wieder von vorne anfängt?

Der Compiler baut defaultmäßig für jede nicht vorhandene ISR einen 
Sprung zum Programmanfang ein (Adresse 0).

Gruß Dietrich

[lex (Gast)]

Mal vereinfacht ausgedrückt:
Im Speicher liegt eine Tabelle mit den Adressen aller InterruptRoutinen.
Tritt ein Ereignis ein das einen Interrupt auslöst (bspw. TimerCompare), 
so wird in dieser Tabelle nach der Adresse gesucht und dorthin 
gesprungen.

Hast du allerdings für deinen Compare-Interrupt keine Routine angelegt, 
so kann in der Tabelle natürlich auch keine Service Routine hinterlegt 
sein.
Stattdessen liegt dort ein Sprung nach _reset.

[Tobias (Gast)]

ok, also wenn ich das richtig verstanden habe, kann ich den Reset 
umgehen in dem ich die nicht benötigten Vergleichswerte wieder lösche?

[Karl H. (kbuchegg)]

Es ist wirklich ganz einfach.
Wenn du hier

  TIMSK4 |= (1<<OCIE4A) | (1<<OCIE4B) | (1<<OCIE4C);

die Interrupts für Output Compare 4 A, Output Compare 4 B und Output 
Compare 4 C freigibst, dann MUSST du auch für jeden davon eine ISR 
haben:

ISR (TIMER4_COMPA_vect)
{
  ...
}

ISR (TIMER4_COMPB_vect)
{
  ...
}

ISR (TIMER4_COMPC_vect)
{
  ...
}

Ob die Funktionen etwas machen oder nicht, spielt keine Rolle. Sie 
müssen nur in deinem Programm existieren.
Jede ISR, die NICHT in deinem Programm existiert, ist standardmässig so 
'verdrahtet', dass sie zu einem Prozessorreset führt. Tritt der 
entsprechende Interrupt auf, dann kommt es daher zu einem 
Prozessorreset.
Und bei dir treten diese Interrupts auf. Denn der Timer läuft, die 
COmpare Register haben einen Wert (auch wenn der 0 ist) und der 
Verglichsmechanismus samt versuchtem Auslösen eines Interrupts läuft 
ständig, wenn der Timer läuft. Und irgendwann ist dann eben der 
Timerwert wieder 0 und damit hast du einen Compare Match zb mit OCR4B. 
Der entsprechende Interrupt ist freigegeben, also wird die ISR 
angesprungen, die du aber nicht geschrieben hast. Statt dessen geht es 
in die 'Default-ISR', die einen Reset auslöst.

Du kannst es dir also aussuchen:
Entweder du baust die Funktionen rein oder du gibst die entsprechenden 
Interrupts (die du nicht benötigst), nicht frei.
Das sind deine 2 Optionen. Such dir die aus, die dir am sinnvollsten 
erscheint.

[Tobias (Gast)]

Ok, danke für den Tipp.
Ich habe die leeren Vergleichswerte rausgenommen. Funktioniert aber 
immer noch nciht so ganz wie ich es gerne hätte :(

[Masl (Gast)]

Tobias schrieb:
> Ok, danke für den Tipp.
> Ich habe die leeren Vergleichswerte rausgenommen. Funktioniert aber
> immer noch nciht so ganz wie ich es gerne hätte :(

Sag mal, hast du die letzten 3 Beiträge mit Absicht überlesen?

Ganz ehrlich, du hast von Tuten und Blasen keine Ahnung. Du doktorst 
irgendwo rum, solange bis es zufällig funktioniert.
Oder aber, es zufällig "annähernd" das macht was du willst.

Ganz ehrlich, was du vorhast ist noch zwei Nummern zu hoch für dich.

Mach das avr-gcc Tutorium hier durch, und zwar von Anfang bis Ende.

[Karl H. (kbuchegg)]

Masl hat es zwar etwas krass ausgedrückt, aber so unrecht hat er nicht.

Das Problem ist halt, dass du einen Haufen Code hast, der nicht wirklich 
funktioniert und keine Ahnung wo man mit Fehlersuche anfangen soll. 
Gerade am Anfang seiner Karriere, kann ein Neuling nichts dümmeres 
machen, als haufenweise ungetesteten Code schreiben. Die beste Methode 
ist immer noch schrittweise vorgehen. Und auch ganz wichtig: von Anfang 
an Testmöglichkeiten vorsehen. Ob das eine UART ist oder ein LCD, oder 
ob man sich mit ein paar LED an ein paar Portpins behelfen muss, wichtig 
ist, dass man nachvollziehen kann, was das Programm macht und vor allen 
Dingen warum es das tut (Variablenwerte!).

Auch wenn die gegenseitige Steuerung der 3 Compare Interrupts vom Timer 
1 ein wenig unübersichtlich ist durch die vielen Flags, die sich 
gegenseitig setzen bzw. freigeben, ... ich denke, der Teil funktioniert. 
Mit einer Statusvariablen, die die Werte von 0 bis 4 durchläuft und in 
den ISR weitergzählt bzw. auf den richtigen Wert geprüft wird, wäre das 
alles wahrscheinlich einfacher nachzuvollziehen gewesen.

Ich hab ja immer noch die Monsterfunktion mit der Berechnung in 
Verdacht. Ob da unter allen Umständen das richtige rauskommt, dafür 
würde ich meine Hand nicht ins Feuer legen, ehe ich nicht auf dem PC die 
Funktion mal in einer Schleife mit wechselnden Werten für die Argumente 
aufgerufen und die Werte kontrolliert habe.

[Karl H. (kbuchegg)]

Der Teil hier

ISR (INT1_vect)        //Leitdauer; 304us Verzögerung
{

    static int LAMBDAmess = 4000;
    if(leitdauerErkennung)
    {
      if(fallendeFlanke)
      {
        fallendeFlanke = 0;
        TCNT3 = 0;
      }
        else //(fallendeFlanke)

bei dem die 'fallende Flanke' mehr zufällig auch wirklich eine fallende 
Flanke ist, ist zb immer noch nicht korrigiert.

[GB (Gast)]

Wenn 1023/230 ein Float mit dem Wert 4,4478 ergeben soll, muss man 
einfach 1023.0/230.0 schreiben.

[Martin L. (maveric00)]

Hallo,

bin ich der einzige, dem aufgefallen ist, dass bei der Berechnung von 
"bruch" eine Division durch Null durchgeführt wird? Es gilt:

nenner = (-(float)sinusVonLambda);

und

int  sinusVonLambda = 0;

und dazwischen wird sinusVonLambda nicht modifiziert.

Abgesehen davon ist bruch als int definiert. Was dann dabei herauskommt 
wage ich nicht zu beurteilen (hängt auch von den trigonometrischen 
Funktionen ab). Insgesammt ist die Linearisierung ein kruder Mix aus int 
und float, ich denke fast, dass hier durchgängig float oder aber eine 
richtige Fixpunkt-Implementation besser wären.

Schöne Grüße,
Martin