杰理新建任务--自定义消息池--信号量调度

新建一个C文件如下：

#include "board_config.h"
#include "system/includes.h"
#include "asm/power_interface.h"
#include "app_config.h"

#undef _DEBUG_H_
#define LOG_TAG_CONST       CASE_TASK
#define LOG_TAG             "[CASE_TASK]"
#include "debug.h"
#define LOG_v(t)  log_tag_const_v_ ## t
#define LOG_i(t)  log_tag_const_i_ ## t
#define LOG_d(t)  log_tag_const_d_ ## t
#define LOG_w(t)  log_tag_const_w_ ## t
#define LOG_e(t)  log_tag_const_e_ ## t
#define LOG_c(t)  log_tag_const_c_ ## t
#define LOG_tag(tag, n) n(tag)
const char LOG_tag(LOG_TAG_CONST,LOG_v) AT(.LOG_TAG_CONST) = 0;
const char LOG_tag(LOG_TAG_CONST,LOG_i) AT(.LOG_TAG_CONST) = 1;
const char LOG_tag(LOG_TAG_CONST,LOG_d) AT(.LOG_TAG_CONST) = 0; //log_debug
const char LOG_tag(LOG_TAG_CONST,LOG_w) AT(.LOG_TAG_CONST) = 1;
const char LOG_tag(LOG_TAG_CONST,LOG_e) AT(.LOG_TAG_CONST) = 1;
const char LOG_tag(LOG_TAG_CONST,LOG_c) AT(.LOG_TAG_CONST) = 1;

//新建任务方式,任务有2种驱动方式
//1、发消息事件 来驱动
//2、信号量    来驱动
#define TASK_RUN_MSG      0x01 //消息
#define TASK_RUN_SEM      0x02 //信号量
#define TASK_RUN_WAY      TASK_RUN_MSG //TASK_RUN_SEM //
//消息大小限制
#define MAX_MSG      (16)                    //固定不能改大
#define MAX_BUF      ((MAX_MSG - 2) * 4 - 1) //固定不能改大

//任务的参数定义
#define CASE_TASK_NAME   "case_task"
#define CASE_TASK_PRIO   2        //任务优先级：1-3
#define CASE_TASK_STACK  1024     //任务栈大小
#define CASE_TASK_QSIZE  256      //任务消息池大小

typedef enum{
    CASE_TASK_MSG_0 = 0,
    CASE_TASK_MSG_1,
}CASE_TASK_MSG;

static int case_task_msg_deal(CASE_TASK_MSG msg, u8 *buf, u8 len)
{
    log_info("%s[msg:%d len:%d]", __func__, msg, len);
    int ret = 0;
    switch (msg) {
    case CASE_TASK_MSG_0:
        log_info("CASE_TASK_MSG_0");
        break;
    case CASE_TASK_MSG_1:
        log_info("CASE_TASK_MSG_1");
        log_info_hexdump(buf, len);
        break;
    default:
        break;
    }
    return ret;
}

static int case_task_post_msg(CASE_TASK_MSG msg, u8 *buf, u8 len)
{
    log_info("%s[msg:%d len:%d]", __func__, msg, len);
    int ret = OS_NO_ERR;
    if(buf == NULL){
        ret = os_taskq_post_msg(CASE_TASK_NAME, 1, msg);
    }else{
        if(len > MAX_BUF){
            ret = -1;
            goto _post_end;
        }
        log_debug_hexdump(buf, len);
        static u8 data[MAX_BUF + 5] ALIGNED(4);
        memset(data, 0x00, sizeof(data));
        data[4] = len;
        memcpy(data + 5, buf, len);
        ((u32 *)data)[0] = msg;
        ret = os_taskq_post_type(CASE_TASK_NAME, Q_MSG, MAX_MSG - 1, data);
    }
_post_end:
    if(ret) log_error("%s[ret:%d]", __func__, ret);
    return ret;
}

