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