自学教程：C++ CPU_SR_ALLOC函数代码示例

//led0任务函数void led0_task(void *p_arg){	OS_ERR err;	u8 test[20];	u8 times = 0;	CPU_SR_ALLOC();	u8 temp;		p_arg = p_arg;	while(1)	{		OS_CRITICAL_ENTER();		temp = FloatTaskTCB.MsgQ.NbrEntriesSize - FloatTaskTCB.MsgQ.NbrEntries;		printf("que remain %d./r/n",temp);		OS_CRITICAL_EXIT();			sprintf((char *)test,"led_send_que %d",times++);		printf("led0 task send que./r/n");		OSTaskQPost((OS_TCB*	)&FloatTaskTCB,	//向任务Msgdis发送消息					(void*		)test,          (OS_MSG_SIZE)20,          (OS_OPT		)OS_OPT_POST_FIFO,					(OS_ERR*	)&err);						OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s					}}

void  *SerialOS_SemCreate (CPU_INT16U  cnt){    OS_EVENT  *psem;    INT8U      os_err;    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    if (OSEventObjIx < 1u) {        CPU_CRITICAL_EXIT();        return ((void *)0);    }    if (OSEventObjIx > SERIAL_OS_MAX_NBR_SEM) {        CPU_CRITICAL_EXIT();        return ((void *)0);    }                                                                /* -------------- GET OS EVENT FROM POOL -------------- */    OSEventObjIx--;    psem = OSEventObj[OSEventObjIx];    CPU_CRITICAL_EXIT();    OSSemSet(psem, cnt, &os_err);    return ((void *)psem);}

void  OS_TLS_LockDel (void  *p_lock){    OS_TLS_LOCK   *p_tls_lock;    OS_ERR         os_err;    CPU_SR_ALLOC();        if (p_lock == (void *)0) {        return;    }        p_tls_lock = (OS_TLS_LOCK *)p_lock;    (void)OSMutexDel((OS_MUTEX *)&p_tls_lock->Mutex,                     (OS_OPT    ) OS_OPT_DEL_ALWAYS,                     (OS_ERR   *)&os_err);    (void)&os_err;    CPU_CRITICAL_ENTER();                                                                  /* Return the OS_TLS_LOCK in front of the list      */    if (OS_TLS_LockPoolListPtr == (OS_TLS_LOCK *)0) {        p_tls_lock->NextPtr  = (OS_TLS_LOCK *)0;    } else {        p_tls_lock->NextPtr = OS_TLS_LockPoolListPtr;    }    OS_TLS_LockPoolListPtr = p_tls_lock;                          CPU_CRITICAL_EXIT();}

CPU_BOOLEAN  SerialBuf_WrOctet (SERIAL_BUF  *pbuf,                                CPU_INT08U   datum){    CPU_SIZE_T  empty_cnt;    CPU_SIZE_T  ix_wr;    CPU_SIZE_T  len;    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    empty_cnt = pbuf->EmptyCnt;    if (empty_cnt == 0) {        CPU_CRITICAL_EXIT();        return (DEF_NO);    }    ix_wr                = pbuf->IxWr;    pbuf->DataPtr[ix_wr] = datum;    pbuf->EmptyCnt       = empty_cnt - 1;    len                  = pbuf->Len;    if (ix_wr + 1 == len) {        pbuf->IxWr = 0;    } else {        pbuf->IxWr = ix_wr + 1;    }    CPU_CRITICAL_EXIT();    return (DEF_YES);}

CPU_BOOLEAN  SerialBuf_RdOctet (SERIAL_BUF  *pbuf,                                CPU_INT08U  *pdatum){    CPU_SIZE_T  empty_cnt;    CPU_SIZE_T  ix_rd;    CPU_SIZE_T  len;    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    len       = pbuf->Len;    empty_cnt = pbuf->EmptyCnt;    if (empty_cnt == len) {        CPU_CRITICAL_EXIT();        return (DEF_NO);    }    ix_rd          = pbuf->IxRd;   *pdatum         = pbuf->DataPtr[ix_rd];    pbuf->EmptyCnt = empty_cnt + 1;    if (ix_rd + 1 == len) {        pbuf->IxRd = 0;    } else {        pbuf->IxRd = ix_rd + 1;    }    CPU_CRITICAL_EXIT();    return (DEF_YES);}

