Linearisierung B2 Stromrichter mit ATMEGA 2561

[Steffen C. (kerkerian)]

Hallo Liebe Leute,

in ein bestehendes Programm habe ich die Funktion "Linearisierung" 
eingebunden die mir einen neuen Zündwinkel ALPHA in Abhängigkeit der 
gemessenen Leitdauer LAMBDA und des am Potentiometer eingestellten 
Wertes u berechnet.

Die Formel für diesen Zündwinkel lautet:

$$\alpha = \pi - \arcsin \left( \frac{\lambda}{\sin \left( \frac{\lambda}{2}\right) * \pi} * \frac{u}{u_\text{max}} \right) - \frac{\lambda}{2}$$

An einer Gleichstrommaschine 200V, 0,51A habe ich meine Funktion 
getestet. Die Linearisierung soll verhindern das bei Belastung die 
Spannung einbricht. Wenn ich Spannungen bis 130V einstelle funktioniert 
alles wunderbar, der neu berechnete ALPHA verhindert das die Spannung 
einbricht. Bei Spannungen größer 130V treten verschiedene Phänomene ein. 
Wenn ich also z.B. 140V einstelle und nicht belaste springt der Wert 
manchmal einfach ohne das ich am Poti drehe auf z.B. 160V, aber nur 
manchmal. Manchmal funktioniert es auch wenn ich bei Spannungen größer 
130V belaste das er die Spannung hält, manchmal jedoch bricht die 
Spannung stark ein auch wenn ich dann nicht mehr belaste bleibt er auf 
dem Spannungswert mit Belastung und springt dann auf einmal nach ca. 
3-20 Sekunden wieder auf den alten Wert.

Mein Quellcode befindet sich im Bildformat im Anhang ich hoffe das ist 
so in Ordnung. Die Variable "drehrichtung" muss noch geändert werden, 
richtig müsste sie "linearisierung" heißen.

Woran kann es liegen? Fehlerhafte Leitdauererkennung? Vielleicht ein VZ1 
Filter für den berechneten ALPHA um Sprünge zu vermeiden?

Vielleicht findet sich hier jemand der Erfahrung mit der Materie hat und 
mal einen Blick drüber werfen kann, ich bin über jegliche Hilfe dankbar.

Gruß Steffen

[Cyblord -. (cyblord)]

Ich frag mich echt, welche Art von Hirnverletzung man erlitten haben 
muss, damit man QuellTEXT als Screenshots anhängt.

[Steffen C. (kerkerian)]

Die Beleidigung ignoriere ich jetzt einfach mal. Ich dachte mir der 
Beitrag wird sonst zu lang aber hier bitte der Quellcode:

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

/*****************************Variablen-Deklaration****************/
float u = 0;
const float uMin = 0;
const float uMax = 1023;
int ALPHA = 17900;
volatile int ALPHAnutz = 17900;
const int ALPHAmax = 17900;
const int ALPHAmin = 10000;        //6500
volatile int LAMBDA = 4000;
int gezuendet = 0;
int ausschaltsicherung = 0;
int drehrichtung = 0;          //!!!DIESE VARIABLE IHREM ZWECK ENTSPRECHEND UMBENENNEN!!!
int leitdauerErkennung = 0;
int steigendeFlanke = 0;
int zweiteHalbwelle = 0;
int weiterZuenden = 0;

/****************************Funktionen-Deklaration****************/
int ADC_Lesen(void);
int Linearisierung();

/****************************MAIN-Funktion*************************/
int main(void)
{
  int linearisierungsBeschraenkung = 20;

  cli();  //Interrupts deaktivieren
  Init();  //Initialisierung
  sei();  //Interrupts aktivieren

  while(1)
  {
    if(drehrichtung == 0)
    {
      ALPHA = (((ALPHAmax - ALPHAmin) / 1023) * (ADC_Lesen()) + ALPHAmin);
    }
    
    if(drehrichtung == 1)
    {
      u = (((uMax - uMin) / 1023) * (ADC_Lesen()) + uMin);

      if(linearisierungsBeschraenkung >= 20)      //alle 20 main-Durchläufe wird hier rein gesprungen
      {
        linearisierungsBeschraenkung = 0;
        ALPHA = Linearisierung();// - 480;  //ACHTUNG: Dieser Korrekturfaktor ist nur für die ALTE Schaltung!!!
      }
    }

    if(ButtonPressed(0, PINA, 2, 500))  //an-/ausschalten
    {
      if(gezuendet)          //aus
      {
        if(ausschaltsicherung)
        {
          gezuendet = 0;

          PORTB |= (1<<PINB2);  //LED links aus
          PORTB |= (1<<PINB4);  //LED rechts aus
          PORTB &= ~(1<<PINB3);  //rote LED an
        }
        else
        {
          _delay_us(2500);
        }
      }
      else              //an
      {
        gezuendet = 1;

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

        if(drehrichtung)
        {
          PORTB &= ~(1<<PINB4);  //LED rechts an
        }
        else
        {
          PORTB &= ~(1<<PINB2);  //LED links an
        }
      }
    }

    if(gezuendet)
    {
      if(ausschaltsicherung)
      {
        if(ButtonPressed(1, PINA, 1, 500))  //Links- oder Rechtslauf
        {
          if(drehrichtung)        //Linkslauf
          {
            drehrichtung = 0;
            PORTB &= ~(1<<PINB2);    //LED links an
            PORTB |= (1<<PINB4);    //LED rechts aus
          }
          else              //Rechtslauf
          {
            drehrichtung = 1;
            PORTB &= ~(1<<PINB4);    //LED rechts an
            PORTB |= (1<<PINB2);    //LED links aus
          }
        }
      }
      else
      {
        _delay_us(2500);
      }
    }
    linearisierungsBeschraenkung++;
  }
}

