MENU
  1. ホーム
  2. C 언어
  3. C 언어로 배우는 인터럽트와 핸들링 기법

C 언어로 배우는 인터럽트와 핸들링 기법

C 언어

C 언어에서 인터럽트와 인터럽트 핸들링은 실시간 시스템 및 임베디드 시스템 개발에서 중요한 역할을 합니다. 인터럽트는 시스템이 특정 이벤트를 즉각적으로 처리할 수 있도록 하는 메커니즘으로, CPU의 주 실행 흐름을 방해하여 이벤트를 처리하는 코드를 실행합니다. 본 기사에서는 인터럽트의 기본 개념, C 언어에서의 구현 방법, 그리고 효율적인 핸들링 기법에 대해 알아봅니다. 이를 통해 인터럽트의 작동 원리를 이해하고, 실제 응용 프로그램에서 이를 효과적으로 활용하는 방법을 배울 수 있습니다.

목차
  1. 인터럽트란 무엇인가?
    1. 인터럽트의 동작 원리
    2. 인터럽트의 주요 특징
    3. 인터럽트의 일반적인 용도
  2. 하드웨어 인터럽트와 소프트웨어 인터럽트
    1. 하드웨어 인터럽트
    2. 소프트웨어 인터럽트
    3. 주요 차이점
  3. 인터럽트 핸들링의 기본 원칙
    1. 핵심 원칙
    2. 효율적인 핸들링을 위한 추가 팁
  4. C 언어에서의 인터럽트 구현
    1. 인터럽트 처리의 기본 구조
    2. 코드 예제: AVR 마이크로컨트롤러에서의 인터럽트
    3. 코드 설명
    4. 주요 고려사항
  5. 인터럽트 우선순위 관리
    1. 인터럽트 우선순위의 기본 개념
    2. 우선순위 관리 방법
    3. 우선순위 관리의 주요 고려사항
    4. 실제 응용
  6. 인터럽트와 멀티스레딩
    1. 인터럽트와 멀티스레딩의 상호작용
    2. 주요 설계 고려사항
    3. 문제 방지를 위한 팁
    4. 실제 응용
  7. 실습: 간단한 인터럽트 처리 프로그램
    1. 목표
    2. 환경 및 요구사항
    3. 코드 예제
    4. 코드 설명
    5. 실행 결과
    6. 확장 및 응용
    7. 결론
  8. 요약

인터럽트란 무엇인가?


인터럽트(Interrupt)는 컴퓨터 시스템에서 특정 이벤트가 발생했음을 CPU에 알려주는 메커니즘입니다. 이를 통해 CPU는 기존 작업을 일시적으로 중단하고, 긴급한 작업을 처리할 수 있습니다.

인터럽트의 동작 원리

  1. 이벤트 발생: 하드웨어 장치나 소프트웨어에 의해 인터럽트가 발생합니다.
  2. 인터럽트 신호 전달: CPU는 인터럽트 컨트롤러(Interrupt Controller)를 통해 신호를 수신합니다.
  3. 현재 작업 저장: CPU는 현재 상태(프로그램 카운터와 레지스터 값 등)를 저장하여 나중에 복구할 수 있도록 준비합니다.
  4. 인터럽트 핸들러 실행: 미리 정의된 인터럽트 핸들러(Interrupt Handler) 코드로 점프하여 해당 작업을 처리합니다.
  5. 원래 작업 복귀: 인터럽트 처리 후, CPU는 저장된 상태를 복구하고 중단된 작업을 이어서 수행합니다.

인터럽트의 주요 특징

  • 비동기적 동작: 인터럽트는 프로그램의 실행 흐름과 독립적으로 발생합니다.
  • 효율적인 리소스 활용: CPU가 특정 이벤트를 기다리지 않고 다른 작업을 수행할 수 있도록 합니다.
  • 우선순위 기반 처리: 시스템은 중요한 인터럽트를 먼저 처리하기 위해 우선순위를 설정할 수 있습니다.

인터럽트의 일반적인 용도

  • 하드웨어 제어: 키보드 입력, 타이머, 네트워크 패킷 수신 등에서 발생하는 하드웨어 이벤트 처리
  • 소프트웨어 이벤트 처리: 예외 상황이나 시스템 호출