void  *OSMemGet (OS_MEM  *p_mem,                 OS_ERR  *p_err){    void    *p_blk;    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == (OS_ERR *)0) {        OS_SAFETY_CRITICAL_EXCEPTION();        return ((void *)0);    }#endif#if OS_CFG_ARG_CHK_EN > 0u    if (p_mem == (OS_MEM *)0) {                             /* Must point to a valid memory partition                 */       *p_err  = OS_ERR_MEM_INVALID_P_MEM;        return ((void *)0);    }#endif    CPU_CRITICAL_ENTER();    if (p_mem->NbrFree == (OS_MEM_QTY)0) {                  /* See if there are any free memory blocks                */        CPU_CRITICAL_EXIT();       *p_err = OS_ERR_MEM_NO_FREE_BLKS;                    /* No,  Notify caller of empty memory partition           */        return ((void *)0);                                 /*      Return NULL pointer to caller                     */    }    p_blk              = p_mem->FreeListPtr;                /* Yes, point to next free memory block                   */    p_mem->FreeListPtr = *(void **)p_blk;                   /*      Adjust pointer to new free list                   */    p_mem->NbrFree--;                                       /*      One less memory block in this partition           */    CPU_CRITICAL_EXIT();   *p_err = OS_ERR_NONE;                                    /*      No error                                          */    return (p_blk);                                         /*      Return memory block to caller                     */}

void  OS_TLS_SetDestruct (OS_TLS_ID            id,                          OS_TLS_DESTRUCT_PTR  p_destruct,                          OS_ERR              *p_err){    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == (OS_ERR *)0) {        OS_SAFETY_CRITICAL_EXCEPTION();        return;    }#endif    if (id >= OS_TLS_NextAvailID) {                             /* See if we exceeded the number of TLS IDs available */       *p_err = OS_ERR_TLS_ID_INVALID;        return;    }         if (OS_TLS_DestructPtrTbl[id] != (OS_TLS_DESTRUCT_PTR)0) {  /* Can only assign a destructor once                  */       *p_err = OS_ERR_TLS_DESTRUCT_ASSIGNED;        return;    }         CPU_CRITICAL_ENTER();    OS_TLS_DestructPtrTbl[id] = p_destruct;    CPU_CRITICAL_EXIT();   *p_err                     = OS_ERR_NONE;}

CPU_BOOLEAN  SerialBuf_Cmp (SERIAL_BUF  *pbuf,                            CPU_INT08U   datum){    CPU_SIZE_T   ix_rd;    CPU_BOOLEAN  full;    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    full = SerialBuf_IsFull(pbuf);    if (full == DEF_NO) {        CPU_CRITICAL_EXIT();        return (DEF_NO);    }    ix_rd = pbuf->IxRd;    if(pbuf->DataPtr[ix_rd] != datum) {        pbuf->IxRd = 0;                                         /* Reset comparison.                                    */        CPU_CRITICAL_EXIT();        return (DEF_NO);    }    ix_rd++;    if (ix_rd == pbuf->Len) {        pbuf->IxRd = 0;        CPU_CRITICAL_EXIT();        return (DEF_YES);    }    pbuf->IxRd = ix_rd;    CPU_CRITICAL_EXIT();    return (DEF_NO);}

