// Creates an empty mailbox. signed char _sys_mbox_new(sys_mbox_t *mbox, int size) { // prarmeter "size" can be ignored in your implementation. u8_t ucErr; PQ_DESCR pQDesc; *mbox = SYS_MBOX_NULL; pQDesc = OSMemGet( pQueueMem, &ucErr ); LWIP_ASSERT("OSMemGet ", ucErr == OS_ERR_NONE ); if( ucErr == OS_ERR_NONE ) { if(size > MAX_QUEUE_ENTRIES ) // 邮箱最多容纳MAX_QUEUE_ENTRIES消息数目 size = MAX_QUEUE_ENTRIES; pQDesc->pQ = OSQCreate( &(pQDesc->pvQEntries[0]), size ); LWIP_ASSERT( "OSQCreate ", pQDesc->pQ != NULL ); if( pQDesc->pQ != NULL ) { *mbox = pQDesc; return ERR_OK; } else { ucErr = OSMemPut( pQueueMem, pQDesc ); return ERR_MEM; } } else return ERR_MEM; }
/********************************************************************************************************* ** Function name: zyMsgAccept ** Descriptions: 无等待获得消息 ** input parameters: ulMsg: zyMsgCreate返回值 ** output parameters: pucMsg: 保存获得的消息 ** Returned value: ZY_OK: 成功 ** 负数: 错误,绝对值参考zy_if.h ** Created by: Chenmingji ** Created Date: 2009-07-23 **-------------------------------------------------------------------------------------------------------- ** Modified by: ** Modified date: *********************************************************************************************************/ INT32S zyMsgAccept (unsigned long ulMsg, INT8U *pucMsgRt) { __ZY_IF_MSG *pimThis; /* 消息通道信息 */ void *pvTmp; pimThis = (__ZY_IF_MSG *)ulMsg; /* * 参数检查 */ if (ulMsg == 0) { return -ZY_PARAMETER_ERR; } #if OS_ARG_CHK_EN == 0 if (pimThis->poeQ == NULL) { return -ZY_PARAMETER_ERR; } if (pimThis->pomMsg == NULL) { return -ZY_PARAMETER_ERR; } #endif /* OS_ARG_CHK_EN */ pvTmp = OSQAccept(pimThis->poeQ); if (pvTmp == NULL) { return -ZY_NOT_OK; } memcpy(pucMsgRt, pvTmp, (size_t)(pimThis->ulMsgSize)); /* 拷贝数据 */ OSMemPut(pimThis->pomMsg, pvTmp); /* 归还缓冲区 */ return ZY_OK; }
void TaskUart(void *pdata) //send message to uart from uartQ { INT8U *pUartMsg; INT8U err; pdata=pdata; Uart_Printf("taskuart\n"); while(1) { // 进程taskuart不断地用pUart_Q里读数据,当有数据时,则进行打印。 pUartMsg=OSQAccept(pUart_Q,&err);//Accept the Msg from Qene; no wait while(pUartMsg) { // Uart_Printf("get msg\n"); Uart_SendString(pUartMsg);//seng str to Uart OSMemPut(pUartMem,pUartMsg); pUartMsg=OSQAccept(pUart_Q,&err);//free Mem } OSTimeDly(OS_TICKS_PER_SEC/5); } }
/* Creates an empty mailbox */ sys_mbox_t sys_mbox_new(int size) { /* prarmeter "size" can be ignored in your implementation */ u8_t ucErr; PQ_DESCR pQDesc; pQDesc = OSMemGet( pQueueMem, &ucErr ); LWIP_ASSERT("OSMemGet ", ucErr == OS_ERR_NONE ); if( ucErr == OS_ERR_NONE ) { if( size > MAX_QUEUE_ENTRIES ) /* 邮箱最多容纳MAX_QUEUE_ENTRIES消息数目 */ { size = MAX_QUEUE_ENTRIES; } pQDesc->pQ = OSQCreate( &(pQDesc->pvQEntries[0]), size ); LWIP_ASSERT( "OSQCreate ", pQDesc->pQ != NULL ); if( pQDesc->pQ != NULL ) { return pQDesc; } else { ucErr = OSMemPut( pQueueMem, pQDesc ); return SYS_MBOX_NULL; } } else { return SYS_MBOX_NULL; } }
/*FUNCTION********************************************************************** * * Function Name : OSA_MsgQPut * Description : This function is used to put a message to a message queue. * Return kStatus_OSA_Success if the message is put successfully, otherwise * return kStatus_OSA_Error. * *END**************************************************************************/ osa_status_t OSA_MsgQPut(msg_queue_handler_t handler, void* pMessage) { INT8U err; void *localMsg; int32_t *from_ptr, *to_ptr; uint32_t msg_size = handler->size; /* Get a memory to save the message. */ localMsg = OSMemGet(handler->pMem, &err); if (!localMsg) { return kStatus_OSA_Error; } /* Copy msg to localMsg */ from_ptr = (int32_t*)pMessage; to_ptr = (int32_t*)localMsg; while (msg_size--) { *to_ptr++ = *from_ptr++; } if (OS_ERR_NONE != OSQPost(handler->pQueue, localMsg)) { OSMemPut(handler->pMem, localMsg); return kStatus_OSA_Error; } return kStatus_OSA_Success; }
void TaskSensores(void *pdata) { #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif struct AdcMsg *m; INT16U value = 0; INT16U ValorTeclado = 0; INT8U err; for(;;) { m = (struct AdcMsg *) OSMemGet(dMemory,&err); if(err == OS_NO_ERR){ OSSemPend(STeclado,0,&err); ValorTeclado = NumeroSensores; OSSemPost(STeclado); m->adc0 = 0; m->adc1 = 0; m->adc2 = 0; switch(ValorTeclado){ case 3: Delay10TCYx(100); SetChanADC(ADC_CH2); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc2 = Temp(value); case 2: Delay10TCYx(100); SetChanADC(ADC_CH1); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc1 = Temp(value); case 1: Delay10TCYx(100); SetChanADC(ADC_CH0); ConvertADC(); while( BusyADC() ); value = ReadADC(); m->adc0 = Temp(value); default: break; } err = OSQPost(QueueADC0,m); if(err == OS_Q_FULL){ OSMemPut(dMemory,m); OSSemPost(STaskTxSerial); } }else{ OSSemPost(STaskTxSerial); } //OSSemPost(STask2); OSTimeDly(1); } }
void OSTaskDelHook (OS_TCB *ptcb) { #if OS_CPU_FPU_EN > 0 if (ptcb->OSTCBOpt & OS_TASK_OPT_SAVE_FP) { /* See if task had FP support */ if (ptcb->OSTCBExtPtr != (void *)0) { /* Yes, OSTCBExtPtr must not be NULL */ OSMemPut(OSFPPartPtr, ptcb->OSTCBExtPtr); /* Return memory block to free pool */ } } #endif (void)ptcb; /* Prevent compiler warning */ }
/********************************************************************************************************* ** Function name: zyMsgPend ** Descriptions: 等待消息 ** input parameters: ulMsg: zyMsgCreate返回值 ** ulDly: 最长等待时间,毫秒为单位 ** output parameters: pucMsgRt: 保存获得的消息 ** Returned value: ZY_OK: 成功 ** 负数: 错误,绝对值参考zy_if.h ** Created by: Chenmingji ** Created Date: 2009-07-23 **-------------------------------------------------------------------------------------------------------- ** Modified by: ** Modified date: *********************************************************************************************************/ INT32S zyMsgPend (unsigned long ulMsg, INT8U *pucMsgRt, INT32U ulDly) { __ZY_IF_MSG *pimThis; /* 消息通道信息 */ INT8U ucErr; /* 错误代码 */ void *pvTmp; pimThis = (__ZY_IF_MSG *)ulMsg; /* * 参数检查 */ if (ulMsg == 0) { return -ZY_PARAMETER_ERR; } #if OS_ARG_CHK_EN == 0 if (pimThis->poeQ == NULL) { return -ZY_PARAMETER_ERR; } if (pimThis->pomMsg == NULL) { return -ZY_PARAMETER_ERR; } #endif /* OS_ARG_CHK_EN */ pvTmp = OSQPend(pimThis->poeQ, (INT16U)((ulDly * OS_TICKS_PER_SEC + 999) / 1000), &ucErr); switch (ucErr) { case OS_ERR_PEVENT_NULL: return -ZY_PARAMETER_ERR; case OS_ERR_EVENT_TYPE: return -ZY_NO_FIND_OBJECT; case OS_TIMEOUT: return -ZY_TIME_OUT; case OS_NO_ERR: break; default: return -ZY_NOT_OK; } memcpy(pucMsgRt, pvTmp, (size_t)(pimThis->ulMsgSize)); /* 拷贝数据 */ OSMemPut(pimThis->pomMsg, pvTmp); /* 归还缓冲区 */ return ZY_OK; }
/*FUNCTION********************************************************************** * * Function Name : OSA_MsgQGet * Description : This function checks the queue's status, if it is not empty, * get message from it and return kStatus_OSA_Success, otherwise, timeout will * be used for wait. The parameter timeout indicates how long should wait in * milliseconds. Pass OSA_WAIT_FOREVER to wait indefinitely, pass 0 will return * kStatus_OSA_Timeout immediately if queue is empty. * This function returns kStatus_OSA_Success if message is got successfully, * returns kStatus_OSA_Timeout if message queue is empty within the specified * 'timeout', returns kStatus_OSA_Error if any errors occur during waiting. * *END**************************************************************************/ osa_status_t OSA_MsgQGet(msg_queue_handler_t handler, void *pMessage, uint32_t timeout) { OS_ERR err; OS_OPT opt; OS_MSG_SIZE dummy; void* localMsg; int32_t *from_ptr, *to_ptr; uint32_t msg_size = handler->size; if (0u == timeout) { opt = OS_OPT_PEND_NON_BLOCKING; } else { opt = OS_OPT_PEND_BLOCKING; timeout = wait_timeout_msec_to_tick(timeout); } localMsg = OSQPend(&(handler->queue), timeout, opt, &dummy, (CPU_TS*)0, &err); if (OS_ERR_NONE == err) { /* Copy localMsg to msg */ to_ptr = (int32_t*)pMessage; from_ptr = (int32_t*)localMsg; while (msg_size--) { *to_ptr++ = *from_ptr++; } OSMemPut(&(handler->mem), localMsg, &err); return kStatus_OSA_Success; } else if ((OS_ERR_PEND_WOULD_BLOCK == err) || (OS_ERR_TIMEOUT == err)) { return kStatus_OSA_Timeout; } else { return kStatus_OSA_Error; } }
/* Deallocates a mailbox. If there are messages still present in the mailbox when the mailbox is deallocated, it is an indication of a programming error in lwIP and the developer should be notified. */ void _sys_mbox_free(sys_mbox_t *mbox) { u8_t ucErr; LWIP_ASSERT( "sys_mbox_free ", *mbox != SYS_MBOX_NULL ); //clear OSQ EVENT OSQFlush( (*mbox)->pQ ); //del OSQ EVENT (void)OSQDel( (*mbox)->pQ, OS_DEL_NO_PEND, &ucErr); LWIP_ASSERT( "OSQDel ", ucErr == OS_ERR_NONE ); //put mem back to mem queue ucErr = OSMemPut( pQueueMem, (*mbox) ); LWIP_ASSERT( "OSMemPut ", ucErr == OS_ERR_NONE ); }
/* Deallocates a mailbox. If there are messages still present in the mailbox when the mailbox is deallocated, it is an indication of a programming error in lwIP and the developer should be notified. */ void sys_mbox_free(sys_mbox_t mbox) { u8_t ucErr; LWIP_ASSERT( "sys_mbox_free ", mbox != SYS_MBOX_NULL ); /* clear OSQ EVENT */ OSQFlush( mbox->pQ ); /* del OSQ EVENT */ (void)OSQDel( mbox->pQ, OS_DEL_NO_PEND, &ucErr); LWIP_ASSERT( "OSQDel ", ucErr == OS_ERR_NONE ); /* put mem back to mem queue */ ucErr = OSMemPut( pQueueMem, mbox ); LWIP_ASSERT( "OSMemPut ", ucErr == OS_ERR_NONE ); }
/*FUNCTION********************************************************************** * * Function Name : OSA_MsgQGet * Description : This function checks the queue's status, if it is not empty, * get message from it and return kStatus_OSA_Success, otherwise, timeout will * be used for wait. The parameter timeout indicates how long should wait in * milliseconds. Pass OSA_WAIT_FOREVER to wait indefinitely, pass 0 will return * kStatus_OSA_Timeout immediately if queue is empty. * This function returns kStatus_OSA_Success if message is got successfully, * returns kStatus_OSA_Timeout if message queue is empty within the specified * 'timeout', returns kStatus_OSA_Error if any errors occur during waiting. * *END**************************************************************************/ osa_status_t OSA_MsgQGet(msg_queue_handler_t handler, void *pMessage, uint32_t timeout) { INT8U err; void* localMsg; int32_t *from_ptr, *to_ptr; uint16_t msg_size = handler->size; if (0U != timeout) { /* If timeout is not 0, convert it to tickes. */ timeout = wait_timeout_msec_to_tick(timeout); localMsg = OSQPend(handler->pQueue, timeout, &err); } else { localMsg = OSQAccept(handler->pQueue, &err); } if (OS_ERR_NONE == err) { /* Copy localMsg to msg */ to_ptr = (int32_t*)(pMessage); from_ptr = (int32_t*)localMsg; while (msg_size--) { *to_ptr++ = *from_ptr++; } OSMemPut(handler->pMem, localMsg); return kStatus_OSA_Success; } else if ((OS_ERR_Q_EMPTY == err) || (OS_ERR_TIMEOUT == err)) { return kStatus_OSA_Timeout; } else { return kStatus_OSA_Error; } }
/*FUNCTION********************************************************************** * * Function Name : OSA_MsgQPut * Description : This function is used to put a message to a message queue. * Return kStatus_OSA_Success if the message is put successfully, otherwise * return kStatus_OSA_Error. * *END**************************************************************************/ osa_status_t OSA_MsgQPut(msg_queue_handler_t handler, void* pMessage) { OS_ERR err; void *localMsg; int32_t *from_ptr, *to_ptr; uint32_t msg_size = handler->size; /* In this case, the message is saved into internal memory */ localMsg = OSMemGet(&(handler->mem), &err); if (!localMsg) { return kStatus_OSA_Error; } /* Copy msg to localMsg. */ from_ptr = (int32_t*)pMessage; to_ptr = (int32_t*)localMsg; while (msg_size--) { *to_ptr++ = *from_ptr++; } OSQPost(&(handler->queue), localMsg, handler->size*sizeof(int32_t), OS_OPT_POST_FIFO, &err); if (OS_ERR_NONE != err) { OSMemPut(&(handler->mem), localMsg, &err); return kStatus_OSA_Error; } return kStatus_OSA_Success; }
void TaskUart(void *pdata) //send message to uart from uartQ { char *pUartMsg; INT8U err; pdata=pdata; while(1) { pUartMsg=OSQAccept(pUart_Q,&err);//Accept the Msg from Qene; no wait while(pUartMsg) { Uart_SendString(pUartMsg);//seng str to Uart OSMemPut(pUartMem,pUartMsg); pUartMsg=OSQAccept(pUart_Q,&err);//free Mem } OSTimeDly(OS_TICKS_PER_SEC/5); } }
void gd_task_network(void *parg) { INT8S res = 0; INT8U err; gd_msg_t *recv_msg = NULL; gd_network_task_t *network_task = &gd_system.network_task; fail_tick = 0; while(1) { recv_msg = (gd_msg_t *)OSQAccept(network_task->q_network, &err); if(recv_msg != NULL) { switch(recv_msg->type) { case GD_MSG_GM_RESET: network_gm_reset(); break; case GD_MSG_GM_INIT: network_gm_init(); break; case GD_MSG_TCP_INIT: network_tcpip_init(); break; case GD_MSG_TCP_MODE_INIT: network_tcpip_mode(); break; case GD_MSG_TCP_CONNECT: network_tcpip_creat(); break; case GD_MSG_SEND_HEARTBEAT: network_heart_beat(); break; case GD_MSG_GM_NO_SIGNAL: network_no_signal(); break; /*unrequest at command*/ case GD_MSG_GM_TCP_LINK1_CLOSE: network_tcpip_state_change(GM_TCPIP_LINK1_CLOSE); break; case GD_MSG_GM_TCP_LINK2_CLOSE: network_tcpip_state_change(GM_TCPIP_LINK2_CLOSE); break; case GD_MSG_GM_TCP_LINK3_CLOSE: network_tcpip_state_change(GM_TCPIP_LINK3_CLOSE); break; case GD_MSG_GM_TCP_SERVER_CLOSE: network_tcpip_state_change(GM_TCPIP_SERVER_CLOSE); break; case GD_MSG_GM_TCP_CLOSE: network_tcpip_state_change(GM_TCPIP_CLOSE); break; case GD_MSG_GM_RECV_SMS: network_wakeup(GM_TCPIP_RECEIVED_SMS); break; case GD_MSG_GM_RECV_RING: network_wakeup(GM_TCPIP_RECEIVED_RING); break; default: break; } res = OSMemPut(gd_system.gd_msg_PartitionPtr, (void*)recv_msg); if(res != OS_ERR_NONE) { //...error.... } } network_heart_beat(); OSTimeDlyHMSM(0, 0, 0, 100); } }
/* ********************************************************************************************************* * App_TaskNoah_Ruler() * * Description : Process Comminucation between Ruler module and Audio Bridge. * Noah protocol layer related data parsing and processing. * This task wait for message event from App_TaskUART_Rx(). Check if the Noah layer data is * valid in the message. * * Argument(s) : p_arg Argument passed to 'App_TaskNoah_Ruler()' by 'OSTaskCreate()'. * * Return(s) : none. * * Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not * used. The compiler should not generate any code for this statement. ********************************************************************************************************* */ void App_TaskNoah_Ruler( void *p_arg ) { (void)p_arg; NOAH_CMD *pPcCmd ; CPU_INT08U *pCmdBuf ; CPU_INT08U rxID ; CPU_INT08U PcCmdRxID_Ruler[4]; CPU_INT08U sum ; CPU_INT08U SessionDone; CPU_INT08U err ; CPU_INT08U *pTaskMsgIN ; CPU_INT08U *pMsg ; pTaskMsgIN = NULL; pMsg = NULL; SessionDone = 0 ; while( DEF_TRUE ) { pTaskMsgIN = (INT8U *)OSQPend( EVENT_MsgQ_RulerUART2Noah, 0, &err ); if( pTaskMsgIN != NULL && OS_ERR_NONE == err ) { pCmdBuf = pTaskMsgIN; // char point to the data buffer pPcCmd = (NOAH_CMD *)pCmdBuf ; //change to NOAH_CMD type rxID = GET_FRAME_ID( pPcCmd->head ) ; //get frame ID, index sum = pPcCmd->checkSum; //get check sum data LED_Toggle(LED_DS2); APP_TRACE_DBG(("\r\n<<")); switch( GET_FRAME_TYPE( pPcCmd->head ) ) {// GET_FRAME_TYPE(pPcCmd->head) get frame type case FRAM_TYPE_DATA : if( (sum == 0) || ( sum == CheckSum(0,pCmdBuf, pPcCmd->DataLen + 2)) ) { // APP_TRACE_INFO(("R[%d]:[0x%2x>0x%2x][",Global_Ruler_Index,PcCmdRxID_Ruler[Global_Ruler_Index],rxID)); // for(unsigned int i = 0; i<pPcCmd->DataLen; i++){ // APP_TRACE_INFO((" %2X", *(unsigned char*)(pPcCmd->Data+i) )); // } // APP_TRACE_INFO((" ]\r\n")); pcSendDateToBuf( EVENT_MsgQ_Noah2RulerUART, SET_FRAME_HEAD(rxID,FRAM_TYPE_ACK), NULL, 0, 0, NULL, 0 ) ; // ACK if( (CPU_INT08U)(PcCmdRxID_Ruler[Global_Ruler_Index]+0x40) == rxID ) { // chweck if frameID repeat PcCmdRxID_Ruler[Global_Ruler_Index] = rxID ; //save this frameID err = Noah_CMD_Parse_Ruler( pPcCmd, &SessionDone); // jump to CMD parse if( (err != OS_ERR_NONE) || (SessionDone == 1) ) { SessionDone = 0; Ruler_CMD_Result = err ; OSTimeDly(2); //wait enough time for ACK to be sent APP_TRACE_DBG((" Res[0x%2x]", Ruler_CMD_Result)); OSSemPost( Done_Sem_RulerUART ); } } else { APP_TRACE_DBG(("PcCmdRxID_Ruler[%d] Err: expect 0x%X, get 0x%X",Global_Ruler_Index,PcCmdRxID_Ruler[Global_Ruler_Index]+0x40,rxID)); } } else { pcSendDateToBuf( EVENT_MsgQ_Noah2RulerUART, SET_FRAME_HEAD(rxID,FRAM_TYPE_NAK), NULL, 0, 0, NULL, 0 ) ; // NAK } break ; case FRAM_TYPE_ESTA : PcCmdRxID_Ruler[Global_Ruler_Index] = 0xC0 ; // ? why 0x40: make sure there can be many same setup frame PcCmdTxID_Ruler[Global_Ruler_Index] = 0x00 ; // OSSemPost( ACK_Sem_RulerUART ); OSSemPost( Done_Sem_RulerUART ); //end the resend pending-- OSTimeDly(1); //wait for the TX buffer is empty //Reset all UART CMD related buffer and release mem do{ //reset mem used by EVENT_MsgQ_RulerUART2Noah pMsg = (INT8U *)OSQAccept( EVENT_MsgQ_Noah2RulerUART, &err ); OSMemPut( pMEM_Part_MsgUART, pMsg ); } while ( pMsg != NULL && OS_ERR_NONE == err ) ; do{ //reset mem used by EVENT_MsgQ_RulerUART2Noah pMsg = (INT8U *)OSQAccept( EVENT_MsgQ_RulerUART2Noah, &err ); OSMemPut( pMEM_Part_MsgUART, pMsg ); } while ( pMsg != NULL && OS_ERR_NONE == err ) ; Queue_Flush( pUART_Send_Buf[RULER_UART] ); //clear uart send&rec data queue Queue_Flush( pUART_Rece_Buf[RULER_UART] ); SessionDone = 0; //init OSSemSet( ACK_Sem_RulerUART, 0, &err ); // clear the sem OSSemSet( Done_Sem_RulerUART, 0, &err ); test_counter4++; APP_TRACE_DBG(("EST/ESTA")); break ; case FRAM_TYPE_ACK : if( rxID == PcCmdTxID_Ruler[Global_Ruler_Index] ) { OSSemPost( ACK_Sem_RulerUART ); test_counter2++; } else { APP_TRACE_INFO_T(("\r\nACK: Got %X, Expect %X\r\n",rxID,PcCmdTxID_Ruler[Global_Ruler_Index] )); } APP_TRACE_DBG(("ACK")); test_counter3++; break ; case FRAM_TYPE_NAK : // dismiss NAK, there will be a resend if no ACK got // OSSemPost( Done_Sem_RulerUART ); test_counter1++; APP_TRACE_DBG(("NAK")); break; default : break ; } //release mem OSMemPut( pMEM_Part_MsgUART, pTaskMsgIN ); } ////OSTimeDly(2); //use OSQPend(), no delay needed!!! } }
/* ********************************************************************************************************* * App_TaskUART_Tx() * * Description : Process UART Transmit related process between Audio Bridge and PC. * Wait for data message from other task that want to send to PC. * * Argument(s) : p_arg Argument passed to 'App_TaskUART_Tx()' by 'OSTaskCreate()'. * * Return(s) : none. * * Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not * used. The compiler should not generate any code for this statement. ********************************************************************************************************* */ void App_TaskUART_Tx( void *p_arg ) { (void)p_arg; CPU_INT08U errCode ; CPU_INT08U *pTaskMsgIN ; pNEW_CMD pPcCmd ; CPU_INT32U counter ; CPU_INT32U size ; CPU_INT32U times ; CPU_INT08U *pChar ; pTaskMsgIN = NULL; pPcCmd = NULL; errCode = UNKOW_ERR_RPT ; // unsigned char tt[512]; // for (unsigned int i = 0; i<512; i++) { // tt[i] = '0'+i; // } //// while(1){ // //// kfifo_put(pUART_Send_kfifo[PC_UART], (unsigned char *)&tt , 512) ; //// UART_WriteStart( PC_UART ); //// OSTimeDly(1); //// //// } // // while (DEF_TRUE) { // // // Noah to Uart transmit // pTaskMsgIN = (INT8U *)OSQPend( EVENT_MsgQ_Noah2PCUART, 0, &errCode ); // // if( pTaskMsgIN != NULL && OS_ERR_NONE == errCode ) { // kfifo_put(pUART_Send_kfifo[PC_UART], (unsigned char *)&tt , 512) ; // UART_WriteStart( PC_UART ); // } // } ////////////////////////////////////////////////////////////////////////////// //pcSendDateToBuf( EVENT_MsgQ_Noah2PCUART, SET_FRAME_HEAD(PcCmdTxID,FRAM_TYPE_EST), NULL, 0, 0, NULL, 0 ) ; // send a EST package on startup while (DEF_TRUE) { // Noah to Uart transmit pTaskMsgIN = (INT8U *)OSQPend( EVENT_MsgQ_Noah2PCUART, 0, &errCode ); if( pTaskMsgIN != NULL && OS_ERR_NONE == errCode ) { // Time_Stamp(); // APP_TRACE_INFO(("\r\n:App_TaskUART_Tx : [%d] start ",pPcCmd->DataLen + 5)); pPcCmd = (pNEW_CMD)pTaskMsgIN ; pChar = (unsigned char *)pTaskMsgIN ; counter = (pPcCmd->data_len[0]<<16) + (pPcCmd->data_len[1]<<8) + pPcCmd->data_len[2]; counter += 8; #if( false ) APP_TRACE_INFO(("\r\n############DATA==counter: %d ####################\r\n",counter)); for(unsigned int i = 0; i< counter; i++ ){ APP_TRACE_INFO(("%0X ", *(pChar+i) )); if(i%32 == 31) { APP_TRACE_INFO(("\r\n")); } } APP_TRACE_INFO(("\r\n##########################################\r\n")); #endif times = counter / UART1_SEND_QUEUE_LENGTH ; counter = counter % UART1_SEND_QUEUE_LENGTH ; if( times ) { for(unsigned int i = 0; i<times; i++ ) { while(1) { size = kfifo_get_free_space( pUART_Send_kfifo[PC_UART] ); if( size >= UART1_SEND_QUEUE_LENGTH ) { kfifo_put(pUART_Send_kfifo[PC_UART], pChar, UART1_SEND_QUEUE_LENGTH) ; pChar += UART1_SEND_QUEUE_LENGTH; break; } //OSTimeDly(1); } UART_WriteStart( PC_UART ); //send data } } if( counter ) { while(1) { size = kfifo_get_free_space( pUART_Send_kfifo[PC_UART] ); if( size >= counter ) { kfifo_put(pUART_Send_kfifo[PC_UART], pChar, counter) ; break; } //OSTimeDly(1); } UART_WriteStart( PC_UART ); //send data } OSMemPut( pMEM_Part_MsgUART, pTaskMsgIN ); } ////OSTimeDly(5); } }
/********************************************************************************************************* ** Function name: zyMsgPost ** Descriptions: 发送消息 ** input parameters: ulMsg: zyMsgCreate返回值 ** pucMsgSend: 要发送的消息 ** ucMod: 发送模式,一般为0 ** output parameters: none ** Returned value: ZY_OK: 成功 ** 负数: 错误,绝对值参考zy_if.h ** Created by: Chenmingji ** Created Date: 2009-07-23 **-------------------------------------------------------------------------------------------------------- ** Modified by: ** Modified date: *********************************************************************************************************/ INT32S zyMsgPost (unsigned long ulMsg, INT8U *pucMsgSend, INT8U ucMod) { __ZY_IF_MSG *pimThis; /* 消息通道信息 */ INT8U ucErr; /* 错误代码 */ void *pvTmp; pimThis = (__ZY_IF_MSG *)ulMsg; /* * 参数检查 */ if (ulMsg == 0) { return -ZY_PARAMETER_ERR; } #if OS_ARG_CHK_EN == 0 if (pimThis->poeQ == NULL) { return -ZY_PARAMETER_ERR; } if (pimThis->pomMsg == NULL) { return -ZY_PARAMETER_ERR; } #endif /* OS_ARG_CHK_EN */ /* * 申请缓冲区 */ pvTmp = OSMemGet(pimThis->pomMsg, &ucErr); switch (ucErr) { case OS_MEM_INVALID_PMEM: return -ZY_NO_FIND_OBJECT; case OS_MEM_NO_FREE_BLKS: return -ZY_NO_MEMORY; case OS_NO_ERR: break; default: return -ZY_NOT_OK; } /* * 发送消息 */ memcpy(pvTmp, pucMsgSend, (size_t)(pimThis->ulMsgSize)); /* 拷贝数据 */ ucErr = OSQPostOpt(pimThis->poeQ, pvTmp, ucMod); /* 保存消息存储位置 */ if (ucErr == OS_NO_ERR) { return ZY_OK; } OSMemPut(pimThis->pomMsg, pvTmp); /* 归还缓冲区 */ switch (ucErr) { case OS_ERR_PEVENT_NULL: return -ZY_PARAMETER_ERR; case OS_ERR_EVENT_TYPE: return -ZY_NO_FIND_OBJECT; case OS_Q_FULL: return -ZY_NO_MEMORY; default: return -ZY_NOT_OK; } }
/******************************************************************************* * Function Name : psr_mgnt_cmd() * Description : mgnt命令的统一处理进程, * Input : pt_prop分别针对额外属性数据体 * Output : None * Return : *******************************************************************************/ STATUS psr_mgnt_cmd(u8 mgnt_cmd, u16 pipe_id, void * pt_prop, ARRAY_HANDLE return_buffer, AUTOHEAL_LEVEL autoheal_level) { u32 expiring_sticks; PIPE_REF pipe_ref; STATUS result; ARRAY_HANDLE mpdu; u8 mpdu_len; ARRAY_HANDLE ptw; result = FAIL; /* check validity of pipe_id */ pipe_ref = inquire_pipe_mnpl_db(pipe_id); if(!pipe_ref) { #ifdef DEBUG_MGNT my_printf("PSR ERR: NO PIPE INFO.\r\n"); #endif if(return_buffer) { return_buffer[0] = NO_PIPE_INFO; } return FAIL; } mpdu = OSMemGet(MINOR); if(!mpdu) { if(return_buffer) { return_buffer[0] = MEM_OUT; } return result; } switch(mgnt_cmd) { case(EXP_MGNT_PING): { expiring_sticks = psr_ping_sticks(pipe_ref); mpdu[0] = (0x80 | EXP_MGNT_PING); mpdu_len = 1; break; } case(EXP_MGNT_DIAG): { DLL_SEND_HANDLE pds; pds = (DLL_SEND_HANDLE)(pt_prop); expiring_sticks = psr_diag_sticks(pipe_ref,pds); ptw = mpdu; *(ptw++) = (0x80 | EXP_MGNT_DIAG); mem_cpy(ptw,pds->target_uid_handle,6); ptw += 6; *(ptw++) = pds->xmode; *(ptw++) = pds->rmode; *(ptw++) = (pds->prop & BIT_DLL_SEND_PROP_SCAN)?1:0; mpdu_len = ptw-mpdu; break; } case(EXP_MGNT_EBC_BROADCAST): { EBC_BROADCAST_HANDLE ebc; ebc = (EBC_BROADCAST_HANDLE)(pt_prop); /* limit ebc window */ switch(ebc->rmode & 0x03) { case(0x00): { if(ebc->window > CFG_EBC_MAX_BPSK_WINDOW) { ebc->window = CFG_EBC_MAX_BPSK_WINDOW; } break; } case(0x01): { if(ebc->window > CFG_EBC_MAX_DS15_WINDOW) { ebc->window = CFG_EBC_MAX_DS15_WINDOW; } break; } case(0x02): { if(ebc->window > CFG_EBC_MAX_DS63_WINDOW) { ebc->window = CFG_EBC_MAX_DS63_WINDOW; } } } expiring_sticks = psr_broadcast_sticks(pipe_ref,ebc); ptw = mpdu; *ptw++ = (0x80 | EXP_MGNT_EBC_BROADCAST); *ptw++ = ebc->bid; *ptw++ = ebc->xmode; *ptw++ = ebc->rmode; *ptw++ = ebc->scan; *ptw++ = ebc->window; *ptw++ = ebc->mask; mpdu_len = 7; /*** todo: add other conditions ***/ if(ebc->mask & BIT_NBF_MASK_UID) { mem_cpy(ptw,ebc->uid,6); ptw += 6; mpdu_len += 6; } if(ebc->mask & BIT_NBF_MASK_METERID) { mem_cpy(ptw,ebc->mid,6); ptw += 6; mpdu_len += 6; } if(ebc->mask & BIT_NBF_MASK_BUILDID) { *ptw++ = ebc->build_id; mpdu_len++; } break; } case(EXP_MGNT_EBC_IDENTIFY): { EBC_IDENTIFY_HANDLE ebc; ebc = (EBC_IDENTIFY_HANDLE)(pt_prop); expiring_sticks = psr_identify_sticks(pipe_ref,ebc); ptw = mpdu; *ptw++ = (0x80 | EXP_MGNT_EBC_IDENTIFY); *ptw++ = ebc->bid; *ptw++ = ebc->num_bsrf; *ptw++ = ebc->max_identify_try; mpdu_len = 4; break; } case(EXP_MGNT_EBC_ACQUIRE): { EBC_ACQUIRE_HANDLE ebc; ebc = (EBC_ACQUIRE_HANDLE)(pt_prop); expiring_sticks = psr_acquire_sticks(pipe_ref,ebc); ptw = mpdu; *ptw++ = (0x80 | EXP_MGNT_EBC_ACQUIRE); *ptw++ = ebc->bid; *ptw++ = ebc->node_index; *ptw++ = ebc->node_num; mpdu_len = 4; break; } case(EXP_MGNT_SET_BUILD_ID): { expiring_sticks = psr_transaction_sticks(pipe_ref,2,9,0); ptw = mpdu; *ptw++ = (0x80 | EXP_MGNT_SET_BUILD_ID); *ptw++ = *(u8 *)(pt_prop); mpdu_len = 2; break; } default: { #ifdef DEBUG_MANIPULATION my_printf("error mgnt cmd %bX\r\n",mgnt_cmd); #endif OSMemPut(MINOR,mpdu); return result; } } // 2013-07-18 autoheal_level 作为参数传入 // 一般地: ping命令的autoheal_level为0, ebc各个命令由于是组网过程中使用, autoheal_level为1(允许重刷pipe, 允许重试) // diag命令要看情况, 在组网过程中使用level1, 在诊断和修复过程中使用level1等等, 这样能保证代码的重用和最大的灵活性 result = psr_transaction(pipe_id, mpdu, mpdu_len, expiring_sticks, return_buffer, autoheal_level); OSMemPut(MINOR,mpdu); if(!result) { #ifdef DEBUG_MANIPULATION my_printf("mgnt psr comm fail\r\n"); #endif return FAIL; } if(result && ((*return_buffer & 0xF0) == 0xF0)) //2013-07-18 status为okay仅表示通信成功, return_buffer首字节为0xFX即表示mgnt层功能失败 { #ifdef DEBUG_MANIPULATION my_printf("mgnt cmd return fail\r\n"); #endif return FAIL; } else { return OKAY; } }
void TaskTxSerial(void *pdata) { #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif struct AdcMsg *Sensores; INT8U err; INT16S Sensor1; INT16S Sensor2; INT16S Sensor3; INT16U Acumulador1; INT16U Acumulador2; INT16U Acumulador3; INT8U contador; INT16U ValorTeclado; INT8S strTx1[5]; INT8S strTx2[5]; INT8S strTx3[5]; for(;;) { OSSemPend(STaskTxSerial,0,&err); Acumulador1=0; Acumulador2=0; Acumulador3=0; for(contador=0 ; contador<10 ; contador++) { Sensores = (struct AdcMsg *) OSQPend(QueueADC0, 0, &err); Acumulador1+=Sensores->adc0; Acumulador2+=Sensores->adc1; Acumulador3+=Sensores->adc2; OSMemPut(dMemory,Sensores); } OSSemPend(STeclado,0,&err); ValorTeclado=NumeroSensores; OSSemPost(STeclado); Sensor1=0; Sensor2=0; Sensor3=0; switch(ValorTeclado){ case 3: Sensor3 = (INT16S) Acumulador3/10; case 2: Sensor2 = (INT16S) Acumulador2/10; case 1: Sensor1 = (INT16S) Acumulador1/10; default: break; } /* itoa(Sensor1,strTx1); putsUSART(strTx1); putrsUSART(SPACE); itoa(Sensor2,strTx2); putsUSART(strTx2); putrsUSART(SPACE); itoa(Sensor3,strTx3); putsUSART(strTx3); putrsUSART(CRLF); */ if(NumeroSensores > 0){ itoa(Sensor1,strTx1); putsUSART(strTx1); putrsUSART(SPACE); if(NumeroSensores > 1){ itoa(Sensor2,strTx2); putsUSART(strTx2); putrsUSART(SPACE); } if(NumeroSensores > 2){ itoa(Sensor3,strTx3); putsUSART(strTx3); } putrsUSART(CRLF); } //OSSemPost(STask1); OSTimeDly(10); } }