static int case_task_sem_deal(void)
{
    int ret = OS_NO_ERR;
    log_info("%s", __func__);

    //跑一些耗时操作

    return ret;
}

static OS_SEM case_task_sem;
static int case_task_post_sem(void)
{
    int ret = OS_NO_ERR;
    log_info("%s", __func__);
    ret = os_sem_post(&case_task_sem);
    if(ret) log_error("%s[ret:%d]", __func__, ret);
    return ret;
}

static void case_task(void *p)
{
#if (TASK_RUN_WAY == TASK_RUN_MSG)
    int ret = 0;
    u32 msg[MAX_MSG];
    while (1) {
        clr_wdt();
        memset(msg, 0x00, sizeof(msg));
        ret = os_taskq_pend("taskq", msg, ARRAY_SIZE(msg));
        if (ret != OS_TASKQ) {
            continue;
        }
        if (msg[0] != Q_MSG) {
            continue;
        }
        log_debug("%s[enter_msg:0x%x]", __func__, msg[1]);
        u8 *buf = (u8 *)(msg + 2);
        ret = case_task_msg_deal(msg[1], buf + 1, buf[0]);
        log_debug("%s[exit_msg:0x%x -> ret:%d]", __func__, msg[1], ret);
    }
#endif
#if (TASK_RUN_WAY == TASK_RUN_SEM)
    int ret = 0;
    while (1) {
        clr_wdt();
        ret = os_sem_pend(&case_task_sem, 0);
        /* os_sem_set(&case_task_sem, 0); */
        log_debug("%s[os_sem_pend -> ret:%d]", __func__, ret);
        ret = case_task_sem_deal();
        log_debug("%s[case_task_sem_deal -> ret:%d]", __func__, ret);
    }
#endif
}
int case_task_init(void)
{
    log_info("%s[MAX_BUF:%d]", __func__, MAX_BUF);
    int ret = OS_NO_ERR;
    os_sem_create(&case_task_sem, 0);
    os_sem_set(&case_task_sem, 0);
    /* ret = task_create(case_task, NULL, CASE_TASK_NAME); */
    ret = os_task_create(case_task, NULL, CASE_TASK_PRIO,
                         CASE_TASK_STACK, CASE_TASK_QSIZE, CASE_TASK_NAME);
    if(ret != OS_NO_ERR)
        log_error("%s %s create fail 0x%x", __func__, CASE_TASK_NAME, ret);
    return ret;
}

int case_task_delete(void)
{
    int ret = OS_NO_ERR;
    ret = task_kill(CASE_TASK_NAME);
    log_info("%s[task_kill(%s):%d]", __func__, CASE_TASK_NAME, ret);
    return ret;
}

///测试函数
static void case_task_loop(void *priv)
{
#if (TASK_RUN_WAY == TASK_RUN_MSG)
    static u32 cnt = 0;
    if(cnt > MAX_BUF){
        return;
    }
    if(cnt == MAX_BUF){
        case_task_delete();
    }
    cnt++;
#if 0
    log_info("只发消息---不带参数");
    case_task_post_msg(CASE_TASK_MSG_0, NULL, 0);
#else
    log_info("发消息---并带一个buf数组");
    u8 buf[MAX_BUF];
    memset(buf, 0x00, sizeof(buf));
    for(u8 i = 0;i < sizeof(buf);i++){
        buf[i] = 0x10 + i;
    }
    case_task_post_msg(CASE_TASK_MSG_1, buf, cnt);
#endif
#endif
}
static void case_task_hi_loop(void *priv)
{
#if (TASK_RUN_WAY == TASK_RUN_SEM)
    case_task_post_sem();
#endif
}

int case_task_test(void)
{
    log_info("%s", __func__);
    case_task_init();
    sys_timer_add(NULL, case_task_loop, 1000 * 1);
    /* sys_s_hi_timer_add(NULL, case_task_hi_loop, 1000 * 5); */
    /* sys_hi_timer_add(NULL, case_task_hi_loop, 4); */
}