UCOSIII（二）

 

 

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "includes.h"

//任務1控制塊
OS_TCB Task1_TCB;

void task1(void *parg);

CPU_STK task1_stk[128];            //任務1的任務堆棧，大小為128字，也就是512字節



//任務2控制塊
OS_TCB Task2_TCB;

void task2(void *parg);

CPU_STK task2_stk[128];            //任務2的任務堆棧，大小為128字，也就是512字節


OS_SEM    SYNC_SEM;                //定義一個信號量，用於任務同步

//主函數
int main(void)
{
    OS_ERR err;

    delay_init(168);                                                      //時鍾初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        //中斷分組配置
    uart_init(9600);                                                   //串口初始化
    LED_Init();                                                         //LED初始化    


    //OS初始化，它是第一個運行的函數,初始化各種的全局變量，例如中斷嵌套計數器、優先級、存儲器
    OSInit(&err);


    //創建任務1
    OSTaskCreate(    (OS_TCB *)&Task1_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task1",                                    //任務的名字
                    (OS_TASK_PTR)task1,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)3,                                                 //任務的優先級        
                    (CPU_STK *)task1_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建任務2
    OSTaskCreate(    (OS_TCB *)&Task2_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task2",                                    //任務的名字
                    (OS_TASK_PTR)task2,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)2,                                                 //任務的優先級        
                    (CPU_STK *)task2_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );

    //創建一個信號量
    OSSemCreate ((OS_SEM*    )&SYNC_SEM,
                 (CPU_CHAR*    )"SYNC_SEM",
                 (OS_SEM_CTR)0,        
                 (OS_ERR*    )&err);


    //啟動OS，進行任務調度
    OSStart(&err);
    
}


void task1(void *parg)
{
    OS_ERR err;

    printf("task1 is create ok\r\n");

    while(1)
    {

        OSSemPend(&SYNC_SEM,0,OS_OPT_PEND_BLOCKING,0,&err); //請求信號量

        printf("task1 is running ...\r\n");

    }

}

void task2(void *parg)
{
    OS_ERR err;

    printf("task2 is create ok\r\n");

    while(1)
    {
        //連續發送3個信號量
        OSSemPost(&SYNC_SEM,OS_OPT_POST_1,&err);                    //發送信號量
        OSSemPost(&SYNC_SEM,OS_OPT_POST_1,&err);                    //發送信號量
        OSSemPost(&SYNC_SEM,OS_OPT_POST_1,&err);                    //發送信號量

        printf("task2 is running ...\r\n");

    
        OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err);         //延時10ms  
    }
}

 

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "includes.h"

//任務1控制塊
OS_TCB Task1_TCB;

void task1(void *parg);

CPU_STK task1_stk[128];            //任務1的任務堆棧，大小為128字，也就是512字節



//任務2控制塊
OS_TCB Task2_TCB;

void task2(void *parg);

CPU_STK task2_stk[128];            //任務2的任務堆棧，大小為128字，也就是512字節


//任務3控制塊
OS_TCB Task3_TCB;

void task3(void *parg);

CPU_STK task3_stk[128];            //任務2的任務堆棧，大小為128字，也就是512字節


OS_FLAG_GRP    g_os_flag;            //定義一個事件標志組


//按鍵初始化函數
void KEY_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOE,ENABLE);  //使能GPIOA GPIOE時鍾
    
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4;                  //PE2,3,4引腳
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN;                                  //輸入
    GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;                                  //上拉輸入
    GPIO_Init(GPIOE,&GPIO_InitStructure);                                         //初始化GPIOE
    
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;                                      //PA0引腳
    GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_DOWN;                                  //下拉輸入
    GPIO_Init(GPIOA,&GPIO_InitStructure);                                         //初始化GPIOA
}


