Timer-Vergleichswerte beim Einschalten scheinbar zufällig

[Daniel K. (kallekalbreyer)]

Hallo,

ich programmiere eine Zündsteuerung in C auf dem ATMega 2561 für eine 
Thyristorschaltung.
Die Steuerung soll durch Drücken eines Tasters gestartet werden und 
danach per Timer-Interrupts netzsynchrone Zündimpulse ausgeben.
Das Ausgeben der Zündimpulse funktioniert einwandfrei, das heißt ich 
kann mir diese auf dem Oszilloskop anschauen und diese auch per 
Potentiometer verschieben.

Nun zu dem Problem:
Wenn ich nach dem Reset per Tastendruck die Steuerung einschalte, werden 
im ersten, sehr kurzen Moment, scheinbar zufällig, zu lange Impulse 
ausgegeben welche zu einem Kurzschluss führen. Nach diesem 
Einschaltvorgang sind aber alle Impulse sauber da und das Programm läuft 
einwandfrei. Beim erneuten Aus-/Einschalten tritt das Problem wieder 
auf.

Zusätzlich verwende ich noch einen zweiten Taster, welcher nur zwischen 
zwei Thyristor-Gruppen wechselt, allerdings keine Interrupts ein- oder 
ausschaltet. Hier ist zu beobachten, dass ein Druck auf diesen Taster 
keines der oben genannten Probleme verursacht, sondern sauber die 
jeweiligen Impulse ausgegeben werden.


Hier der gesamte Quellcode:

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

/*****************************VARIABLEN-Deklaration****************/
int einschaltzustand = 0;
int zweiteHalbwelle = 0;
int ausschaltsicherung = 0;
volatile int Drehrichtung = 0;
 

uint16_t ADC_Wert;

int ALPHA = 0;
int ALPHAmin = 6500;  
int ALPHAmax = 18000;   

/*****************************PORT-Initialisierung*****************/
void PortInit(void)
{
  DDRD &= ~(1<<PIND0);              
  DDRF &= ~(1<<PINF0);              
  DDRA &= ~((1<<PINA2) | (1<<PINA1));        
  PORTA |= (1<<PINA2) | (1<<PINA1);        
  
  DDRA |= (1<<PINA7) | (1<<PINA6) | (1<<PINA5) | (1<<PINA4);      
  PORTA &= ~((1<<PINA7) | (1<<PINA6) | (1<<PINA5) | (1<<PINA4));    
  DDRB |= (1<<PINB2) | (1<<PINB3) | (1<<PINB4);            
  PORTB |= (1<<PINB2) | (1<<PINB3) | (1<<PINB4);            
}

/*****************************TIMER1-Initialisierung***************/
void Timer1Init(void) 
{
  TCCR1B = 0x00;  
  TCCR1A = 0x00;  

  TIMSK1 |= (1<<OCIE1A) | (1<<OCIE1B) | (1<<OCIE1C); 

  EIMSK |= (1<<INT0);        
  EICRA |= (1<<ISC01);        

  TCCR1B = 0x02;          
}

void AdcInit(void)
{
   ADMUX |= (0<<MUX0) | (0<<MUX1) | (0<<MUX2);     
   ADMUX &= ~((1<<REFS0) | (1<<REFS1));       
   ADMUX|=(0<<ADLAR);                 
   ADCSRA |=(1<<ADSC);               
   ADCSRA |=(1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);  
}

uint16_t ADC_Lesen(void)
{
  ADCSRA |=(1<<ADEN);           
  ADCSRA |= (1<<ADSC);              
  while (ADCSRA & (1<<ADSC));      

  ADCSRA &= ~(1<<ADEN);        
  return ADCW;               
}

/*****************************Initialisierung***************/
void Init(void)
{
  PortInit();
  Timer1Init();
  AdcInit();
  PORTB &= ~(1<<PINB3);  
}

/******************************EXTERNER Interrupt*****************/
ISR (INT0_vect)
{      
  OCR1A = ALPHA;
  TCNT1 = 0;
}

/******************************SOFTWARE Interrupts****************/
ISR (TIMER1_COMPA_vect)
{  
  if(Drehrichtung == 0)
  {
    PORTA |= (1<<PINA4);            
  }
  else
  {    
      //PORTA |= (1<<PINA7);    
  }
  OCR1B = ALPHA + 2000;  

  zweiteHalbwelle = 0;
  ausschaltsicherung = 0;
}

ISR (TIMER1_COMPB_vect)
{    
  if(Drehrichtung == 0)
  {
    PORTA &= ~(1<<PINA4);    
    PORTA &= ~(1<<PINA5);    
  }
  else
  {
    PORTA &= ~(1<<PINA6);    
    PORTA &= ~(1<<PINA7);    
  }

  ausschaltsicherung = 1;

  if(zweiteHalbwelle == 0)
  {
    OCR1C = ALPHA + 20000;

    zweiteHalbwelle = 1;
  }
}