/******************************EXTERNE Interrupts*****************/

/*Netzsynchronisation*/
ISR (INT0_vect)        //NDG; 240us Verzögerung bei altem Leistungsteil
{
  TCNT1 = 0;
  ALPHAnutz = ALPHA;
  OCR1A = ALPHAnutz;
}

/*Leitdauererfassung*/
ISR (INT1_vect)        //Leitdauer; 304us Verzögerung bei altem Leistungsteil
{
  static int LAMBDAmess = 4000;
  if(bit_is_clear(PIND, 1))    
  {
    steigendeFlanke = 1;
    TCNT3 = 0;
  }
  else if(steigendeFlanke)
  {
    steigendeFlanke = 0;
    LAMBDAmess = TCNT3;// + 608;    //ACHTUNG: Dieser Korrekturfaktor ist nur für die ALTE Schaltung!!!

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

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

/*Timer1: Zünden und Löschen der Thyristoren*/
ISR (TIMER1_COMPA_vect)         //Zündung erste Halbwelle
{
  if(gezuendet)
  {
    zweiteHalbwelle = 1;
    ausschaltsicherung = 0;
    weiterZuenden = 1;

    PORTA |= (1<<PINA4);      //T1 an
    PORTA |= (1<<PINA5);      //T2 an


    OCR1B = ALPHAnutz + 400;
  }
}

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

        PORTA &= ~(1<<PINA4);    //T1T2 aus
        PORTA &= ~(1<<PINA5);    //T3T4 aus

        PORTA &= ~(1<<PINA6);    //T5T6 aus
        PORTA &= ~(1<<PINA7);    //T7T8 aus

      if(zweiteHalbwelle)
      {
        zweiteHalbwelle = 0;
        OCR1C = ALPHAnutz + 20000;
      }
      else
      {
        weiterZuenden = 0;
      }
    }
  }
}

ISR (TIMER1_COMPC_vect)          //Zündung zweite Halbwelle
{
  if(gezuendet)
  {
    if(weiterZuenden)
    {
      ausschaltsicherung = 0;

      PORTA |= (1<<PINA6);      //T3 an
      PORTA |= (1<<PINA7);      //T4 an

      OCR1B = ALPHAnutz + 20400;
    }
  }
}

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

/*Linearisierung*/
int Linearisierung()
{
  if(LAMBDA < 12)        //Gleichung gilt nur für LAMBDA > 0!
  {
    LAMBDA = 12;
  }
  else if (LAMBDA > 20000)  //Lambda darf max. Pi werden
  {
    LAMBDA = 20000;
  }

  const float Pi = 20000;
  float relativ_u = u / uMax;

  float Term1 = LAMBDA / 2;
  float Term2 = Sinus(Term1);
  float Term3 = Term2 / 10000;
  float Term4 = Term3* Pi;
  float Term5 = LAMBDA / Term4;
  float Term6 = Term5 * relativ_u;
  float Term7 = Term6 * 10000;
  float Term8 = ArcSinus(Term7);

  float result = Pi - Term8 - Term1;
  
  if(result > 19000)  // 171°
  {
    result = 19000;
  }
  else if(result < 8000)
  {
    result = 8000;
  }
  return result;  
}

/*Analog-Digital-Konvertierung*/
int ADC_Lesen(void)
{
  ADCSRA |=(1<<ADEN);           //ADC aktivieren
  ADCSRA |= (1<<ADSC);              //nächste Umwandlung starten
  while (ADCSRA & (1<<ADSC));      //warten bis die Umwandlung abgeschlossen ist

  ADCSRA &= ~(1<<ADEN);        //ADC deaktivieren
  return ADCW;            //Ergebnis von 0 bis 1023 ausgeben
}

[Cyblord -. (cyblord)]

Ja viel besser... NICHT

ProTip für Kopfverletzte: Du kannst und sollst Quellcode als Datei 
anhängen. Aber als Quellcode (also direkt .c) und nicht als Bild. Aber 
weißt, wenns schon daran scheitert, was will man da noch groß auf den 
Inhalt eingehen?

[spess53 (Gast)]

Hi

>Ich dachte mir der Beitrag wird sonst zu lang ...

Ja. Deshalb postet man den auch als Anhang.

MfG Spess

[Steffen C. (kerkerian)]

So habe die .c Datei im Ausgangsposting angehängt. Ich hoffe damit sind 
jetzt alle, auch die 
im-internet-anonym-beleidiger-und-im-echten-leben-so-klein-mit-hut-Leute 
,  zufrieden.

[Steffen C. (kerkerian)]

Hat sich erledigt, es war ein Hardwarefehler bei der Leitdauererfassung.