Introduction to interrupts

The main thread

Lst. ¿lst:interrupt_setup? shows a code fragment of main() that performs the two interrupt setup tasks: First, registering the interrupt to occur on falling-edge transitions on DIO0 of connector A, and assigning it to IRQ number 2. And second, creating the interrupt thread. Note that the code implementing the main() function activity of displaying the count is placed after the thread is created, as indicated in the listing.¹

int32_t irq_status;
uint8_t irqNumber = 2;

// Specify  IRQ channel settings
MyRio_IrqDi irqDI0;
irqDI0.dioCount          = IRQDIO_A_0CNT;
irqDI0.dioIrqNumber      = IRQDIO_A_0NO;
irqDI0.dioIrqEnable      = IRQDIO_A_70ENA;
irqDI0.dioIrqRisingEdge  = IRQDIO_A_70RISE;
irqDI0.dioIrqFallingEdge = IRQDIO_A_70FALL;
irqDI0.dioChannel        = Irq_Dio_A0;

// Declare the thread resource, and set the IRQ number
ThreadResource irqThread0;
irqThread0.irqNumber = IrqNumber;

// I. Register DI0 IRQ. Terminate if not successful
irq_status = Irq_RegisterDiIrq(&irqDI0,
                               &(irqThread0.irqContext),
                               irqNumber,              // IrqNumber
                               1,                      // Count
                               Irq_Dio_FallingEdge);   // TriggerType

// Set the ready flag to enable the new thread
irqThread0.irqThreadRdy = NiFpga_True;

// II.  Create new thread to catch the IRQ
pthread_t thread;
irq_status = pthread_create(&thread,
                            NULL,                      // attr default ok
                            DI_ISR,                    // start routine
                            &irqThread0);

// Other main() tasks go here.

irqThread0.irqThreadRdy = NiFpga_False;                // signal thread to end
irq_status = pthread_join(thread, NULL);
irq_status = Irq_UnregisterDiIrq(&irqDI0,
                                 irqThread0.irqContext,
                                 irqNumber);

The interrupt thread

This is the separate thread that was named and started by the pthread_create() function: DI_ISR. Its overall task is to perform any necessary functions in response to the interrupt. This thread will execute until signaled to stop by main().

As shown in , the Digital Input ISR thread consists of three tasks: (1) cast the thread resource to a more useful form; (2) service the interrupts, until signaled to stop; and (3) terminate the thread. Let’s examine each task separately.

in DI_ISR() is to cast its input argument (passed as void *) into appropriate form. In our case, we cast the resource argument back to the ThreadResource structure. For example, declare

ThreadResource *threadResource = (ThreadResource*) resource;

is to enter a while loop that processes each interrupt. This loop should continue until the irqThreadRdy flag (set in main()) indicates that the thread should end. For example, the condition expression of the while loop might be

while (threadResource->irqThreadRdy == NiFpga_True) { // ... loop block

Within the loop, two Loop Tasks are performed for each repetition:

Use the Irq_Wait() function to pause the loop while waiting for the interrupt. For our case, the call might be

uint32_t irqAssert = 0;
Irq_Wait(threadResource->irqContext,
         threadResource->irqNumber,
         &irqAssert,
         (NiFpga_Bool*) &(threadResource->irqThreadRdy));

Notice that it receives the ThreadResource context and IRQ number information and returns the irqThreadRdy flag set in the main() thread.

Because the Irq_Wait() times out automatically after 100 ms, we must check the irqAssert flag to see if our numbered IRQ has been asserted.

In addition, after the interrupt is serviced, it must be acknowledged to the scheduler, as in the following code:

if (irqAssert & (1 << threadResource->irqNumber)) {
  /*  Your interrupt service code here */
  Irq_Acknowledge(irqAssert);
}

(after the end of the loop) is to terminate the new thread and return from the function:

pthread_exit(NULL);
return NULL;