ISR (TIMER1_COMPC_vect)  
{  
  if(Drehrichtung == 0)
  {
    PORTA |= (1<<PINA5);    
  }
  else
  {    
    //PORTA |= (1<<PINA6);    
  }

  OCR1B = ALPHA + 22000;    

  ausschaltsicherung = 0;
}

/****************************MAIN function*************************/
int main(void)
{
  cli();  
  Init();  

  while(1)
  {  
    ADC_Wert = ADC_Lesen();
    ALPHA = ((ALPHAmax - ALPHAmin)/(1024)) * (ADC_Wert) + ALPHAmin;

    if(ButtonPressed(0, PINA, 2, 500))  
    {
      if(einschaltzustand == 0)  
      {
        sei();

        PORTB |= (1<<PINB3);    

        if(Drehrichtung == 1)
        {
          PORTB &= ~(1<<PINB4);  
        }
        else
        {
          PORTB &= ~(1<<PINB2);            
        }

        einschaltzustand = 1;
      }
      else            
      {
        if(ausschaltsicherung == 0)
        {
          _delay_us(2500);
        }
        else
        {
          cli();

          PORTB |= (1<<PINB2);  
          PORTB |= (1<<PINB4);  
          PORTB &= ~(1<<PINB3);  

          einschaltzustand = 0;
        }
      }
    }

    if(einschaltzustand == 1)
    {
      if(ButtonPressed(1, PINA, 1, 500))  
      {
        if(Drehrichtung == 0)    
        {  
          PORTB &= ~(1<<PINB4);  
          PORTB |= (1<<PINB2);  
          Drehrichtung = 1;
        }
        else            
        {
          PORTB &= ~(1<<PINB2);  
          PORTB |= (1<<PINB4);  
          Drehrichtung = 0;
        }
      }
    }
  }
}

Hier der Quellcode für die "ButtonPress" Funktion, vielleicht hängt es 
auch damit zusammen:

#include<avr/io.h>



DDRC |= 1 << PINC5; 
PORTC ^= 1 << PINC5;
DDRC &= ~(1 << PINC4);
PORTC |= 1 << PINC4;

int Pressed = 0;
int Pressed_Confidence_Level = 0; 
int Released_Confidence_Level = 0; 


if (bit_is_clear(PINC, 4))
{
  Pressed_Confidence_Level ++; 
  Released_Confidence_Level = 0; 
  if (Pressed_Confidence_Level >500) 
  {
    if (Pressed == 0)
    {
      PORTC ^= 1 << PINB5;
      Pressed = 1;
    }
    Pressed_Confidence_Level = 0;
  }
}
else
{
  Released_Confidence_Level ++; 
  Pressed_Confidence_Level = 0; 
  if (Released_Confidence_Level >500)
  {
    Pressed = 0;
    Released_Confidence_Level = 0;
  }
}

Wenn mir jemand weiterhelfen kann wäre ich sehr dankbar, da ich mich 
schon seit 2 Tagen mit diesem Problem beschäftige und mir langsam die 
Lösungsansätze ausgehen...

Vielen Dank!

[Hubert G. (hubertg)]

Die Ausgänge sind von Moment des Einschalten der Spannung bis zur 
Initialisierung undefiniert hochohmig. Das könnte das von dir 
beschriebene Verhalten erklären.
Die Ausgänge über hochohmige Widerstände auf ein definiertes Potential 
legen.

[Daniel K. (kallekalbreyer)]

Danke Hubert!

Leider kann ich das erst am Montag ausprobieren...
Ich meld mich wenn ichs ausprobiert habe.

Viele Grüße,
Daniel

[Daniel K. (kallekalbreyer)]

Hallo Hubert,

ich habe mit diversen Widerstände (von 10k bis 330M) die Ausgänge 
beschaltet. Leider tritt das Problem sogar noch beim 330M unverändert 
auf.
Vielleicht hab ich das Problem auch nicht präzise genug erläutert. 
Deshalb füge ich 2 Screenshots vom Oszilloskop in den Anhang.
Der Erste zeigt genau das Problem, wobei erwähnt werden muss, dass 
dieser nur einer von vielen Verläufen ist und sich selten wiederholt. 
Dies tritt fast jedesmal auf, wenn man mit dem Taster die Interrupts mit 
dem SEI-Befehl global zulässt.
Auf dem zweiten Screenshot ist der Verlauf einen kurzen Moment nach dem 
Tastdruck dargestellt und ist absolut zufriedenstellend.

[Läubi .. (laeubi)]

Daniel Kalbreyer schrieb:
> ich habe mit diversen Widerstände (von 10k bis 330M) die Ausgänge
> beschaltet

Und wie?