//主函數
int main(void)
{
    OS_ERR err;

    delay_init(168);                                                      //時鍾初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        //中斷分組配置
    uart_init(115200);                                                   //串口初始化
    LED_Init();                                                         //LED初始化    


    //OS初始化，它是第一個運行的函數,初始化各種的全局變量，例如中斷嵌套計數器、優先級、存儲器
    OSInit(&err);


    //創建任務1
    OSTaskCreate(    (OS_TCB *)&Task1_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task1",                                    //任務的名字
                    (OS_TASK_PTR)task1,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)3,                                                 //任務的優先級        
                    (CPU_STK *)task1_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建任務2
    OSTaskCreate(    (OS_TCB *)&Task2_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task2",                                    //任務的名字
                    (OS_TASK_PTR)task2,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)2,                                                 //任務的優先級        
                    (CPU_STK *)task2_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );

    //創建任務3
    OSTaskCreate(    (OS_TCB *)&Task3_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task3",                                    //任務的名字
                    (OS_TASK_PTR)task3,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)2,                                                 //任務的優先級        
                    (CPU_STK *)task3_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建一個事件標志組
    OSFlagCreate(    (OS_FLAG_GRP*    )&g_os_flag,
                    (CPU_CHAR*)"os_flag",
                    (OS_FLAGS)0,
                    (OS_ERR*        )&err);

    //按鍵初始化
    KEY_Init();


    //啟動OS，進行任務調度
    OSStart(&err);
    
}


void task1(void *parg)
{
    OS_ERR err;

    OS_FLAGS os_flag;

    printf("task1 is create ok\r\n");

    while(1)
    {
            if(PAin(0) == 0)
            {
                //去抖動
                OSTimeDlyHMSM(0,0,0,20,OS_OPT_TIME_HMSM_STRICT,&err);         //延時20ms  

                if(PAin(0) == 0)
                {
                    //發送事件標志，標志值為0x1，設置g_os_flag的bit0為1
                    os_flag= OSFlagPost((OS_FLAG_GRP*    )&g_os_flag,
                                            (OS_FLAGS)0x1,
                                            (OS_OPT)OS_OPT_POST_FLAG_SET,
                                            &err);

                    printf("task1,os_flag=%02X\r\n",os_flag);

                }

            }

            OSTimeDlyHMSM(0,0,0,20,OS_OPT_TIME_HMSM_STRICT,&err);             //延時20ms  


    }

}

void task2(void *parg)
{
    OS_ERR err;

    OS_FLAGS os_flag;

    printf("task2 is create ok\r\n");



    while(1)
    {
        if(PEin(2) == 0)
        {
            OSTimeDlyHMSM(0,0,0,20,OS_OPT_TIME_HMSM_STRICT,&err);         //延時20ms  

            if(PEin(2) == 0)
            {
                //發送事件標志，標志值為0x2，設置g_os_flag的bit1為1
                os_flag= OSFlagPost((OS_FLAG_GRP*    )&g_os_flag,
                                    (OS_FLAGS)0x2,
                                    (OS_OPT)OS_OPT_POST_FLAG_SET,
                                    &err);

                printf("task2,os_flag=%02X\r\n",os_flag);

            }

        }

        OSTimeDlyHMSM(0,0,0,20,OS_OPT_TIME_HMSM_STRICT,&err);         //延時20ms  

    }

}

void task3(void *parg)
{
    OS_ERR err;

    OS_FLAGS os_flag;

    printf("task3 is create ok\r\n");

    while(1)
    {
        //OS_OPT_PEND_FLAG_SET_ANY 和OS_OPT_PEND_FLAG_SET_ALL是有區別的
        //前者是等待任意一個事件，后者要確保所有事件成立
        os_flag= OSFlagPend((OS_FLAG_GRP*    )&g_os_flag,
                            (OS_FLAGS)0x3,                        //等待bit1和bit0置位
                            (OS_TICK)0,                            //0代表是默認一直阻塞等待
                            (OS_OPT)OS_OPT_PEND_FLAG_SET_ANY+OS_OPT_PEND_FLAG_CONSUME,    //等待事件標志組任何一位置位
                            (CPU_TS *)0,                        //默認不記錄時間戳
                            &err);

        printf("task3,os_flag=%02X\r\n",os_flag);

    }

}

 

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "includes.h"

//任務1控制塊
OS_TCB Task1_TCB;

void task1(void *parg);

CPU_STK task1_stk[128];            //任務1的任務堆棧，大小為128字，也就是512字節



//任務2控制塊
OS_TCB Task2_TCB;

void task2(void *parg);

CPU_STK task2_stk[128];            //任務2的任務堆棧，大小為128字，也就是512字節


