Mehrere Interruptquellen in NIOS II registrieren.

[MemY (Gast)]

Hallo,

ich habe eine Frage bezgl. der Registrierung von mehreren 
Interruptquellen in NIOS II.

Und zwar sollen insgesamt sechs GPIO-Ports mit jeweils einer Breite von 
32 Bit Interruptfaehig gemacht werden.
In QSYS habe ich hierbei folgende Interruptprioritaeten vergeben:

-  Input_0 (Messwert A speichern); Prioritaet: 2
-  Input_2  (Messwert B speichern); Prioritaet: 3
-  Input_3 (Messwert C speichern); Prioritaet: 4
-  Input_4 (Messwert D speichern); Prioritaet: 5
-  Input_5 (Messwert E speichern); Prioritaet: 6
-  Input_6 (Messwert auslesen ); Prioritaet: 7


Ueber ein Interrupt an den ersten fuenf GPIO-Ports (Input_0, Input_2, 
Input_3, Input_4, Input_5) werden Daten (Messwerte zu unbestimmten 
Zeitpunkten) in ein RAM geschrieben.
Mit einem Interrupt an dem sechsten GPIO-Port (Input_6) sollen die Daten 
(zu unbestimmten Zeitpunkten) aus dem RAM gelesen werden.


Mein Ansatz zur Registrierung sieht wie folgt aus:

// ERSTER INTERRUPT INITITALISIEREN
 /* Recast the edge_capture pointer to match the alt_irq_register() function prototype. */
// siehe http://www.mikrocontroller.net/topic/229699
 void* edge_capture_ptr = (void*) &edge_capture;
 /* Enable first 31 interrupts. */
 IOWR_ALTERA_AVALON_PIO_IRQ_MASK(INPUT_0_IRQ_BASE, 0xFFFFFFFF);
 /* Reset the edge capture register. */
 IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_0_IRQ_BASE, 0x00000000);
 /* Register the interrupt handler. */
 alt_irq_register(INPUT_0_IRQ_IRQ, edge_capture_ptr, handle_pio_interrupts);

// ZWEITER INTERRUPT INITITALISIEREN
 /* Recast the edge_capture pointer to match the alt_irq_register() function prototype. */
// siehe http://www.mikrocontroller.net/topic/229699
 void* edge_capture2_ptr = (void*) &edge_capture2;
 /* Enable first 31 interrupts. */
 IOWR_ALTERA_AVALON_PIO_IRQ_MASK(INPUT_2_IRQ_BASE, 0xFFFFFFFF);
 /* Reset the edge capture register. */
 IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_2_IRQ_BASE, 0x00000000);
 /* Register the interrupt handler. */
 alt_irq_register(INPUT_2_IRQ_IRQ, edge_capture2_ptr, handle_pio2_interrupts);

.
.
.

// SECHSTER INTERRUPT INITITALISIEREN
 /* Recast the edge_capture pointer to match the alt_irq_register() function prototype. */
// siehe http://www.mikrocontroller.net/topic/229699
 void* edge_capture6_ptr = (void*) &edge_capture6;
 /* Enable first 31 interrupts. */
 IOWR_ALTERA_AVALON_PIO_IRQ_MASK(INPUT_6_IRQ_BASE, 0xFFFFFFFF);
 /* Reset the edge capture register. */
 IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_6_IRQ_BASE, 0x00000000);
 /* Register the interrupt handler. */
 alt_irq_register(INPUT_6_IRQ_IRQ, edge_capture6_ptr, handle_pio6_interrupts);
  
  
void handle_pio_interrupts(void* context, alt_u32 id)
{
    /* Cast context to edge_capture's type. It is important that this be
     * declared volatile to avoid unwanted compiler optimization. */
    volatile int* edge_capture_ptr = (volatile int*) context;

    /* Store the value in the PIO's edge capture register in *context. */
    *edge_capture_ptr = IORD_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_0_IRQ_BASE);

    //Wenn ein IR auftritt, dann in Buffer speichern
    SendeDaten = IORD_ALTERA_AVALON_PIO_DATA(INPUT_0_IRQ_BASE);
    BufferIn(SendeDaten);

    /* Reset the PIO's edge capture register. */
    IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_0_IRQ_BASE, 0);


}