인터럽트는 시스템의 반응성을 높이고 리소스를 효율적으로 활용하기 위한 핵심 요소로, 다양한 시스템에서 폭넓게 사용됩니다.

하드웨어 인터럽트와 소프트웨어 인터럽트


인터럽트는 발생 원인에 따라 하드웨어 인터럽트와 소프트웨어 인터럽트로 나눌 수 있습니다. 이 두 유형은 발생 조건과 처리 방식에서 차이가 있습니다.

하드웨어 인터럽트


하드웨어 인터럽트는 물리적인 장치에서 발생하는 이벤트로 인해 트리거됩니다.
예시:

  • 키보드 입력: 키를 누를 때 발생하는 인터럽트
  • 타이머 이벤트: 특정 시간 간격마다 발생하는 인터럽트
  • I/O 장치 요청: 하드 디스크, 네트워크 카드 등의 데이터 전송 요청

특징:

  • 장치에서 직접 인터럽트 신호를 CPU에 보냅니다.
  • 주로 인터럽트 컨트롤러를 통해 관리됩니다.
  • 일반적으로 높은 우선순위를 가집니다(예: 긴급한 하드웨어 이벤트).

소프트웨어 인터럽트


소프트웨어 인터럽트는 소프트웨어에서 명령어 실행을 통해 의도적으로 발생시킵니다.
예시:

  • 시스템 호출(System Call): 사용자 모드에서 커널 모드로 전환하기 위해 사용
  • 예외 처리(Exception Handling): 잘못된 메모리 접근이나 0으로 나누기 등

특징:

  • CPU에서 특정 명령어(예: int 명령)를 실행하여 발생합니다.
  • 개발자가 프로그래밍으로 인터럽트를 발생시킬 수 있습니다.
  • 디버깅 및 오류 처리에 유용하게 사용됩니다.

주요 차이점

특징하드웨어 인터럽트소프트웨어 인터럽트
발생 원인물리적 장치 이벤트소프트웨어 명령어 실행
예시키보드 입력, 네트워크 요청시스템 호출, 예외 처리
우선순위상대적으로 높음상대적으로 낮음
제어 방식장치에서 CPU로 신호 전송프로그래머에 의해 발생

하드웨어 인터럽트와 소프트웨어 인터럽트는 각각의 특성과 용도에 따라 시스템에서 균형 잡힌 방식으로 사용됩니다. 이를 이해하고 적절히 활용하면 효율적인 시스템 설계가 가능합니다.

인터럽트 핸들링의 기본 원칙


효율적이고 안정적인 인터럽트 처리를 위해서는 몇 가지 핵심 원칙을 따라야 합니다. 인터럽트 핸들링의 기본 원칙은 응답 시간을 최소화하고, 시스템의 안정성과 일관성을 유지하는 데 초점이 맞춰져 있습니다.

핵심 원칙

1. 인터럽트 핸들러는 신속해야 한다


인터럽트 핸들러는 가능한 짧은 시간 내에 실행을 완료해야 합니다.

  • CPU 점유 시간을 최소화하여 다른 인터럽트가 차단되지 않도록 합니다.
  • 복잡한 작업은 핸들러에서 처리하지 않고 별도의 작업 스케줄러로 넘기는 것이 좋습니다.

2. 상태를 안전하게 저장하고 복구한다


인터럽트가 발생하면 CPU의 상태(레지스터, 프로그램 카운터 등)를 저장하고, 핸들링이 끝난 후 이를 정확히 복구해야 합니다.

  • 저장과 복구 과정은 하드웨어나 운영 체제가 자동으로 처리하는 경우가 많습니다.
  • 잘못된 상태 복구는 시스템 오류를 유발할 수 있으므로 신중해야 합니다.

3. 동기화 문제를 방지한다


인터럽트 핸들러는 다른 코드와 동시에 실행될 수 있으므로, 데이터 동기화 문제를 주의해야 합니다.

  • 뮤텍스(Mutex) 또는 스핀락(Spinlock) 등의 동기화 메커니즘을 사용합니다.
  • 크리티컬 섹션을 최소화하여 교착 상태를 방지합니다.

4. 우선순위를 고려한 처리


여러 인터럽트가 발생할 경우, 우선순위가 높은 인터럽트를 먼저 처리해야 합니다.

  • 인터럽트 우선순위 레벨(IPL)을 설정하여 중요한 작업이 지연되지 않도록 합니다.
  • 우선순위에 따라 핸들러가 중첩 처리될 수 있어야 합니다.

