Timer Interruptproblem

[Bernhard W. (dieseldunst)]

Hallo Leute,

mein Problem betrifft die Timer Interrupt Funktion meines 
ArduinoMega2560 (ATmega2560).

Mein Schrittmotorprogramm berechnet die entsprechende Schrittweite vor 
jedem Schritt neu. Bei einem Schritt erfolgt das Ausgabesignal dann 
durch einen kurzen Puls (~20us). Anschließend wird überprüft wieviele 
Mikrosekunden vergangen sind ,sodass der nächste Schritt ausgeführt 
wird.

Ich möchte aber nun ein Rechtecksignal für den Schrittmotortreiber 
erzeugen, das genau die Hälfte des Schrittes ein und die andere 
ausgeschalten ist. Durchführen wollte ich es, in dem ich bei Beginn des 
Schrittes die aktuelle Systemzeit des Mikrocontrollers einlese und die 
Hälfte der Schrittdauer dazu addiere. Anschließend läuft ein 
Timerinterrupt (alle 20us) und vergleicht die aktuelle Systemzeit mit 
der "Halbzeit" und schaltet nach der "Halbzeit" das Signal aus, sodass 
ein 50/50 Rechtecksignal entsteht.

Leider funktioniert das bis jetzt überhaupt nicht so, wie ich es mir 
gedacht habe. In einem kleinen Programm habe ich einmal versucht meinen 
Fehler zu finden. Da ich mit keiner delay Funktion (bei 
Interruptverwendung) eine Frequenz für die SChrittweite vorgeben kann 
mache ich es im Beispiel durch eine Vielzahl an Rechnungen. Der Code 
generiert ein Rechtecksignal mit 0,5Hz. Das funktioniert aber nur wenn 
ich eine Funktion wie delayMicroseconds(1) in der Whileschleife 
mitaufrufe.

Sieht hier jemand den Fehler, wieso die delayFunktion unbedingt in die 
While-Schleife gehört? Mache ich einen Grundsätzlichen Fehler bei der 
Verwendung des Interrupts?

unsigned long     zeit=0;
float             rechenwert;
unsigned long     messzeit=0;
unsigned long     endzeit=0;

void setup()
{   
  Serial.begin(9600);      // open the serial port at 9600 bps:    
  pinMode(3, OUTPUT);    
  digitalWrite(3, LOW);    
  pinMode(2, OUTPUT);    
  digitalWrite(2, LOW);   
}
  

void loop()
{
  Inter1();  
  while(zeit==0)
  {
      
      endzeit=3000000; ////neuer Wert mit einer Sekunde Wartezeit
     
      delayMicroseconds(1); 
     
      for(long i=0;i<1223258;i++)
      {
      rechenwert=sqrt(987651);
      }   
      
      endzeit=0;  /////neuer Wert mit einer Sekunde Wartezeit
      for(long i=0;i<1223258;i++)
      {
      rechenwert=sqrt(987651);
      }   
        
      //endzeit=micros()+halbeschrittweite;
           
  }  
}



void Inter1() //Interrupt Funktion Einschalten
{  
  
 // initialize timer1 
  noInterrupts();           // disable all interrupts
  TCCR4A = 0;
  TCCR4B = 0;
  TCNT4  = 0;

  OCR4A = 1600;            // compare match register 16MHz/256/2Hz    160
  TCCR4B |= (1 << WGM42);   // CTC mode  
  TCCR4B |= (0<<CS42)|(1<<CS41)|(0<<CS40);    // 256 prescaler       8
  TIMSK4 |= (1 << OCIE4A);  // enable timer compare interrupt        -----> 10 us
  interrupts();             // enable all interrupts                  
 
  }


void noInter1() //Interrupt Funktion Ausschalten
{
  TCCR4B |= (0<<CS42)|(0<<CS41)|(0<<CS40);    // 256 prescaler 
}


ISR(TIMER4_COMPA_vect)          // timer compare interrupt service routine
{
  // if (micros()<endzeit)
 if (2000000<endzeit)
    {
    digitalWrite(3, HIGH);        
    }
 else
   {
    digitalWrite(3, LOW);
    }
    
}

[Karl H. (kbuchegg)]

> Mache ich einen Grundsätzlichen Fehler bei der Verwendung des Interrupts?

Ich hätte gesagt: ja.

Das würde ich komplett anders machen.
Der Timer wird auf Compare Match gesetzt (kein CTC!). Vorteiler so 
gewählt, dass sich da vernünftige Zeiten ergeben.

Im Compare Match Interrupt wird der Pin umgeschaltet und einfach eine 
Differenz zum OCR Register dazugezählt. D.h. mit dieser Differenz 
steuerst du, wann der Compare Match, und damit das Pin umschalten das 
nächste mal passiert.

Und das ganze Gefrickel mit Millisekunden fällt raus.

  TCCR4B |= (0<<CS42)|(1<<CS41)|(0<<CS40);    // 256 prescaler       8
  TIMSK4 |= (1 << OCIE4A);  // enable timer compare interrupt        -----> 10 us
  interrupts();             // enable all interrupts                  


.....

ISR(TIMER4_COMPA_vect)          // timer compare interrupt service routine
{
  digitalWrite(3, !digitalRead( 3 ) );        

  OCR4A += Differenz;
}

durch variieren der Werte in "Differenz" steuerst du die Frequenz mit 
der der Pin toggelt.

[Bernhard W. (dieseldunst)]

Danke für den Hinweis! Hat mir sehr geholfen. Musste mein Verständnis 
für die Timer Interrupts erweitern ^^ Auf die Idee wäre ich zudem nicht 
so schnell gekommen. Grüße