path: root/positioning/client/src/POS_sensor_API/Sensor_API.cpp

/*
 * @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 name        :Sensor_API.cpp
 *    System name        :GPF
 *    Subsystem name    :Sensor I/F library
 *    Program name    :SensorI/F API
 ******************************************************************************/

#include <stdio.h>
#include <vehicle_service/POS_sensor_API.h>
#include <vehicle_service/POS_define.h>
#include <vehicle_service/POS_sensor_API.h>
#include <vehicle_service/positioning_base_library.h>
#include "POS_sensor_private.h"
#include "Sensor_Common_API.h"
#include "Sensor_API_private.h"
#include "Sensor_Common_API.h"
#include "Vehicle_API_Dummy.h"
#include "Vehicle_API_private.h"
#include "Naviinfo_API.h"
#include "POS_private.h"

/*************************************************/
/*           Global variable                      */
/*************************************************/
/********************************************************************************
 * TAG      :TG_GPS_REQ_RESET
 * ABSTRACT :GPS reset request
 * NOTE     :I/F information between host applications(Reset mode)
 ********************************************************************************/
/**
 * @brief    POS_RegisterListenerPkgSensData Return code list
 */
static const SENSOR_RET_PKG g_ret_list_reg_lis_pkg_sens_data[SENSOR_PUBLIC_DID_NUM] = {
    /* GRADE2   GRADE1     DID (Key)     */
    {TRUE,      TRUE,     POS_DID_SPEED_PULSE        },
    {FALSE,     TRUE,     POS_DID_SPEED_KMPH         },
    {TRUE,      TRUE,     POS_DID_GYRO_X             },
    {TRUE,      TRUE,     POS_DID_GYRO_Y             },
    {TRUE,      TRUE,     POS_DID_GYRO_Z             },
    {TRUE,      TRUE,     POS_DID_GSNS_X             },
    {TRUE,      TRUE,     POS_DID_GSNS_Y             },
    {TRUE,      TRUE,     POS_DID_GSNS_Z             },
    {FALSE,     TRUE,     POS_DID_GPS_ANTENNA        },
    {TRUE,      TRUE,     POS_DID_SNS_COUNTER        },
    {FALSE,     TRUE,     POS_DID_SPEED_PULSE_FST    },
    {FALSE,     TRUE,     POS_DID_GYRO_X_FST         },
    {FALSE,     TRUE,     POS_DID_GYRO_Y_FST         },
    {FALSE,     TRUE,     POS_DID_GYRO_Z_FST         },
    {FALSE,     TRUE,     POS_DID_GPS__CWORD82__NMEA },
    {FALSE,     TRUE,     POS_DID_GPS__CWORD82___CWORD44_GP4   },
    {FALSE,     TRUE,     POS_DID_GPS__CWORD82__FULLBINARY },
    {FALSE,     TRUE,     POS_DID_GPS_NMEA           },
    {TRUE,      TRUE,     POS_DID_REV                },
    {FALSE,     TRUE,     POS_DID_REV_FST            },
    {TRUE,      TRUE,     POS_DID_GYRO_TEMP          },
    {FALSE,     TRUE,     POS_DID_GYRO_TEMP_FST      },
    {FALSE,     TRUE,     POS_DID_GSNS_X_FST         },
    {FALSE,     TRUE,     POS_DID_GSNS_Y_FST         },
    {FALSE,     TRUE,     POS_DID_GSNS_Z_FST         },
    {TRUE,      TRUE,     POS_DID_PULSE_TIME         },
    {FALSE,     TRUE,     POS_DID_GPS_CLOCK_DRIFT    },
    {FALSE,     TRUE,     POS_DID_GPS_CLOCK_FREQ     },
    {FALSE,     TRUE,     VEHICLE_DID_GPS_TIME       }, /* For local use */
    {FALSE,     TRUE,     VEHICLE_DID_GPS_TIME_RAW   }, /* For local use */
    {FALSE,     TRUE,     VEHICLE_DID_GPS_WKNROLLOVER}  /* For local use */
};

/**
 * @brief    POS_RegisterListenerSensData Return code list
 */