#define TASK_Q_NUM    64        //發任務內建消息隊列的長度

//主函數
int main(void)
{
    OS_ERR err;

    delay_init(168);                                                      //時鍾初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        //中斷分組配置
    uart_init(9600);                                                   //串口初始化
    LED_Init();                                                         //LED初始化    


    //OS初始化，它是第一個運行的函數,初始化各種的全局變量，例如中斷嵌套計數器、優先級、存儲器
    OSInit(&err);
    
    

    //創建任務1
    OSTaskCreate(    (OS_TCB *)&Task1_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task1",                                    //任務的名字
                    (OS_TASK_PTR)task1,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)3,                                                 //任務的優先級        
                    (CPU_STK *)task1_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建任務2
    OSTaskCreate(    (OS_TCB *)&Task2_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task2",                                    //任務的名字
                    (OS_TASK_PTR)task2,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)2,                                                 //任務的優先級        
                    (CPU_STK *)task2_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)TASK_Q_NUM,                                    //任務2需要使用內建消息隊列，消息隊列長度為64個字    
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //啟動OS，進行任務調度
    OSStart(&err);
    
}


void task1(void *parg)
{
    uint32_t msg_cnt=0;
    
    char pbuf[64];
    
    OS_ERR err;

    printf("task1 is create ok\r\n");

    while(1)
    {

        msg_cnt++;
        
        sprintf((char*)pbuf,"msg_cnt=%d\r\n",msg_cnt);
        
        //發送消息
        OSTaskQPost((OS_TCB*    )&Task2_TCB,    //向任務task2發送消息
                    (void*        )pbuf,
                    (OS_MSG_SIZE)strlen(pbuf),
                    (OS_OPT        )OS_OPT_POST_FIFO,
                    (OS_ERR*    )&err);

        printf("task1 is running ...\r\n");
        
        
        OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err);         //延時1S

    }

}

void task2(void *parg)
{
    char *p;
    OS_MSG_SIZE size;
    
    OS_ERR err;

    printf("task2 is create ok\r\n");

    while(1)
    {
        //請求消息
        p=OSTaskQPend((OS_TICK        )0,
                      (OS_OPT        )OS_OPT_PEND_BLOCKING,
                      (OS_MSG_SIZE*    )&size,
                      (CPU_TS*        )0,
                      (OS_ERR*      )&err );
        
        printf("task2 is running ...\r\n");
        printf(p);
    }
}

 

 

/*
描述：

1.當前創建了軟件定時器1，工作頻率為100Hz，優先級為2，可在os_cfg_app.h進行設置
        #define  OS_CFG_TMR_TASK_PRIO              2u               
        #define  OS_CFG_TMR_TASK_RATE_HZ         100u   

2.創建任務1，優先級為3,；創建任務2，優先級為4
*/
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "includes.h"

//任務1控制塊
OS_TCB Task1_TCB;

void task1(void *parg);

CPU_STK task1_stk[128];            //任務1的任務堆棧，大小為128字，也就是512字節



//任務2控制塊
OS_TCB Task2_TCB;

void task2(void *parg);

CPU_STK task2_stk[128];            //任務2的任務堆棧，大小為128字，也就是512字節


OS_TMR tmr1;                    //定時器1
//軟件定時器1回調函數
void tmr1_callback(void *ptmr,void *p_arg);


//主函數
int main(void)
{
    OS_ERR err;

    delay_init(168);                                                          //時鍾初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                            //中斷分組配置
    uart_init(9600);                                                           //串口初始化
    LED_Init();                                                             //LED初始化    


    //OS初始化，它是第一個運行的函數,初始化各種的全局變量，例如中斷嵌套計數器、優先級、存儲器
    OSInit(&err);


    //創建任務1
    OSTaskCreate(    (OS_TCB *)&Task1_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task1",                                    //任務的名字
                    (OS_TASK_PTR)task1,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)3,                                                 //任務的優先級        
                    (CPU_STK *)task1_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建任務2
    OSTaskCreate(    (OS_TCB *)&Task2_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task2",                                    //任務的名字
                    (OS_TASK_PTR)task2,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)4,                                                 //任務的優先級        
                    (CPU_STK *)task2_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );
    
    //創建軟件定時器1
    OSTmrCreate(   (OS_TMR               *)&tmr1,                            //軟件定時器1
                   (CPU_CHAR             *)"tmr1",                            //定時器名字
                   (OS_TICK               )20,                                //20*10=200ms,延遲200ms執行
                   (OS_TICK               )100,                                //100*10=1000ms，執行周期為1000ms
                   (OS_OPT                )OS_OPT_TMR_PERIODIC,                //周期模式
                   (OS_TMR_CALLBACK_PTR   )tmr1_callback,                    //軟件定時器1回調函數
                   (void                 *)0,                                //參數為0
                   (OS_ERR               *)&err);                            //返回的錯誤碼
                   
    //啟動軟件定時器1
    OSTmrStart(&tmr1,&err);


    //啟動OS，進行任務調度
    OSStart(&err);
    
}

