Interrupt löst dauernd aus

[Peter M. (allforone)]

Hallo,
Ich habe nur einen Interrupthandler. Dieser ist für drei interrupts 
zuständig. (SPI)
Er löst die ganze Zeit und es kommt zu dem Watchdogfehler, das Programm 
kehrt nicht in die Main zurück. Leider kann ich den Fehler nicht finden.

// Includes ----------------------------------------------------------------------------------------
#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "SPIDriver.h"


// Variablen ---------------------------------------------------------------------------------------
uint8 c_Data = 0x02;
static int sbufferpos = 0;

// Prototypen --------------------------------------------------------------------------------------
void SendeTakt(int takt);

// Main --------------------------------------------------------------------------------------------
void main(void) {

  

    spi_init();
    spi_setMode(Master, RisingEdge, LeadingEdge, LSBfirst);
    spi_selectChip(true);
    spi_enableInterrupt(true);
    
  
      for(;;)
      {
        __RESET_WATCHDOG();
        if(spi_checkComplete() == true)
        {
          c_Data = spi_receiveData();
          SendeTakt(27);
          
        }
      }  
   } 

__interrupt VectorNumber_Vspi1 void ISR_SPI() {

  uint8 Temp;
  if(sbufferpos==32) {
  sbufferpos = 0;
  } 
  else{
     sbufferpos = sbufferpos +1;

   if(SPI1S_SPRF == 1) {
      c_Data = spi_receiveData();
   } 
   else if(SPI1S_SPTEF == 1) {
      Temp = SPI1D;
      SendeTakt(27);    
   } 
   else{
      //Fehler
   }
   
  }
}

// Funktionen -----------------------------------------------------------------------------------------
void SendeTakt(int takt) {

  byte buffer[32];
  if(takt== 27) { //Wertzuweisung von buffer
 
  } 
  else if(takt == 26){  //Wertzuweisung von buffer
 
  } 
  else {
  }
    spi_sendData(buffer[sbufferpos]);
   
}

[♪Geist (Gast)]

Flag nicht gelöscht?

[RS (Gast)]

Mach doch mal aus dieser Zeile

sbufferpos==32

sbufferpos >= 32

[Peter M. (allforone)]

Ein Bit bzw. Flag bekomme ich nicht gelöscht.

"This bit is set when there is room in the transmit data buffer. It is 
cleared byreading SPI1S with SPTEF set, followed by writing a data value 
to the transmit buffer at SPI1D. SPI1S must be read with SPTEF = 1 
before writing data to SPI1D or the SPI1D write will be ignored. SPTEF 
generates an SPTEF CPU interrupt request if the SPTIE bit in the SPI1C1 
is also set. SPTEF is automatically set when a data byte transfers from 
the transmit buffer into the transmit shift register. For an idle SPI 
(no data in the transmit buffer or the shift register and no transfer in 
progress), data written to SPI1D is transferred to the shifter almost
immediately so SPTEF is set within two bus cycles allowing a second 
8-bit data value to be queued into the transmit buffer. After completion 
of the transfer of the value in the shift register, the queued value 
from the
transmit buffer will automatically move to the shifter and SPTEF will be 
set to indicate there is room for new data in the transmit buffer. If no 
new data is waiting in the transmit buffer, SPTEF simply remains set and 
no data moves from the buffer to the shifter.
0 SPI transmit buffer not empty
1 SPI transmit buffer empty"

Hier ein auszug aus dem Datenblatt.
Sobald ich keine neuen Daten mehr schreiben will, und das SPTEF Flag 
gesetzt bleibt, löst die ganze Zeit das Interrupt aus.

"SPTEF simply remains set..." Genau das versuche ich eigentlich...

Jemand eine Idee?


#Nachtrag:

__interrupt VectorNumber_Vspi1 void ISR_SPI() {

    uint8 Temp;
    uint8 Tempo1;
    uint8 Tempo2;
    
    
    
  //Flags speichern
  Tempo1 = SPI1S_SPRF;
  Tempo2 = SPI1S_SPTEF;
  
  //Flags löschen
  SPI1S_SPRF = 0;
  SPI1S_SPTEF = 0;


   if(Tempo1 == 1) {
      
      Temp = spi_receiveData();
   } 
   else if(Tempo2 == 1) 
   {
      //schreibbereit    
   } 
   else{
      //Fehler
   }

}

So versuche ich es mittlerweile, leider auch ohne Erfolg. Einfach 0 
setzen geht nicht.

[amateur (Gast)]

>Mach doch mal aus dieser Zeile

Sollte nichts ändern, wenn der obige Code vollständig ist.

Beinhaltet: "spi_enableInterrupt(true);" auch das obligatorische "sei;"?

[Peter M. (allforone)]

void spi_enableInterrupt(bool b_Option)
{
  if(b_Option == true)
  {
    // SPI Interrupt einschalten
    SPI1C1 = SPI1C1|(SPI1C1_SPIE_MASK);
    SPI1C1 = SPI1C1|(SPI1C1_SPTIE_MASK);

    // Interrupts freigeben
    EnableInterrupts;
  }
  else
  {
    // SPI Interrupt abschalten
    SPI1C1 = SPI1C1&~(SPI1C1_SPIE_MASK);
  }
}

EnableInterrupts steht für sei().

[Peter M. (allforone)]

Irgendjemand noch eine Idee?

Zur Info:
Controller MC9S08AW60 (freescale)

[jojo (Gast)]

Jan R. schrieb:
> So versuche ich es mittlerweile, leider auch ohne Erfolg. Einfach 0
> setzen geht nicht.