static const SENSOR_RET_PKG g_ret_list_reg_lis_sens_data[SENSOR_PUBLIC_DID_NUM] = {
    /* GRADE2   GRADE1     DID (Key)     */
    {TRUE,      TRUE,      POS_DID_SPEED_PULSE        },
    {FALSE,     TRUE,      POS_DID_SPEED_KMPH         },
    {TRUE,      TRUE,      POS_DID_GYRO_X             },
    {TRUE,      TRUE,      POS_DID_GYRO_Y             },
    {TRUE,      TRUE,      POS_DID_GYRO_Z             },
    {TRUE,      TRUE,      POS_DID_GSNS_X             },
    {TRUE,      TRUE,      POS_DID_GSNS_Y             },
    {TRUE,      TRUE,      POS_DID_GSNS_Z             },
    {TRUE,      TRUE,      POS_DID_GPS_ANTENNA        },
    {FALSE,     TRUE,      POS_DID_SNS_COUNTER        },
    {TRUE,      TRUE,      POS_DID_SPEED_PULSE_FST    },
    {TRUE,      TRUE,      POS_DID_GYRO_X_FST         },
    {TRUE,      TRUE,      POS_DID_GYRO_Y_FST         },
    {TRUE,      TRUE,      POS_DID_GYRO_Z_FST         },
    {TRUE,      TRUE,      POS_DID_GPS__CWORD82__NMEA },
    {FALSE,     TRUE,      POS_DID_GPS__CWORD82___CWORD44_GP4   },
    {TRUE,      TRUE,      POS_DID_GPS__CWORD82__FULLBINARY },
    {FALSE,     TRUE,      POS_DID_GPS_NMEA           },
    {FALSE,     TRUE,      POS_DID_REV                },
    {TRUE,      TRUE,      POS_DID_REV_FST            },
    {TRUE,      TRUE,      POS_DID_GYRO_TEMP          },
    {TRUE,      TRUE,      POS_DID_GYRO_TEMP_FST      },
    {TRUE,      TRUE,      POS_DID_GSNS_X_FST         },
    {TRUE,      TRUE,      POS_DID_GSNS_Y_FST         },
    {TRUE,      TRUE,      POS_DID_GSNS_Z_FST         },
    {FALSE,     TRUE,      POS_DID_PULSE_TIME         },
    {FALSE,     TRUE,      POS_DID_GPS_CLOCK_DRIFT    },
    {FALSE,     TRUE,      POS_DID_GPS_CLOCK_FREQ     },
    {FALSE,     TRUE,      VEHICLE_DID_GPS_TIME           }, /* For local use */
    {FALSE,     TRUE,      VEHICLE_DID_GPS_TIME_RAW       }, /* For local use */
    {FALSE,     TRUE,      VEHICLE_DID_GPS_WKNROLLOVER    }  /* For local use */
};

/**
 * @brief    POS_GetSensData Return code list
 */
static const SENSOR_RET_PKG g_ret_list_get_sens_data[SENSOR_PUBLIC_DID_NUM] = {
    /* GRADE2   GRADE1     DID (Key)     */
    {TRUE,      TRUE,      POS_DID_SPEED_PULSE        },
    {FALSE,     TRUE,      POS_DID_SPEED_KMPH         },
    {TRUE,      TRUE,      POS_DID_GYRO_X             },
    {TRUE,      TRUE,      POS_DID_GYRO_Y             },
    {TRUE,      TRUE,      POS_DID_GYRO_Z             },
    {TRUE,      TRUE,      POS_DID_GSNS_X             },
    {TRUE,      TRUE,      POS_DID_GSNS_Y             },
    {TRUE,      TRUE,      POS_DID_GSNS_Z             },
    {TRUE,      TRUE,      POS_DID_GPS_ANTENNA        },
    {FALSE,     TRUE,      POS_DID_SNS_COUNTER        },
    {FALSE,     TRUE,      POS_DID_SPEED_PULSE_FST    },
    {FALSE,     TRUE,      POS_DID_GYRO_X_FST         },
    {FALSE,     TRUE,      POS_DID_GYRO_Y_FST         },
    {FALSE,     TRUE,      POS_DID_GYRO_Z_FST         },
    {TRUE,      TRUE,      POS_DID_GPS__CWORD82__NMEA       },
    {FALSE,     TRUE,      POS_DID_GPS__CWORD82___CWORD44_GP4   },
    {TRUE,      TRUE,      POS_DID_GPS__CWORD82__FULLBINARY },
    {FALSE,     TRUE,      POS_DID_GPS_NMEA           },
    {FALSE,     TRUE,      POS_DID_REV                },
    {FALSE,     TRUE,      POS_DID_REV_FST            },
    {TRUE,      TRUE,      POS_DID_GYRO_TEMP          },
    {FALSE,     TRUE,      POS_DID_GYRO_TEMP_FST      },
    {FALSE,     TRUE,      POS_DID_GSNS_X_FST         },
    {FALSE,     TRUE,      POS_DID_GSNS_Y_FST         },
    {FALSE,     TRUE,      POS_DID_GSNS_Z_FST         },
    {FALSE,     TRUE,      POS_DID_PULSE_TIME         },
    {FALSE,     TRUE,      POS_DID_GPS_CLOCK_DRIFT    },
    {FALSE,     TRUE,      POS_DID_GPS_CLOCK_FREQ     },
    {FALSE,     TRUE,      VEHICLE_DID_GPS_TIME           }, /* For local use */
    {FALSE,     TRUE,      VEHICLE_DID_GPS_TIME_RAW       }, /* For local use */
    {FALSE,     TRUE,      VEHICLE_DID_GPS_WKNROLLOVER    }  /* For local use */
};

