bool SendMtkBinCmd(u8 *strCmd) { int len = 0,ret = 0; unsigned char outBuffer[256]; // At initial, the protocol setting of the communication UART is supposed to be PMTK protocol. // Since EPO data are transferred using MTK Binary Packet, you have to change the protocol setting to MTK Binary Protocol // before starting EPO Transfer Protocol. You can use PMTK command 253 to change the UART protocol setting. // Please refer to 7.1 for the details of PMTK command 253. Ql_memset(outBuffer,0,sizeof(outBuffer)); Ql_memcpy((void *)outBuffer, strCmd, Ql_strlen(strCmd)); len = Ql_strlen(outBuffer); outBuffer[len++] = 0x0D; outBuffer[len++] = 0x0A; outBuffer[len] = '\0'; /*send the data of outBuffer to the GPS module example L70 ect. */ ret = Ql_UART_Write(m_gnssUartPort,outBuffer,len); if (ret < len) { APP_DEBUG("SendMtkBinCmd Only part of bytes are written, %d/%d \r\n", ret, len); return FALSE; } return TRUE; }
void CSD_Establish(char* csdNumber) { char strCsdDialAT[30]; s32 len = Ql_sprintf(strCsdDialAT, "ATD%s\r\n", csdNumber); APP_DEBUG("<-- Dialing CSD number: %s -->\r\n", csdNumber); Ql_UART_Write(m_myVirtualPort, strCsdDialAT, len); }
static void InitializeSerialPort(void) { s32 ret; // Register & open UART port // UART port ret = Ql_UART_Register(m_myUartPort, CallBack_UART_Hdlr, NULL); if (ret < QL_RET_OK) { Ql_Debug_Trace("Fail to register serial port[%d], ret=%d\r\n", m_myUartPort, ret); } ret = Ql_UART_Open(m_myUartPort, 115200, FC_NONE); if (ret < QL_RET_OK) { Ql_Debug_Trace("Fail to open serial port[%d], ret=%d\r\n", m_myUartPort, ret); } Ql_UART_Write(m_myUartPort, "\r\nRDY\r\n", Ql_strlen("\r\nRDY\r\n")); // Register & open virtual serial port ret = Ql_UART_Register(m_myVirtualPort, CallBack_UART_Hdlr, NULL); if (ret < QL_RET_OK) { APP_DEBUG("Fail to register serial port[%d], ret=%d\r\n", m_myVirtualPort, ret); } ret = Ql_UART_Open(m_myVirtualPort, 115200, FC_NONE); if (ret < QL_RET_OK) { APP_DEBUG("Fail to open serial port[%d], ret=%d\r\n", m_myVirtualPort, ret); } }
void CSD_Disconnect(void) { // -------- Received END command, exit from CSD data mode ------- APP_DEBUG("<-- Exit from CSD data mode -->\r\n"); Ql_UART_SendEscap(m_myVirtualPort); // -------- Close CSD connection ------- APP_DEBUG("<-- Close CSD connection -->\r\n"); Ql_UART_Write(m_myVirtualPort, "ATH\n", 4); }
u8 *getHead() { // check over if(textBuf.uOverFlag > 0 && textBuf.lostTextAdr == textBuf.head) { Ql_strcpy((char *)textBuf.temp_out_buff, "[@OVF] "); Ql_UART_Write(_DEBUG_UART_PORT, textBuf.temp_out_buff, _PREFIX_LEN); _RESET_DBG_BUFFER return NULL; }
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; } }
bool ReadAckAndSendEpoPacket(u8 * inBuffer,int dataLen) { int ret = 0,sendLen = 0; unsigned char outBuf[256] = {0}; if(dataLen >= EPO_BIN_ACK_LEN) { if((g_u2LastEpoSeq < g_i4NumSvEpoPkt) && (g_i4NumSvEpoPkt >= 1)) { if(g_u2LastEpoSeq != g_u2EpoSeq) { if(!fgWait_Epo_Ack(inBuffer,dataLen)) { /* send again */ sendLen = MTKBIN_3EPO_PKT_LNG; ret = Ql_UART_Write(m_gnssUartPort,g_szPktData,sendLen); if (ret < sendLen) { APP_DEBUG("ReadAckAndSendEpoPacket send again Only part of bytes are written, %d/%d \r\n", ret, sendLen); return FALSE; } return TRUE; } else { APP_DEBUG(textBuf,"Update EPO Progress£º%d/%d \r\n",g_u2EpoSeq,g_i4NumSvEpoPkt); if(g_u2EpoSeq < g_i4NumSvEpoPkt) { 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("ReadAckAndSendEpoPacket Only part of bytes are written, %d/%d \r\n", ret, sendLen); return FALSE; } g_u2LastEpoSeq = g_u2EpoSeq; g_u2EpoSeq++; return TRUE; } else { APP_DEBUG("ReadAckAndSendEpoPacket fgEPO_Get_One_Pkt error !!! \r\n"); return FALSE; } } else { // Generate final MTK_BIN_EPO packet to indicate the GPS receiver that the process is finish. // The function fgEPO_Get_Final_Pkt must be implemented by the programmer. vEPO_Get_Final_Pkt(g_szPktData); // Send final MTK_BIN_EPO packet to the GPS receiver. The packet size of MTK_BIN_EPO is MTKBIN_3EPO_PKT_LNG. // Then the process is finished. // The function SendData must be implemented by the programmer. sendLen = MTKBIN_3EPO_PKT_LNG; ret = Ql_UART_Write(m_gnssUartPort,g_szPktData,sendLen); if (ret < sendLen) { APP_DEBUG("ReadAckAndSendEpoPacket Only part of bytes are written, %d/%d \r\n", ret, sendLen); return FALSE; } // Switch UART protocol setting to PMTK packet format and baudrate 115200 for the communication UART. // Please refer to section 7.2 for the details of ¡°Change UART format packet¡±. // The function SendMtkBinCmd must be implemented by the programmer. outBuf[0] = 0x04; outBuf[1] = 0x24; outBuf[2] = 0x0e; outBuf[3] = 0x00; outBuf[4] = 0xfd; outBuf[5] = 0x00; outBuf[6] = 0x00; outBuf[7] = 0x00; outBuf[8] = 0x00; outBuf[9] = 0x00; outBuf[10] = 0x00; outBuf[11] = 0xf3; outBuf[12] = 0x0d; outBuf[13] = 0x0a; sendLen = 14; ret = Ql_UART_Write(m_gnssUartPort,outBuf,sendLen); if (ret < sendLen) { APP_DEBUG("ReadAckAndSendEpoPacket restore packet, %d/%d \r\n", ret, sendLen); return FALSE; } Ql_FS_Close(g_pEpoFile); g_u2LastEpoSeq = 0; g_i4NumSvEpoPkt = 0; g_u2EpoSeq = 0; g_pEpoFile = 0; APP_DEBUG(textBuf,"\r\nOK \r\n"); return TRUE; } return FALSE; } } else { APP_DEBUG("ReadAckAndSendEpoPacket else error !!!\r\n"); return FALSE; } } else { return FALSE; } } return FALSE; }
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; } }
s32 Ar_CAN_send_message(void) { static CANPkt *current_pkt = NULL; static PeripheryMessage *current_msg = NULL; #ifndef NO_CB OUT_DEBUG_2("Ar_CAN_send_message(already_in_progress=%s)\r\n", _b_sending_in_progress ? "TRUE" : "FALSE"); #endif while (1) { // get message and packet // first msg check if (!current_msg) current_msg = _tx_buffer.pFirstMsg; // second msg check if (!current_msg) { _b_sending_in_progress = FALSE; _tx_buffer_state = CAN_Tx_Standby; return ERR_BUFFER_IS_EMPTY; } // first pkt check if (!current_pkt) { current_pkt = current_msg->pkt_chain_head; } else { if (CAN_Tx_ReadyToSend == _tx_buffer_state) { current_pkt = current_pkt->pNext; current_msg->last_pkt_id++; } } // second pkt check if (current_pkt) { _b_sending_in_progress = TRUE; break; } CAN_remove_message(&_tx_buffer, current_msg); current_msg = NULL; current_pkt = NULL; } u8 buf[MCUPKT_BEGIN_DATABLOCK + CAN_DATA_BYTES_PER_PKT + 1] = {0}; // MCUPKT_ prefix + datalen + CRC buf[MCUPKT_MARKER] = MCU_PACKET_MARKER; buf[MCUPKT_PARENTDEV_UIN_H] = current_msg->unit.uin >> 8; buf[MCUPKT_PARENTDEV_UIN_L] = current_msg->unit.uin; buf[MCUPKT_PARENTDEV_TYPE] = current_msg->unit.type; u8 last_pkt_bitmask = (current_pkt == current_msg->pkt_chain_tail) ? 0x80 : 0x00; buf[MCUPKT_PKT_NUMBER] = last_pkt_bitmask | current_msg->last_pkt_id; u8 bodylen = current_pkt ? current_pkt->len : 0; buf[MCUPKT_DATABLOCK_LENGTH] = bodylen + 3; // 3 bytes: Cmd, SUIN, SType buf[MCUPKT_COMMAND_CODE] = current_msg->command; buf[MCUPKT_SUBDEV_UIN] = current_msg->unit.suin; buf[MCUPKT_SUBDEV_TYPE] = current_msg->unit.stype; for (u8 i = 0; i < bodylen; ++i) buf[MCUPKT_BEGIN_DATABLOCK + i] = current_pkt->data[i]; buf[MCUPKT_BEGIN_DATABLOCK + bodylen] = evaluateMcuCRC(buf); s32 ret = Ql_UART_Write(UART_PORT3, buf, MCUPKT_BEGIN_DATABLOCK + bodylen + 1); if (ret < 0) { OUT_DEBUG_1("Ql_UART_Write(UART_PORT3) = %d error\r\n", ret); CAN_remove_message(&_tx_buffer, current_msg); current_msg = NULL; current_pkt = NULL; return ret; } _tx_buffer_state = CAN_Tx_WaitForCANACK; return RETURN_NO_ERRORS; }
void CSD_Answer(void) { Ql_UART_Write(m_myVirtualPort, "ATA\n", 4); }
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara) { s32 ret; APP_DEBUG("CallBack_UART_Hdlr: port=%d, event=%d, level=%d, p=%x\r\n", port, msg, level, customizedPara); switch (msg) { case EVENT_UART_READY_TO_READ: { if (m_myUartPort == port) { // Write the data from UART port to virtual serial port s32 totalBytes = ReadSerialPort(port, m_RxBuf_UartPort, sizeof(m_RxBuf_UartPort)); APP_DEBUG("m_RxBuf_UartPort:%s\r\n",m_RxBuf_UartPort ); if (totalBytes > 0) { if (m_bCsdConnected && Ql_StrPrefixMatch(m_RxBuf_UartPort, "+++")) { // -------- Disconnect CSD ------- CSD_Disconnect(); m_bCsdConnected = FALSE; }else{ // No CSD connection, then transparently transmit the data from UART port to virtual serial port // And make sure all data is sent out s32 realSentByte = 0; do { ret = Ql_UART_Write(m_myVirtualPort, m_RxBuf_UartPort + realSentByte, totalBytes - realSentByte); if (ret > 0 && ret < (totalBytes - realSentByte)) { Ql_Sleep(100); } realSentByte += ret; APP_DEBUG("CallBack_UART_Hdlr ret:%d realSentByte:%d \r\n",ret,realSentByte ); } while (realSentByte != totalBytes); } } } else if (m_myVirtualPort == port) { // Write the data from virtual serial port to UART port s32 totalBytes = ReadSerialPort(port, m_RxBuf_VirtualPort, sizeof(m_RxBuf_VirtualPort)); APP_DEBUG(" m_RxBuf_VirtualPort:%s\r\n",m_RxBuf_VirtualPort ); if (totalBytes > 0) { if (Ql_strstr(m_RxBuf_VirtualPort, "\r\nRING\r\n")) { // -------- Received RING, answer CSD call ------- CSD_Answer(); } else if (Ql_strstr(m_RxBuf_VirtualPort, "CONNECT")) { // -------- Received CONNECT 9600, CSD connected ------- m_bCsdConnected = TRUE; } Ql_UART_Write(m_myUartPort, m_RxBuf_VirtualPort, totalBytes); } } break; } default: break; } }