自定义循环队列、软件定时器、事件集，实用嵌入式代码库

toolkit
├── include                         // 包含文件目录
|   ├── toolkit.h                   // toolkit头文件
|   └── toolkit_cfg.h               // toolkit配置文件
├── src                             // toolkit源码目录
|   ├── tk_queue.c                  // 循环队列源码
|   ├── tk_timer.c                  // 软件定时器源码
|   └── tk_event.c                  // 事件集源码
├── samples                         // 例子
|   ├── tk_queue_samples.c          // 循环队列使用例程源码
|   ├── tk_timer_samples.c          // 软件定时器使用例程源码
|   └── tk_event_samples.c          // 事件集使用例程源码
└── README.md                       // 说明文档

struct tk_queue *tk_queue_create(uint16_t queue_size, uint16_t max_queues, bool keep_fresh);

int main(int argc, char *argv[])
{
    /* 动态方式创建一个循环队"queue",缓冲区大小50字节，不保持最新 */
    struct tk_queue *queue = tk_queue_create(50, 1, false);
    if( queue == NULL){
        printf("队列创建失败!\n");
    }
    /* ... */
    /* You can add your code under here. */
    return 0;
}

bool tk_queue_delete(struct tk_queue *queue);

bool tk_queue_init(struct tk_queue *queue, void *queuepool, uint16_t pool_size, uint16_t queue_size, bool keep_fresh);

int main(int argc, char *argv[])
{
    /* 定义一个循环队列 */
    struct tk_queue queue;
    /* 定义循环队列缓冲区 */
    uint8_t queue_pool[100];
    /* 静态方式创建一个循环队列"queue",缓存区为queue_pool，大小为queue_pool的大小,模式为保持最新 */
    if( tk_queue_init(&queue, queue_pool, sizeof(queue_pool), 
                      sizeof(queue_pool[0]), true) == false){
        printf("队列创建失败!\n");
    }
    /* ... */
    /* You can add your code under here. */
}

bool tk_queue_detach(struct tk_queue *queue);

bool tk_queue_clean(struct tk_queue *queue);

bool tk_queue_empty(struct tk_queue *queue);

bool tk_queue_full(struct tk_queue *queue);

bool tk_queue_peep(struct tk_queue *queue, void *pval);

bool tk_queue_remove(struct tk_queue *queue);

bool tk_queue_push(struct tk_queue *queue, void *val);

bool tk_queue_pop(struct tk_queue *queue, void *pval);

uint16_t tk_queue_curr_len(struct tk_queue *queue);

uint16_t tk_queue_push_multi(struct tk_queue *queue, void *pval, uint16_t len);

uint16_t tk_queue_pop_multi(struct tk_queue *queue, void *pval, uint16_t len);

bool tk_timer_func_init(uint32_t (*get_tick_func)(void));

struct tk_timer *tk_timer_create(void(*timeout_callback)(struct tk_timer *timer));

/* 定义获取系统tick回调函数 */
uint32_t get_sys_tick(void)
{
    return tick;
}

/* 定时器超时回调函数 */
void timer_timeout_callback(struct tk_timer *timer)
{
    printf("timeout_callback: timer timeout:%ld\n", get_sys_tick());
}

int main(int argc, char *argv[])
{
    /* 初始化软件定时器功能，并配置tick获取回调函数*/
    tk_timer_func_init(get_sys_tick);
    
    /* 定义定时器指针 */
    tk_timer_t timer = NULL;
    /* 动态方式创建timer,并配置定时器超时回调函数 */
    timer = tk_timer_create((tk_timer_timeout_callback *)timer_timeout_callback);
    if (timer == NULL)
    {
        printf("定时器创建失败!\n");
        return 0;
    }
    /* ... */
    /* You can add your code under here. */
    return 0;
}

bool tk_timer_delete(struct tk_timer *timer);

bool tk_timer_init(struct tk_timer *timer, void (*timeout_callback)(struct tk_timer *timer));

/* 定义获取系统tick回调函数 */
uint32_t get_sys_tick(void)
{
    return tick;
}

/* 定时器超时回调函数 */
void timer_timeout_callback(struct tk_timer *timer)
{
    printf("timeout_callback: timer timeout:%ld\n", get_sys_tick());
}

int main(int argc, char *argv[])
{
    /* 定义定时器timer */
    struct tk_timer timer;
    bool result = tk_timer_init( &timer,(tk_timer_timeout_callback *)timer_timeout_callback);
    if (result == NULL)
    {
        printf("定时器创建失败!\n");
        return 0;
    }
    /* ... */
    /* You can add your code under here. */
    return 0;
}

bool tk_timer_detach(struct tk_timer *timer);

bool tk_timer_start(struct tk_timer *timer, tk_timer_mode mode, uint32_t delay_tick);

bool tk_timer_stop(struct tk_timer *timer);

bool tk_timer_continue(struct tk_timer *timer);

bool tk_timer_restart(struct tk_timer *timer);

tk_timer_mode tk_timer_get_mode(struct tk_timer *timer);

tk_timer_state tk_timer_get_state(struct tk_timer *timer);

bool tk_timer_loop_handler(void);

typedef void (*timeout_callback)(struct tk_timer *timer);

/* 定义两个回调函数，对应定时器timer1和timer2 */
void timer1_timeout_callback(struct tk_timer *timer){
	printf("定时器1超时!\n");
}
void timer2_timeout_callback(struct tk_timer *timer){
	printf("定时器2超时!\n");
}
/* 创建两个定时器,配置单独超时回调函数 */
timer1 = tk_timer_create((timeout_callback *)timer1_timeout_callback);
timer2 = tk_timer_create((timeout_callback *)timer2_timeout_callback);

/* 定时器timer1和timer2共用一个回调函数，在回调函数做区分 */
void timer_timeout_callback(struct tk_timer *timer){
	if (timer == timer1)
		printf("定时器1超时!\n");
    else if (timer == timer2)
        printf("定时器2超时!\n");
}
/* 创建两个定时器,使用相同的超时回调函数 */
timer1 = tk_timer_create((timeout_callback *)timer_timeout_callback);
timer2 = tk_timer_create((timeout_callback *)timer_timeout_callback);

struct tk_event *tk_event_create(void);

bool tk_event_delete(struct tk_event *event);

bool tk_event_init(struct tk_event *event);

bool tk_event_send(struct tk_event *event, uint32_t event_set);

bool tk_event_recv(struct tk_event *event, uint32_t event_set, uint8_t option, uint32_t *recved);