효율적인 핸들링을 위한 추가 팁

  • 재진입 가능성(Reentrant Safety): 인터럽트 핸들러가 다시 호출되어도 문제가 없도록 설계합니다.
  • 에러 검출 및 복구: 인터럽트 핸들러에서 발생할 수 있는 오류를 탐지하고, 시스템을 안정적으로 복구하는 로직을 포함시킵니다.
  • 로깅과 디버깅: 인터럽트 핸들러의 동작을 추적할 수 있도록 로깅 기능을 추가합니다.

인터럽트 핸들링의 기본 원칙을 준수하면 시스템의 안정성과 반응성을 극대화할 수 있습니다. 이러한 원칙은 다양한 환경에서의 인터럽트 처리 설계에 필수적입니다.

C 언어에서의 인터럽트 구현


C 언어에서는 하드웨어 및 소프트웨어 인터럽트를 처리하기 위한 다양한 방법을 제공합니다. 이는 주로 특정 마이크로컨트롤러의 레지스터와 인터럽트 벡터를 활용하여 구현됩니다. 아래는 인터럽트 처리의 일반적인 구조와 코드 예제를 설명합니다.

인터럽트 처리의 기본 구조

  1. 인터럽트 벡터 테이블 설정:
  • 특정 인터럽트가 발생했을 때 실행할 핸들러의 주소를 저장하는 테이블입니다.
  • 이 테이블은 일반적으로 하드웨어에 의해 관리됩니다.
  1. 인터럽트 핸들러 함수 작성:
  • 특정 인터럽트를 처리할 코드로 구성됩니다.
  • 핸들러는 짧고 간결하게 작성해야 합니다.
  1. 인터럽트 활성화:
  • 특정 하드웨어 인터럽트를 활성화하거나 소프트웨어 인터럽트를 트리거합니다.

코드 예제: AVR 마이크로컨트롤러에서의 인터럽트

#include <avr/io.h>
#include <avr/interrupt.h>

// LED를 제어하기 위한 핀 설정
#define LED_PIN PB0

// 인터럽트 핸들러 함수
ISR(TIMER1_COMPA_vect) {
    // LED 토글
    PORTB ^= (1 << LED_PIN);
}

int main(void) {
    // LED 핀을 출력 모드로 설정
    DDRB |= (1 << LED_PIN);

    // 타이머 1 초기화
    TCCR1B |= (1 << WGM12);   // CTC 모드 설정
    TIMSK1 |= (1 << OCIE1A);  // 비교 일치 인터럽트 활성화
    OCR1A = 15624;            // 비교 일치 값 설정 (1초 간격)
    TCCR1B |= (1 << CS12);    // 분주기 설정 (256)

    // 글로벌 인터럽트 활성화
    sei();

    while (1) {
        // 메인 루프
    }
    return 0;
}

코드 설명

  1. ISR 매크로:
  • 인터럽트 핸들러를 정의하는 매크로로, TIMER1_COMPA_vect는 특정 타이머 인터럽트를 나타냅니다.
  1. LED 토글:
  • 인터럽트가 발생할 때마다 LED 상태를 반전시킵니다.
  1. 글로벌 인터럽트 활성화:
  • sei() 명령어를 사용하여 시스템 전역 인터럽트를 활성화합니다.

주요 고려사항

  • 타이밍 정확성: 타이머와 클럭 주파수를 적절히 설정하여 정확한 인터럽트 타이밍을 유지해야 합니다.
  • 오버헤드 관리: 인터럽트 핸들러에서 복잡한 연산은 피하고, 가능한 한 간결한 작업만 수행해야 합니다.
  • 디버깅: 인터럽트는 디버깅이 어렵기 때문에 로깅이나 시뮬레이션 도구를 활용하는 것이 중요합니다.

C 언어에서의 인터럽트 구현은 하드웨어의 동작을 세부적으로 제어할 수 있는 강력한 방법입니다. 이를 통해 효율적이고 반응성이 높은 시스템을 개발할 수 있습니다.

인터럽트 우선순위 관리


여러 인터럽트가 동시에 발생할 경우, 시스템은 우선순위를 기반으로 처리 순서를 결정합니다. 인터럽트 우선순위 관리(Priority Management)는 중요한 인터럽트를 신속하게 처리하고, 덜 중요한 작업은 나중에 실행되도록 조율하는 데 핵심적인 역할을 합니다.

