| 
 
初级会员 
 
	积分168金钱168 注册时间2020-9-2在线时间41 小时 | 
 
 
 楼主|
发表于 2020-12-23 11:22:02
|
显示全部楼层 
| 本帖最后由 binzhang 于 2020-12-23 11:23 编辑 
 #define START_TASK_PRIO                3
 //任务堆栈大小
 #define START_STK_SIZE                 128
 //任务控制块
 OS_TCB StartTaskTCB;
 //任务堆栈
 CPU_STK START_TASK_STK[START_STK_SIZE];
 //任务函数
 void start_task(void *p_arg);
 
 //任务优先级
 #define REC_TASK_PRIO                4
 //任务堆栈大小
 #define REC_STK_SIZE                 128
 //任务控制块
 OS_TCB REC_TaskTCB;
 //任务堆栈
 CPU_STK REC_TASK_STK[REC_STK_SIZE];
 void REC_task(void *p_arg);
 
 //任务优先级
 #define USART2_SendData_TASK_PRIO                5
 //任务堆栈大小
 #define USART2_SendData_STK_SIZE                 128
 //任务控制块
 OS_TCB USART2_SendData_TaskTCB;
 //任务堆栈
 CPU_STK USART2_SendData_TASK_STK[USART2_SendData_STK_SIZE];
 //任务函数
 void USART2_SendData_task(void *p_arg);
 
 //任务优先级
 #define Handle_TASK_PRIO                6
 //任务堆栈大小
 #define Handle_STK_SIZE                 128
 //任务控制块
 OS_TCB Handle_TaskTCB;
 //任务堆栈
 CPU_STK Handle_TASK_STK[Handle_STK_SIZE];
 //任务函数
 void Handle_task(void *p_arg);
 
 //任务优先级
 #define length_TASK_PRIO                7
 //任务堆栈大小
 #define length_STK_SIZE                 128
 //任务控制块
 OS_TCB length_TaskTCB;
 //任务堆栈
 CPU_STK length_TASK_STK[length_STK_SIZE];
 //任务函数
 void length_task(void *p_arg);
 
 //主函数
 int main(void)
 {
 OS_ERR err;
 CPU_SR_ALLOC();
 
 delay_init();  //时钟初始化
 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//中断分组配置
 uart_init(115200);   //串口初始化
 LED_Init();         //LED初始化
 //BEEP_Init();
 USART2_Init(115200);
 KEY_Init();
 OSInit(&err);                    //初始化UCOSIII
 OS_CRITICAL_ENTER();        //进入临界区
 //创建开始任务
 OSTaskCreate((OS_TCB         * )&StartTaskTCB,                //任务控制块
 (CPU_CHAR        * )"start task",                 //任务名字
 (OS_TASK_PTR )start_task,                         //任务函数
 (void                * )0,                                        //传递给任务函数的参数
 (OS_PRIO          )START_TASK_PRIO,     //任务优先级
 (CPU_STK   * )&START_TASK_STK[0],        //任务堆栈基地址
 (CPU_STK_SIZE)START_STK_SIZE/10,        //任务堆栈深度限位
 (CPU_STK_SIZE)START_STK_SIZE,                //任务堆栈大小
 (OS_MSG_QTY  )0,                                        //任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息
 (OS_TICK          )0,                                        //当使能时间片轮转时的时间片长度,为0时为默认长度,
 (void           * )0,                                        //用户补充的存储区
 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, //任务选项
 (OS_ERR         * )&err);                                //存放该函数错误时的返回值
 OS_CRITICAL_EXIT();        //退出临界区
 OSStart(&err);      //开启UCOSIII
 }
 
 //开始任务任务函数
 void start_task(void *p_arg)
 {
 OS_ERR err;
 CPU_SR_ALLOC();
 p_arg = p_arg;
 
 CPU_Init();
 #if OS_CFG_STAT_TASK_EN > 0u
 OSStatTaskCPUUsageInit(&err);          //统计任务
 #endif
 
 #ifdef CPU_CFG_INT_DIS_MEAS_EN                //如果使能了测量中断关闭时间
 CPU_IntDisMeasMaxCurReset();
 #endif
 
 #if        OS_CFG_SCHED_ROUND_ROBIN_EN  //当使用时间片轮转的时候
 //使能时间片轮转调度功能,时间片长度为1个系统时钟节拍,既1*5=5ms
 OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);
 #endif
 
 OS_CRITICAL_ENTER();        //进入临界区
 //创建TASK1任务
 OSTaskCreate((OS_TCB         * )&REC_TaskTCB,
 (CPU_CHAR        * )"REC task",
 (OS_TASK_PTR )REC_task,
 (void                * )0,
 (OS_PRIO          )REC_TASK_PRIO,
 (CPU_STK   * )&REC_TASK_STK[0],
 (CPU_STK_SIZE)REC_STK_SIZE/10,
 (CPU_STK_SIZE)REC_STK_SIZE,
 (OS_MSG_QTY  )0,
 (OS_TICK          )0,
 (void           * )0,
 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
 (OS_ERR         * )&err);
 
 //创建TASK2任务
 OSTaskCreate((OS_TCB         * )&USART2_SendData_TaskTCB,
 (CPU_CHAR        * )"USART2_SendData task",
 (OS_TASK_PTR )USART2_SendData_task,
 (void                * )0,
 (OS_PRIO          )USART2_SendData_TASK_PRIO,
 (CPU_STK   * )&USART2_SendData_TASK_STK[0],
 (CPU_STK_SIZE)USART2_SendData_STK_SIZE/10,
 (CPU_STK_SIZE)USART2_SendData_STK_SIZE,
 (OS_MSG_QTY  )0,
 (OS_TICK          )0,
 (void           * )0,
 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
 (OS_ERR         * )&err);
 //创建TASK3任务
 OSTaskCreate((OS_TCB         * )&Handle_TaskTCB,
 (CPU_CHAR        * )"Handle task",
 (OS_TASK_PTR )Handle_task,
 (void                * )0,
 (OS_PRIO          )Handle_TASK_PRIO,
 (CPU_STK   * )&Handle_TASK_STK[0],
 (CPU_STK_SIZE)Handle_STK_SIZE/10,
 (CPU_STK_SIZE)Handle_STK_SIZE,
 (OS_MSG_QTY  )0,
 (OS_TICK          )0,
 (void           * )0,
 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
 (OS_ERR         * )&err);
 OSTaskCreate((OS_TCB         * )&length_TaskTCB,
 (CPU_CHAR        * )"length task",
 (OS_TASK_PTR )length_task,
 (void                * )0,
 (OS_PRIO          )length_TASK_PRIO,
 (CPU_STK   * )&length_TASK_STK[0],
 (CPU_STK_SIZE)length_STK_SIZE/10,
 (CPU_STK_SIZE)length_STK_SIZE,
 (OS_MSG_QTY  )0,
 (OS_TICK          )0,
 (void           * )0,
 (OS_OPT      )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
 (OS_ERR         * )&err);
 OS_CRITICAL_EXIT();        //退出临界区
 OSTaskDel((OS_TCB*)0,&err);        //删除start_task任务自身
 }
 
 
 //2.4G无线接收数据任务函数
 void REC_task(void *p_arg)
 {
 u8 i;
 OS_ERR err;
 CPU_SR_ALLOC();
 p_arg = p_arg;
 
 OS_CRITICAL_ENTER();        //进入临界区
 drv_spi_init();
 NRF24L01_Gpio_Init();
 
 NRF24L01_check();
 RF24L01_Init();                    //初始化NRF24L01
 //RF24L01_Set_Mode(MODE_TX);
 RF24L01_Set_Mode( MODE_RX );                //接收模式
 OS_CRITICAL_EXIT();        //退出临界区
 while(1)
 {
 
 i = NRF24L01_RxPacket( Rx_buff );                //接收字节
 //printf("任务1\r\n");
 if( 0 != i )
 {
 drv_uart_tx_bytes(Rx_buff,i);
 Rec_flag=1;
 }
 OSTimeDlyHMSM(0,0,0,110,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
 }
 }
 
 //串口2发送数据任务函数
 void USART2_SendData_task(void *p_arg)
 {
 u8 i=0;
 OS_ERR err;
 CPU_SR_ALLOC();
 p_arg = p_arg;
 
 OS_CRITICAL_ENTER();        //进入临界区
 RecToUsart2();
 checkData();
 OS_CRITICAL_EXIT();        //退出临界区
 while(1)
 {
 //printf("任务2\r\n");
 if(USART2Flag==1)
 {
 for(i=0;i<USART2_LEN;i++)
 {
 while( RESET == USART_GetFlagStatus( USART2, USART_FLAG_TXE ));
 USART_SendData(USART2,USART2_BUFF);
 }
 }
 else if(USART2Flag==0)
 {
 clearBuff();
 }
 OSTimeDlyHMSM(0,0,0,100,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
 }
 }
 //数据处理任务函数
 void Handle_task(void *p_arg)
 {
 
 OS_ERR err;
 CPU_SR_ALLOC();
 p_arg = p_arg;
 
 while(1)
 {
 //printf("任务3\r\n");
 //                        if(USART1_RX_BUF[9]<=2)//如果气压值小于某个值时蜂鸣器发声
 //                        {
 //
 //                        }
 //                        if(Rx_buff[2]==0x04)//如果遥控器发来的是倒退命令,则启动步进电机的收线功能,根据到退的速度来进行调整步进电机的速度
 //                        {
 //
 //                        }
 //                        if(0==KEY_Scan(1))//检测按键并手动收线功能
 //                        {
 //
 //                        }
 
 OSTimeDlyHMSM(0,0,0,80,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
 }
 
 }
 //行走距离计算
 void length_task(void *p_arg)
 {
 OS_ERR err;
 CPU_SR_ALLOC();
 p_arg = p_arg;
 
 while(1)
 {
 //printf("任务4\r\n");
 //根据编码器来计算机器人行走的距离
 OSTimeDlyHMSM(0,0,0,80,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
 }
 }
 void drv_uart_tx_bytes( uint8_t* TxBuffer, uint8_t Length )
 {
 while( Length-- )
 {
 while( RESET == USART_GetFlagStatus( USART1, USART_FLAG_TXE ));
 USART_SendData(USART1,*TxBuffer);
 TxBuffer++;
 }
 }
 void USART1_IRQHandler(void)         //串口1接收数据中断服务函数
 {
 unsigned char r;
 OSIntEnter();
 
 if(USART_GetFlagStatus(USART1,USART_IT_RXNE)!=RESET)
 {
 printf("串口1中断接收任务产生\r\n");
 r=USART_ReceiveData(USART1);
 USART1_RX_BUF[USART1_REC_CNT]=r;
 USART1_REC_CNT++;
 if(USART1_REC_LEN==USART1_REC_CNT)
 {
 USART1RecFlag=1;
 }
 }
 USART_ClearITPendingBit(USART1,USART_FLAG_TC); //清除中断标志
 analyData();
 OSIntExit();
 }
 
 | 
 |