summaryrefslogtreecommitdiffstats
path: root/positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp')
-rw-r--r--positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp608
1 files changed, 608 insertions, 0 deletions
diff --git a/positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp b/positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp
new file mode 100644
index 00000000..13159b47
--- /dev/null
+++ b/positioning_hal/src/GpsCommon/MDev_GpsRecv.cpp
@@ -0,0 +1,608 @@
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+* @file MDev_GpsRecv.cpp
+*/
+
+/*---------------------------------------------------------------------------*/
+// Include files
+
+#include "MDev_GpsRecv.h"
+#include "MDev_Gps_Common.h"
+#include "positioning_common.h"
+#include "MDev_Gps_API.h"
+//extern "C" {
+//#include <stub/gps_mng_api.h>
+//}
+
+/*---------------------------------------------------------------------------*/
+// Global values
+
+#define FTEN_DRIVER 0
+#define TEST_HAL2
+
+#if FTEN_DRIVER
+static GpsMngApiObj g_gps_mng_obj;
+#endif
+
+/*---------------------------------------------------------------------------*/
+// Functions
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_RecvThread
+ * ABSTRACT : GPS communication management reception thread
+ * FUNCTION : GPS communication management reception thread main
+ * ARGUMENT : PVOID pv....Thread creation arguments
+ * NOTE : -
+ * RETURN : TRUE
+ ******************************************************************************/
+EFrameworkunifiedStatus DevGpsRecvThread(HANDLE h_app) {
+ int32 ret = GPS_RCV_RET_NML;
+ int32 gps_ret = 0;
+ BOOL* p_thread_stop_req = &g_gps_rcv_thread_stop;
+
+ (void)PosSetupThread(h_app, ETID_POS_GPS_RECV);
+
+ /* Initializing process */
+ DevGpsRecvInit();
+
+#if FTEN_DRIVER
+ gps_ret = GpsMngApiOpen(&g_gps_mng_obj);
+ if (gps_ret != GPS_CTL_RET_SUCCESS) {
+ printf("[For test] GpsMngApiOpen open failed\n");
+ }
+#endif
+
+ while (1) {
+ /* Thread stop request is received */
+ if (TRUE == *p_thread_stop_req) {
+ /* Thread stop processing */
+ DevGpsRecvThreadStopProcess();
+ }
+
+ ret = DevGpsRecvReadRcvData(&g_gps_rcvdata);
+
+ if (GPS_RCV_RET_NML == ret) {
+ /* For reception (normal) */
+ DevGpsRecvRcvNormal();
+ }
+ }
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_Recv_Init
+ * ABSTRACT : Receive thread initialization processing
+ * FUNCTION : Initialize the receive thread
+ * ARGUMENT : -
+ * NOTE : -
+ * RETURN : -
+ ******************************************************************************/
+void DevGpsRecvInit(void) {
+ /* Clears the receive buffer */
+ DevGpsRecvClrRcvBuf();
+
+ /* Clear receive error count */
+ g_wrecv_err = 0;
+
+ return;
+}
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_Recv_ClrRcvBuf
+ * ABSTRACT : Buffer clear processing
+ * FUNCTION : Clears the receive buffer for serial reception.
+ * ARGUMENT : -
+ * NOTE : -
+ * RETURN : -
+ ******************************************************************************/
+void DevGpsRecvClrRcvBuf(void) {
+ /*-----------------------------------------------------------------------*/
+ /* Clear serial receive data storage buffer */
+ /*-----------------------------------------------------------------------*/
+ memset(&g_gps_rcvdata, 0, sizeof(TG_GPS_RECV_RcvData));
+
+ /*-----------------------------------------------------------------------*/
+ /* Clear receive data storage buffer */
+ /*-----------------------------------------------------------------------*/
+ memset(&g_gps_rcvbuf, 0, sizeof(TG_GPS_RECV_RcvBuf));
+
+ /*-----------------------------------------------------------------------*/
+ /* Clear analysis data buffer */
+ /*-----------------------------------------------------------------------*/
+ memset(&g_gps_ana_databuf, 0, sizeof(TG_GPS_RECV_AnaDataBuf));
+
+ /*-----------------------------------------------------------------------*/
+ /* Clear receive frame buffer */
+ /*-----------------------------------------------------------------------*/
+ memset(&g_gps_rcv_framebuf, 0, sizeof(TG_GPS_RECV_RcvFrameBuf));
+}
+
+/*******************************************************************************
+ * MODULE : DevGpsRecvJudgeStartSeqence
+ * ABSTRACT : Start sequence determination process
+ * FUNCTION : Determine whether or not the beginning of the data is the start sequence of the _CWORD82_ command
+ * ARGUMENT : const u_char *buf_p ... Pointer to analysis data
+ * u_int16 ana_size ... Size of data to be analyzed
+ * NOTE :
+ * RETURN : GPS__CWORD82__RET_START_SEQ_NONE ... No start sequence
+ * GPS__CWORD82__RET_START_SEQ_NMEA ... NMEA Start Sequences
+ * GPS__CWORD82__RET_START_SEQ_FULL ... Full Customization Start Sequence
+ ******************************************************************************/
+static int32 DevGpsRecvJudgeStartSeqence(const u_char *buf_p, u_int16 ana_size) {
+ int32 ret = GPS__CWORD82__RET_START_SEQ_NONE;
+
+ if ((ana_size >= 1) && (buf_p[0] == 0x24u)) {
+ /* Ignore -> No applicable rules for MISRA-C */ /* 0x24: '$' QAC 285 */
+ ret = GPS__CWORD82__RET_START_SEQ_NMEA;
+ } else if ((ana_size >= 1) && (buf_p[0] == 0xB0)) {
+ ret = GPS__CWORD82__RET_START_SEQ_FULL;
+ } else if ((ana_size >= 1) && (buf_p[0] == 0xC6)) {
+ /* #GPF_60_024 */
+ ret = GPS__CWORD82__RET_START_SEQ_BIN;
+ } else if ((ana_size >= 1) && (buf_p[0] == 0xB5)) {
+ /* #GPF_60_024 */
+ ret = GPS_UBLOX_RET_START_SEQ_UBX;
+ } else {
+ ret = GPS__CWORD82__RET_START_SEQ_NONE;
+ }
+
+ return ret;
+}
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_Recv_SearchFrameData
+ * ABSTRACT : Frame detection processing
+ * FUNCTION : Find if a frame exists in the data
+ * ARGUMENT : TG_GPS_RECV_AnaDataBuf *adbuf_p ... Pointer to the analysis data storage buffer
+ * u_int16 *ana_size; ... Analysis completion data size
+ * NOTE : Since it is assumed that the beginning of the frame is stored in the analysis start offset,
+ * when the beginning of the frame is detected in the middle of the buffer,
+ * the processing is terminated with the data up to that point as abnormal format data.
+ * RETURN : GPS_RCV_FRMSRCH_ERR_FORMAT ... Frame format error
+ * GPS_RCV_FRMSRCH_FIXED ... Frame determination
+ * GPS_RCV_FRMSRCH_NOT_FIXED ... Frame undetermined
+ * GPS_RCV_FRMSRCH_NO_DATA ... No analysis data
+ ******************************************************************************/
+int32 DevGpsRecvSearchFrameData(const TG_GPS_RECV_AnaDataBuf *adbuf_p, u_int16 *ana_size) {
+ int32 ret = GPS_RCV_FRMSRCH_ERR_FORMAT; /* Return value(Frame format error) */
+ /* ++ GPS _CWORD82_ support */
+ int32 start_seq_type = GPS__CWORD82__RET_START_SEQ_NONE; /* Fully customized or NMEA */
+ /* -- GPS _CWORD82_ support */
+ u_int16 start_offset = 0; /* Analysis start offset */
+ u_int16 i = 0;
+ u_int16 d_size = 0; /* Unanalyzed data size */
+
+ /* Offset Initialization */
+ start_offset = adbuf_p->offset; /* Start of analysis */ /* Ignore -> No applicable rules for MISRA-C */
+
+ /* Setting of unanalyzed data size */
+ d_size = adbuf_p->datsize - start_offset;
+
+ /* For size 0 */
+ if (d_size == 0) {
+ /* No analysis data */
+ ret = GPS_RCV_FRMSRCH_NO_DATA;
+ /* Set the analysis completion size to 0. */
+ *ana_size = 0; /* Ignore -> No applicable rules for MISRA-C */
+ } else {
+ /* Since it is assumed that beginning of the frame is stored in the analysis start offset, */
+ /* determine if the start sequence is the first one. */
+
+ /* ++ GPS _CWORD82_ support */
+ start_seq_type = DevGpsRecvJudgeStartSeqence(&(adbuf_p->datbuf[start_offset]), d_size);
+
+ if (start_seq_type != GPS__CWORD82__RET_START_SEQ_NONE) {
+ /* -- GPS _CWORD82_ support */
+ /* Set the frame as undetermined */
+ ret = GPS_RCV_FRMSRCH_NOT_FIXED;
+
+ /* ++ GPS _CWORD82_ support */
+ /* Find end sequence */
+ if (start_seq_type == GPS__CWORD82__RET_START_SEQ_NMEA) {
+ for (i = 0; i < d_size; i++) {
+ if (adbuf_p->datbuf[(start_offset + i)] == 0x0A) {
+ /* If the end sequence is found, */
+ /* end as frame fix. */
+ ret = GPS_RCV_FRMSRCH_FIXED;
+
+ /* Set the frame size for the analysis completion size. */
+ *ana_size = i + 1;
+
+ break;
+ }
+ }
+
+ if (i == d_size) {
+ if (i >= GPS__CWORD82__CMD_LEN_MAX) {
+ /* If no end sequence is found, */
+ /* frame format error. */
+ ret = GPS_RCV_FRMSRCH_ERR_FORMAT;
+ /* After that, searching for start sequence. */
+ } else {
+ /* Because the end sequence cannot be analyzed, */
+ /* frame undetermined. */
+ ret = GPS_RCV_FRMSRCH_NOT_FIXED;
+
+ /* Set the size of unanalyzed data for the analysis completion size. */
+ *ana_size = d_size;
+ }
+ }
+ } else if (start_seq_type == GPS__CWORD82__RET_START_SEQ_FULL) {
+ /* #GPF_60_024 */
+ /* Is there one frame of data for full customization information? */
+ if (d_size >= GPS__CWORD82__FULLBINARY_LEN) {
+ /* Is there an end sequence? */
+ if (adbuf_p->datbuf[( (start_offset + GPS__CWORD82__FULLBINARY_LEN) - 1)] == 0xDA) {
+ /* Ignore -> MISRA-C:2004 Rule 12.1 */
+ /* If an end sequence is found, */
+ /* end as frame fix. */
+ ret = GPS_RCV_FRMSRCH_FIXED;
+
+ /* Set the frame size for the analysis completion size. */
+ *ana_size = GPS__CWORD82__FULLBINARY_LEN;
+ } else {
+ /* If it is not an end sequence, */
+ /* frame format error. */
+ ret = GPS_RCV_FRMSRCH_ERR_FORMAT;
+ /* Searching for Start Sequence */
+ }
+ } else {
+ /* Because the end sequence cannot be analyzed, */
+ /* frame undetermined. */
+ ret = GPS_RCV_FRMSRCH_NOT_FIXED;
+
+ /* Set the size of unanalyzed data for the analysis completion size. */
+ *ana_size = d_size;
+ }
+ } else if (start_seq_type == GPS__CWORD82__RET_START_SEQ_BIN) {
+ /* Is there data for one standard binary frame? */
+ if (d_size >= GPS__CWORD82__NORMALBINARY_LEN) {
+ /* Is there an end sequence? */
+ if (adbuf_p->datbuf[((start_offset + GPS__CWORD82__NORMALBINARY_LEN) - 1)] == 0xDA) {
+ /* Ignore -> MISRA-C:2004 Rule 12.1 */
+ /* If an end sequence is found, */
+ /* end as frame fix. */
+ ret = GPS_RCV_FRMSRCH_FIXED;
+
+ /* Set the frame size for the analysis completion size. */
+ *ana_size = GPS__CWORD82__NORMALBINARY_LEN;
+ } else {
+ /* If it is not an end sequence, */
+ /* frame format error. */
+ ret = GPS_RCV_FRMSRCH_ERR_FORMAT;
+ /* Searching for Start Sequence */
+ }
+ } else {
+ /* Because the end sequence cannot be analyzed, */
+ /* frame undetermined. */
+ ret = GPS_RCV_FRMSRCH_NOT_FIXED;
+
+ /* Set the size of unanalyzed data for the analysis completion size. */
+ *ana_size = d_size;
+ }
+ } else if (start_seq_type == GPS_UBLOX_RET_START_SEQ_UBX) {
+ /* TODO Checksum calculation using data from start_offset to d_size */
+ /* TODO Check that the checksum is correct. (See test code.) */
+ /* If the if checksums match, */
+ /* end as frame fix. */
+ ret = GPS_RCV_FRMSRCH_FIXED;
+
+ /* Set the frame size for the analysis completion size. */
+ *ana_size = d_size;
+ } else {
+ }
+ /* -- #GPF_60_024 */
+ } else {
+ /* It is not a start sequence, so it is regarded as a frame format error. */
+ ret = GPS_RCV_FRMSRCH_ERR_FORMAT;
+
+ /* After that, searching for Start Sequence. */
+ }
+
+ /* If the frame format is abnormal, search for the start sequence. */
+ if (ret == GPS_RCV_FRMSRCH_ERR_FORMAT) {
+ POSITIONING_LOG("FORMAT ERROR [start_seq_type:%d]\n", start_seq_type);
+
+ /* Assuming that the start sequence has not been found until the end, */
+ /* the size of the analysis completed is set as the size of the unanalyzed data. */
+ *ana_size = d_size;
+
+ /* ++ GPS _CWORD82_ support (Search from the second byte for safety (at least the first byte is checked at the beginning of the function)))*/
+ for (i = start_offset + 1; i < (u_int32)(start_offset + d_size); i++) {
+ /* for( i = (start_offset + 2); i < (u_int32)(start_offset + d_size); i++ ) */
+ /* -- GPS _CWORD82_ support */
+ /* Start Sequence? */
+ /* ++ GPS _CWORD82_ support */
+ if (DevGpsRecvJudgeStartSeqence(&(adbuf_p->datbuf[i]), d_size) != GPS__CWORD82__RET_START_SEQ_NONE) {
+ /* if( (adbuf_p->datbuf[(i-1)] == GPS_CODE_START_SQ_HI) && */
+ /* (adbuf_p->datbuf[i] == GPS_CODE_START_SQ_LOW) ) */
+ /* -- GPS _CWORD82_ support */
+ /* In the case of a start sequence, the analysis is completed before that. #01 */
+ *ana_size = (i - start_offset - 1);
+
+ break;
+ }
+ }
+ }
+ }
+
+ return ret;
+}
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_Recv_ReadRcvData
+ * ABSTRACT : Data reception processing
+ * FUNCTION : Read serial data
+ * ARGUMENT : TG_GPS_RECV_RcvData* pst_rcv_data : Receive data read buffer
+ * NOTE : -
+ * RETURN : T_ErrCodes Error code
+ * MCSUB_NML Normal
+ * MCCOM_ERR_SYSTEM Abnormality
+ ******************************************************************************/
+int32 DevGpsRecvReadRcvData(TG_GPS_RECV_RcvData* pst_rcv_data) {
+ int32 ret = GPS_RCV_RET_ERR;
+ INT32 gps_ret = 0;
+
+#if FTEN_DRIVER
+ static int msg_kind = GPS_RCV_NMEA_GGA;
+
+ // Serial data capture
+ GpsMngApiDat gps_mng_data;
+
+ memset(&gps_mng_data, 0, sizeof(gps_mng_data));
+#ifdef TEST_HAL2
+ if (msg_kind > GPS_RCV_NMEA_RMC) {
+ msg_kind = GPS_RCV_NMEA_GGA;
+ }
+#else
+ if (msg_kind == GPS_RCV_NMEA_GGA) {
+ msg_kind = GPS_RCV_NMEA_RMC;
+ } else if (msg_kind == GPS_RCV_NMEA_RMC) {
+ msg_kind = GPS_RCV_NMEA_GGA;
+ } else {
+ msg_kind = GPS_RCV_NMEA_GGA;
+ }
+#endif
+
+ gps_ret = GpsMngApiGetRcvMsg(&g_gps_mng_obj, msg_kind, &gps_mng_data);
+
+#ifdef TEST_HAL2
+ msg_kind++;
+#endif
+
+ pst_rcv_data->us_read_size = (u_int16)gps_mng_data.dataLength;
+
+ if (pst_rcv_data->us_read_size >= GPS_RCV_MAXREADSIZE) {
+ return GPS_RCV_RET_ERR_SYSTEM;
+ }
+
+ memcpy(pst_rcv_data->uc_read_data, gps_mng_data.data, pst_rcv_data->us_read_size);
+
+ // Add '\0'
+ pst_rcv_data->uc_read_data[pst_rcv_data->us_read_size] = '\0';
+
+ if (GPS_CTL_RET_SUCCESS != gps_ret) {
+ ret = GPS_RCV_RET_ERR_SYSTEM;
+ } else {
+ ret = GPS_RCV_RET_NML;
+ }
+#endif
+
+ return ret;
+}
+
+/*******************************************************************************
+ * MODULE : DEV_Gps_Recv_RcvNormal
+ * ABSTRACT : Receive (normal) Receive processing
+ * FUNCTION : Receive (normal) Processing at event reception
+ * ARGUMENT : -
+ * NOTE :
+ * RETURN : -
+ ******************************************************************************/
+void DevGpsRecvRcvNormal(void) {
+ TG_GPS_RECV_RcvData* pst_rcv_data = NULL; /* Buffer for reading serial data */
+ TG_GPS_RECV_RcvBuf* pst_rcv_buf = NULL; /* Receive data storage buffer */
+ TG_GPS_RECV_AnaDataBuf* pst_ana_data_buf = NULL; /* Analysis data storage buffer */
+ TG_GPS_RECV_RcvFrameBuf* pst_rcv_frame_buf = NULL; /* Receive frame buffer */
+ int32 i_ret = 0; /* Frame Detection Result */
+ u_int16 ana_size = 0; /* Data analysis size storage */
+
+ /* Initializing process */
+ pst_ana_data_buf = &g_gps_ana_databuf;
+
+ /* Fast _CWORD71_ processing(memset fix) */
+ /* Initializes the offset that needs initialization in the receive data storage buffer. */
+ pst_ana_data_buf->offset = 0;
+
+ /* Serial continuous reception data analysis processing */
+ pst_rcv_data = &g_gps_rcvdata;
+ pst_rcv_buf = &g_gps_rcvbuf;
+ memcpy(&(pst_ana_data_buf->datbuf[0]), &(pst_rcv_buf->r_buf[0]), pst_rcv_buf->r_size);
+ memcpy(&(pst_ana_data_buf->datbuf[pst_rcv_buf->r_size]),
+ &(pst_rcv_data->uc_read_data[0]),
+ pst_rcv_data->us_read_size);
+
+ pst_ana_data_buf->datsize = pst_rcv_buf->r_size + pst_rcv_data->us_read_size;
+
+ /* Serial receive data analysis process */
+ do {
+ /* Frame detection processing */
+ i_ret = DevGpsRecvSearchFrameData(pst_ana_data_buf, &ana_size);
+
+ /* For frame determination */
+ if (i_ret == GPS_RCV_FRMSRCH_FIXED) {
+ /* Frames are stored in the receive frame buffer. */
+ pst_rcv_frame_buf = &g_gps_rcv_framebuf;
+ memset(pst_rcv_frame_buf, 0, sizeof(TG_GPS_RECV_RcvFrameBuf)); /* Ignore -> No applicable rules for MISRA-C */
+ /* Ignore -> No applicable rules for MISRA-C */ /* QAC 3200 */
+ memcpy(& (pst_rcv_frame_buf->buf[0]),
+ &(pst_ana_data_buf->datbuf[pst_ana_data_buf->offset]),
+ ana_size);
+ pst_rcv_frame_buf->size = ana_size;
+
+ /* Reception of the command */
+ /* Send receipt notice (command) to main thread */
+ /* Send Received Data to Main Thread */
+ DevGpsRecvSndRcvData(pst_rcv_frame_buf);
+ } else if (i_ret == GPS_RCV_FRMSRCH_NOT_FIXED) {
+ /* Store unconfirmed data in the received data storage buffer, */
+ /* and leave no unanalyzed data. */
+ memset(pst_rcv_buf, 0, sizeof(TG_GPS_RECV_RcvBuf)); /* Ignore -> No applicable rules for MISRA-C */
+ memcpy(& (pst_rcv_buf->r_buf[0]),
+ &(pst_ana_data_buf->datbuf[pst_ana_data_buf->offset]),
+ ana_size);
+ pst_rcv_buf->r_size = ana_size;
+ i_ret = GPS_RCV_FRMSRCH_NO_DATA;
+ } else if (i_ret == GPS_RCV_FRMSRCH_ERR_FORMAT) {
+ /* [Measures against resetting with 1S + _CWORD82_]From here */
+ /* Clears the unanalyzed data stored in the receive data storage buffer, */
+ /* and flag is set to "No Unparsed Data" so that data can be parsed from the beginning of the next. */
+ memset(&(pst_rcv_buf->r_buf[0]), 0, pst_rcv_buf->r_size);
+ pst_rcv_buf->r_size = 0;
+ i_ret = GPS_RCV_FRMSRCH_NO_DATA;
+ /* [Measures against resetting with 1S + _CWORD82_]Up to this point */
+ /* Since this section discards garbage data, */
+ /* not subject to diagnosis registration. */
+ /* Diagnosis registration check */
+ } else if (i_ret == GPS_RCV_FRMSRCH_NO_DATA) {
+ /* Ignore -> No applicable rules for MISRA-C */
+ memset(pst_rcv_buf, 0, sizeof(TG_GPS_RECV_RcvBuf));
+ /* Termination */
+ } else {
+ /* No unanalyzed data is assumed because it is impossible. */
+ i_ret = GPS_RCV_FRMSRCH_NO_DATA;
+
+ /* Ignore -> No applicable rules for MISRA-C */
+ memset(pst_rcv_buf, 0, sizeof(TG_GPS_RECV_RcvBuf));
+ }
+
+ /* Update analysis data offset */
+ pst_ana_data_buf->offset += ana_size;
+
+ /* Repeat until no unanalyzed data is found. */
+ } while (i_ret != GPS_RCV_FRMSRCH_NO_DATA);
+}
+
+/********************************************************************************
+ * MODULE : DEV_RcvDATA
+ * ABSTRACT : Acknowledgement
+ * FUNCTION : Send message notifications to the communication management thread
+ * ARGUMENT : TG_GPS_RCV_DATA *ptg_rcv_data....I/F information between the receiving thread
+ * and the communication management thread
+ * NOTE :
+ * RETURN : RET_API :RET_NORMAL:Normal completion
+ * :RET_ERROR:ABENDs
+ ********************************************************************************/
+RET_API DevRcvData(const TG_GPS_RCV_DATA* ptg_rcv_data) {
+ RET_API ret = RET_NORMAL; /* Return value */
+ u_int16 w_size = 0; /* Data length setting */
+ u_int16 w_all_len = 0; /* Sent message length */
+ u_int16 w_mode = 0; /* Mode information */
+ RID req_id = 0; /* Resources ID */
+ T_APIMSG_MSGBUF_HEADER tg_header; /* Message header */
+
+ // Initialzie struct
+ memset(&tg_header, 0, sizeof(tg_header));
+
+ /* Transmitting buffer */
+ u_int8 by_snd_buf[(sizeof(T_APIMSG_MSGBUF_HEADER) + sizeof(TG_GPS_RCV_DATA))];
+
+ /* Calculation of transmission data length */
+ w_size = ptg_rcv_data->bydata_len + sizeof(ptg_rcv_data->dwret_status) + sizeof(ptg_rcv_data->bydata_len);
+
+ /* <<Creation of message header section>>>> */
+ tg_header.signo = 0; /* Signal information setting */
+ tg_header.hdr.sndpno = PNO_NAVI_GPS_RCV; /* Source thread No. setting */
+ tg_header.hdr.respno = 0; /* Destination process No. */
+ tg_header.hdr.cid = CID_GPS_RECVDATA; /* Command ID setting */
+ tg_header.hdr.msgbodysize = w_size; /* Message data length setting */
+ tg_header.hdr.rid = req_id; /* Resource ID Setting */
+ tg_header.hdr.reserve = 0; /* Reserved area clear */
+
+ memcpy(&by_snd_buf[ 0 ], &tg_header, sizeof(T_APIMSG_MSGBUF_HEADER));
+ /* <<Creation of data section>> */
+ /* Copy data to send buffer */
+ memcpy(&by_snd_buf[ sizeof(T_APIMSG_MSGBUF_HEADER)], ptg_rcv_data, w_size);
+
+ /* <<Messaging>> */
+ /* Calculation of Sent Message Length */
+ w_all_len = w_size + sizeof(T_APIMSG_MSGBUF_HEADER);
+
+ /* Mode information(Reserved) */
+ w_mode = 0;
+
+ /* Message transmission request */
+ ret = _pb_SndMsg(PNO_NAVI_GPS_MAIN, w_all_len, reinterpret_cast<void*>(by_snd_buf), w_mode);
+
+ /* End of the process */
+ return ret;
+}
+
+/********************************************************************************
+ * MODULE : DEV_Gps_Recv_SndRcvData
+ * ABSTRACT : Receive data transmission processing
+ * FUNCTION : Transmit received data
+ * ARGUMENT : TG_GPS_RECV_RcvFrameBuf *frame_baf Receive frame buffer pointer
+ * NOTE : Fetches a command from the receive frame buffer and
+ * issue received data notifications to the main thread
+ * RETURN : None
+ ********************************************************************************/
+void DevGpsRecvSndRcvData(const TG_GPS_RECV_RcvFrameBuf* p_frame_buf) {
+ TG_GPS_RCV_DATA tg_rcv_data;
+ u_int16 w_cmd_len = 0;
+
+ // Initialzie struct
+ memset(&tg_rcv_data, 0, sizeof(tg_rcv_data));
+
+ if (p_frame_buf != NULL) {
+ w_cmd_len = p_frame_buf->size;
+
+ if (w_cmd_len <= GPS_READ_LEN) {
+ /* Ignore -> No applicable rules for MISRA-C */
+ memset(&tg_rcv_data, 0, sizeof(TG_GPS_RCV_DATA));
+
+ /* Status Settings */
+ tg_rcv_data.dwret_status = GPS_RECVOK;
+
+ /* Command length setting */
+ tg_rcv_data.bydata_len = w_cmd_len;
+
+ /* Receive data setting */
+ /* Sending from the Beginning of the Sirf Binary #03 */
+ memcpy(&tg_rcv_data.bygps_data[0], &p_frame_buf->buf[0], w_cmd_len);
+
+ /* Issuance of reception notice */
+ DevRcvData(&tg_rcv_data); /* Ignore -> No applicable rules for MISRA-C */
+ }
+ }
+}
+
+/**
+ * @brief
+ * Pos_Gps_Recv Thread Stop Processing
+ */
+void DevGpsRecvThreadStopProcess(void) {
+#if FTEN_DRIVER
+ GpsMngApiClose(&g_gps_mng_obj);
+#endif
+ PosTeardownThread(ETID_POS_GPS_RECV);
+ return;
+}
+
+/*---------------------------------------------------------------------------*/
+/*EOF*/