인터럽트 우선순위의 기본 개념

  1. 우선순위 레벨(Priority Level)
  • 각 인터럽트에는 특정 우선순위가 할당됩니다.
  • 우선순위가 높은 인터럽트는 낮은 우선순위의 인터럽트를 차단하거나 중단시킬 수 있습니다.
  1. 중첩 가능성(Nested Interrupts)
  • 우선순위가 높은 인터럽트가 발생하면, 현재 실행 중인 낮은 우선순위의 핸들러를 중단하고 즉시 높은 우선순위를 처리합니다.
  1. 인터럽트 마스킹(Interrupt Masking)
  • 특정 인터럽트를 비활성화하거나 차단하여, 중요한 작업 중에는 방해받지 않도록 설정할 수 있습니다.

우선순위 관리 방법

1. 하드웨어 기반 우선순위

  • 인터럽트 컨트롤러 사용:
    인터럽트 컨트롤러(예: PIC, APIC)는 하드웨어적으로 인터럽트 우선순위를 관리합니다.
  • 우선순위 레지스터 설정:
    마이크로컨트롤러에서 특정 레지스터를 설정하여 우선순위를 제어합니다.

코드 예제 (ARM Cortex-M):

#include "stm32f4xx.h"

void setup_interrupt_priorities() {
    // NVIC에서 우선순위 설정 (0: 최고 우선순위)
    NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 1); // 타이머 1 업데이트 인터럽트
    NVIC_SetPriority(USART1_IRQn, 2);        // UART 인터럽트

    // 인터럽트 활성화
    NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
    NVIC_EnableIRQ(USART1_IRQn);
}

2. 소프트웨어 기반 우선순위

  • 인터럽트 핸들러 내부에서 추가 로직을 구현하여 우선순위를 소프트웨어적으로 조정합니다.

코드 예제:

volatile int high_priority_event = 0;

void ISR_high_priority() {
    high_priority_event = 1;
}

void ISR_low_priority() {
    if (!high_priority_event) {
        // 낮은 우선순위 작업 실행
    }
}

우선순위 관리의 주요 고려사항

  1. 교착 상태 방지
  • 잘못된 우선순위 설정은 교착 상태(Deadlock)를 초래할 수 있으므로, 신중한 설계가 필요합니다.
  1. 응답 시간 최소화
  • 중요한 인터럽트가 지연되지 않도록 우선순위 설계 시 응답 시간을 고려해야 합니다.
  1. 우선순위 역전 방지
  • 낮은 우선순위의 작업이 높은 우선순위 작업보다 먼저 실행되지 않도록 설계합니다.

실제 응용

  • 실시간 시스템: 로봇 제어, 의료기기 등에서 중요한 이벤트를 빠르게 처리하기 위해 우선순위 관리가 필수적입니다.
  • 네트워크 시스템: 데이터 패킷 처리에서 중요한 패킷을 우선적으로 처리하는 데 활용됩니다.

효율적인 인터럽트 우선순위 관리는 시스템의 안정성과 성능을 유지하는 데 필수적이며, 특히 실시간 시스템에서 매우 중요합니다.

인터럽트와 멀티스레딩


인터럽트와 멀티스레딩은 동시에 실행되는 작업을 처리하기 위한 주요 기술로, 두 개념 간의 상호작용은 시스템 성능과 안정성에 큰 영향을 미칩니다. 적절한 설계를 통해 인터럽트와 멀티스레딩 간의 충돌이나 리소스 경합 문제를 방지할 수 있습니다.

인터럽트와 멀티스레딩의 상호작용

1. 동시성 문제

  • 인터럽트와 스레드는 동일한 데이터나 리소스를 동시에 접근할 수 있으므로, 데이터 경합 문제가 발생할 수 있습니다.
  • 예를 들어, 한 스레드가 데이터를 수정하는 도중에 인터럽트 핸들러가 동일한 데이터에 접근하면 충돌이 발생할 수 있습니다.

2. 우선순위 처리

  • 인터럽트는 대부분의 멀티스레드 작업보다 높은 우선순위를 가지며, 즉시 처리됩니다.
  • 멀티스레딩 환경에서는 인터럽트 처리와 스레드 간의 우선순위를 조율해야 합니다.