/**
 * @brief
 *   DID-decision functions for Sensor API
 *
 *    Determines whether or not the DID specified by the public API corresponds to the DID.
 *
 * @param[in]     did    Data ID
 * @param[in]    mode    Operation mode 1:For Package Delivery Registration API<br>
 *                                 2:For Sensor Data Delivery Registration API<br>
 *                                 3:For Sensor Data Acquisition API
 *
 * @return    TRUE    Be supported
 *             FALSE    Not supported
 */
BOOL SensorJudgeDid(DID did, uint8_t mode) {
    BOOL                    ret = FALSE;
    UNIT_TYPE               type;
    const SENSOR_RET_PKG    *pkg_list = NULL;
    int32_t i;

    /* Set Return pakage list */
    switch (mode) {
        case MODE_REGISTER_LISTENER_PKG_SENS_DATA: /* POS_RegisterListenerPkgSensData */
        {
            pkg_list = g_ret_list_reg_lis_pkg_sens_data;
            break;
        }
        case MODE_REGISTER_LISTENER_SENSDATA: /* POS_RegisterListenerSensData */
        {
            pkg_list = g_ret_list_reg_lis_sens_data;
            break;
        }
        case MODE_GET_SENSDATA: /* POS_GetSensData */
        {
            pkg_list = g_ret_list_get_sens_data;
            break;
        }
        default:
            /* Error log */
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [mode = %d]", mode);
            break;
    }

    if (pkg_list != NULL) {
        /* Search Return code list for DID */
        for (i = 0; i < SENSOR_PUBLIC_DID_NUM; i++) {
            if (did == pkg_list[i].did) {
                break;
            }
        }

        if (i != SENSOR_PUBLIC_DID_NUM) {
            /* Get Unit type */
            type = GetEnvSupportInfo();
            switch (type) {
                case UNIT_TYPE_GRADE1:
                {
                    ret = pkg_list[i].GRADE1_ret;
                    break;
                }
                case UNIT_TYPE_GRADE2:
                {
                    /*
                     *  Note.
                     *  This feature branches processing depending on the unit type.
                     */
                    ret = pkg_list[i].GRADE2_ret;
                    break;
                }
                default:
                    /* Error log */
                    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
                                  "GetEnvSupportInfo ERROR [type = %d]", type);
                    break;
            }
        } else {
            /* Error log */
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR [did = %d]", did);
        }
    }

    return ret;
}