der Flag wird durchs Setzten gelöscht, also nicht 0 sonder 1.


Interrupt: Zeitverhalten eines Timerinterrupts

Beitrag "ATMEGA128: Interruptflag löschen durch setzen?"

[holger (Gast)]

>der Flag wird durchs Setzten gelöscht, also nicht 0 sonder 1.

Beim AVR, aber bei seinem Freescale?

[M. N. (Gast)]

Jan R. schrieb:
> Sobald ich keine neuen Daten mehr schreiben will, und das SPTEF Flag
> gesetzt bleibt, löst die ganze Zeit das Interrupt aus.

Das ist ja auch richtig, damit die Übertragung überhaupt gestartet wird.
Nachdem das letzte Byte übertragen wurde, mußt Du den Interrupt 
abschalten.

Das könnte so aussehen:
spi_enableInterrupt(false);

[Amateur (Gast)]

Ich kenne Deinen Prozessor nicht, aber "Frage an Radio Eriwan"
Wie wichtig ist die Sequenz:

Temp = SPI1D;

eigentlich?

Ein Compiler, der was auf sich hält, streicht diesen Befehl ersatzlos, 
da Temp in der Folge nicht verwendet wird.

Stichwort: volatile.

[Peter D. (peda)]

Amateur schrieb:
> Stichwort: volatile.

IO-Register werden in der Regel im *.h File als volatile gecastet.
Zum Lesezugriff reicht aus:

SPI1D;

[Peter M. (allforone)]

M. N. schrieb:
> Das ist ja auch richtig, damit die Übertragung überhaupt gestartet wird.
> Nachdem das letzte Byte übertragen wurde, mußt Du den Interrupt
> abschalten.
>
> Das könnte so aussehen:
> spi_enableInterrupt(false);

Ok, dass wusste ich so nicht. Dann muss ich das Interrupt einfach 
ausschalten.

Bei der jetztigen Codeversion habe ich das Interrupt noch nicht 
ausgeschaltet, aber es funktioniert in dem Sinne von es schreibt die 
ganze Zeit.

void main(void) {

    spi_init();
    spi_setMode(Master, FallingEdge, LeadingEdge, MSBfirst);
    spi_selectChip(true);
    spi_enableInterrupt(true);
    
      for(;;)
      {
        __RESET_WATCHDOG();

          if( spi_checkComplete()==true) {
            
          SendeTakt(27);
          }
      }  
   } 

__interrupt VectorNumber_Vspi1 void ISR_SPI() {

    __RESET_WATCHDOG();

    if(sbufferpos<32) {
        sbufferpos = sbufferpos + 1;

           if((SPI1S&(SPI1S_SPRF_MASK)) == 0) {
           } 
           else{
              SPI1S;
              SPI1D;
           }
           if((SPI1S&(SPI1S_SPTEF_MASK)) == 0){  
           } 
            else{
              SPI1S;
              SendeTakt(27);
            }
    }
    else{
       sbufferpos = 0;
    }  
}

Hier die spi_checkComplete:

bool spi_checkComplete()
{
  uint8 Temp;

  if((SPI1S&(SPI1S_SPTEF_MASK)) == 0)
  {
    return false;
  }
  else
  {
    // SPI Data Buffer lesen um Interrupt Bit zu leeren
    Temp = SPI1D;
    return true;
  }
}

Den Watchdog sollte man ja eigentlich nciht im Interrupt feeden. Wenn 
ich es allerdings nicht mache, wird das Watchdoginterrupt nach etwa 20 
Durchläufen des Sendevorgangs ausgelöst. Ziemlich komisch, es werden 
keine Fehler angezeigt -> COP Watchdog caused a Reset

Hat hier noch jemand eine Idee?

Controller: MC9S08AW60 (freescale)
http://www.freescale.com/files/microcontrollers/doc/data_sheet/MC9S08AW60.pdf


Auf jeden Fall schon mal vielen Dank für die hilfreichen Antworten!

[jojo (Gast)]

Datenblatt Seite 179
"
10.6.1 Clearing Timer Interrupt Flags
TPM interrupt flags are cleared by a 2-step process that includes a read 
of the flag bit while it is set (1)
followed by a write of 0 to the bit. If a new event is detected between 
these two steps, the sequence is reset
and the interrupt flag remains set after the second step to avoid the 
possibility of missing the new event.
"

[Peter M. (allforone)]

Ok, nur es ist ja ein SPI Interrupt.
Und wieso kommt der Fehler beim ca. 20. Durchlauf und nicht schon beim 
ersten?

[M. N. (Gast)]

Jan R. schrieb:
> Und wieso kommt der Fehler beim ca. 20. Durchlauf und nicht schon beim
> ersten?

Das wirst Du herausfinden und uns mitteilen :-)

[Peter M. (allforone)]

Ich kann euch mitteilen, dass es so ist. Wieso wird bei mir leider 
schwer...

Aber sehe ich das richtig, dass man zwangsläufig in der ISR den 
Schreibvorgang starten muss.

Ein solches Konstrukt funktioniert nicht:

main(){
    while(sbufferpos < buffergöße)
    {
    SendeData(bufferpos);
    }
}

ISR()
{
    if(Transmissionbuffer == empty)
    {
    sbufferpos++; 
    } 
}

Wenn man es so machen würde, würde das Interrupt ja permanent ausgelöst 
werden, da das Transmissionbufferemptyflag nicht acknowledged wird. Sehe 
ich das richtig?