3. 스레드 안전성(Thread Safety)

  • 인터럽트 핸들러는 재진입 가능(Reentrant)하도록 설계되어야 하며, 스레드 안전성을 보장하기 위한 추가 메커니즘이 필요합니다.

주요 설계 고려사항

1. 크리티컬 섹션 보호

  • 인터럽트 핸들러와 스레드가 동시에 접근하는 공유 자원은 크리티컬 섹션으로 보호해야 합니다.
  • 스핀락(Spinlock) 또는 뮤텍스(Mutex)를 사용하여 상호 배제를 보장합니다.

예제 코드:

volatile int shared_data = 0;
volatile int interrupt_flag = 0;

void ISR_handler() {
    interrupt_flag = 1;
    shared_data++;
}

void thread_function() {
    while (1) {
        if (interrupt_flag) {
            interrupt_flag = 0;
            // 공유 데이터 처리
            shared_data *= 2;
        }
    }
}

2. 인터럽트 마스킹

  • 특정 크리티컬 섹션에서는 인터럽트를 일시적으로 비활성화하여 안전한 작업이 이루어지도록 합니다.
  • 인터럽트 마스킹은 짧은 시간 동안만 유지해야 합니다.

예제 코드:

void critical_section() {
    cli(); // 인터럽트 비활성화
    // 크리티컬 작업
    sei(); // 인터럽트 활성화
}

3. 우선순위 기반 스케줄링

  • 멀티스레딩과 인터럽트 간의 효율적인 스케줄링을 위해 우선순위 기반 스케줄링을 설계합니다.

문제 방지를 위한 팁

  • 재진입 가능 설계: 인터럽트 핸들러가 중첩 호출되어도 문제가 없도록 설계합니다.
  • 타이밍 분석: 인터럽트 처리 시간과 스레드 실행 시간을 분석하여 동작을 최적화합니다.
  • 디버깅 도구 활용: 인터럽트와 스레드 간의 상호작용을 시뮬레이션하여 문제를 사전에 탐지합니다.

실제 응용

  • 임베디드 시스템: 센서 데이터 수집과 실시간 처리에서 인터럽트와 멀티스레딩이 함께 사용됩니다.
  • 운영 체제 커널: 하드웨어 이벤트 처리와 스레드 스케줄링 간의 조율이 필요합니다.

인터럽트와 멀티스레딩은 고성능 시스템 개발의 핵심 요소입니다. 적절한 설계 원칙을 따른다면, 동시성 문제를 해결하고 시스템의 안정성과 반응성을 높일 수 있습니다.

실습: 간단한 인터럽트 처리 프로그램


이 실습에서는 하드웨어 타이머 인터럽트를 활용하여 간단한 LED 깜박임 프로그램을 작성합니다. 이 예제는 인터럽트의 동작 원리를 이해하고, 실제 시스템에서 이를 구현하는 방법을 보여줍니다.

목표

  • 하드웨어 타이머 인터럽트를 설정하여 주기적인 작업을 수행합니다.
  • 인터럽트 핸들러를 작성하고, LED를 주기적으로 깜박이게 합니다.

환경 및 요구사항

  • 마이크로컨트롤러: AVR ATmega328P(Arduino Uno)
  • IDE: Arduino IDE 또는 AVR-GCC
  • 하드웨어: LED와 저항(330Ω)

코드 예제

#include <avr/io.h>
#include <avr/interrupt.h>

// LED가 연결된 핀 정의
#define LED_PIN PB0

// 타이머 1 비교 일치 인터럽트 핸들러
ISR(TIMER1_COMPA_vect) {
    // LED 상태 토글
    PORTB ^= (1 << LED_PIN);
}

void setup_timer() {
    // 타이머 1 설정
    TCCR1B |= (1 << WGM12); // CTC 모드
    OCR1A = 15624;          // 비교 일치 값 설정 (1초 간격)
    TCCR1B |= (1 << CS12);  // 분주기 256 설정
    TIMSK1 |= (1 << OCIE1A); // 비교 일치 인터럽트 활성화
}

int main(void) {
    // LED 핀을 출력 모드로 설정
    DDRB |= (1 << LED_PIN);

    // 타이머 설정
    setup_timer();

    // 전역 인터럽트 활성화
    sei();

    // 메인 루프 (실질적으로는 비어 있음)
    while (1) {
        // 주 작업은 인터럽트 핸들러에서 처리
    }

    return 0;
}