void task1(void *parg)
{
    OS_ERR err;

    printf("task1 is create ok\r\n");

    while(1)
    {
        printf("task1 is running ...\r\n");
        
        OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err);         //延時1S  

    }
}

void task2(void *parg)
{
    OS_ERR err;

    printf("task2 is create ok\r\n");

    while(1)
    {

        printf("task2 is running ...\r\n");
        
        OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err);         //延時1S  
        
        
    }
}

void tmr1_callback(void *ptmr,void *p_arg)
{
    //軟件定時器回調函數禁止使用任何的阻塞或者刪除定時器函數
    printf("tmr1_callback\r\n");
}

 

/*
描述：

1.當前創建了軟件定時器1，工作頻率為100Hz，優先級為2，可在os_cfg_app.h進行設置
        #define  OS_CFG_TMR_TASK_PRIO              2u               
        #define  OS_CFG_TMR_TASK_RATE_HZ         100u   

2.創建任務1，優先級為3,；創建任務2，優先級為4


3.測試結果：    任務1、任務2、軟件定時器回調函數通過臨界區代碼保護了共享資源，各任務之間很好地執行
*/
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "includes.h"

//任務1控制塊
OS_TCB Task1_TCB;

void task1(void *parg);

CPU_STK task1_stk[128];                                                        //任務1的任務堆棧，大小為128字，也就是512字節



//任務2控制塊
OS_TCB Task2_TCB;

void task2(void *parg);

CPU_STK task2_stk[128];                                                        //任務2的任務堆棧，大小為128字，也就是512字節


OS_TMR tmr1;                                                                //定時器1
//軟件定時器1回調函數
void tmr1_callback(void *ptmr,void *p_arg);

OS_Q          queue;                                                        //聲明消息隊列
OS_SEM        sem;                                                          //聲明多值信號量
OS_PEND_DATA  mul_pend_array [ 2 ];                                         //聲明等待對象數組

