ChibiOS/RT OS库与IPC机制#

一、OS库概述#

ChibiOS/RT的OS库（OS Library）是内核之上的高级组件集合，提供了一系列可选的IPC（进程间通信）机制和资源管理工具。OS库通过 oslib.h 头文件对外暴露接口，需要在系统初始化时调用 chLibInit() 进行初始化。

OS库的组件是可选的，可以通过 oslibconf.h 配置文件逐个启用或禁用。这种模块化设计使得开发者可以根据项目需求裁剪系统，节省宝贵的ROM和RAM资源。

1
#include "oslib.h"
2

3
void system_init(void) {
4
    /* 初始化内核 */
5
    halInit();
6
    chSysInit();
7

8
    /* 初始化OS库 */
9
    chLibInit();
10
}

OS库提供的主要IPC机制包括：

机制	数据类型	适用场景
队列（Queue）	消息（`msg_t`）	通用消息传递
对象队列（Objects Queue）	对象指针	对象池管理
对象FIFO（Objects FIFO）	固定大小对象	高性能对象传递
对象缓存（Object Cache）	任意对象	缓存与复用
动态对象工厂（Factory）	动态对象	对象生命周期管理

二、队列（Queue）#

队列是最基础的IPC机制，用于在线程之间传递 msg_t 类型的消息。队列采用FIFO（先进先出）策略，支持超时等待。

2.1 数据结构#

1
typedef struct {
2
    msg_t *buf;          /* 消息缓冲区指针 */
3
    cnt_t cnt;           /* 缓冲区大小 */
4
    cnt_t wrptr;         /* 写指针 */
5
    cnt_t rdptr;         /* 读指针 */
6
    cnt_t n;             /* 当前消息数量 */
7
    /* ... 内部等待队列 ... */
8
} queue_t;

2.2 初始化与基本操作#

1
/* 定义缓冲区和队列 */
2
#define QUEUE_SIZE 16
3
static msg_t queue_buffer[QUEUE_SIZE];
4
static queue_t queue;
5

6
void queue_example_init(void) {
7
    /* 初始化队列 */
8
    chQueueInit(&queue, queue_buffer, QUEUE_SIZE);
9
}
10

11
/* 生产者线程：发送消息 */
12
static THD_WORKING_AREA(wa_producer, 256);
13
static THD_FUNCTION(producer_thread, arg) {
14
    (void)arg;
15
    msg_t msg = 0;
16

17
    while (true) {
18
        /* 发送消息，超时100个系统滴答 */
19
        msg_t result = chQueueSendTimeout(&queue, &msg, TIME_MS2I(100));
20
        if (result == MSG_OK) {
21
            /* 发送成功 */
22
        }
23
        msg++;
24
        chThdSleepMilliseconds(50);
25
    }
26
}
27

28
/* 消费者线程：接收消息 */
29
static THD_WORKING_AREA(wa_consumer, 256);
30
static THD_FUNCTION(consumer_thread, arg) {
31
    (void)arg;
32
    msg_t msg;
33

34
    while (true) {
35
        /* 无限等待接收消息 */
36
        msg_t result = chQueueReceiveTimeout(&queue, &msg, TIME_INFINITE);
37
        if (result == MSG_OK) {
38
            /* 处理接收到的消息 */
39
            chprintf((BaseSequentialStream *)&SD1, "Received: %d\r\n", msg);
40
        }
41
    }
42
}

2.3 队列操作函数#

1
/* 初始化 */
2
void chQueueInit(queue_t *qp, msg_t *buf, cnt_t n);
3

4
/* 发送消息 */
5
msg_t chQueueSend(queue_t *qp, const msg_t *msgp);
6
msg_t chQueueSendTimeout(queue_t *qp, const msg_t *msgp, sysinterval_t timeout);
7
msg_t chQueueSendI(queue_t *qp, const msg_t *msgp);
8

9
/* 接收消息 */
10
msg_t chQueueReceive(queue_t *qp, msg_t *msgp);
11
msg_t chQueueReceiveTimeout(queue_t *qp, msg_t *msgp, sysinterval_t timeout);
12
msg_t chQueueReceiveI(queue_t *qp, msg_t *msgp);
13

14
/* 向前看（不移除） */
15
msg_t chQueuePeek(queue_t *qp, msg_t *msgp);
16

17
/* 获取当前消息数量 */
18
cnt_t chQueueGetCountI(queue_t *qp);

