void custom_at_handler(void)
{
    char *p=NULL;
    AT_Response response = INVAT;
    u8 off;

    if (!pData)
        return;

    p = pData;
    response = parse_at_response(&off);
    p+=off;

    switch(response)
    {
        case CPIN:
        {
            if (Ql_strncmp(p," READY",6)==0)
            {
                Ql_sprintf((char *)buffer,"\r\nCPIN is ready\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                Ql_sprintf((char *)buffer,"\r\nSet timer for 5 second\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                
                timer.timeoutPeriod = Ql_SecondToTicks(5);
                Ql_StartTimer(&timer);
                
            }else if (Ql_strncmp(p," SIM PIN",8)==0)
            {
                Ql_sprintf((char *)buffer,"\r\nSIM PIN is needed\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                
                Ql_memset(atbuffer,0,100);
                Ql_sprintf((char *)atbuffer,"AT+CPIN=1234\n");
                Ql_SendToModem(ql_md_port1,atbuffer,Ql_strlen((char *)atbuffer));    
            }
            break;
        }
        
        default:
            break;
    }
}
void ql_entry(void)
{
    s32 ret;
    bool keepGoing = TRUE;
    bool isContinued = FALSE;
    u32 cnt = 0; 
    
    Ql_DebugTrace("OpenCPU: Hello TTS !\r\n\r\n");    /* Print out messages through DEBUG port */
    Ql_SetDebugMode(BASIC_MODE);    /* Only after the device reboots, 
                                     *  the set debug-mode takes effect. 
                                     */

    // Initialize TTS, and register callback function
    Ql_TTS_Initialize(&Callback_TTS_Play);
    
    while(keepGoing)
    {
        Ql_GetEvent(&g_event);
        switch(g_event.eventType)
        {
            case EVENT_UARTDATA:
            {
                // TODO: receive and handle data from UART
                ascii* pChar;
                s16  strLen;
                PortData_Event* pDataEvt = (PortData_Event*)&g_event.eventData.uartdata_evt;

                /* Change audio path (Command: audio path=0/1/2)
                *  0 = the main audio path
                *  1 = earphone audio path
                *  2 = loudspeaker audio path
                */ 
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "audio path=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u8 audPath;
                    char* p1;
                    char* p2;
                    Ql_DebugTrace((char*)pDataEvt->data);
                    p1 = Ql_strstr((char*)pDataEvt->data, "=");
                    p2 = Ql_strstr((char*)pDataEvt->data, "\r\n");
                    Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                    memcpy(g_buffer, p1 + 1, p2 - p1 -1);
                    if (Ql_strcmp(g_buffer, "1") == 0)
                    {
                        audPath = QL_AUDIO_PATH_HEADSET;
                    }
                    else if (Ql_strcmp(g_buffer, "2") == 0)
                    {
                        audPath = QL_AUDIO_PATH_LOUDSPEAKER;
                    }
                    else
                    {
                        audPath = QL_AUDIO_PATH_NORMAL;
                    }
                    if (!Ql_VoiceCallChangePath(audPath))
                    {
                        Ql_DebugTrace("Fail to change audio path.\r\n");
                    }
                    else
                    {
                        Ql_DebugTrace("Change audio path to %d.\r\n", audPath);
                    }
                    break;
                }

                // Start tts speech (Command: start tts=...)
                strLen = Ql_sprintf(g_buffer, "start tts=");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    char* pCh = NULL;
                    pCh = Ql_strstr((char*)pDataEvt->data, "=");
                    if (pCh != NULL)
                    {
                        Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                        Ql_strncpy(g_buffer, pCh + 1, pDataEvt->len - (pCh - (char*)pDataEvt->data + 1) - 2);
                        Ql_DebugTrace("Ql_TTS_Play(), len=%d\r\n", Ql_strlen(g_buffer));
                        ret = Ql_TTS_Play((u8*)g_buffer, sizeof(g_buffer));
                        if (ret < 0)
                        {
                            Ql_DebugTrace("Fail to play TTS.\r\n");
                            break;
                        }
                        else
                        {
                            Ql_DebugTrace("Playing finished.\r\n");
                        }
                    }
                    break;
                }
                
                // Stop TTS (Command: stop tts)
                Ql_memset(g_buffer, 0x0, Ql_strlen(g_buffer));
                strLen = Ql_sprintf(g_buffer, "stop tts\r\n");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    Ql_DebugTrace(g_buffer);
                    Ql_TTS_Stop();
                    break;
                }
                
                // Query TTS' status (Command: tts?)
                Ql_memset(g_buffer, 0x0, Ql_strlen(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts?\r\n");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    Ql_DebugTrace(g_buffer);
                    ret = Ql_TTS_Query();
                    switch (ret)
                    {
                    	case TTS_STATUS_IDLE:
                            Ql_DebugTrace("TTS: idle\r\n");
                    	    break;
                    	case TTS_STATUS_PLAYING:
                    	    Ql_DebugTrace("TTS: playing\r\n");
                    	    break;
                    	default:
                    	    Ql_DebugTrace("Fail to query TTS' status. Error code: %d\r\n", ret);
                    	    break;
                    }
                    break;
                }

                // Set volume (Command: tts vol=0..100)
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts vol=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u8 ttsVol;
                    char* p1;
                    char* p2;
                    Ql_DebugTrace((char*)pDataEvt->data);
                    p1 = Ql_strstr((char*)pDataEvt->data, "=");
                    p2 = Ql_strstr((char*)pDataEvt->data, "\r\n");
                    Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                    memcpy(g_buffer, p1 + 1, p2 - p1 -1);
                    ttsVol = Ql_atoi(g_buffer);
                    ttsVol = (ttsVol > 100) ? 100 : ttsVol;
                    Ql_SetVolume_Ex(VOL_TYPE_MEDIA, QL_AUDIO_PATH_HEADSET, ttsVol);
                    break;
                }
                
               // Set TTS Style 
               // Set TTS fastest voice speed
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style1=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VOICE_SPEED,TTS_SPEED_MAX);
                    Ql_DebugTrace("Set TTS fastest voice speed.\r\n");
                    break;
                }
                // Set TTS minimized volume.
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style2=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VOLUME,TTS_VOLUME_MIN);
                    Ql_DebugTrace("Set TTS minimized volume.\r\n");
                    break;
                }
                // Set TTS voice effect --eccentric
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style3=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VEMODE,TTS_VEMODE_ECCENTRIC);
                    Ql_DebugTrace("Set TTS voice effect --eccentric.\r\n");
                    break;
                }
            }

            /*************************************
            *  'Case' another EVENT if needed.
            *
            **************************************/
            
            default:
                break;
        }
    }
}
bool VerifyFileAndSendFirstEpoPacket(u8 *strFilePath)
{
    int ret = 0,filesize = 0;
    int sendLen = 0;
        
    if((strFilePath == NULL) || (Ql_strlen(strFilePath) == 0))
    {
         APP_DEBUG("VerifyFileAndSendFirstEpoPacket, strFilePath %s \r\n", strFilePath);             
        return FALSE;
    }
    ret = Ql_FS_Check((char*)strFilePath);
    if(ret != QL_RET_OK)
    {
        APP_DEBUG("Ql_FS_Check, strFilePath %s error \r\n", strFilePath);            
        return FALSE;
    }
    filesize = Ql_FS_GetSize((char*)strFilePath);       
    if(filesize < 0)
    {
        APP_DEBUG("Ql_FS_GetSize, filesize %d error \r\n ", filesize);            
        return FALSE;
    }       
    if (Ql_strncmp((char*)strFilePath,"RAM:", 4))
    {
        g_pEpoFile = Ql_FS_Open((char*)strFilePath, QL_FS_READ_ONLY);
    }
    else
    {
        g_pEpoFile = Ql_FS_OpenRAMFile((char*)strFilePath, QL_FS_READ_ONLY, filesize);
    }        
    // Read in the EPO file, and then verify the validity of EPO data. If the input EPO file is not in valid MTK EPO format, the
    // programmer shall terminate the process.
    if(g_pEpoFile < 0)
    {
        Ql_FS_Close(g_pEpoFile);
        APP_DEBUG("Ql_FS_OpenRAMFile, g_pEpoFile %d error \r\n ", g_pEpoFile);            
        return FALSE;
    }
    else
    {
        if (!fgEPO_Verify_File(g_pEpoFile))
        {
            Ql_FS_Close(g_pEpoFile);
            APP_DEBUG("fgEPO_Verify_File, g_pEpoFile %d error \r\n", g_pEpoFile);                    
            return FALSE;
        }
    }                    
    // Get total number of MTK_BIN_EPO packets that will be sent.
    g_i4NumSvEpoPkt =  i2EPO_Get_Num_Pkt(g_pEpoFile);       
    // Start EPO Data Transfer Protocol to send EPO data
    // fgEPO_Get_One_Pkt takes out three SAT data from the EPO file and encapsulated them in a MTK_BIN_EPO packet
    // with appropriate EPO SEQ number.
    // In order to save the total transferring time, we suggest to generate current EPO packet first, and then wait for
    // MTK_BIN_ACK_EPO acknowledge of the previous MTK_BIN_EPO packet from the GPS receiver.
    // The function fgEPO_Get_One_Pkt must be implemented by the programmer.
    g_u2LastEpoSeq = 0;
    g_u2EpoSeq = 0;
    Ql_memset(g_szPktData,0,sizeof(g_szPktData));
    if (fgEPO_Get_One_Pkt(g_u2EpoSeq, g_pEpoFile, g_szPktData))
    {
        sendLen =  MTKBIN_3EPO_PKT_LNG;
        ret = Ql_UART_Write(m_gnssUartPort,g_szPktData,sendLen);
        if (ret < sendLen)
        {
            APP_DEBUG("VerifyFileAndSendFirstEpoPacket Only part of bytes are written, %d/%d \r\n", ret, sendLen);            
            return FALSE;
        }
        // Update sequence number
        g_u2LastEpoSeq = g_u2EpoSeq;
        g_u2EpoSeq++;
        return TRUE;
    }
    else
    {
        APP_DEBUG("VerifyFileAndSendFirstEpoPacket fgEPO_Get_One_Pkt error \r\n");
        return FALSE;
    }

}
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara)
{
    //APP_DEBUG("CallBack_UART_Hdlr: port=%d, event=%d, level=%d, p=%x\r\n", port, msg, level, customizedPara);
    u32 rdLen=0;
    s32 ret;
    char *pData= NULL;
    char *p=NULL;
    char *p1=NULL;
    char *p2=NULL;
    bool    bRet = FALSE;
    
    switch (msg)
    {
        case EVENT_UART_READY_TO_READ:
        {
            if(UART_PORT1 == port)
            {  
                do
                {                   
                    Ql_memset(m_RxBuf_mcuUart, 0x0, sizeof(m_RxBuf_mcuUart));
                    rdLen = Ql_UART_Read(port, m_RxBuf_mcuUart, sizeof(m_RxBuf_mcuUart));
                    pData = m_RxBuf_mcuUart;
                    /*set last tail data eq 0*/
                    pData[rdLen + 1] = '\0';                    
                   
                    /*cmd: DEPO*/
                    p = Ql_strstr(pData,"DEPO");                    
                    if (p)
                    {
                        APP_DEBUG(textBuf,"\r\nDEPO \r\n");
                        bRet = SendMtkBinCmd("$PMTK253,1,0*37");
                        if(!bRet)
                        {
                            APP_DEBUG(textBuf,"\r\n Send $PMTK Error \r\n");
                            break;
                        }
                        else
                        {
                            bRet = VerifyFileAndSendFirstEpoPacket(s_s8FilePath);
                             if(!bRet)
                            {
                                APP_DEBUG(textBuf,"\r\n VerifyFile Error \r\n");                                
                                break;
                            }
                             else
                             {
                                APP_DEBUG(textBuf,"Update EPO Progress Start £º\r\n");
                             }
                        }
                        break;
                    }

                    
                    /*cmd:  QueryAvailableStorage=UFS*/
                    p = Ql_strstr(pData,"QueryAvailableStorage");
                    if (p)
                    {
                        if(Ql_strstr(pData,"=UFS"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(1);        // UFS
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size);   
                                    
                        }else if(Ql_strstr(pData,"=SD"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(2);  //SD
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size); 
                        }else if(Ql_strstr(pData,"=RAM"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(3);  //RAM
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size); 
                        }else
                        {
                            APP_DEBUG(textBuf,"QueryAvailableStorage param error!\r\n"); 
                        }
                        break;
                    }
                    
                    /*cmd: WriteFile=password.txt*/
                    p = Ql_strstr(pData,"WriteFile=");
                    if (p)
                    {
                        s32 s32Res = -1;
                        u32 uiFlag = 0;
                        u32 i=0;
                        char stmpdir[100],dir[100];
                        char *p1[100];
                        //u32 filesize = 10240;
                        u32 filesize = 276480;

                        p = Ql_strstr(pData, "=");
                        (*p) = '\0';
                        p++;

                        Ql_memset(s_s8FilePath, 0, sizeof(s_s8FilePath));  //File Name
                        Ql_strcpy((char *)s_s8FilePath, p);

                        uiFlag |= QL_FS_READ_WRITE;
                        uiFlag |= QL_FS_CREATE;

                        flag = 1;                     

                        if(Ql_strncmp((char*)s_s8FilePath,"RAM:",4))
                        {
                            ret = Ql_FS_Open((u8*)s_s8FilePath, uiFlag);
                            
                        }
                        else
                        {
                           ret = Ql_FS_OpenRAMFile((u8*)s_s8FilePath, uiFlag,filesize); 
                        }
                        if(ret >= QL_RET_OK)
                        {
                            filehandle = ret;
                        }

                        APP_DEBUG(textBuf,"filehandle=%d\r\n",filehandle);

                        break;
                    }


                    //Receiving data and StopWrite
                    if (flag)
                    {

                        u32 writeedlen;
                        p = Ql_strstr(pData,"StopWrite");
                        if (p)
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"Ql_WriteFinish()\r\n");

                            break;
                        }
                        ret = Ql_FS_Write(filehandle, (u8*)pData, rdLen, &writeedlen);
                        if(ret== QL_RET_OK)
                        {
                            //APP_DEBUG(textBuf,"Ql_File()=%d: writeedlen=%d,Download times=%d\r\n",ret, writeedlen,flag++);

                        }else if(ret == QL_RET_ERR_FILEDISKFULL)
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"Storage Full,close file! ret=%d\r\n",ret);
                            break;
                        }else
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"write error,close file!ret=%d \r\n",ret);
                            break;
                        }
                    }                                
                   

                    /*cmd: AT Command*/

                    if (Ql_strstr(pData,"AT")||Ql_strstr(pData,"at") || Ql_strstr(pData,"At") || Ql_strstr(pData,"aT"))
                    {
                        //APP_DEBUG(textBuf,"%s", pData);
                        Ql_UART_Write(VIRTUAL_PORT1,(u8*)pData,rdLen);
                        
                        break;
                    }
                    
                }while(rdLen > 0);

            }
            else if(UART_PORT3 == port)
            {
                s32 totalBytes = ReadSerialPort(port, m_RxBuf_gnssUART, sizeof(m_RxBuf_gnssUART));                
                if (totalBytes <= 0)
                {
                    APP_DEBUG("<-- No data in gnssUART buffer! -->\r\n");
                    return;
                }
                
                 ReadAckAndSendEpoPacket(m_RxBuf_gnssUART,totalBytes);

            }   
           else if((VIRTUAL_PORT1 == port) || (VIRTUAL_PORT2 == port))
            {
                s32 ret,totalBytes;

                totalBytes = ReadSerialPort(port, m_RxBuf_VirtualPort, sizeof(m_RxBuf_VirtualPort));
                if (totalBytes <= 0)
                {
                    APP_DEBUG("<-- No data in virtural UART buffer! -->\r\n");
                    return;
                }
                Ql_UART_Write(UART_PORT1,(u8*)m_RxBuf_VirtualPort,totalBytes);

            }
            
            break;
        }
        default:
            break;
    }
}
Example #5
0
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara)
{
    u32 rdLen=0;
    s32 ret;
    char *p=NULL;
    char *p1=NULL;
    char *p2=NULL;
    u8 write_buffer[4]={'a','b','c','D'};
    u8 read_buffer[6]={0x00,0x00,0x00,0x00,0x00,0x00};
    u8 registerAdrr[2]={0x01,0x45};
    switch (msg)
    {
        case EVENT_UART_READY_TO_READ:
        {
            Ql_memset(m_Read_Buffer, 0x0, sizeof(m_Read_Buffer));
            rdLen = Ql_UART_Read(port, m_Read_Buffer, sizeof(m_Read_Buffer));

            //command-->Init the IIC , type 0 Лђеп 1.
            p = Ql_strstr(m_Read_Buffer,"Ql_IIC_Init=");
            if(p)
            {
                char* p1 = NULL;
                char* p2 = NULL;
                u8 NumberBuf[10];
                s8 IIC_type=0;
                p1 = Ql_strstr(m_Read_Buffer, "=");
                p2 = Ql_strstr(m_Read_Buffer, "\r\n");
                Ql_memset(NumberBuf, 0x0, sizeof(NumberBuf));
                Ql_memcpy(NumberBuf, p1 + 1, p2 - p1 -1);
                IIC_type = Ql_atoi(NumberBuf);
                if(0 == IIC_type)// simultion iic test, and we choose PINNAME_GPIO4, PINNAME_GPIO5 for IIC SCL and SDA pins
                {                    
                    ret = Ql_IIC_Init(0,PINNAME_CTS,PINNAME_RTS,0);
                    if(ret < 0)
                    {
                        APP_DEBUG("\r\n<--Failed!! Ql_IIC_Init channel 0 fail ret=%d-->\r\n",ret);
                        break;
                    }
                    APP_DEBUG("\r\n<--pins(%d & %d) Ql_IIC_Init channel 0 ret=%d-->\r\n",PINNAME_CTS,PINNAME_RTS,ret);
                    break;
                }
                else if(1 == IIC_type)// IIC controller
                {
                    ret = Ql_IIC_Init(1,PINNAME_RI,PINNAME_DCD,1);
                    if(ret < 0)
                    {
                        APP_DEBUG("\r\n<--Failed!! IIC controller Ql_IIC_Init channel 1 fail ret=%d-->\r\n",ret);
                        break;
                    }
                    APP_DEBUG("\r\n<--pins(SCL=%d,SDA=%d) IIC controller Ql_IIC_Init channel 1 ret=%d-->\r\n",PINNAME_RI,PINNAME_DCD,ret);
                    break;

                }
                else
                {
                    APP_DEBUG("\r\n<--IIC type error!!!!-->\r\n");
                    break;
                }

            }
	     //command-->IIC config,  IIC controller interface
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Config=0\r\n");//   simultion IIC  (channel 0)
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Config(0,TRUE, 0x07, 0);// simultion IIC interface ,do not care the IicSpeed.
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !!Ql_IIC_Config channel 0 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--Ql_IIC_Config channel 0 ret=%d-->\r\n",ret);
                break;
            }
            
            //command-->IIC config,  IIC controller interface
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Config=1\r\n");//   IIC controller  (channel 1)
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Config(1,TRUE, 0x07, 300);// just for the IIC controller
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Config channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Config channel 1 ret=%d-->\r\n",ret);
                break;
            }
            
            //command-->IIC write  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write(0, 0x07, write_buffer, 4);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Write channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Write ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write(1, 0x07, write_buffer,4);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Write channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Write ret=%d-->\r\n",ret);
                break;
            }

            //command-->IIC read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Read=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Read(0, 0x07, read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Read channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Read ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Read=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Read(1, 0x07, write_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Read channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Read ret=%d-->\r\n",ret);
                break;
            }

            //command-->IIC write then read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write_Read=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write_Read(0, 0x07, registerAdrr, 2,read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Write_Read channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Write_Read ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write_Read=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write_Read(1, 0x07, registerAdrr, 2,read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Write_Read channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Write_Read ret=%d-->\r\n",ret);
                break;
            }

                
            
            //command-->IIC write then read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Uninit=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Uninit(0);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Uninit channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Uninit ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Uninit=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Uninit(1);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Uninit channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                 APP_DEBUG("\r\n<--IIC controller (chnnlNo 1) Ql_IIC_Uninit  ret=%d-->\r\n",ret);
                break;
            }
            
        APP_DEBUG("\r\n<--Not found this command, please check you command-->\r\n");
        }
    default:
        break;
    }
}