//主函數
int main(void)
{
    OS_ERR err;

    delay_init(168);                                                          //時鍾初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                            //中斷分組配置
    uart_init(9600);                                                           //串口初始化
    LED_Init();                                                             //LED初始化    


    //OS初始化，它是第一個運行的函數,初始化各種的全局變量，例如中斷嵌套計數器、優先級、存儲器
    OSInit(&err);


    //創建任務1
    OSTaskCreate(    (OS_TCB *)&Task1_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task1",                                    //任務的名字
                    (OS_TASK_PTR)task1,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)3,                                                 //任務的優先級        
                    (CPU_STK *)task1_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)0,                                            //禁止任務消息隊列
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );


    //創建任務2
    OSTaskCreate(    (OS_TCB *)&Task2_TCB,                                    //任務控制塊
                    (CPU_CHAR *)"Task2",                                    //任務的名字
                    (OS_TASK_PTR)task2,                                        //任務函數
                    (void *)0,                                                //傳遞參數
                    (OS_PRIO)4,                                                 //任務的優先級        
                    (CPU_STK *)task2_stk,                                    //任務堆棧基地址
                    (CPU_STK_SIZE)128/10,                                    //任務堆棧深度限位，用到這個位置，任務不能再繼續使用
                    (CPU_STK_SIZE)128,                                        //任務堆棧大小            
                    (OS_MSG_QTY)64,                                            //任務消息隊列64字
                    (OS_TICK)0,                                                //默認時間片長度                                                                
                    (void  *)0,                                                //不需要補充用戶存儲區
                    (OS_OPT)OS_OPT_TASK_NONE,                                //沒有任何選項
                    &err                                                    //返回的錯誤碼
                );
    
    //創建軟件定時器1
    OSTmrCreate(   (OS_TMR               *)&tmr1,
                   (CPU_CHAR             *)"tmr1",
                   (OS_TICK               )20,
                   (OS_TICK               )100,
                   (OS_OPT                )OS_OPT_TMR_PERIODIC,
                   (OS_TMR_CALLBACK_PTR   )tmr1_callback,
                   (void                 *)0,
                   (OS_ERR               *)&err);
                   
                   
    //啟動軟件定時器1
    OSTmrStart(&tmr1,&err);

    /* 創建多值信號量 sem */
    OSSemCreate (    (OS_SEM      *)&sem,                //指向要創建的多值信號量
                    (CPU_CHAR    *)"Sem For Test",      //多值信號量的名字
                    (OS_SEM_CTR   )0,                   //多值信號量初始不可用
                    (OS_ERR      *)&err);                 //返回錯誤類型
                             
    /* 創建消息隊列 queue */
    OSQCreate (        (OS_Q         *)&queue,               //指向要創建的消息隊列
                    (CPU_CHAR     *)"Queue For Test",     //消息隊列的名字
                    (OS_MSG_QTY    )20,                   //最多可容20條消息
                    (OS_ERR       *)&err);                //返回錯誤類型


    /* 初始化要等待的多個內核對象 */
    mul_pend_array [ 0 ] .PendObjPtr = ( OS_PEND_OBJ * ) & sem;
    mul_pend_array [ 1 ] .PendObjPtr = ( OS_PEND_OBJ * ) & queue;
    
    
    //啟動OS，進行任務調度
    OSStart(&err);
    
}

void task1(void *parg)
{
    static uint32_t task_cnt=0;
    
    char buf[64]={0};
    
    OS_ERR err;

    printf("task1 is create ok\r\n");

    while(1)
    {
        task_cnt++;
        
        sprintf(buf,"task1 run cnt=%d",task_cnt);
        
        /* 發布消息到消息隊列 queue */
        OSQPost (    (OS_Q        *)&queue,                                //消息隊列
                    (void        *)buf,                                 //消息內容
                    (OS_MSG_SIZE  )strlen(buf),                          //消息長度
                    (OS_OPT       )OS_OPT_POST_FIFO|OS_OPT_POST_ALL,    //發到隊列且發送給所有任務
                    (OS_ERR      *)&err);                                 //返回錯誤類型
            
        OSTimeDlyHMSM(0,0,3,0,OS_OPT_TIME_HMSM_STRICT,&err);             //延時3S  

    }
}

void task2(void *parg)
{
    OS_ERR err;

    printf("task2 is create ok\r\n");

    while(1)
    {
        /* 等待多個內核對象 */
        OSPendMulti((OS_PEND_DATA  *)mul_pend_array,       //等待對象數組
                    (OS_OBJ_QTY     )2,                    //等待對象數目
                    (OS_TICK        )0,                    //無期限等待
                    (OS_OPT         )OS_OPT_PEND_BLOCKING, //阻塞任務
                    (OS_ERR        *)&err);                //返回錯誤類型

        /* 查看哪些等待對象可用 */
        if ( mul_pend_array [0] .RdyObjPtr == mul_pend_array [0] .PendObjPtr ) //如果 sem 可用
        {
            printf("find tmr1 running...\r\n");
        } 
        
        
        if ( mul_pend_array [1] .RdyObjPtr == mul_pend_array [1] .PendObjPtr )//如果 queue 可用
        {
            printf("recv msg:%s,len：%d\r\n",(char *) mul_pend_array[1] .RdyMsgPtr, mul_pend_array [1] .RdyMsgSize );
        }
                
    }
}

//軟件定時器回調函數禁止使用任何的阻塞或者刪除定時器函數
void tmr1_callback(void *ptmr,void *p_arg)
{
    OS_ERR      err;
    
    OSSemPost(&sem,OS_OPT_POST_1,&err);                    //釋放信號量        
}