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); } }
//======================================================== //Function Name:msgQAccept //Syntax: INT32S msgQAccept(MSG_Q_ID msgQId, INT32U *msg_id, void *para, INT32U maxParaNByte) //Purpose: Check whether a message is available from a message queue //Note: //Parameters: MSG_Q_ID msgQId /* message queue on which to send */ // INT32U *msg_id /* message id */ // void *para /* message and type received */ // INT32U maxNByte /* message size */ //Return: -1: queue is empty or fail // 0: success //======================================================= INT32S msgQAccept(MSG_Q_ID msgQId, INT32U *msg_id, void *para, INT32U maxParaNByte) { INT8U err; void *pMsg; pMsg = OSQAccept(msgQId->pEvent, &err); if (err!=OS_NO_ERR || !pMsg) { return -1; } MSG_Q_LOCK(); if (maxParaNByte > msgQId->maxMsgLength) { MSG_Q_UNLOCK(); #if MSG_Q_DEBUG == 1 DBG_PRINT("msg receive err:message size is too large\r\n"); #endif return -1; } *msg_id = *((INT32U *) pMsg); if (maxParaNByte && para) { gp_memcpy((INT8S *) para, (INT8S *) pMsg + 4, maxParaNByte); } *(INT32U *) pMsg = 0; /* free message */ MSG_Q_UNLOCK(); return 0; }
/********************************************************************************************************* ** 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 { 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); } }
/* ******************************************************************************* ** ** This function waits until a message is available in the given mailqueue. ** The suspend argument controls whether this function will be in blocking ** mode or not while waiting for a message. A waiting message will be cleared. ** ******************************************************************************* */ RTOS_Message RTOS_MailqueueWait( RTOS_Mailqueue mailqueue, RTOS_Flag suspend ) { INT8U error = OS_NO_ERR; void* message = 0; if( ! RTOS_MailqueueIsValid( mailqueue ) ) return( (RTOS_Message)0 ); if( suspend ) message = OSQPend( (OS_EVENT*)mailqueue, (INT16U)0, &error ); else message = OSQAccept( (OS_EVENT*)mailqueue ); if( ( error != OS_NO_ERR ) || ( message == 0 ) ) return( (RTOS_Message)0 ); return( message ); }
/*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; } }
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!!! } }
void TaskTwoRiscSystemMonitorRisc0(void *data) { unsigned char err; unsigned int msg; unsigned short ret = 0; OS_TCB tcb_data; unsigned int temp; unsigned int vstd = 0; BspStartTicker(OS_TICKS_PER_SEC); OSStatInit(); #ifdef PRINT_IN_TASK print_init_buffer(); #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscPrint, (void *)0, (void *)&StkTaskTwoRiscPrint[sizeof(StkTaskTwoRiscPrint) / sizeof(StkTaskTwoRiscPrint[0]) - 1], PRIOR_TASK_PRINT,\ PRIOR_TASK_PRINT, (void *)&StkTaskTwoRiscPrint[0], sizeof(StkTaskTwoRiscPrint) / sizeof(StkTaskTwoRiscPrint[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR); #else OSTaskCreate(TaskTwoRiscPrint, (void *)0, (void *)&StkTaskTwoRiscPrint[STK_SIZE_TaskTwoRiscPrint - 1], PRIOR_TASK_PRINT); #endif #endif printf("\r\n"); printf("**********************************************************************\r\n"); printf("* Risc%d: Two Risc System Monitor Task *\r\n", RiscRdID()); printf("**********************************************************************\r\n"); printf("\r\n"); #ifdef AUDIO_MODULE_INCLUDE gptAudioTaskReady = 0; #endif #ifdef VIDEO_MODULE_INCLUDE tVideoLinuxToUcos *pVideoPackage; unsigned int VideoStatusBak; unsigned int *pInt; Risc_Packet_t risc_packet; VideoStatusBak = 0; gVideoStatus = 0; /******************************************************************* the code below is to fix the audio input channel 0 queue underflow bug, details see bug number 5 in "avsyncbuglist.xls" in buglist. *******************************************************************/ McScMap(VSC_RD_Y0_M, VSC_RD_Y0_S); McScMap(VSC_RD_U0_M, VSC_RD_U0_S); McScMap(VSC_RD_V0_M, VSC_RD_V0_S); McScMap(VSC_RD_Y1_M, VSC_RD_Y1_S); McScMap(VSC_RD_U1_M, VSC_RD_U1_S); McScMap(VSC_RD_V1_M, VSC_RD_V1_S); /*******************************************************************/ gtVinFormat.yuv_format = YUV420; gtVinFormat.camera_format = NTSC; //0: NTSC mode, 1: PAL mode if(gtVinFormat.camera_format == PAL) { gtVinFormat.width = 704; gtVinFormat.height = 576; } else { gtVinFormat.width = 704; gtVinFormat.height = 480; } decode_flag = MPEG_ENCODE; //20071129;indicate the encode mode of the bit stream default is MPEG mode #ifdef DVR gChecksumEnabled = TRUE; // enable checksum #else gChecksumEnabled = FALSE; // please do not change the default value #endif #ifdef DVR gImage_Mode = EVENODD_IMAGE;//MERGED_IMAGE; #else gImage_Mode = EVENODD_IMAGE; #endif gImgEncodeMode = ENCODEBOTH; #endif #ifdef DVR MM74HC595Init(); #endif gtPrintMsgControl.en_print_all_msg = 1; gtPrintMsgControl.en_print_periodical_msg = 1; memset((void *)>Statistics, 0, sizeof(gtStatistics)); /* David's email on Dec 12 to improve performance for video & mpeg */ *(volatile int *)0xa8040000 = 0x1680596; *(volatile int *)0xa8020000 = 0x11115; *(volatile int *)0xa8020004 = 0x0a77; RiscIntrInit(); RiscFlagIntrInit(); IICinit(); TwoRiscCommInit(); #ifdef DUAL_CPU_MODE RiscSemUnLock(7); // tell risc1 ISR table has been created! #endif gptQMsgTwoRiscSystemMonitor = OSQCreate(&ArrayQMsgSysMonitor[0], ArrayQMsgSysMonitor_MAX); #ifdef VIDEO_MODULE_INCLUDE gRvoDisplayMode = RVO_DISPLAY_BOTH; gFreqFromCrystal = TRUE; //TRUE: external, FALSE:internal gVoutClkSet = FALSE; gCameraSelectDigital = TRUE;//TRUE:digital,FALSE:analog extern unsigned int gVinOddEvenFrameSelect; extern unsigned int gVscOddEvenFrameSelect; gVinOddEvenFrameSelect = ODD_FRAME_FIRST; #ifdef DVR gVscOddEvenFrameSelect = ODD_FRAME_FIRST; #else gVscOddEvenFrameSelect = EVEN_FRAME_FIRST; #endif #ifdef MOTION_DETECTION //wy:motion detect init gMotionSensi = 0; //default disable motion detection. gIsMDEnabled = FALSE; //default disable motion detection. gMdType = mdtemporalDif; //default motion detection method. #endif #ifdef BAND_WIDTH_CONTROL set_cbr_default(); #endif #ifdef AV_SYNC set_avsync_default(); #endif #ifdef DISPLAY_INCLUDE #ifdef VIDEO_JITTER_BUFFER QEeventVodeoL2U = OSQCreate(pQVideoL2UPackage, VIDEO_L2U_PKG_NUMBER); if(QEeventVodeoL2U == NULL) _PRINTF("\r\nxxxxxxxx: Risc0: OSQCreate QEeventVodeoL2U error!\r\n"); #endif #ifdef STARTUP_PICTURE err = OSQPost(gptQMsgTwoRiscSystemMonitor, (void *)TWO_RISC_SYSTEM_OPEN_VOUT); if(err != OS_NO_ERR) printf("\r\nRISC0: OSMboxPost error! err = %d!\r\n", err); #endif #endif #endif #ifdef TASK_STATISTIC_EN if( #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskStatistics, (void *)0, (void *)&StkTaskStatistics[sizeof(StkTaskStatistics) / sizeof(StkTaskStatistics[0]) - 1], PRIOR_TASK_STATISTICS,\ PRIOR_TASK_STATISTICS, (void *)&StkTaskStatistics[0], sizeof(StkTaskStatistics) / sizeof(StkTaskStatistics[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR #else OSTaskCreate(TaskStatistics, (void *)0, (void *)&StkTaskStatistics[STK_SIZE_TaskStatistics - 1], PRIOR_TASK_STATISTICS) != OS_NO_ERR #endif ) { debug ("\r\nTaskCreate TaskCount1s error\r\n"); } #endif //RiscTimerInit(1000000); while(1) { #if 0 //#ifdef VIDEO_JITTER_BUFFER pVideoPackage = (tVideoLinuxToUcos *)OSQPend(QEeventVodeoL2U, 200 * OS_TICKS_PER_SEC /1000, &err); if(err == OS_NO_ERR) { VideoFrameReceive.addr = pVideoPackage->addr; VideoFrameReceive.size = pVideoPackage->len; VideoFrameReceive.TimeStamp = pVideoPackage->tstamp; err = VBufSaveOneFrame(&VideoBuffer1, &VideoFrameReceive); if(err) printf("xxx save viedo frame to buffer error! err = %d\n", err); else { //printf("depth = %d, space = %d\n", VideoFrameReceive.CurrentDepth, VideoFrameReceive.CurrentSpace); //printf("w = 0x%8.8x, %d, %d\n", VideoFrameReceive.addr, VideoFrameReceive.size, VideoFrameReceive.TimeStamp); } RiscDecCNT(VIDEO_LINUX_TO_UCOS_CNT, 1); if(OSSemPost(gptVideoLinuxToUcosMbox) != OS_NO_ERR) printf("Risc0:OSMboxPost error!\r\n"); } else if(err == OS_TIMEOUT) ;//printf("ucos receive video package time out!\n"); msg = (unsigned int)OSQAccept(gptQMsgTwoRiscSystemMonitor); if(msg) #else msg = (unsigned int)OSQPend(gptQMsgTwoRiscSystemMonitor, 200 * OS_TICKS_PER_SEC /1000, &err); if(err == OS_NO_ERR) #endif { switch(msg) { case TWO_RISC_SYSTEM_RECEIVE_LINUX_MSG: while(1) { if(TwoRiscCommRecPacket() != SUCCESSFUL) { break; } } break; #ifdef VIDEO_MODULE_INCLUDE #ifdef DISPLAY_INCLUDE case TWO_RISC_SYSTEM_CLOSE_VOUT: gVoutEnable = 0; break; case TWO_RISC_SYSTEM_CLOSE_DISPLAY_TASK: gVoutEnable = 0; printf("Close Display Task!\n"); //del task if(OSTaskDel(PRIOR_TASK_DISPLAY) != OS_NO_ERR ) printf("OSTaskDel failed!\n"); else printf("OSTaskDel OK!\n"); OSSemDel_w(gptMpegDecodeReadyToStart, OS_DEL_ALWAYS, &err); OSSemDel_w(gptVideoLinuxToUcosMbox, OS_DEL_ALWAYS, &err); #ifdef AV_SYNC OSSemDel_w(gptRiscTimerIntrOccur, OS_DEL_ALWAYS, &err); #endif OSQDel(gptMpeg4DecodeOutputReady, OS_DEL_ALWAYS, &err); if(err != OS_NO_ERR) printf("OSQDel failed!\n"); #ifdef PIP_ENABLE OSQDel (gptMqueueVideoInFrame, OS_DEL_ALWAYS, &err); if(err != OS_NO_ERR) printf("OSQDel failed, err = %d!", err); gVideoStatus &= ~tPipEn; #endif break; case TWO_RISC_SYSTEM_OPEN_VOUT: if(OSTaskQuery(PRIOR_TASK_DISPLAY, &tcb_data) == OS_NO_ERR) { //if(OSTaskCreate(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[STK_SIZE_TaskTwoRiscDisplay - 1], PRIOR_TASK_DISPLAY) != OS_NO_ERR) { if(gVoutEnable == 0) { gVoutEnable = 1; GetVoutInterface(); VoutInterfaceIntialize(gtDisplayFormat.vout_format); /* printf("Init 7171 "); if(HwADV7171Initialize(gtDisplayFormat.vout_format) == SUCCESSFUL) // 0: NTSC mode,1: pal mode printf("ok\n"); else printf("failed\n"); */ if(gtDisplayFormat.vout_format == LCD) { gtDisplayFormat.vout_interlaced = FALSE; } else { // NTSC or PAL gtDisplayFormat.vout_interlaced = TRUE; } #ifdef OSD_ENABLE unsigned int task_rollstr_flag = 0; if(gtOsdCurrent.osd_format!=gtDisplayFormat.vout_format){ if(OSTaskQuery(PRIOR_TASK_ROLLSTR, &tcb_data) == OS_NO_ERR){ task_rollstr_flag = 1; if(OSTaskDel(PRIOR_TASK_ROLLSTR) != OS_NO_ERR ) debug("OSTaskDel(PRIOR_TASK_ROLLSTR) failed!\n"); } if(gtDisplayFormat.vout_format == NTSC){ gtOsdCurrent.osd_format = NTSC; gtOsdCurrent.width = 704; gtOsdCurrent.height = 480; } else if(gtDisplayFormat.vout_format == PAL){ gtOsdCurrent.osd_format = PAL; gtOsdCurrent.width = 704; gtOsdCurrent.height = 576; } else if(gtDisplayFormat.vout_format == LCD){ gtOsdCurrent.osd_format = LCD; gtOsdCurrent.width = 480; gtOsdCurrent.height = 240; } //printf("\ngtOsdCurrent.width=%d,gtOsdCurrent.height=%d\n", gtOsdCurrent.width, gtOsdCurrent.height); gtOsdCurrent.start_pixel = 0; gtOsdCurrent.start_line = 0; gtOsdCurrent.backgroundColor = 15; gtOsdCurrent.OSD_T_Mask = 15; gtOsdCurrent.fill_addr = (((unsigned int)OSD_memory_0)&0x1fffffff); gtOsdCurrent.display_addr = (((unsigned int)OSD_memory_0)&0x1fffffff); InitOsdMemory(gtOsdCurrent.start_pixel ,gtOsdCurrent.start_line, gtOsdCurrent.width, gtOsdCurrent.height , gtOsdCurrent.backgroundColor, gtOsdCurrent.fill_addr, gtOsdCurrent.OSD_T_Mask); if(task_rollstr_flag == 1){ if( #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskRollString, (void *)0, (void *)&StkTaskRollStr[sizeof(StkTaskRollStr) / sizeof(StkTaskRollStr[0]) - 1], PRIOR_TASK_ROLLSTR,\ PRIOR_TASK_ROLLSTR, (void *)&StkTaskRollStr[0], sizeof(StkTaskRollStr) / sizeof(StkTaskRollStr[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR #else OSTaskCreate(TaskRollString, (void *)0, (void *)&StkTaskRollStr[STK_SIZE_ROLLSTR - 1], PRIOR_TASK_ROLLSTR) != OS_NO_ERR #endif ) debug ("\r\nTaskCreate TaskRollString error!\r\n"); else{ debug("\r\nTaskCreate TaskRollString OK!\r\n"); } } } #endif VscInit(); AppVscStart(); gVideoStatus |= tVoutEn; } } else { TwoRiscDisplayRvoPipOsdInit(); if( #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[sizeof(StkTaskTwoRiscDisplay) / sizeof(StkTaskTwoRiscDisplay[0]) - 1], PRIOR_TASK_DISPLAY,\ PRIOR_TASK_DISPLAY, (void *)&StkTaskTwoRiscDisplay[0], sizeof(StkTaskTwoRiscDisplay) / sizeof(StkTaskTwoRiscDisplay[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR) != OS_NO_ERR #else OSTaskCreate(TaskTwoRiscDisplay, (void *)0, (void *)&StkTaskTwoRiscDisplay[STK_SIZE_TaskTwoRiscDisplay - 1], PRIOR_TASK_DISPLAY) != OS_NO_ERR #endif ) printf("\r\nTaskTwoRiscDisplay create error!\r\n"); } break; case TWO_RISC_SYSTEM_CLOSE_PIP: gPipEnable = 0; break; case TWO_RISC_SYSTEM_CLOSE_RVO: gRvoEnable = 0; break; case TWO_RISC_SYSTEM_CLOSE_OSD: gOsdEnable = 0; break; case TWO_RISC_SYSTEM_OPEN_RVO: if(gRvoEnable == 0) { if(gVoutEnable == 1) { gVoutReEnable = 1; } gRvoEnable = 1; } break; case TWO_RISC_SYSTEM_OPEN_PIP: if(gPipEnable == 0) { if(gVoutEnable == 1) { gVoutReEnable = 1; } gPipEnable = 1; } break; #ifdef OSD_ENABLE case TWO_RISC_SYSTEM_OPEN_OSD: if(gOsdEnable==0) { if(gVoutEnable == 1) gVoutReEnable = 1; gOsdEnable =1; } /*if (OSTaskCreate(TaskRollString, (void *)0, (void *)&StkTaskRollStr[STK_SIZE_ROLLSTR - 1], PRIOR_TASK_ROLLSTR) != OS_NO_ERR) { debug ("\r\nTaskCreate TaskRollString error!\r\n"); } else printf("\r\nTaskCreate TaskRollString succed!\r\n");*/ break; #endif #endif case TWO_RISC_SYSTEM_OPEN_VIN: #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]) - 1], PRIOR_TASK_IPCAM,\ PRIOR_TASK_IPCAM, (void *)&StkTaskTwoRisc0IPCamera[0], sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR); #else OSTaskCreate(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[TaskTwoRiscMpegEncode_STK_SIZE - 1], PRIOR_TASK_IPCAM); #endif #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]) - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE,\ PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE, (void *)&StkTaskTwoRiscSendMpegH263Encode[0], sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR); #else OSTaskCreate(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[TaskTwoRiscSendMpegh263Encode_STK_SIZE - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE); #endif break; case TWO_RISC_SYSTEM_REOPEN_VIN_TASK: { INT8U dret = 0; DIS_VIN_VIDEO(); debug("before OSTaskDel(PRIOR_TASK_IPCAM).\n"); OSTaskDel(PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE); dret = OSTaskDel(PRIOR_TASK_IPCAM); debug("after OSTaskDel(PRIOR_TASK_IPCAM).\n"); if (dret != OS_NO_ERR ) debug("OSTaskDel(PRIOR_TASK_IPCAM) failed.\n"); else debug("OSTaskDel(PRIOR_TASK_IPCAM) success.\n"); OSSemDel_w(gptSemMpegEncodeReady, OS_DEL_ALWAYS, &err); OSSemDel_w(gptSemMp4EncodeOutBufReady, OS_DEL_ALWAYS, &err); OSMboxDel_w(gptMboxVideoInFrame, OS_DEL_ALWAYS, &err); OSMboxDel_w(gptMboxMpegEncodeOutFrame, OS_DEL_ALWAYS, &err); gVideoStatus &= ~tVinEn; #if 0 #ifdef PIP_ENABLE OSQDel (gptMqueueVideoInFrame, OS_DEL_ALWAYS, &err); if(err != OS_NO_ERR) printf("OSQDel failed, err = %d!", err); #endif #endif #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]) - 1], PRIOR_TASK_IPCAM,\ PRIOR_TASK_IPCAM, (void *)&StkTaskTwoRisc0IPCamera[0], sizeof(StkTaskTwoRisc0IPCamera) / sizeof(StkTaskTwoRisc0IPCamera[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR); #else OSTaskCreate(TaskTwoRiscVinMpegEncode, (void *)0, (void *)&StkTaskTwoRisc0IPCamera[TaskTwoRiscMpegEncode_STK_SIZE - 1], PRIOR_TASK_IPCAM); #endif #ifdef CHIP_CFG_STACK_CHECK OSTaskCreateExt(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]) - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE,\ PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE, (void *)&StkTaskTwoRiscSendMpegH263Encode[0], sizeof(StkTaskTwoRiscSendMpegH263Encode) / sizeof(StkTaskTwoRiscSendMpegH263Encode[0]), (void *)0, OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_CLR); #else OSTaskCreate(TaskTwoRiscSendMpegH263Encode, (void *)0, (void *)&StkTaskTwoRiscSendMpegH263Encode[TaskTwoRiscSendMpegh263Encode_STK_SIZE - 1], PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE); #endif } break; case TWO_RISC_SYSTEM_DEL_VIN_TASK: DIS_VIN_VIDEO(); INT8U dret = 0; debug("before OSTaskDel(PRIOR_TASK_IPCAM).\n"); OSTaskDel(PRIOR_TASK_TWO_RISC_SEND_MPEG_H263_ENCODE); dret = OSTaskDel(PRIOR_TASK_IPCAM); debug("after OSTaskDel(PRIOR_TASK_IPCAM).\n"); if (dret != OS_NO_ERR ) debug("OSTaskDel(PRIOR_TASK_IPCAM) failed.\n"); else debug("OSTaskDel(PRIOR_TASK_IPCAM) success.\n"); OSSemDel_w(gptSemMpegEncodeReady, OS_DEL_ALWAYS, &err); OSSemDel_w(gptSemMp4EncodeOutBufReady, OS_DEL_ALWAYS, &err); OSMboxDel_w(gptMboxVideoInFrame, OS_DEL_ALWAYS, &err); OSMboxDel_w(gptMboxMpegEncodeOutFrame, OS_DEL_ALWAYS, &err); gVideoStatus &= ~tVinEn; break; #endif /*VIDEO_MODULE_INCLUDE*/ #ifdef DVR /* wg add for DVR 2007.08.16 */ case TWO_RISC_SYSTEM_DVR_READ_MOTION_DETECTION: Hw2835ReadMDRegister(); #endif break; #ifdef VIDEO_MODULE_INCLUDE case TWO_RISC_SYSTEM_SET_CLOCK: if(gFreqFromCrystal == FALSE) { printf("\nTaskTwoRiscVinMpegEncode: camera clock is created from Vout!\n"); CctlVoutClkSet(); } else { printf("\nTaskTwoRiscVinMpegEncode: camera clock is created from external crystal!\n"); CctlVoutClkSet(); } gCameraSelectDigital = -1; //initialize it to avoid default FALSE pcurrent_camera = GetDigitCamera(); if(pcurrent_camera) { gCameraSelectDigital = TRUE; }else { pcurrent_camera = GetAnalogCamera(); if(pcurrent_camera) { gCameraSelectDigital = FALSE; if(pcurrent_camera != NULL) //has found digital camera or 7181 pcurrent_camera->camera_init(); else { // printf("\nTaskTwoRiscVinMpegEncode: no analog cameras found!\n"); } if(pcurrent_camera->GetCamVideoStd) { //is the chip support video standard detection? if(pcurrent_camera->GetCamVideoStd(&vstd) == SUCCESSFUL) { //get analog camera and video standard if((gtVinFormat.camera_format != vstd)) { gtVinFormat.camera_format = vstd; } } } } } break; #endif default: printf("\nTaskTwoRiscSystemMonitorRisc0: type(%d) error!\n", msg); break; } } #ifdef VIDEO_MODULE_INCLUDE #ifdef DISPLAY_INCLUDE if(gVoutEnable == 0) gVideoStatus &= ~tVoutEn; #endif if(VideoStatusBak != gVideoStatus) { debug("\n>>>>>>>>>>>>>>>>>>\n"); VideoStatusBak = gVideoStatus; //don't send gVideoStatus, it will be change in other task while you send! pInt = (unsigned int *)&risc_packet; risc_packet.start = RISC_PKT_START; risc_packet.main_type = tVideo; risc_packet.sub_type = tCheckVideoStatus; risc_packet.length = 0x8; risc_packet.status = 0; *(pInt + 2) = VideoStatusBak; risc_packet.end = RISC_PKT_END; if(TwoRiscCommSendPacket((unsigned int *)&risc_packet, RPACKET_LEN) == SUCCESSFUL) RiscFlagSet(); // Set risc1 flag to interrupt risc1 else debug("\r\nSend Video Status error!\r\n"); } #endif /* VIDEO_MODULE_INCLUDE */ } }
// Non-blocking waiting on a message queue bool PeekOn(Queue queue) { INT8U err; OSQAccept(queue, &err); return err == OS_ERR_NONE; }