/**
 * @brief
 *    Vehicle Sensor Information Extended Package Delivery Registration
 *  Sensor information is delivered for the first time.,Extension Packaging and Registering for Delivery.
 *
 * @param[in]  hApp                    Application handle
 * @param[in]  notifyName            Destination thread name
 * @param[in]  ucPkgNum                Number of package data(1 to 16)
 * @param[in]  *pulDid                Pointer to an array of data IDs for vehicle information
 * @param[in]  ucCtrlFlg            Delivery control<br>
 *                Delivery registration: SENSOR_DELIVERY_REGIST<br>
 *                Delivery stop: SENSOR_DELIVERY_STOP        (Note: Not mounted)<br>
 *                Resume delivery: SENSOR_DELIVERY_RESTART    (Note: Not mounted)
 * @param[in]  ucDeliveryTiming        Delivery timing<br>
 *                Updating    : SENSOR_DELIVERY_TIMING_UPDATE<br>
 *                Changing    : SENSOR_DELIVERY_TIMING_CHANGE
 *
 * @return    SENSOR_RET_NORMAL                Successful registration<br>
 *            SENSOR_RET_ERROR_CREATE_EVENT    Event generation failure<br>
 *            SENSOR_RET_ERROR_PARAM            Parameter error<br>
 *            SENSOR_RET_ERROR_DID            Unregistered ID<br>
 *            SENSOR_RET_ERROR_BUFFULL        FULL of delivery registers<br>
 *            SENSOR_RET_ERROR_NOSUPPORT        Unsupported environment<br>
 *            SENSOR_RET_ERROR_INNER            Internal abnormality
 *
 */