코드 설명

  1. ISR(TIMER1_COMPA_vect):
  • 타이머 1 비교 일치 인터럽트가 발생했을 때 호출되는 핸들러입니다.
  • LED의 상태를 토글하여 깜박이는 동작을 구현합니다.
  1. 타이머 설정:
  • CTC 모드로 타이머를 설정하고, 비교 일치 값을 설정하여 1초 간격으로 인터럽트를 발생시킵니다.
  1. 인터럽트 활성화:
  • sei() 함수로 전역 인터럽트를 활성화합니다.

실행 결과

  • LED가 1초 간격으로 켜지고 꺼지는 것을 확인할 수 있습니다.
  • 메인 루프는 비어 있으며, 모든 작업은 인터럽트 핸들러에서 처리됩니다.

확장 및 응용

1. 다중 타이머 활용

  • 추가 타이머를 설정하여 서로 다른 주기의 작업을 수행합니다.

2. 소프트웨어 인터럽트 추가

  • 소프트웨어 인터럽트를 활용하여 이벤트 기반 동작을 추가합니다.

3. 디버깅 기능 추가

  • 인터럽트 발생 횟수를 카운팅하거나, UART를 통해 로그를 출력하여 동작을 확인합니다.

결론


이 실습을 통해 인터럽트 핸들러와 하드웨어 타이머 설정의 기본 개념을 익힐 수 있습니다. 간단한 LED 제어를 시작으로, 더 복잡한 실시간 작업으로 확장할 수 있습니다. 인터럽트는 임베디드 시스템 개발에서 핵심적인 역할을 하므로, 이를 제대로 이해하고 활용하는 것이 중요합니다.

요약


본 기사에서는 C 언어에서 인터럽트와 인터럽트 핸들링의 기본 개념부터 구현 방법, 우선순위 관리, 멀티스레딩과의 상호작용, 그리고 간단한 실습까지 다뤘습니다.

인터럽트는 실시간 시스템에서 필수적인 메커니즘으로, CPU의 자원을 효율적으로 사용하고 이벤트에 즉각적으로 대응할 수 있게 합니다. 효율적인 핸들링을 위해서는 인터럽트의 구조와 동작 원리를 이해하고, 크리티컬 섹션 보호와 우선순위 관리 같은 설계 원칙을 준수해야 합니다.

실습 예제를 통해 인터럽트의 실제 구현 방법을 배우고, 이를 확장하여 복잡한 응용 프로그램을 설계할 수 있습니다. 인터럽트는 시스템의 안정성과 반응성을 높이는 데 중요한 역할을 하므로, 이를 정확히 이해하고 활용하는 것이 중요합니다.

C 언어
C언어 인터럽트 인터럽트 핸들링
목차
  1. 인터럽트란 무엇인가?
    1. 인터럽트의 동작 원리
    2. 인터럽트의 주요 특징
    3. 인터럽트의 일반적인 용도
  2. 하드웨어 인터럽트와 소프트웨어 인터럽트
    1. 하드웨어 인터럽트
    2. 소프트웨어 인터럽트
    3. 주요 차이점
  3. 인터럽트 핸들링의 기본 원칙
    1. 핵심 원칙
    2. 효율적인 핸들링을 위한 추가 팁
  4. C 언어에서의 인터럽트 구현
    1. 인터럽트 처리의 기본 구조
    2. 코드 예제: AVR 마이크로컨트롤러에서의 인터럽트
    3. 코드 설명
    4. 주요 고려사항
  5. 인터럽트 우선순위 관리
    1. 인터럽트 우선순위의 기본 개념
    2. 우선순위 관리 방법
    3. 우선순위 관리의 주요 고려사항
    4. 실제 응용
  6. 인터럽트와 멀티스레딩
    1. 인터럽트와 멀티스레딩의 상호작용
    2. 주요 설계 고려사항
    3. 문제 방지를 위한 팁
    4. 실제 응용
  7. 실습: 간단한 인터럽트 처리 프로그램
    1. 목표
    2. 환경 및 요구사항
    3. 코드 예제
    4. 코드 설명
    5. 실행 결과
    6. 확장 및 응용
    7. 결론
  8. 요약