/***********************************************************************       PngGetData** Function description*   This routine is called by GUI_PNG_DrawEx(). The routine is responsible*   for setting the data pointer to a valid data location with at least*   one valid byte.** Parameters:*   p           - Pointer to application defined data.*   NumBytesReq - Number of bytes requested.*   ppData      - Pointer to data pointer. This pointer should be set to*                 a valid location.*   StartOfFile - If this flag is 1, the data pointer should be set to the*                 beginning of the data stream.** Return value:*   Number of data bytes available.*/static int PngGetData(void * p, const U8 ** ppData, unsigned NumBytesReq, U32 Off) {	static int readaddress=0;	FIL * phFile;	U8 *pData;	UINT NumBytesRead;	#if SYSTEM_SUPPORT_OS		CPU_SR_ALLOC();	#endif		pData = (U8*)*ppData;	phFile = (FIL *)p;		//移动指针到应该读取的位置	if(Off == 1) readaddress = 0;	else readaddress=Off;		#if SYSTEM_SUPPORT_OS		OS_CRITICAL_ENTER();	//临界区	#endif	f_lseek(phFile,readaddress); 		//读取数据到缓冲区中	f_read(phFile,pData,NumBytesReq,&NumBytesRead);				#if SYSTEM_SUPPORT_OS		OS_CRITICAL_EXIT();//退出临界区	#endif	return NumBytesRead;//返回读取到的字节数}

void  CSP_TmrInit (void){    CSP_DEV_NBR  per_nbr;    CSP_DEV_NBR  tmr_nbr;    CSP_TMR_REG  *p_tmr_reg;    CPU_SR_ALLOC();    for (tmr_nbr = CSP_TMR_NBR_00; tmr_nbr <= CSP_TMR_NBR_03; tmr_nbr++) {        p_tmr_reg = (CSP_TMR_REG *)CSP_TmrAddrTbl[tmr_nbr];        per_nbr   = (CSP_DEV_NBR  )CSP_TmrPerTbl[tmr_nbr];                CPU_CRITICAL_ENTER();        CSP_PM_PerClkEn(per_nbr);        p_tmr_reg->MCR    = DEF_BIT_NONE;        p_tmr_reg->MRx[0] = 0u;        p_tmr_reg->MRx[1] = 0u;        p_tmr_reg->MRx[2] = 0u;        p_tmr_reg->IR     = DEF_BIT_FIELD(5u, 0u);        p_tmr_reg->TCR    = DEF_BIT_NONE;                p_tmr_reg->MCR    = DEF_BIT_NONE;        p_tmr_reg->EMR    = DEF_BIT_NONE;        CSP_PM_PerClkDis(per_nbr);                CPU_CRITICAL_EXIT();    }}

CPU_BOOLEAN  CSP_DMA_CH_FreeExt (CSP_DEV_NBR  ch_nbr)                               {    CSP_DMA_REG     *p_dma_reg;        CSP_DMA_CH_REG  *p_dma_ch_reg;    CSP_DMA_CH      *p_ch_tbl;        CPU_SR_ALLOC();#if (CSP_CFG_ARG_CHK_EN == DEF_ENABLED)             if (ch_nbr > CSP_DMA_CH_MAX_NBR - 1u) {        return (DEF_FAIL);    }#endif        p_dma_reg    = (CSP_DMA_REG *)CSP_ADDR_DMA_REG;    p_dma_ch_reg = &(p_dma_reg->CHx[ch_nbr]);    p_ch_tbl     = &CSP_DMA_ChTbl[ch_nbr];            CPU_CRITICAL_ENTER();    p_dma_reg->IntTCClr    = DEF_BIT(ch_nbr);                   /* Clear all pending interrupts.                        */    p_dma_reg->IntErrClr   = DEF_BIT(ch_nbr);        p_ch_tbl->State        = CSP_DMA_CH_STATE_FREE;             /* Free the channel.                                    */    p_dma_ch_reg->SrcAddr  = DEF_BIT_NONE;                      /* Unitialize DMA channel cfg & ctrl registers.         */    p_dma_ch_reg->DestAddr = DEF_BIT_NONE;    p_dma_ch_reg->Cfg      = DEF_BIT_NONE;    p_dma_ch_reg->Ctrl     = DEF_BIT_NONE;           CPU_CRITICAL_EXIT();    return (DEF_OK);}

void  OSTimeDly (OS_TICK   dly,                 OS_OPT    opt,                 OS_ERR   *p_err){    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == (OS_ERR *)0) {        OS_SAFETY_CRITICAL_EXCEPTION();        return;    }#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u    if (OSIntNestingCtr > (OS_NESTING_CTR)0u) {             /* Not allowed to call from an ISR                        */       *p_err = OS_ERR_TIME_DLY_ISR;        return;    }#endif    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0u) {       /* Can't delay when the scheduler is locked               */       *p_err = OS_ERR_SCHED_LOCKED;        return;    }    switch (opt) {        case OS_OPT_TIME_DLY:        case OS_OPT_TIME_TIMEOUT:        case OS_OPT_TIME_PERIODIC:             if (dly == (OS_TICK)0u) {                      /* 0 means no delay!                                      */                *p_err = OS_ERR_TIME_ZERO_DLY;                 return;             }             break;        case OS_OPT_TIME_MATCH:             break;        default:            *p_err = OS_ERR_OPT_INVALID;             return;    }    OS_CRITICAL_ENTER();    OSTCBCurPtr->TaskState = OS_TASK_STATE_DLY;    OS_TickListInsert(OSTCBCurPtr,                      dly,                      opt,                      p_err);    if (*p_err != OS_ERR_NONE) {         OS_CRITICAL_EXIT_NO_SCHED();         return;    }    OS_RdyListRemove(OSTCBCurPtr);                          /* Remove current task from ready list                    */    OS_CRITICAL_EXIT_NO_SCHED();    OSSched();                                              /* Find next task to run!                                 */   *p_err = OS_ERR_NONE;}

void  OS_TLS_LockCreate (void  **p_lock){    OS_TLS_LOCK   *p_tls_lock;    OS_ERR         os_err;    CPU_SR_ALLOC();        if (p_lock == (void **)0) {        return;    }    if (OS_TLS_LockPoolListPtr == (OS_TLS_LOCK *)0) {             /* If 'OS_TLS_LOCK' object pool is empty?           */        *p_lock = (void *)0;                                      /*   return a 'NULL' pointer.                       */        return;    }    p_tls_lock = OS_TLS_LockPoolListPtr;                          /* Get the first object in the list.                */    OSMutexCreate((OS_MUTEX *)&p_tls_lock->Mutex,                 /* Create the mutex in the kernel.                  */                  (CPU_CHAR *) 0,				                         (OS_ERR   *)&os_err);			                                    					           if (os_err != OS_ERR_NONE) {                                  /* If the mutex create funtion fail?                */        *p_lock = (void *)0;                                      /* ... return a 'NULL' pointer.                     */         return;        						           }											           CPU_CRITICAL_ENTER();    OS_TLS_LockPoolListPtr = p_tls_lock->NextPtr;                 /* Move HEAD pointer to the next object in the list.*/    CPU_CRITICAL_EXIT();        *p_lock = (void *)p_tls_lock;                                 /* Return the new 'OS_TLS_LOCK' object pointer.     */}

void  OS_TLS_Init (OS_ERR *p_err){    CPU_INT16U    ix;    OS_TLS_LOCK  *p_lock;    CPU_SR_ALLOC();    OS_TLS_NextAvailID = 0u;    OS_TLS_LibID       = OS_TLS_GetID(p_err);        CPU_CRITICAL_ENTER();                                                                       /* Create the link list of OS_TLS_LOCK objects.    */    for (ix = 0u; ix < (OS_TLS_LOCK_MAX - 1u); ix++) {        p_lock             = &OS_TLS_LockPoolTbl[ix];        p_lock->NextPtr    = &OS_TLS_LockPoolTbl[ix + 1u];    }        p_lock                 = &OS_TLS_LockPoolTbl[OS_TLS_LOCK_MAX - 1u];    p_lock->NextPtr        = (OS_TLS_LOCK *)0;                     /* Last node points to 'NULL'                      */    OS_TLS_LockPoolListPtr = &OS_TLS_LockPoolTbl[0];               /* Initialize the list head pointer.               */    CPU_CRITICAL_EXIT();    }

void  OS_TickTask (void  *p_arg){    OS_ERR  err;    CPU_TS  ts_delta;    CPU_TS  ts_delta_dly;    CPU_TS  ts_delta_timeout;    CPU_SR_ALLOC();    (void)&p_arg;                                               /* Prevent compiler warning                             */    while (DEF_ON) {        (void)OSTaskSemPend((OS_TICK  )0,                            (OS_OPT   )OS_OPT_PEND_BLOCKING,                            (CPU_TS  *)0,                            (OS_ERR  *)&err);                   /* Wait for signal from tick interrupt                  */        if (err == OS_ERR_NONE) {            OS_CRITICAL_ENTER();            OSTickCtr++;                                        /* Keep track of the number of ticks                    */#if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u))            TRACE_OS_TICK_INCREMENT(OSTickCtr);                 /* Record the event.                                    */#endif            OS_CRITICAL_EXIT();            ts_delta_dly     = OS_TickListUpdateDly();            ts_delta_timeout = OS_TickListUpdateTimeout();            ts_delta         = ts_delta_dly + ts_delta_timeout; /* Compute total execution time of list updates         */            if (OSTickTaskTimeMax < ts_delta) {                OSTickTaskTimeMax = ts_delta;            }        }    }}

OS_TLS_ID  OS_TLS_GetID (OS_ERR  *p_err){    OS_TLS_ID  id;    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == (OS_ERR *)0) {        OS_SAFETY_CRITICAL_EXCEPTION();        return ((OS_TLS_ID)OS_CFG_TLS_TBL_SIZE);    }#endif    CPU_CRITICAL_ENTER();    if (OS_TLS_NextAvailID >= OS_CFG_TLS_TBL_SIZE) {              /* See if we exceeded the number of IDs available   */       *p_err = OS_ERR_TLS_NO_MORE_AVAIL;                         /* Yes, cannot allocate more TLS                    */        CPU_CRITICAL_EXIT();        return ((OS_TLS_ID)OS_CFG_TLS_TBL_SIZE);    }         id    = OS_TLS_NextAvailID;									  /* Assign the next available ID                     */    OS_TLS_NextAvailID++;										  /* Increment available ID for next request          */    CPU_CRITICAL_EXIT();   *p_err = OS_ERR_NONE;    return (id);}

//浮点测试任务void float_task(void *p_arg){	OS_ERR err;	CPU_SR_ALLOC();	static float float_num = 0.01;	//uint32_t temp = &float_num;	while(1)	{		float_num+=0.01f;		OS_CRITICAL_ENTER();	//进入临界区		//printf("float_num的值为: %.4f/r/n",float_num);		OS_CRITICAL_EXIT();		//退出临界区		if(float_num > 0.901f && float_num < 0.919f)		{				OSTaskSuspend((OS_TCB*)&Led0TaskTCB,&err);				printf("挂起LED任务/n/r");		}		if(float_num > 1.991f && float_num < 2.001f)		{				OSTaskResume((OS_TCB*)&Led0TaskTCB,&err);				printf("恢复LED任务/n/r");				float_num = 0.0f;		}		OSTimeDlyHMSM(0,0,0,300,OS_OPT_TIME_HMSM_STRICT,&err); //延时300ms		}}

void  SerialOS_SemDel (void  *psem){    INT8U       os_err;#if (SERIAL_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)    CPU_SIZE_T  i;#endif    CPU_SR_ALLOC();    OSSemPendAbort((OS_EVENT *) psem,                   (INT8U     ) OS_PEND_OPT_BROADCAST,                   (INT8U    *)&os_err);    CPU_CRITICAL_ENTER();    if (OSEventObjIx >= SERIAL_OS_MAX_NBR_SEM) {        CPU_CRITICAL_EXIT();        return;    }#if (SERIAL_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)                  /* ----------------- VALIDATE OS EVENT ---------------- */    for (i = 0u; i < OSEventObjIx; i++) {        if (OSEventObj[i] == (OS_EVENT *)psem) {            CPU_CRITICAL_EXIT();            return;        }    }#endif                                                                /* --------------- FREE OS EVENT TO POOL -------------- */    OSEventObj[OSEventObjIx] = (OS_EVENT *)psem;    OSEventObjIx++;    CPU_CRITICAL_EXIT();}

//主函数int main(void){	OS_ERR err;	CPU_SR_ALLOC();		delay_init(168);  //时钟初始化	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//中断分组配置	uart_init(115200);   //串口初始化	LED_Init();         //LED初始化		LCD_Init();			//LCD初始化		KEY_Init();			//按键初始化	BEEP_Init();		//初始化蜂鸣器	FSMC_SRAM_Init();	//初始化SRAM	my_mem_init(SRAMIN);//初始化内部RAM	ucos_load_main_ui();//加载主UI		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}

CPU_BOOLEAN  CSP_DMA_XferStartExt (CSP_DEV_NBR     ch_nbr,                                   void           *p_dest,                                   void           *p_src,                                                                      CPU_SIZE_T      xfer_size,                                   CSP_OPT_FLAGS   opt){       CSP_DMA_REG     *p_dma_reg;    CSP_DMA_CH_REG  *p_dma_ch_reg;    CPU_INT32U       reg_ctrl;        CPU_SR_ALLOC();                                                                /* ------------------ ARGUMENTS CHECKING -------------- */#if (CSP_CFG_ARG_CHK_EN == DEF_ENABLED)                 if (ch_nbr > CSP_DMA_CH_MAX_NBR - 1u) {                     /* Invalid channel number?                              */        return (DEF_FAIL);    }                                                                /* Channel not available?                               */    if (CSP_DMA_ChTbl[ch_nbr].State != CSP_DMA_CH_STATE_ALLOC) {        return (DEF_FAIL);    }    if ((p_dest == (void *)0) ||                                /* Null pointers?                                        */        (p_src  == (void *)0)) {        return (DEF_FAIL);    }    #endif        p_dma_reg    = (CSP_DMA_REG *)CSP_ADDR_DMA_REG;                      p_dma_ch_reg = &(p_dma_reg->CHx[ch_nbr]);    reg_ctrl     = p_dma_ch_reg->Ctrl;    DEF_BIT_CLR(reg_ctrl, CSP_DMA_MSK_CH_CTRL_XFER_SIZE |                          CSP_DMA_BIT_CH_CTRL_SI        |                          CSP_DMA_BIT_CH_CTRL_DI        |                          CSP_DMA_BIT_CH_CTRL_I);    DEF_BIT_SET(reg_ctrl, (xfer_size & CSP_DMA_MSK_CH_CTRL_XFER_SIZE));    if (DEF_BIT_IS_SET(opt, CSP_DMA_OPT_FLAG_XFER_SRC_INC)) {        DEF_BIT_SET(reg_ctrl, CSP_DMA_BIT_CH_CTRL_SI);    }        if (DEF_BIT_IS_SET(opt, CSP_DMA_OPT_FLAG_XFER_DEST_INC)) {        DEF_BIT_SET(reg_ctrl, CSP_DMA_BIT_CH_CTRL_DI);            }                    CPU_CRITICAL_ENTER();    p_dma_ch_reg->SrcAddr     = (CPU_INT32U )p_src;    p_dma_ch_reg->DestAddr    = (CPU_INT32U )p_dest;           p_dma_ch_reg->Ctrl        = reg_ctrl;    DEF_BIT_CLR(p_dma_ch_reg->Cfg, CSP_DMA_BIT_CH_CFG_ITC   |                                    CSP_DMA_BIT_CH_CFG_IE);    DEF_BIT_SET(p_dma_ch_reg->Cfg, CSP_DMA_BIT_CH_CFG_CH_EN);     CPU_CRITICAL_EXIT();    return (DEF_OK);}

void  OSMemPut (OS_MEM  *p_mem,                void    *p_blk,                OS_ERR  *p_err){    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == DEF_NULL) {        OS_SAFETY_CRITICAL_EXCEPTION();        return;    }#endif#if (OS_CFG_ARG_CHK_EN == DEF_ENABLED)    if (p_mem == DEF_NULL) {                                    /* Must point to a valid memory partition               */#if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN == DEF_ENABLED))        TRACE_OS_MEM_PUT_FAILED(p_mem);                         /* Record the event.                                    */#endif       *p_err  = OS_ERR_MEM_INVALID_P_MEM;        return;    }    if (p_blk == DEF_NULL) {                                    /* Must release a valid block                           */#if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN == DEF_ENABLED))        TRACE_OS_MEM_PUT_FAILED(p_mem);                         /* Record the event.                                    */#endif       *p_err  = OS_ERR_MEM_INVALID_P_BLK;        return;    }#endif#if (OS_CFG_OBJ_TYPE_CHK_EN == DEF_ENABLED)    if (p_mem->Type != OS_OBJ_TYPE_MEM) {                       /* Make sure the memory block was created               */       *p_err = OS_ERR_OBJ_TYPE;        return;    }#endif    CPU_CRITICAL_ENTER();    if (p_mem->NbrFree >= p_mem->NbrMax) {                      /* Make sure all blocks not already returned            */        CPU_CRITICAL_EXIT();#if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN == DEF_ENABLED))        TRACE_OS_MEM_PUT_FAILED(p_mem);                         /* Record the event.                                    */#endif       *p_err = OS_ERR_MEM_FULL;        return;    }    *(void **)p_blk    = p_mem->FreeListPtr;                    /* Insert released block into free block list           */    p_mem->FreeListPtr = p_blk;    p_mem->NbrFree++;                                           /* One more memory block in this partition              */    CPU_CRITICAL_EXIT();#if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN == DEF_ENABLED))    TRACE_OS_MEM_PUT(p_mem);                                    /* Record the event.                                    */#endif   *p_err              = OS_ERR_NONE;                           /* Notify caller that memory block was released         */}

void  OS_QPost (OS_Q         *p_q,                void         *p_void,                OS_MSG_SIZE   msg_size,                OS_OPT        opt,                CPU_TS        ts,                OS_ERR       *p_err){    OS_OBJ_QTY     cnt;    OS_OPT         post_type;    OS_PEND_LIST  *p_pend_list;    OS_PEND_DATA  *p_pend_data;    OS_PEND_DATA  *p_pend_data_next;    OS_TCB        *p_tcb;    CPU_SR_ALLOC();    OS_CRITICAL_ENTER();    p_pend_list = &p_q->PendList;    if (p_pend_list->NbrEntries == (OS_OBJ_QTY)0) {         /* Any task waiting on message queue?                     */        if ((opt & OS_OPT_POST_LIFO) == (OS_OPT)0) {        /* Determine whether we post FIFO or LIFO                 */            post_type = OS_OPT_POST_FIFO;        } else {            post_type = OS_OPT_POST_LIFO;        }        OS_MsgQPut(&p_q->MsgQ,                              /* Place message in the message queue                     */                   p_void,                   msg_size,                   post_type,                   ts,                   p_err);        OS_CRITICAL_EXIT();        return;    }    if ((opt & OS_OPT_POST_ALL) != (OS_OPT)0) {             /* Post message to all tasks waiting?                     */        cnt = p_pend_list->NbrEntries;                      /* Yes                                                    */    } else {        cnt = (OS_OBJ_QTY)1;                                /* No                                                     */    }    p_pend_data = p_pend_list->HeadPtr;    while (cnt > 0u) {        p_tcb            = p_pend_data->TCBPtr;        p_pend_data_next = p_pend_data->NextPtr;        OS_Post((OS_PEND_OBJ *)((void *)p_q),                p_tcb,                p_void,                msg_size,                ts);        p_pend_data = p_pend_data_next;        cnt--;    }    OS_CRITICAL_EXIT_NO_SCHED();    if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0) {        OSSched();                                          /* Run the scheduler                                      */    }   *p_err = OS_ERR_NONE;}

void  OSQCreate (OS_Q        *p_q,                 CPU_CHAR    *p_name,                 OS_MSG_QTY   max_qty,                 OS_ERR      *p_err){    CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICAL    if (p_err == (OS_ERR *)0) {        OS_SAFETY_CRITICAL_EXCEPTION();        return;    }#endif#ifdef OS_SAFETY_CRITICAL_IEC61508    if (OSSafetyCriticalStartFlag == DEF_TRUE) {       *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;        return;    }#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              /* Not allowed to be called from an ISR                   */       *p_err = OS_ERR_CREATE_ISR;        return;    }#endif#if OS_CFG_ARG_CHK_EN > 0u    if (p_q == (OS_Q *)0) {                                 /* Validate arguments                                     */       *p_err = OS_ERR_OBJ_PTR_NULL;        return;    }    if (max_qty == (OS_MSG_QTY)0) {                         /* Cannot specify a zero size queue                       */       *p_err = OS_ERR_Q_SIZE;        return;    }#endif    OS_CRITICAL_ENTER();    p_q->Type    = OS_OBJ_TYPE_Q;                           /* Mark the data structure as a message queue             */    p_q->NamePtr = p_name;    OS_MsgQInit(&p_q->MsgQ,                                 /* Initialize the queue                                   */                max_qty);    OS_PendListInit(&p_q->PendList);                        /* Initialize the waiting list                            */#if OS_CFG_DBG_EN > 0u    OS_QDbgListAdd(p_q);#endif    OSQQty++;                                               /* One more queue created                                 */    OS_CRITICAL_EXIT_NO_SCHED();   *p_err = OS_ERR_NONE;}

void  OS_MsgQEntriesPeakReset (OS_MSG_Q  *p_msg_q){    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    p_msg_q->NbrEntriesMax = (OS_MSG_QTY)0;    CPU_CRITICAL_EXIT();}

void  Math_RandSetSeed (RAND_NBR  seed){    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();    Math_RandSeedCur = seed;    CPU_CRITICAL_EXIT();}

static  CPU_TS  OS_TickListUpdateDly (void){    OS_TCB       *p_tcb;    OS_TICK_LIST *p_list;    CPU_TS        ts_start;    CPU_TS        ts_delta_dly;#if OS_CFG_DBG_EN > 0u    OS_OBJ_QTY    nbr_updated;#endif    CPU_SR_ALLOC();                                                                                                                                          OS_CRITICAL_ENTER();    ts_start    = OS_TS_GET();#if OS_CFG_DBG_EN > 0u    nbr_updated = (OS_OBJ_QTY)0u;#endif    p_list      = &OSTickListDly;    p_tcb       = p_list->TCB_Ptr;                                          if (p_tcb != (OS_TCB *)0) {        p_tcb->TickRemain--;        while (p_tcb->TickRemain == 0u) {#if OS_CFG_DBG_EN > 0u            nbr_updated++;											    /* Keep track of the number of TCBs updated          */#endif            if (p_tcb->TaskState == OS_TASK_STATE_DLY) {                p_tcb->TaskState = OS_TASK_STATE_RDY;                OS_RdyListInsert(p_tcb);                                /* Insert the task in the ready list                 */            } else if (p_tcb->TaskState == OS_TASK_STATE_DLY_SUSPENDED) {                p_tcb->TaskState = OS_TASK_STATE_SUSPENDED;            }            p_list->TCB_Ptr = p_tcb->TickNextPtr;            p_tcb           = p_list->TCB_Ptr;                          /* Get 'p_tcb' again for loop                        */            if (p_tcb == (OS_TCB *)0) {#if OS_CFG_DBG_EN > 0u                p_list->NbrEntries = (OS_OBJ_QTY)0u;#endif                break;            } else {#if OS_CFG_DBG_EN > 0u                p_list->NbrEntries--;#endif                p_tcb->TickPrevPtr = (OS_TCB *)0;            }        }    }#if OS_CFG_DBG_EN > 0u    p_list->NbrUpdated = nbr_updated;#endif    ts_delta_dly       = OS_TS_GET() - ts_start;                        /* Measure execution time of the update              */    OS_CRITICAL_EXIT();    return (ts_delta_dly);}

static  void  BSP_PLL_Init (void){    CPU_REG32   reg_val;    CPU_SR_ALLOC();    CPU_CRITICAL_ENTER();                                                                /* System clock divider configuration.                  */    BSP_REG_SIM_CLKDIV1 = (BSP_SIM_CLKDIV1_OUTDIV1_DIV2 |       /* Clock 1 divide by 2.                                 */                           BSP_SIM_CLKDIV1_OUTDIV4_DIV2);       /* Clock 4 divide by 2.                                 */                                                                /* Multipurpose clock generator configuration.          */    BSP_REG_MCG_C2 = (BSP_MCG_C2_LOCRE0          |              /* Generate a reset request on a loss of ext ref clk.   */                      BSP_MCG_C2_RANGE_HIGH_FREQ |              /* Select high freq range for the crystal oscillator.   */                      BSP_MCG_C2_EREFS0);                       /* Select oscillator as the source for the ext ref clk. */    BSP_REG_MCG_C1 = (BSP_MCG_C1_CLKS_EXT_CLK    |              /* Selects the ext ref clk as the clk source for MCG.   */                      BSP_MCG_C1_FRDIV_8);                      /* Divide the ext ref clk by 256 for the FLL.           */    while (DEF_BIT_IS_SET(BSP_REG_MCG_S, BSP_MCG_S_IREFST)) {   /* Wait for Reference clock Status bit to clear.        */        ;    }    do {                                                        /* Wait for clock status bits to show clock.            */        reg_val = (BSP_REG_MCG_S & BSP_MCG_S_CLKST_MASK) >> 2u; /* source is ext ref clk.                               */    } while (reg_val != 0x2);                                                                /* --------------------- PLL0 CFG --------------------- */    BSP_REG_MCG_C5  = BSP_MCG_C5_PRDIV0_4;                      /* Select PLL0 external reference divider.              */    BSP_REG_MCG_C6 = (BSP_MCG_C6_PLLS    |                      /* Select the PLL output.                               */                      BSP_MCG_C6_CME0    |                      /* Enable the loss of clock monitoring circuit.         */                      BSP_MCG_C6_VDIV0_MUL_48);    while (DEF_BIT_IS_CLR(BSP_REG_MCG_S, BSP_MCG_S_PLLST)) {    /* Wait for PLL status bit to set.                      */        ;    }    while (DEF_BIT_IS_CLR(BSP_REG_MCG_S, BSP_MCG_S_LOCK0)) {    /* Wait for LOCK bit to set.                            */        ;    }    DEF_BIT_CLR(BSP_REG_MCG_C1, BSP_MCG_C1_CLKS_MASK);          /* Clear CLKS to switch CLKS mux to PLL as MCG_OUT.     */    do {        reg_val = (BSP_REG_MCG_S & BSP_MCG_S_CLKST_MASK) >> 2u;    } while (reg_val != 0x3);                                   /* Wait for clock status bits to update.                */    SIM_SOPT2 |= SIM_SOPT2_PLLFLLSEL_MASK;                      /* Set PLLFLLSEL to select the PLL for this clk src.    */    CPU_CRITICAL_EXIT();}

void bus_send_string(char *buf){	u16 i;	CPU_SR_ALLOC();		OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();	for (i = 0; buf[i] != '/0'; i++)		bus_send(&buf[i], 1);	OS_CRITICAL_EXIT();}

/*******************************************************************************函 数 名：	USART1_IRQHandler功能说明：	串口中断处理参	  数：	无返 回 值：	无*******************************************************************************/void USART2_IRQHandler(void){    if(USART2->SR&(1<<5))//接收到数据    {        CPU_SR_ALLOC();        ENTER_CRITICAL();        fifo_putc(&phy_rcvUsartfifo, USART2->DR);        EXIT_CRITICAL();    }    USART2->SR &=~(1<<5);}

void  CSP_IntVectDeref (CSP_INT_VECT  *p_vect){#if (CSP_CFG_INT_ISR_ARG_EN == DEF_ENABLED)    void          *p_int_arg;#endif    CPU_FNCT_PTR   int_isr_fnct;#if (CSP_CFG_INT_ISR_EXEC_MEAS_EN == DEF_ENABLED) && /    (CPU_CFG_TS_EN               == DEF_ENABLED)    CPU_TS         ts;    CPU_SR_ALLOC();#endif    int_isr_fnct =  p_vect->FnctPtr;#if (CSP_CFG_INT_ISR_ARG_EN == DEF_ENABLED)    p_int_arg    =  p_vect->ArgPtr;#endif   if (int_isr_fnct != (CPU_FNCT_PTR)0) {#if (CSP_CFG_INT_ISR_EXEC_MEAS_EN == DEF_ENABLED) && /    (CPU_CFG_TS_EN                == DEF_ENABLED)        ts = CPU_TS_Get32();                                    /* Get current time stamp.                              */#endif#if (CSP_CFG_INT_NESTING_EN == DEF_ENABLED)        CPU_IntEn();#endif#if (CSP_CFG_INT_ISR_ARG_EN == DEF_ENABLED)        (*int_isr_fnct)(p_int_arg);                             /* Call interrupt handler                               */#else        (*int_isr_fnct)((void *)0);                             /* Call interrupt handler (default argument)            */#endif#if (CSP_CFG_INT_NESTING_EN == DEF_ENABLED)        CPU_IntDis();#endif#if (CSP_CFG_INT_ISR_EXEC_MEAS_EN == DEF_ENABLED) && /    (CPU_CFG_TS_EN                == DEF_ENABLED)        ts = CPU_TS_Get32() - ts;                               /* Compute delta time between start and end.            */                                                                /* Detect peak value                                    */        CPU_CRITICAL_ENTER();        if (p_vect->TimeMax < ts) {            p_vect->TimeMax = ts;        }        p_vect->TimeCur = ts;        CPU_CRITICAL_EXIT();#endif   }}