三、对象队列（Objects Queue）#

对象队列与普通队列类似，但它传递的是对象指针而非消息值。这使得对象队列非常适合管理对象池，避免了数据拷贝的开销。

3.1 数据结构#

1
typedef struct {
2
    void **buf;          /* 对象指针缓冲区 */
3
    cnt_t cnt;           /* 缓冲区大小 */
4
    cnt_t wrptr;         /* 写指针 */
5
    cnt_t rdptr;         /* 读指针 */
6
    cnt_t n;             /* 当前对象数量 */
7
    /* ... 内部等待队列 ... */
8
} objects_queue_t;

3.2 初始化与基本操作#

1
#define OBJ_QUEUE_SIZE 8
2
static void *obj_queue_buffer[OBJ_QUEUE_SIZE];
3
static objects_queue_t obj_queue;
4

5
/* 假设有一个自定义结构体 */
6
typedef struct {
7
    int id;
8
    char data[32];
9
} my_object_t;
10

11
static my_object_t objects[OBJ_QUEUE_SIZE];
12

13
void obj_queue_example_init(void) {
14
    /* 初始化对象队列 */
15
    chObjectsQueueInit(&obj_queue, obj_queue_buffer, OBJ_QUEUE_SIZE);
16

17
    /* 将预分配的对象放入队列 */
18
    for (int i = 0; i < OBJ_QUEUE_SIZE; i++) {
19
        objects[i].id = i;
20
        chObjectsQueuePost(&obj_queue, &objects[i]);
21
    }
22
}
23

24
/* 生产者：发布对象 */
25
static THD_WORKING_AREA(wa_obj_producer, 256);
26
static THD_FUNCTION(obj_producer_thread, arg) {
27
    (void)arg;
28

29
    while (true) {
30
        my_object_t *obj;
31
        msg_t result = chObjectsQueueFetchTimeout(&obj_queue, (void **)&obj, TIME_MS2I(200));
32
        if (result == MSG_OK) {
33
            /* 使用对象 */
34
            obj->id++;
35
            chprintf((BaseSequentialStream *)&SD1, "Object %d processed\r\n", obj->id);
36

37
            /* 归还对象 */
38
            chObjectsQueuePost(&obj_queue, obj);
39
        }
40
        chThdSleepMilliseconds(100);
41
    }
42
}

3.3 对象队列操作函数#

1
/* 初始化 */
2
void chObjectsQueueInit(objects_queue_t *oqp, void **buf, cnt_t n);
3

4
/* 发布对象 */
5
msg_t chObjectsQueuePost(objects_queue_t *oqp, void *objp);
6
msg_t chObjectsQueuePostTimeout(objects_queue_t *oqp, void *objp, sysinterval_t timeout);
7
msg_t chObjectsQueuePostI(objects_queue_t *oqp, void *objp);
8

9
/* 获取对象 */
10
msg_t chObjectsQueueFetch(objects_queue_t *oqp, void **objp);
11
msg_t chObjectsQueueFetchTimeout(objects_queue_t *oqp, void **objp, sysinterval_t timeout);
12
msg_t chObjectsQueueFetchI(objects_queue_t *oqp, void **objp);
13

14
/* 向前看 */
15
msg_t chObjectsQueuePeek(objects_queue_t *oqp, void **objp);

四、对象FIFO（Objects FIFO）#

对象FIFO是ChibiOS/RT中性能最高的IPC机制之一。它专为传递固定大小的对象而设计，内部使用环形缓冲区，支持零拷贝操作。

4.1 数据结构#

1
typedef struct {
2
    uint8_t *buf;        /* 内部缓冲区 */
3
    size_t objsize;      /* 单个对象大小 */
4
    cnt_t cnt;           /* 对象容量 */
5
    cnt_t wrptr;         /* 写指针 */
6
    cnt_t rdptr;         /* 读指针 */
7
    cnt_t n;             /* 当前对象数量 */
8
    /* ... 内部等待队列 ... */
9
} objects_fifo_t;

4.2 初始化与基本操作#

1
#define FIFO_OBJ_SIZE sizeof(sensor_data_t)
2
#define FIFO_OBJ_COUNT 16
3

4
/* 定义FIFO结构和缓冲区 */
5
static objects_fifo_t sensor_fifo;
6
static uint8_t sensor_fifo_buffer[FIFO_OBJ_COUNT * FIFO_OBJ_SIZE];
7

