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