SENSOR_RET_API POS_RegisterListenerPkgSensData(HANDLE hApp,
                                               PCSTR notifyName,
                                               uint8_t ucPkgNum,
                                               DID *pulDid, uint8_t ucCtrlFlg, uint8_t ucDeliveryTiming) {
    SENSOR_RET_API                   ret;            /* Return value */
    BOOL                             ret_b;
    RET_API                          ret_api;      /* System API return value */
    EventID                          event_id;     /* Event ID */
    int32_t                          event_val;    /* Event value */
    SENSOR_MSG_DELIVERY_ENTRY_DAT    data;         /* Message data */
    int32_t                          i;            /* Generic counters */
    PNO                              ch_pno;       /* Converted internal PNO    */
    UNIT_TYPE                        type;         /* Supported HW Configuration Type    */

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");

    ret = SENSOR_RET_NORMAL;
    /* Check Handle */
    if (hApp == NULL) {
        /* NULL terminates with an abnormal parameter */
        ret = SENSOR_RET_ERROR_PARAM;
    }

    if (ret == SENSOR_RET_NORMAL) {
        /* Positioning Base API initialization */
        _pb_Setup_CWORD64_API(hApp);

        /* Supported HW Configuration Check */
        type = GetEnvSupportInfo();
        if (UNIT_TYPE_GRADE1 == type) {
            /* GRADE1 */
            ret = SENSOR_RET_NORMAL;
        } else if (UNIT_TYPE_GRADE2 == type) {
          /*
           *  Note.
           *  This feature branches processing depending on the unit type.
           */
            ret = SENSOR_RET_ERROR_NOSUPPORT;
        } else {
            /* Environment error */
            ret = SENSOR_RET_ERROR_NOSUPPORT;
        }
    }

    if (ret == SENSOR_RET_NORMAL) {
        /* Check Delivery Control Designation */
        if (SENSOR_DELIVERY_REGIST != ucCtrlFlg) {
            /* Parameters other than delivery registration terminated abnormally. */
            ret = SENSOR_RET_ERROR_PARAM;
        } else if ((ucDeliveryTiming != SENSOR_DELIVERY_TIMING_CHANGE) &&
                   (ucDeliveryTiming != SENSOR_DELIVERY_TIMING_UPDATE)) {
            /* Check delivery timing */
            /* Change delivery timing,Terminate as a parameter error except update */
            ret = SENSOR_RET_ERROR_PARAM;
        } else if (notifyName == NULL) {
            /* Check Thread Name */
            /* NULL terminates with an abnormal parameter */
            ret = SENSOR_RET_ERROR_PARAM;
        } else if ((0 == ucPkgNum) || (SENSOR_PKG_DELIVERY_MAX < ucPkgNum)) {
            /* Check Package Data Count */
            /* Out-of-range is terminated as a parameter error. */
            ret = SENSOR_RET_ERROR_PARAM;
        } else if (pulDid == NULL) {
            /* Check Data ID */
            /* NULL terminates with an abnormal parameter */
            ret = SENSOR_RET_ERROR_PARAM;
        } else {
            /* Check if data ID is acceptable */
            for (i = 0; i < ucPkgNum; i++) {
                /* Judge DID */
                ret_b = SENSOR_DID_JUDGE_REGLIS_PKG(pulDid[i]);
                if (ret_b == FALSE) {
                    /* An unacceptable ID terminates with an abnormal parameter. */
                    ret = SENSOR_RET_ERROR_PARAM;
                    break;
                } else {
                    ret = SENSOR_RET_NORMAL;
                }
            }
        }
    }

    if (ret == SENSOR_RET_NORMAL) {
        /* Resource acquisition */
        if (VehicleGetResource() == TRUE) {

        /* Initialization */
        event_id = 0;
        event_val = 0;
        memset(reinterpret_cast<void *>(&data), 0, sizeof(SENSOR_MSG_DELIVERY_ENTRY_DAT));

        /* Get PNO from Thread Name */
        ch_pno = _pb_CnvName2Pno(notifyName);

        /* Event Generation */
        event_id = PosCreateEvent(ch_pno);

        if (0 != event_id) {
            /* Successful event generation */

            /*--------------------------------------------------------------*
             *    Send Vehicle Sensor Information Delivery Registration Message                    *
             *--------------------------------------------------------------*/
            /* Create Message Data */
            data.pno             = ch_pno;
            data.pkg_num         = ucPkgNum;
            data.delivery_timing = ucDeliveryTiming;
            data.ctrl_flg        = ucCtrlFlg;
            data.event_id        = event_id;
            for (i = 0; i < ucPkgNum; i++) {
                data.did[i] = pulDid[i];
            }

            /* Messaging */
            ret_api = PosSndMsg(ch_pno,
                                PNO_VEHICLE_SENSOR,
                                CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT,
                                (uint16_t)sizeof(SENSOR_MSG_DELIVERY_ENTRY_DAT),
                                (const void *)&data);

            if (RET_NORMAL == ret_api) {
                /* Message transmission processing is successful */
                /* Wait for completion event from vehicle sensor thread */
                ret_api = _pb_WaitEvent(event_id,
                                        SAPI_EVWAIT_VAL,
                                        SENSOR_RET_ERROR_MIN,
                                        SENSOR_RET_NORMAL,
                                        &event_val,
                                        POS_API_TIME_OUT_MS);
                if (RET_NORMAL != ret_api) {
                    /* Return an internal error */
                    ret = SENSOR_RET_ERROR_INNER;
                } else {
                    /* Return from Event Wait */
                    /* Set event value (processing result) as return value */
                    ret = (SENSOR_RET_API)event_val;
                }
            } else {
                /* Message transmission processing failed */
                /* Return an internal error */
                ret = SENSOR_RET_ERROR_INNER;
            }

            /* Event deletion */
            ret_api = PosDeleteEvent(event_id);
        } else {
            /* Event generation failure */
            ret = SENSOR_RET_ERROR_CREATE_EVENT;
        }
        } else {
            /* When resource shortage occurs, the system terminates with an insufficient resource error. */
            ret = SENSOR_RET_ERROR_RESOURCE;
        }
        /* Resource release */
        VehicleReleaseResource();
    }

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "- [ret = %d]", ret);

    return ret;
}

/*******************************************************************************
 * MODULE    : PosCreateEvent
 * ABSTRACT  : Event creation process
 * FUNCTION  : Generate an event
 * ARGUMENT  : pno        : Thread ID
 * NOTE      :
 * RETURN    : Non-zero        : Event ID
 *           : Zero            : Event generation failure
 ******************************************************************************/
EventID PosCreateEvent(PNO pno) {
    EventID    event_id;          /* Event ID */
    char       event_name[32];    /* Event name character string buffer */
    RET_API    ret_api;           /* System API return value */

    /* Initialization of event name character string buffer */
    (void)memset(reinterpret_cast<void *>(event_name), 0, sizeof(event_name));

    /* Event name creation */
    snprintf(event_name, sizeof(event_name), "SENSOR_%X", pno);    /* Ignore->MISRA-C++:2008 Rule 5-2-12 */

    /* Event Generation */
    event_id = _pb_CreateEvent(FALSE , 0, event_name);    /* Ignore->MISRA-C++:2008 Rule 5-2-12 */

    if (0 != event_id) {
        /* For successful event generation */

        /* Initialize the event */
        ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, SENSOR_EVENT_VAL_INIT);
        if (RET_NORMAL != ret_api) {
            /* Event initialization failed */

            /* Delete Event and Return Event Generation Failed */
            ret_api = PosDeleteEvent(event_id);
            event_id = 0;
        }
    }

    return event_id;
}