8
/* 传感器数据结构 */
9
typedef struct {
10
    uint32_t timestamp;
11
    int16_t temperature;
12
    uint16_t humidity;
13
    int32_t pressure;
14
} sensor_data_t;
15

16
void fifo_example_init(void) {
17
    /* 初始化对象FIFO */
18
    chObjectsFifoObjectInit(&sensor_fifo, sensor_fifo_buffer,
19
                            FIFO_OBJ_COUNT, FIFO_OBJ_SIZE);
20
}
21

22
/* 传感器线程：发布数据 */
23
static THD_WORKING_AREA(wa_sensor, 512);
24
static THD_FUNCTION(sensor_thread, arg) {
25
    (void)arg;
26

27
    while (true) {
28
        sensor_data_t data;
29
        data.timestamp = chVTGetSystemTimeX();
30
        data.temperature = read_temperature();
31
        data.humidity = read_humidity();
32
        data.pressure = read_pressure();
33

34
        /* 发布数据到FIFO */
35
        msg_t result = chObjectsFifoPostTimeout(&sensor_fifo, &data, TIME_MS2I(50));
36
        if (result != MSG_OK) {
37
            /* FIFO已满，数据丢失 */
38
        }
39

40
        chThdSleepMilliseconds(1000);
41
    }
42
}
43

44
/* 数据处理线程：获取数据 */
45
static THD_WORKING_AREA(wa_processor, 512);
46
static THD_FUNCTION(processor_thread, arg) {
47
    (void)arg;
48
    sensor_data_t data;
49

50
    while (true) {
51
        /* 从FIFO获取数据 */
52
        msg_t result = chObjectsFifoFetchTimeout(&sensor_fifo, &data, TIME_INFINITE);
53
        if (result == MSG_OK) {
54
            process_sensor_data(&data);
55
        }
56
    }
57
}

4.3 对象FIFO操作函数#

1
/* 初始化 */
2
void chObjectsFifoObjectInit(objects_fifo_t *ofp, uint8_t *buf,
3
                             cnt_t cnt, size_t objsize);
4

5
/* 发布对象（会拷贝数据） */
6
msg_t chObjectsFifoPost(objects_fifo_t *ofp, const void *objp);
7
msg_t chObjectsFifoPostTimeout(objects_fifo_t *ofp, const void *objp, sysinterval_t timeout);
8
msg_t chObjectsFifoPostI(objects_fifo_t *ofp, const void *objp);
9

10
/* 获取对象（会拷贝数据） */
11
msg_t chObjectsFifoFetch(objects_fifo_t *ofp, void *objp);
12
msg_t chObjectsFifoFetchTimeout(objects_fifo_t *ofp, void *objp, sysinterval_t timeout);
13
msg_t chObjectsFifoFetchI(objects_fifo_t *ofp, void *objp);

五、对象缓存（Object Cache）#

对象缓存提供了一种高效的对象复用机制，支持LRU（最近最少使用）淘汰策略和Hash查找。它适用于需要频繁分配和释放固定类型对象的场景。

5.1 数据结构#

1
typedef struct {
2
    void **cache;         /* 缓存对象指针数组 */
3
    cnt_t size;           /* 缓存容量 */
4
    cnt_t count;          /* 当前缓存对象数量 */
5
    /* LRU相关字段 */
6
    /* Hash相关字段 */
7
} obj_cache_t;

5.2 初始化与基本操作#

1
#define CACHE_SIZE 32
2

3
static obj_cache_t buffer_cache;
4
static void *cache_buffer[CACHE_SIZE];
5

6
/* 缓冲区对象 */
7
typedef struct {
8
    size_t size;
9
    uint8_t data[256];
10
} buffer_object_t;
11

12
static buffer_object_t buffer_objects[CACHE_SIZE];
13

14
void cache_example_init(void) {
15
    /* 初始化对象缓存 */
16
    chObjCacheObjectInit(&buffer_cache, cache_buffer, CACHE_SIZE);
17

18
    /* 预填充缓存 */
19
    for (int i = 0; i < CACHE_SIZE; i++) {
20
        chObjCacheFree(&buffer_cache, &buffer_objects[i]);
21
    }
22
}
23