void handle_pio2_interrupts(void* context, alt_u32 id)
{
    /* Cast context to edge_capture's type. It is important that this be
     * declared volatile to avoid unwanted compiler optimization. */
    volatile int* edge_capture2_ptr = (volatile int*) context;

    /* Store the value in the PIO's edge capture register in *context. */
    *edge_capture2_ptr = IORD_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_2_IRQ_BASE);

    //Wenn ein IR auftritt, dann in Buffer speichern
    SendeDaten = IORD_ALTERA_AVALON_PIO_DATA(INPUT_2_IRQ_BASE);
    BufferIn(SendeDaten);

    /* Reset the PIO's edge capture register. */
    IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_2_IRQ_BASE, 0);


}
.
.
.
void handle_pio6_interrupts(void* context, alt_u32 id)
{
    /* Cast context to edge_capture's type. It is important that this be
     * declared volatile to avoid unwanted compiler optimization. */
    volatile int* edge_capture6_ptr = (volatile int*) context;

    /* Store the value in the PIO's edge capture register in *context. */
    *edge_capture6_ptr = IORD_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_6_IRQ_BASE);

  //Lese aus Buffer (aus der letzten belegten Stelle)
  check = BufferOut(EmpfangsDaten);
  if(check == 0){
    IOWR_ALTERA_AVALON_PIO_DATA(OUTPUT_0_BASE, 0xCAFEAFFE);
  }
  else{
    IOWR_ALTERA_AVALON_PIO_DATA(OUTPUT_0_BASE, *EmpfangsDaten);
  }
    /* Reset the PIO's edge capture register. */
    IOWR_ALTERA_AVALON_PIO_EDGE_CAP(INPUT_6_IRQ_BASE, 0);


}

Mein Problem ist nun, dass ich manche Interrupt „Anfragen“ (Auslesen aus 
dem RAM) verloren gehen. Kann das an meiner Registrierung liegen? Ist 
mein Konzept falsch? Habt Ihr eine Idee?

Vielen Dank schonmal,
MemY

[MemY (Gast)]

Hat keiner eine Idee?

Bisher konnte ich keinen Fehler finden...
Ausschließen kann ich, dass die ISR (handle_pio6_interrupts() ) zu lange 
durchlaeuft und dadurch einen neuen IRQ ignoriert.

[Kest (Gast)]

Ich denke, Deine Fragestellung ist etwas komplex, deshalb kommen keine 
Anworten bzw. keine Hinweise. Versuch mal Dein Problem bzw. Frage auf 
wenige Zeilen zusammenzuschrumpfen. Vielleicht sogar ein Screenshot von 
QSYS, vielleicht weis dann jemand mehr.

Ich selber habe nie (oder selten) was mit Interrupts und NIOS gemacht, 
kann also nicht helfen. Aber als Tipp: reduziere die Anzahl der 
Interrupts und schaue, ob da welche verloren gehen oder nicht.

Kest

[MemY (Gast)]

Hallo Kest!

Kest schrieb:
> Ich denke, Deine Fragestellung ist etwas komplex, deshalb kommen keine
> Anworten bzw. keine Hinweise.

Ja sry...

Kest schrieb:
> Ich selber habe nie (oder selten) was mit Interrupts und NIOS gemacht,
> kann also nicht helfen. Aber als Tipp: reduziere die Anzahl der
> Interrupts und schaue, ob da welche verloren gehen oder nicht.

Es scheint nun zu funktionieren und die Registrierung der Interrupts 
ist/war soweit korrekt.

Problem war ein anderer Interrupt-Eingang (von einem weiteren Nios) der 
den Interrupt des sechsten GPIO-Ports (Input_6) generiert.

Gruß
MemY