/*******************************************************************************
 * MODULE    : PosDeleteEvent
 * ABSTRACT  : Event deletion processing
 * FUNCTION  : Delete events
 * ARGUMENT  : event_id    : Event ID of the event to delete
 * NOTE      :
 * RETURN    : RET_NORMAL    : Normal completion
 *           : RET_EV_NONE    : Specified event does not exist
 ******************************************************************************/
RET_API PosDeleteEvent(EventID event_id) {
    return(_pb_DeleteEvent(event_id));
}

/*******************************************************************************
 * MODULE    : SensorLinkShareData
 * ABSTRACT  : Link to shared memory
 * FUNCTION  : Link to shared memory
 * ARGUMENT  : **share_top    : Storage destination of shared memory top address
 *           : *share_size    : Storage destination of shared memory area size
 *           : *offset    : Offset storage destination to free shared memory area
 * NOTE      :
 * RETURN    : RET_NORMAL    : Normal completion
 *           : RET_ERROR    : There is no shared memory area.
 ******************************************************************************/
RET_API SensorLinkShareData(void **share_top, uint32_t *share_size, uint16_t *offset) {  // LCOV_EXCL_START 8:dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    RET_API         ret_api;    /* System API return value */
    SemID           sem_id;     /* Semaphore ID */
    SENSOR_SHARE    *share_top_tmp;
    int32_t         i;

    /* Initialization */
    ret_api = RET_ERROR;

    /* Create Semaphore */
    sem_id = _pb_CreateSemaphore(const_cast<char *>(SENSOR_SEMAPHO_NAME));
    if (0 != sem_id) {
        /* Semaphore Lock */
        ret_api = _pb_SemLock(sem_id);
        if (RET_NORMAL == ret_api) {
            /* Link to shared memory */
            ret_api = _pb_LinkShareData(const_cast<char *>(SENSOR_SHARE_NAME), share_top, share_size);
            if (RET_NORMAL == ret_api) {
                /* By searching the free shared memory area,Offset is calculated if there is free space. */
                share_top_tmp = reinterpret_cast<SENSOR_SHARE *>(*share_top);

                /* Because the first block of the shared memory area is the control area,Loop from i = 1 */
                for (i = 1; i < SENSOR_SHARE_BLOCK_NUM; i++) {
                    if (SENSOR_SHARE_UNLOCK == share_top_tmp->mng.lock_info[i]) {
                        break;
                    }
                }
                if (i < SENSOR_SHARE_BLOCK_NUM) {
                    /* Empty space */
                    /* Lock the block */
                    share_top_tmp->mng.lock_info[i] = SENSOR_SHARE_LOCK;

                    /* Calculate the offset to the block */
                    *offset = static_cast<uint16_t>(i * SENSOR_SHARE_BLOCK_SIZE);

                    /* Normal completion */
                    ret_api = RET_NORMAL;
                } else {
                    /* No free space */
                    ret_api = RET_ERROR;
                }
            } else {
                /* Failed link to shared memory */
                ret_api = RET_ERROR;
            }
            /* Semaphore unlock */
            _pb_SemUnlock(sem_id);
        } else {
            /* Semaphore lock failed */
            ret_api = RET_ERROR;
        }
    } else {
        /* Semaphore creation failed */
        ret_api = RET_ERROR;
    }

    return ret_api;
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : SensorUnLinkShareData
 * ABSTRACT  : Unlinking shared memory
 * FUNCTION  : Unlink shared memory
 * ARGUMENT  : *share_top    : Start address of shared memory
 *           : offset        : Offset to shared memory free area
 * NOTE      :
 * RETURN    : RET_NORMAL    : Normal completion
 *           : RET_ERROR    : There is no shared memory area./semaphore error
 ******************************************************************************/
RET_API SensorUnLinkShareData(SENSOR_SHARE *share_top, uint16_t offset) {  // LCOV_EXCL_START 8:dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    RET_API    ret_api;    /* System API return value */
    SemID      sem_id;     /* Semaphore ID */
    int32_t    i;

    /* Initialization */
    ret_api = RET_ERROR;

    /* Create Semaphore */
    sem_id = _pb_CreateSemaphore(const_cast<char *>(SENSOR_SEMAPHO_NAME));
    if (0 != sem_id) {
        /* Semaphore Lock */
        ret_api = _pb_SemLock(sem_id);
        if (RET_NORMAL == ret_api) {
            /* Unlock the block */
            i = static_cast<int32>(offset) / SENSOR_SHARE_BLOCK_SIZE;
            share_top->mng.lock_info[i] = SENSOR_SHARE_UNLOCK;

            /* Semaphore unlock */
            _pb_SemUnlock(sem_id);

            /* Normal completion */
            ret_api = RET_NORMAL;
        } else {
            /* Semaphore lock failed */
            ret_api = RET_ERROR;
        }
    } else {
        /* Semaphore creation failed */
        ret_api = RET_ERROR;
    }

    return ret_api;
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : SensorSetShareData
 * ABSTRACT  : Write processing to shared memory
 * FUNCTION  : Write shared memory
 * ARGUMENT  : *share_top    : Start address of shared memory
 *           : offset        : Offsets to shared memory write destination
 *           : *data_src    :
             : size_src :
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void SensorSetShareData(void *share_top, uint16_t offset, const void *data_src, uint16_t size_src) {  // LCOV_EXCL_START 8:dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    SENSOR_SHARE_BLOCK_DAT *share_dat;

    /* Calculate Shared Memory Write Address */
    share_dat = reinterpret_cast<SENSOR_SHARE_BLOCK_DAT *>(reinterpret_cast<uint8_t *>(share_top) + offset);
    /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */

    /* Clear Shared Memory */
    memset(reinterpret_cast<void *>(share_dat), 0, sizeof(SENSOR_SHARE_BLOCK_DAT));

    /* Set write size to shared memory */
    share_dat->size = size_src;

    /* Set specified data in shared memory */
    memcpy(reinterpret_cast<void *>(&share_dat->data), data_src, (size_t)size_src);
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : PosSndMsg
 * ABSTRACT  : Message transmission processing
 * FUNCTION  : Send a message to the specified PNO
 * ARGUMENT  : pno_src            : Source PNO
 *           : pno_dest        : Destination PNO
 *           : cid            : Command ID
 *           : msg_len            : Message data body length
 *           : *msg_len        : Pointer to message data
 * NOTE      :
 * RETURN    : RET_NORMAL        : Normal completion
 *           : RET_ERRNOTRDY    : Destination process is not wakeup
 *           : RET_ERRMSGFULL    : Message queue overflows
 *           : RET_ERRPARAM        : Buffer size error
 ******************************************************************************/
RET_API PosSndMsg(PNO pno_src, PNO pno_dest, CID cid, uint16_t msg_len, const void *msg_data) {
    SENSOR_INTERNAL_MSG_BUF   msg_buf;        /* message buffer */
    T_APIMSG_MSGBUF_HEADER    *msg_hdr;       /* Pointer to the message header */
    RET_API                   ret_api;        /* Return value */
    PCSTR                     thread_name;    /* Destination thread name                */

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");

    /* _CWORD71_ processing speed(Memset modification) */
    /* Initializing the header of the message buffer */
    memset(reinterpret_cast<void *>(&msg_buf.hdr), 0, sizeof(T_APIMSG_MSGBUF_HEADER));

    /* Get pointer to send buffer */
    msg_hdr = reinterpret_cast<T_APIMSG_MSGBUF_HEADER *>(reinterpret_cast<void *>(&msg_buf));

    /*--------------------------------------------------------------*
     *    Create message headers                                    *
     *--------------------------------------------------------------*/
    msg_hdr->hdr.sndpno         = pno_src;    /* Source PNO */
    msg_hdr->hdr.cid            = cid;        /* Command ID */
    msg_hdr->hdr.msgbodysize    = msg_len;    /* Message data body length */

    /*--------------------------------------------------------------*
     *    Create message data                                    *
     *--------------------------------------------------------------*/
    if ((0 != msg_data) && (0 != msg_len)) {    /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
        /* Set the message data */
        memcpy(reinterpret_cast<void *>(msg_buf.data), msg_data, (size_t)msg_len);
    }
    /*--------------------------------------------------------------*
     * Send messages                                            *
     *--------------------------------------------------------------*/
    /* Get Thread Name from PNO */
    if (pno_dest <= SYS_PNO_MAX) {
        thread_name = POS_THREAD_NAME;
    } else {
        thread_name = _pb_CnvPno2Name(pno_dest);
    }

    if ((pno_dest <= SYS_PNO_MAX) && (pno_src <= SYS_PNO_MAX)) {
        /* Internal debug log output */
        FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "[LOG pno_dest = 0x%x]", pno_dest);

        /* Internal Process Transmission and Reception Messages */
        ret_api = _pb_SndMsg(pno_dest,
                             (uint16_t)(sizeof(T_APIMSG_MSGBUF_HEADER) + msg_len),/* Ignore->MISRA-C++:2008 Rule 5-0-5 */
                             reinterpret_cast<void *>(&msg_buf), 0);
    } else {
        /* Internal debug log output */
        FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, 
                      "[LOG thread_name = %s, cid = 0x%x]", thread_name, cid);

        /* External Process Transmission and Reception Messages */
        ret_api = _pb_SndMsg_Ext(thread_name,
                                 cid,
                                 (uint16_t)(msg_len),    /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
                                 reinterpret_cast<void *>(&(msg_buf.data)), 0);
    }
    /* If RET_ERROR,Register a dialog if called from a Vehicle related thread */ /* Task_30332 */
    if (ret_api == RET_ERROR) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "[ERROR]");
    }

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "- [ret = %d]", ret_api);

    return ret_api;
}

