Interrupt TMS320F2808

[Tim R. (mugen)]

Mit der Auführung der Interrupts habe ich keine Probleme.
Zurzeit benutzte ich zu Testzwecken den Timer0 Interrupt und den 
SCIA-RECEIVE Interrupt. Eigentlich möchte ich, dass der Timer0 Interrupt 
den SCIA Interrupt unterbricht. Sprich der Timer0 hat immer die höchste 
Priorität. Laut Docu müsste dies auch so sein, allerdings zweifle ich 
daran. Entweder eine Unterbrechung durch einen anderen Interrupt ist 
nicht möglich, oder die Interrupts werden nacheinander abgefertigt. 
Letzteres ist nicht erwünscht. Hat jemand evtl. einen Tipp?

Source-Auszug:

EALLOW; 
PieVectTable.TINT0 = &cpu_timer0_isr;
PieVectTable.SCIRXINTA = &sciaRxFifoIsr;
EDIS;  
//=================================================================

// Enable CPU INT1 which is connected to CPU-Timer 0:
// Enable SPIRXINTA:
IER = 0x101;
//=================================================================
// Enable TINT0 in the PIE: Group 1 interrupt 7
PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

PieCtrlRegs.PIEIER9.bit.INTx1=1;     // PIE Group 9, INT1 --- SPIRXINTA

//=================================================================
// Enable global Interrupts and higher priority real-time debug events:
EINT;   // Enable Global interrupt INTM
ERTM; 
//=================================================================

interrupt void cpu_timer0_isr(void)
{

//Hier steht der Source

 // Acknowledge this interrupt to receive more interrupts from group 1
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}
//=================================================================
interrupt void sciaRxFifoIsr(void)
{
PieCtrlRegs.PIEIFR1.bit.INTx7 = 0;
PieCtrlRegs.PIEACK.all|=0x100;       // Issue PIE ack

for(;;){}  // Zu Testzwecken
}

[Tim R. (mugen)]

In den letzten Zeilen befindet sich ein Fehler, daher der überarbeitete 
Source für den SCIA Interrupt:

interrupt void sciaRxFifoIsr(void)
{



  Uint16 i;
  Uint16 l_dummy[16];

  for(i=0;i<16;i++)
  {
     l_dummy[i]=SciaRegs.SCIRXBUF.all;   // Read data
  }

  SciaRegs.SCIFFRX.bit.RXFFOVRCLR=1;   // Clear Overflow flag
  SciaRegs.SCIFFRX.bit.RXFFINTCLR=1;   // Clear Interrupt flag


  PieCtrlRegs.PIEIFR9.bit.INTx1 = 0;
  PieCtrlRegs.PIEACK.all|=0x100;       // Issue PIE ack
  for(;;){}


}

[Micha (Gast)]

Ich würde sagen, dass du das entsprechende Interrupt-Flag löschen und 
den PIE-Ack durchführen musst und zwar am Anfang der SCI-ISR und nicht 
erst am Ende.

Also ungefähr so:

interrupt void sciaRxFifoIsr(void)
{
  Uint16 i;
  Uint16 l_dummy[16];

  SciaRegs.SCIFFRX.bit.RXFFOVRCLR=1;   // Clear Overflow flag
  SciaRegs.SCIFFRX.bit.RXFFINTCLR=1;   // Clear Interrupt flag
  PieCtrlRegs.PIEACK.all|=0x100;       // Issue PIE ack
  /* ist 0x100 hier wirklich richtig? (siehe unten) */

  for(i=0;i<16;i++)
  {
     l_dummy[i]=SciaRegs.SCIRXBUF.all;   // Read data
  }

  for(;;){}
}

Übrigens:

<zitat spru712f, Seite 124>
Rule 1: Never clear a PIEIFR bit by software
</zitat>

<zitat spru712f, Seite 140>
Each bit in PIEACK refers to a specific PIE group. Bit 0 refers to 
interrupts in PIE group 1 that are MUXed into INT1 up to Bit 11, which 
refers to PIE group 12 that is MUXed into CPU INT12.
</zitat>

[Tim R. (mugen)]

@Micha:

Auf Rule 1 bin ich auch schon gestoßen und habe dies kompensiert. 
Zurzeit kann ich den Interrupt durch einen anderen Interrupt 
unterbrechen, allerdings nutze ich dafür "EINT" - Maskierter Interrupt, 
was ja eigentlich richtig sein müsste. Wann die SCI-Flags gelöscht 
werden müssen ist vermutlich eine kleine Streitfrage. Ich kann aber 
sagen, dass ich nun keine Übertragungsfehler mehr habe und ein größerer 
Stream ohne Probleme zu empfangen ist.

Test-Source:

interrupt void sciaRxFifoIsr(void)     // SCI-A
{
  static Uint16 l_receive_index = 0;
  static Uint16 l_receive_start = 0;
  
     PieCtrlRegs.PIEACK.all = PIEACK_GROUP9;   // Enable PIE interrupts  
  EINT;  // Enable Maskable Interrupt

  //==============================================================================================
  // Code zur Verarbeitung: SCIA-FIFO auslesen und flags löschen
  //==============================================================================================
  for(l_receive_index=l_receive_start;l_receive_index<16+l_receive_start;l_receive_index++)
  {
     ReceivedChar[l_receive_index]=SciaRegs.SCIRXBUF.all;   // Read data
  }
  l_receive_start = l_receive_start + 15;
  if(l_receive_start >= 100)
  {
  l_receive_start = 0;
  }

  SciaRegs.SCIFFRX.bit.RXFFOVRCLR=1;   // Clear Overflow flag
  SciaRegs.SCIFFRX.bit.RXFFINTCLR=1;   // Clear Interrupt flag
  //==============================================================================================
//  for(;;){}

  // Restore registers saved:
  DINT;  // Disable Maskable Interrupt
}