Interrupts and their handling in real-time computing

Task I.—Register the DI0 Interrupt Request

The myRIO C library provides a function to reserve the interrupt from the FPGA and configure the DI and the IRQ. Its prototype is

int32_t Irq_RegisterDiIrq(MyRio_IrqDi *irqChannel,
                          NiFpga_IrqContext *irqContext,
                          uint8_t irqNumber,
                          uint32_t count,
                          Irq_Dio_Type type);

Its return value is 0 for success, and its five input arguments are

1. irqChannel: A pointer to a structure containing the registers and settings for the IRQ I/O to modify; defined in DIIRQ.h as

   typedef struct{
     uint32_t dioCount;           // count register
     uint32_t dioIrqNumber;       // number register
     uint32_t dioIrqEnable;       // enable register
     uint32_t dioIrqRisingEdge;   // rising edge-trig register
     uint32_t dioIrqFallingEdge;  // falling edge-trig register
     Irq_Channel dioChannel;      // physical DIO channel number
   } MyRio_IrqDi;

   This structure identifies the digital channel and how it is to be configured.

2. irqContext: A pointer to a context variable identifying the interrupt to be reserved. It is the first component of the previously given thread resources structure.

3. irqNumber: The IRQ number (1–8) distinguishes this from other interrupts.

4. count: The number of times that an interrupt condition is met to trigger the interrupt.

5. type: The trigger type that is used to increment the count.

Task II.—Create the interrupt thread

The ISR will run in a pthread (subsection 5.3.1). The function pthread_create(), called from main(), creates a new thread and configures it to service the DI interrupt. Its prototype is

int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine) (void *),
                   void *arg);

where the four input arguments are

1. thread: A pointer to a thread identifier.
2. attr: A pointer to thread attributes. Use NULL to apply the default attributes.
3. start_routine: The name of the function to start in the new thread.
4. arg: The thread resource.

The fourth argument is a pointer to the same thread resource structure defined above and used in the second argument of Irq_RegisterDiIrq(). Just prior to creating the thread, main() will set the IRQ thread ready flag to enable the ISR to process interrupts.

Once the interrupt thread is created and enabled, the main thread (in our case, running the function main()) can carry out its tasks while the interrupt thread runs independently.

Terminating the ISR thread and unregistering the interrupt

When the main thread has completed its tasks, it can signal the interrupt thread to terminate by resetting the interrupt ready flag:

irqThread0.irqThreadRdy = NiFpga_False;

Then the main thread should join the ISR thread to wait for its completion:

pthread_join(irqThread0, NULL);

Finally, the interrupt must be unregistered:

status = Irq_UnregisterDiIrq(&irqDI0,
                             irqThread0.irqContext,
                             irqThread0.irqNumber);

All that remains is to write the ISR.

Writing a digital input interrupt service routine

The function started in the interrupt thread created by the pthread_create() is generically called start_routine(), but it should be given a specific name for the digital interrupt ISR, such as DI_ISR(). Its role is to respond to the interrupt. This thread will execute until signaled to stop by main().

The ISR corresponds to the third argument of pthread_create(), so it must conform with that prototype. For instance, a valid ISR function is

void* DI_ISR(void *thread_resource) {
  // service the interrupt
}

The argument of the starting routine, void* thread_resource, should be cast to a pointer to the ThreadResource defined in the main thread. Remember that it is by this means that the two threads communicate.

Assuming that more than one interrupt is to be processed, the ISR should enter a loop, waiting for each instance of the registered IRQ to occur. That loop should terminate when signaled by the interrupt ready flag. The Irq_Wait() function supplied by the myRIO C library can be invoked to pause the ISR thread until it is activated by its IRQ. The prototype is

void Irq_Wait(NiFpga_IrqContext irqContext,
              NiFpga_Irq irqNumber,
              uint32_t *irqAssert,
              NiFpga_Bool *continueWaiting);

The first, second, and fourth arguments correspond to the members of the ThreadResource irqThread0 created in the main thread. For example, it might be programmed as¹

Irq_Wait(thread_resource->irqContext,
         thread_resource->irqNumber,
         &irqAssert,
         (NiFpga_Bool*) &(thread_resource->irqThreadRdy));

The variable of the third argument, the integer irqAssert, indicates which interrupt has occurred. If an IRQ is asserted during the Irq_Wait(), its bit will be assigned to &irqAssert. The irqNumber indicates the position in irqAssert of the bit corresponding to the specific interrupt. This allows us to test for an assertion and acknowledge it with a bit mask. For example,

if (irqAssert & (1 << thread_resource->irqNumber)) {
  // service the interrupt here
  Irq_Acknowledge(irqAssert);    // acknowledge the IRQ(s)
}

The code necessary to respond to the IRQ interrupt should be placed inside the if-statement here.

Once the loop has terminated, we can close the ISR pthread and return a pointer, which can be NULL, as follows:

pthread_exit(NULL);
return NULL;

In lab 5, we will implement an ISR to process an indefinite number of DI interrupts.