24
/* 分配对象 */
25
static THD_WORKING_AREA(wa_cache_user, 512);
26
static THD_FUNCTION(cache_user_thread, arg) {
27
    (void)arg;
28

29
    while (true) {
30
        buffer_object_t *obj;
31

32
        /* 从缓存分配对象 */
33
        msg_t result = chObjCacheAlloc(&buffer_cache, (void **)&obj);
34
        if (result == MSG_OK) {
35
            /* 使用对象 */
36
            process_buffer(obj);
37

38
            /* 释放对象回缓存 */
39
            chObjCacheFree(&buffer_cache, obj);
40
        } else {
41
            /* 缓存为空，需要动态分配 */
42
            obj = chHeapAlloc(NULL, sizeof(buffer_object_t));
43
            if (obj != NULL) {
44
                process_buffer(obj);
45
                chHeapFree(obj);
46
            }
47
        }
48

49
        chThdSleepMilliseconds(50);
50
    }
51
}

5.3 对象缓存操作函数#

1
/* 初始化 */
2
void chObjCacheObjectInit(obj_cache_t *cp, void **buf, cnt_t size);
3

4
/* 分配对象 */
5
msg_t chObjCacheAlloc(obj_cache_t *cp, void **objp);
6
msg_t chObjCacheAllocI(obj_cache_t *cp, void **objp);
7

8
/* 释放对象 */
9
msg_t chObjCacheFree(obj_cache_t *cp, void *objp);
10
msg_t chObjCacheFreeI(obj_cache_t *cp, void *objp);
11

12
/* 获取缓存状态 */
13
cnt_t chObjCacheGetCountI(obj_cache_t *cp);

六、动态对象工厂（Factory）#

动态对象工厂提供了一种管理动态对象生命周期的机制。它允许注册、创建和回收对象，支持对象的引用计数和延迟释放。

6.1 数据结构#

1
typedef struct {
2
    void *obj;            /* 对象指针 */
3
    sysinterval_t lifetime; /* 对象生命周期 */
4
    /* ... 其他管理字段 ... */
5
} factory_object_t;
6

7
typedef struct {
8
    factory_object_t *objects;  /* 对象数组 */
9
    cnt_t cnt;                  /* 对象数量 */
10
    /* ... 内部管理字段 ... */
11
} factory_t;

6.2 初始化与基本操作#

1
#define FACTORY_MAX_OBJECTS 16
2

3
static factory_t my_factory;
4
static factory_object_t factory_objects[FACTORY_MAX_OBJECTS];
5

6
/* 可创建的对象类型 */
7
typedef struct {
8
    int type;
9
    void *data;
10
    size_t size;
11
} managed_object_t;
12

13
static managed_object_t managed_objects[FACTORY_MAX_OBJECTS];
14

15
void factory_example_init(void) {
16
    /* 初始化工厂 */
17
    chFactoryObjectInit(&my_factory, factory_objects, FACTORY_MAX_OBJECTS);
18

19
    /* 注册对象到工厂 */
20
    for (int i = 0; i < FACTORY_MAX_OBJECTS; i++) {
21
        managed_objects[i].type = 0;
22
        managed_objects[i].data = NULL;
23
        managed_objects[i].size = 0;
24
        chFactoryRegisterObject(&my_factory, &factory_objects[i],
25
                                &managed_objects[i]);
26
    }
27
}
28

29
/* 工作线程：获取和使用对象 */
30
static THD_WORKING_AREA(wa_factory_user, 512);
31
static THD_FUNCTION(factory_user_thread, arg) {
32
    (void)arg;
33

34
    while (true) {
35
        factory_object_t *fobj;
36
        managed_object_t *mobj;
37

38
        /* 从工厂获取对象 */
39
        msg_t result = chFactoryTakeObject(&my_factory, &fobj,
40
                                           TIME_MS2I(100));
41
        if (result == MSG_OK) {
42
            /* 获取关联的托管对象 */
43
            mobj = (managed_object_t *)chFactoryGetUserData(fobj);
44

45
            /* 使用对象 */
46
            mobj->type = 1;
47
            process_object(mobj);
48

49
            /* 归还对象到工厂 */
50
            chFactoryReleaseObject(&my_factory, fobj);
51
        }
52

53
        chThdSleepMilliseconds(200);
54
    }
55
}

6.3 工厂操作函数#

1
/* 初始化 */
2
void chFactoryObjectInit(factory_t *fp, factory_object_t *objs, cnt_t cnt);
3

4
/* 注册对象 */
5
msg_t chFactoryRegisterObject(factory_t *fp, factory_object_t *fobj, void *data);
6
msg_t chFactoryRegisterObjectI(factory_t *fp, factory_object_t *fobj, void *data);
7

