RTOS Queue 활용 — By-Value·By-Reference·Timeout 패턴

1
typedef struct { uint32_t ts; int16_t x, y, z; } sample_t;
2
QueueHandle_t samples;
3

4
void task_imu(void *arg) {
5
    sample_t s;
6
    for (;;) {
7
        read_accel(&s.x, &s.y, &s.z);
8
        s.ts = xTaskGetTickCount();
9
        if (xQueueSend(samples, &s, 0) != pdTRUE)
10
            stats.drop++;        /* full이면 즉시 drop */
11
    }
12
}
13

14
void task_logger(void *arg) {
15
    sample_t s;
16
    for (;;) {
17
        xQueueReceive(samples, &s, portMAX_DELAY);
18
        log_sample(&s);
19
    }
20
}
21

22
int main(void) {
23
    samples = xQueueCreate(64, sizeof(sample_t));
24
}

1
typedef struct { uint8_t data[1024]; size_t len; } pkt_t;
2

3
QueueHandle_t pkt_q;
4
static pkt_t pool[8];
5
SemaphoreHandle_t pool_sem;
6

7
pkt_t *pkt_alloc(void) {
8
    if (xSemaphoreTake(pool_sem, 0) != pdTRUE) return NULL;
9
    /* free list에서 하나 가져오기 */
10
    return pool_pop();
11
}
12

13
void pkt_free(pkt_t *p) {
14
    pool_push(p);
15
    xSemaphoreGive(pool_sem);
16
}
17

18
void task_rx(void *arg) {
19
    for (;;) {
20
        pkt_t *p = pkt_alloc();
21
        radio_read(p->data, &p->len);
22
        xQueueSend(pkt_q, &p, portMAX_DELAY);   /* pointer 한 word만 복사 */
23
    }
24
}
25

26
void task_parse(void *arg) {
27
    pkt_t *p;
28
    for (;;) {
29
        xQueueReceive(pkt_q, &p, portMAX_DELAY);
30
        parse(p);
31
        pkt_free(p);
32
    }
33
}

1
void UART_IRQHandler(void) {
2
    BaseType_t hp = pdFALSE;
3
    uint8_t byte = USART1->DR;
4
    xQueueSendFromISR(rx_q, &byte, &hp);
5
    portYIELD_FROM_ISR(hp);
6
}

1
/* drop on full — sender가 빠를 때 */
2
xQueueSend(q, &item, 0);
3

4
/* block on full — sender가 늦춰져도 됨 */
5
xQueueSend(q, &item, portMAX_DELAY);
6

7
/* replace on full — 최신 값만 의미 있음 */
8
xQueueOverwrite(latest_q, &item);    /* length=1 queue에만 */

1
QueueSetHandle_t qs = xQueueCreateSet(20);
2
xQueueAddToSet(cmd_q, qs);
3
xQueueAddToSet(timer_q, qs);
4

5
void task_dispatch(void *arg) {
6
    for (;;) {
7
        QueueHandle_t active = xQueueSelectFromSet(qs, portMAX_DELAY);
8
        if (active == cmd_q) {
9
            cmd_t c; xQueueReceive(cmd_q, &c, 0);
10
            handle_cmd(&c);
11
        } else if (active == timer_q) {
12
            tick_t t; xQueueReceive(timer_q, &t, 0);
13
            handle_tick(&t);
14
        }
15
    }
16
}

1
StreamBufferHandle_t sb = xStreamBufferCreate(1024, 1);
2

3
/* sender — 가변 길이 byte stream */
4
xStreamBufferSend(sb, "hello\n", 6, 0);
5

6
/* receiver */
7
char buf[64];
8
size_t n = xStreamBufferReceive(sb, buf, sizeof(buf), portMAX_DELAY);

1
연산                              시간 (Cortex-M4 72 MHz)
2
xQueueSend (sizeof 12 B)          1.4 µs
3
xQueueSend (sizeof 256 B)         3.2 µs  ← memcpy 비용
4
xQueueSend (pointer only, 4 B)    1.1 µs
5
xQueueReceive (block → wake)      6.8 µs
6
xStreamBufferSend (32 B)          1.3 µs

1
RAM 사용량
2
queue (N=64, item 12 B)           Queue 구조 + 768 B
3
queue (N=8, pointer 4 B)          Queue 구조 + 32 B + pool 8 KB

1
void send_msg(void) {
2
    char buf[64];               /* stack */
3
    sprintf(buf, "hello");
4
    xQueueSend(q, &buf, 0);     /* receiver가 받기 전에 buf 소멸 */
5
}

1
pkt_t *p = pkt_alloc();
2
xQueueSend(q, &p, 0);    /* p가 NULL이면 receiver crash */

1
QueueHandle_t q = xQueueCreate(64, sizeof(pkt_t *));   /* 4 B per slot */
2
pkt_t p;
3
xQueueSend(q, &p, 0);    /* by-value인 줄 알았다면 첫 4 byte만 복사됨 */

1
xQueueSend(q, &item, portMAX_DELAY);   /* consumer가 죽으면 producer도 영구 block */