//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 } }