Semaphore 개념 분해 — Counting·Binary·P/V 연산

1
xSemaphoreTake(sem, timeout);   // P
2
xSemaphoreGive(sem);            // V

1
SemaphoreHandle_t data_ready = xSemaphoreCreateBinary();
2

3
// ISR — 데이터 도착 알림
4
void USART_IRQHandler(void) {
5
    BaseType_t woken = pdFALSE;
6
    xSemaphoreGiveFromISR(data_ready, &woken);
7
    portYIELD_FROM_ISR(woken);
8
}
9

10
// Task — 데이터 처리
11
void rx_task(void *arg) {
12
    while (1) {
13
        xSemaphoreTake(data_ready, portMAX_DELAY);
14
        process_uart_data();
15
    }
16
}

1
// 5개 buffer 풀
2
SemaphoreHandle_t bufferPool = xSemaphoreCreateCounting(5, 5);
3

4
void producer(void *arg) {
5
    while (1) {
6
        xSemaphoreTake(bufferPool, portMAX_DELAY);  // 자원 1개 점유
7
        Buffer *buf = allocate_buffer();
8
        fill_buffer(buf);
9
        push_to_consumer(buf);
10
    }
11
}
12

13
void consumer(void *arg) {
14
    while (1) {
15
        Buffer *buf = pop_from_producer();
16
        process(buf);
17
        free_buffer(buf);
18
        xSemaphoreGive(bufferPool);                  // 자원 반환
19
    }
20
}

1
typedef struct {
2
    int count;                  // 현재 카운터
3
    int max_count;              // 최대 (counting만)
4
    List_t wait_list;           // P()에서 대기 중인 task들
5
} Semaphore_t;
6

7
int sem_take(Semaphore_t *s, TickType_t timeout) {
8
    portENTER_CRITICAL();
9
    if (s->count > 0) {
10
        s->count--;
11
        portEXIT_CRITICAL();
12
        return SUCCESS;
13
    }
14
    // 대기 list에 자신 추가
15
    add_to_wait_list(s->wait_list, current_task);
16
    portEXIT_CRITICAL();
17

18
    block_with_timeout(timeout);  // ← context switch
19
    // 깨어남
20
    return (timeout_expired) ? TIMEOUT : SUCCESS;
21
}
22

23
void sem_give(Semaphore_t *s) {
24
    portENTER_CRITICAL();
25
    if (!list_empty(s->wait_list)) {
26
        Task_t *waiter = pop_highest_priority(s->wait_list);
27
        wake_task(waiter);          // Ready list로
28
    } else {
29
        s->count++;
30
    }
31
    portEXIT_CRITICAL();
32
}

1
SemaphoreHandle_t click_counter = xSemaphoreCreateCounting(255, 0);
2

3
// ISR — 버튼 클릭마다
4
xSemaphoreGiveFromISR(click_counter, &woken);
5

6
// Task — 누적된 클릭 처리
7
while (xSemaphoreTake(click_counter, 0) == pdTRUE) {
8
    process_one_click();
9
}

1
SemaphoreHandle_t rate_limit = xSemaphoreCreateCounting(10, 10);
2
// 10 token으로 시작
3

4
// 매 100 ms마다 1 token 보충 (timer task)
5
void refill_timer(void) {
6
    xSemaphoreGive(rate_limit);
7
}
8

9
// 요청 시 token 소비
10
void request(void *arg) {
11
    xSemaphoreTake(rate_limit, portMAX_DELAY);
12
    do_request();
13
}

1
// ISR Give — OK
2
xSemaphoreGiveFromISR(sem, &woken);
3

4
// ISR Take — 거의 안 함 (의미 없음, blocking 불가)
5
// 굳이 한다면 timeout=0으로
6
xSemaphoreTakeFromISR(sem, &woken);

1
// ISR
2
volatile int ready = 0;
3
ready = 1;
4
xSemaphoreGiveFromISR(sem, &woken);
5

6
// Task
7
if (!ready) {                          // (1)
8
    // ← ISR이 여기서 발생, ready=1, give!
9
    xSemaphoreTake(sem, portMAX_DELAY); // (2) 영원히 대기
10
}

1
T_low가 semaphore 소유 → T_high가 take 대기
2
T_med가 실행 → T_low preempt
3
T_high가 *T_med 끝날 때까지* 대기 (priority inversion)

1
// Dynamic — heap에서
2
SemaphoreHandle_t sem = xSemaphoreCreateBinary();
3

4
// Static — 컴파일 타임 메모리
5
StaticSemaphore_t sem_buf;
6
SemaphoreHandle_t sem = xSemaphoreCreateBinaryStatic(&sem_buf);