Daniel Kalbreyer schrieb:
> Dies tritt fast jedesmal auf, wenn man mit dem Taster die Interrupts mit
> dem SEI-Befehl global zulässt.

Lösch doch Vorher mal alle Interruptflags.

[Peter D. (peda)]

Daniel Kalbreyer schrieb:
> wenn man mit dem Taster die Interrupts mit
> dem SEI-Befehl global zulässt.

Aha.
Wenn Du erst per Taste Interrupts freigibst, drängeln sich natürlich 
alle bis dahin aufgelaufenen Interrupts und werden schnellstmöglichst 
behandelt.

Die (Nicht-)Freigabe behindert nicht das Setzen der Pending-Flags.
Das wäre ja auch äußerst blöd, dann könnten Interrupts verloren gehen.

[Karl H. (kbuchegg)]

Hmm.
So wie ich das sehe, genügt es nicht einfach nur mittels sei()/cli() die 
Interrupts zuzulassen. Denn: Der Timer läuft ja weiter. Und wenn dann 
der sei() gegeben wird, hast du keine Kontrolle darüber welcher der 
Comnpare-Match Interrupts als erster kommt, weil du ja keine Kontrolle 
über den Zählerstand des Timers hast.

D.h. du musst dir Logik einbauen, die sicherstellt, dass nach dem sei() 
erst mit einem Compare-Match A (wenn ich das richtig gesehen) die ganze 
Sache wieder ins Rollen kommt. Nachdem du mittels cli() die ganze Sache 
abgestellt hast, werden Compare Matches auf B bzw. C ignoriert und kein 
Ausgang geschaltet, solange bis der darauffolgende Match auf A alles 
wieder freigibt.

Auch bin ich mir nicht sicher, ob du einfach so mittels cli() die ganze 
Steuerung abdrehen darfst. Denn im schlimmsten Fall kommt der cli() 
genau mitten im Puls. Wodurch dir dann der Ausgang im letzten Zustand 
hängen bleibt.


-> Ich würde das ganze NICHT mittels sei()/cli() lösen, sondern mit 
einer globalen Variablen, die aussagt, ob die Zündung eingeschaltet ist 
oder nicht. Im Compare Match A wird diese Variable abgefragt und nur 
wenn freigegeben, wird auch eine weitere Variable auf true gesetzt, die 
im Compare Match B bzw. C abgefragt wird und nur dann, wenn die auf true 
steht, dann werden auch die Aktionen gemacht. Im Compare Match C wird 
die Variable dann wieder auf false gesetzt, sodass die nächste 
Pulssequenz durch einen erneuten COmpare Match A erst wieder freigegeben 
werden muss. Kommt diese Freigabe nie (weil du sie per Taster abgedreht 
hast), dann erfolgen auch die Aktionen im Match B bzw. C nicht.

volatile uint8_t doSparkle;
volatile uint8_t continueSparkle;

ISR (TIMER1_COMPA_vect)
{
  if (doSparkle)
  {
    continueSparkle = TRUE;


    if(Drehrichtung == 0)
    {
      PORTA |= (1<<PINA4);            
    }
    else
    {    
    .....
  }

  OCR1B = ALPHA + 2000;
  ....
}

ISR (TIMER1_COMPB_vect)
{
  if (continueSparkle)
  {
    if(Drehrichtung == 0)
    {
    ....
  }
}

ISR (TIMER1_COMPC_vect)  
{  
  if (continueSparkle)
  {
    continueSparkle = FALSE;

    if(Drehrichtung == 0)
      ....
  }
}


int main()
{
  ....


     if( irgendwas Taster gedrückt )
       doSparkle = TRUE;

     if( irgendein anderer Taster
       doSparkle = FALSE;


}

der Timer läuft durch und auch die Interrupts sind zu allen Zeiten 
aktiv.
Auf die Art ist sichergestellt, dass
* die komplette an den Pins sichtbare Sequenz immer mit einem Compare 
Match A beginnt
* auch nach abschalten der Zündung die komplette Pin-Sequenz bis zu 
einem Compare Match C durchlaufen wird.

D.h. im Grunde: Die Logik der Zündung läuft die ganze Zeit. Lediglich 
das Schalten der Ausgangspins wird durch Variablen unterdrückt, der 
ganze OCR Mechanismus läuft weiter. Wodurch extern gesehen, die Zündung 
abgeschaltet ist. Aber: sie läuft sauber an und sie stoppt auch sauber.

[Daniel K. (kallekalbreyer)]

Vielen Dank Karl-Heinz,

die Idee ist brillant und funktioniert mit ein paar kleinen Änderungen 
einwandfrei.
Die Zündimpulse kommen sauber beim Einschalten und machen keinen Ärger 
mehr.

Du hast mir sehr weiter geholfen und mich vor einem weiteren 
deprimierenden Abend bewahrt.

Nochmals vielen Dank und viele Grüße,
Daniel