Interrupt Handling and Interrupt Service Routines in C Language

In the development of embedded systems and operating systems, interrupts are an important mechanism. They allow programs to respond immediately to specific events without the need to constantly poll device status. This article will provide a detailed introduction to interrupt handling in C language and its related concepts, suitable for beginners to learn.

What is an Interrupt?

An interrupt is a signal sent by computer hardware or software to notify the CPU that an event needs to be handled. When an interrupt occurs, the CPU pauses the currently executing task, saves its state, and then executes the code associated with that interrupt, which is called an Interrupt Service Routine (ISR).

Types of Interrupts

1. External Interrupts: Generated by external devices (such as keyboards, mice, network interfaces, etc.).
2. Internal Interrupts: Generated by internal conditions of the program (such as division by zero errors, overflows, etc.).
3. Timer Interrupts: Generated by the system timer for time management.

The Basic Process of Interrupts

1. An event occurs, triggering the corresponding hardware or software signal.
2. The CPU checks for pending interrupt requests after completing the current instruction.
3. If there are any, it halts the current task and saves the context information.
4. It jumps to the corresponding ISR to execute the code.
5. After the ISR completes, it restores the previously saved context information and continues executing the interrupted task.

A Simple Example in C Language

Below, we will demonstrate how to set up and use an ISR in a C language environment through a simple example. Suppose we want to handle a middle key input as an external event:

Example Code

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
// Define a global variable to represent the key state
volatile sig_atomic_t key_pressed = 0;
// Interrupt Service Routine
void handle_signal(int signal) {
    if (signal == SIGINT) {
        key_pressed = 1; // Set the key pressed flag
        printf("Interrupt received! Key pressed.\n");
    }
}
int main() {
    // Register SIGINT signal handler
    signal(SIGINT, handle_signal);
    printf("Press Ctrl+C to trigger the interrupt...\n");
    while (1) {
        if (key_pressed) {
            // Perform corresponding actions, such as cleaning up resources or exiting the loop
            printf("Exiting program gracefully...\n");
            break;
        }
        // Simulate the main program running process
        sleep(1);
    }
    return 0;
}

Code Explanation

• <span>#include <signal.h></span>: Includes the signal header file to use signal-related functions.
• <span>volatile sig_atomic_t key_pressed</span>: Declares a global variable<span>key_pressed</span> to mark whether a key signal has been received. The <span>volatile</span> keyword ensures that the compiler does not optimize this variable, thus guaranteeing that each access is the latest value.
• <span>handle_signal(int signal)</span>: Defines our ISR, which is called when SIGINT (usually the Ctrl+C key combination) is received, setting<span>key_pressed</span> to 1 and printing a message.
• In the main function, we register the SIGINT signal with our ISR, then enter an infinite loop. Inside the loop, if<span>key_pressed</span> is detected as true, we perform the corresponding actions and exit the loop.

Conclusion

Through the above content, we have learned what an interrupt is and how to implement a simple ISR in a C language environment. This is just a simplified demonstration of more complex application scenarios. In actual application development, the design of interrupts and ISRs may involve more details, such as priority management and shared resource protection, but understanding the basic principles is crucial for further learning.

I hope this article helps you better understand interrupts and ISRs in C language!