8
/* 获取对象 */
9
msg_t chFactoryTakeObject(factory_t *fp, factory_object_t **fobjp, sysinterval_t timeout);
10
msg_t chFactoryTakeObjectI(factory_t *fp, factory_object_t **fobjp);
11

12
/* 释放对象 */
13
msg_t chFactoryReleaseObject(factory_t *fp, factory_object_t *fobj);
14
msg_t chFactoryReleaseObjectI(factory_t *fp, factory_object_t *fobj);
15

16
/* 获取用户数据 */
17
void *chFactoryGetUserData(factory_object_t *fobj);

七、IPC机制选择指南#

在实际项目中，选择合适的IPC机制需要考虑多个因素：

graph TB A[选择IPC机制] --> B{需要传递什么?} B -->|简单消息| C[队列 Queue] B -->|对象指针| D{对象大小是否固定?} B -->|固定大小数据| E[对象FIFO] D -->|是| E D -->|否| F{需要缓存复用?} F -->|是| G[对象缓存] F -->|否| H[对象队列] C --> I[轻量级, 适合简单通信] E --> J[高性能, 零拷贝] G --> K[高效复用, LRU淘汰] H --> L[灵活指针传递] I --> M[控制命令, 状态通知] J --> N[传感器数据, 音频流] K --> O[缓冲区管理, 网络包] L --> P[异步任务分发]

选择建议#

场景	推荐机制	理由
线程间简单命令传递	队列	最轻量，开销最小
传感器数据采集	对象FIFO	固定大小结构，高性能
网络包缓冲池	对象缓存	LRU淘汰，高效复用
异步任务分发	对象队列	灵活传递任意对象指针
复杂对象生命周期管理	动态工厂	支持引用计数和延迟释放
音频流处理	对象FIFO	零拷贝，确定性延迟
日志缓冲	队列	简单可靠，FIFO顺序

性能对比#

1
/* 性能测试示例：队列 vs 对象FIFO */
2
#include "ch.h"
3
#include "oslib.h"
4

5
#define TEST_ITERATIONS 10000
6

7
static queue_t test_queue;
8
static msg_t test_queue_buffer[64];
9

10
static objects_fifo_t test_fifo;
11
static uint8_t test_fifo_buffer[64 * sizeof(large_data_t)];
12

13
typedef struct {
14
    uint32_t data[16];  /* 64字节数据 */
15
} large_data_t;
16

17
void performance_test(void) {
18
    systime_t start, end;
19

20
    /* 测试队列性能 */
21
    chQueueInit(&test_queue, test_queue_buffer, 64);
22
    start = chVTGetSystemTimeX();
23
    for (int i = 0; i < TEST_ITERATIONS; i++) {
24
        msg_t msg = i;
25
        chQueueSend(&test_queue, &msg);
26
        chQueueReceive(&test_queue, &msg);
27
    }
28
    end = chVTGetSystemTimeX();
29
    chprintf((BaseSequentialStream *)&SD1, "Queue: %d ticks\r\n",
30
             (int)(end - start));
31

32
    /* 测试对象FIFO性能 */
33
    chObjectsFifoObjectInit(&test_fifo, test_fifo_buffer, 64, sizeof(large_data_t));
34
    large_data_t data = {0};
35
    start = chVTGetSystemTimeX();
36
    for (int i = 0; i < TEST_ITERATIONS; i++) {
37
        chObjectsFifoPost(&test_fifo, &data);
38
        chObjectsFifoFetch(&test_fifo, &data);
39
    }
40
    end = chVTGetSystemTimeX();
41
    chprintf((BaseSequentialStream *)&SD1, "Objects FIFO: %d ticks\r\n",
42
             (int)(end - start));
43
}

八、总结#

ChibiOS/RT的OS库提供了丰富且灵活的IPC机制，每种机制都有其特定的适用场景。在实际开发中，应根据数据类型、性能需求、内存限制等因素综合考虑，选择最合适的IPC机制。

队列：最基础的IPC，适合简单消息传递
对象队列：传递对象指针，适合对象池管理
对象FIFO：高性能固定大小对象传递，适合传感器数据等场景
对象缓存：提供LRU淘汰策略，适合缓冲区管理
动态工厂：完整的对象生命周期管理，适合复杂应用场景

合理使用这些IPC机制，可以构建出高效、可靠的嵌入式多线程系统。

JJZBQA