/**
 * @brief
 *  Sensor information acquisition
 *
 *  Obtain sensor information
 *
 * @param[in] hApp          HANDLE   - Application handle
 * @param[in] did         DID      - Data ID for vehicle information
 * @param[in] dest_data     void*    - Pointer representing the storage destination of vehicle sensor information
 * @param[in] dest_size    uint16_t - Storage destination size of vehicle sensor information(byte)
 *
 * @return  0 or more                        Stored data size(Include illegal)<br>
 *          POS_RET_ERROR_CREATE_EVENT   Event generation failure<br>
 *          POS_RET_ERROR_OUTOF_MEMORY   Shared memory allocation failed<br>
 *          POS_RET_ERROR_SIZE           Storage destination size error<br>
 *          POS_RET_ERROR_DID            Unregistered ID<br>
 *          POS_RET_ERROR_NOSUPPORT      Unsupported environment
 *
 */
POS_RET_API POS_GetSensData(HANDLE hApp, DID did, void *dest_data, uint16_t dest_size)
{
    POS_RET_API     ret;                               /* Return value */
    UNIT_TYPE       type = UNIT_TYPE_NONE;            /* Supported HW Configuration Type    */
    BOOL            ret_b;

    /** NULL checking */
    if ((hApp == NULL) || (dest_data == NULL)) {
        /** Parameter error */
        ret = POS_RET_ERROR_PARAM;
    } else {
        /* Positioning Base API initialization */
        _pb_Setup_CWORD64_API(hApp);

        /* Supported HW Configuration Check */
        type = GetEnvSupportInfo();
        if (UNIT_TYPE_GRADE1 == type) {
            /* GRADE1 */
            ret = POS_RET_NORMAL;
        } else if (UNIT_TYPE_GRADE2 == type) {
          /*
           *  Note.
           *  This feature branches processing depending on the unit type.
           */
            ret = POS_RET_ERROR_NOSUPPORT;
        } else {
            /* Environment error */
            ret = POS_RET_ERROR_NOSUPPORT;
        }
    }

    if (ret == NAVIINFO_RET_NORMAL) {
        /* Judge DID*/
        ret_b = SENSOR_DID_JUDGE_GET(did);
        if (ret_b == FALSE) {
            /* An unacceptable ID is regarded as a parameter error. */
            ret = POS_RET_ERROR_PARAM;
        } else {
            /* Data acquisition process */
            ret = PosGetProc(did, dest_data, dest_size);
        }
    }

    return ret;
}