service/vehicle/positioning/server/src/Sensor/SensorLog.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file
  19  *   SensorLog.cpp
  20  * @brief
  21  *   Sensor Logging service functionality
  22  */
  23
  24 /*---------------------------------------------------------------------------------*
  25  * Include Files                                                                   *
  26  *---------------------------------------------------------------------------------*/
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #ifdef __cplusplus
  33 }
  34 #endif
  35
  36 #include <positioning_hal.h>
  37 #include <unistd.h>
  38 #include "SensorLog.h"
  39 #include "Sensor_Common_API.h"
  40 #include <zlib.h>
  41 #include "POS_private.h"
  42
  43 /*---------------------------------------------------------------------------------*
  44  * Definition                                                                      *
  45  *---------------------------------------------------------------------------------*/
  46 /* Sensor Log Type */
  47 typedef enum {
  48     SENSLOG_TYPE_SYS_INPUT = 0,                 /* Sensor Log Type-SYS (INPUT)  */
  49     SENSLOG_TYPE_SYS_OUTPUT,                    /* Sensor Log Type-SYS (OUTPUT) */
  50     SENSLOG_TYPE_GPS_INPUT,                     /* Sensor Log Type-GPS (INPUT)  */
  51     SENSLOG_TYPE_GPS_OUTPUT,                    /* Sensor Log Type-GPS (OUTPUT) */
  52     SENSLOG_TYPE_NAVI_INPUT,                    /* Sensor Log Type-NAVI(INPUT)  */
  53     SENSLOG_TYPE_NAVI_OUTPUT,                   /* Sensor Log Type-NAVI(OUTPUT) */
  54     SENSLOG_TYPE_POS_OUTPUT,                    /* Sensor Log Type-POS (OUTPUT) */
  55     SENSLOG_TYPE_CMD_INPUT,                     /* Sensor Log Type-CMD (INPUT)  */
  56     SENSLOG_TYPE_CMD_OUTPUT,                    /* Sensor Log Type-CMD (OUTPUT) */
  57
  58     SENSLOG_TYPE_COUNT                          /* Sensor Log Type-Counting     */
  59 } SENSLOG_TYPE;
  60
  61 #define SENSLOG_VALIDFLAG_ON            (1)     /* Effective specific flag ON              */
  62 #define SENSLOG_VALIDFLAG_OFF           (0)     /* Enable flag OFF             */
  63 #define SENSLOG_FILEPATH_SIZE           (128)   /* Output path size            */
  64 #define SENSLOG_FILENAME_SIZE           (64)    /* Output file name size      */
  65 #define SENSLOG_CONFIG_TEXT_SIZE        (128)   /* config file size/line */
  66 #define SENSLOG_LEN_MIN                 (1)     /* Record Length-Minimum         */
  67 #define SENSLOG_LEN_MAX                 (900)   /* Record Length-Maximum         */
  68 #define SENSLOG_LEN_DEFAULT             (300)   /* Record length-default value   */
  69 #define SENSLOG_GEN_MIN                 (1)     /* Number of generations-minimum value             */
  70 #define SENSLOG_GEN_MAX                 (999)   /* Number of generations-maximum value             */
  71 #define SENSLOG_GEN_DEFAULT             (100)   /* Number of generations-default value       */
  72 #define SENSLOG_BUF_MIN                 (2272)  /* Buffer Size-Minimum         */
  73 #define SENSLOG_BUF_MAX                 (11360) /* Buffer size-maximum value         */
  74 #define SENSLOG_BUF_DEFAULT             (4544)  /* Buffer size-default value   */
  75 #define SENSLOG_OUTPUTFLAG_NEW          (0)     /* Output Flag-New */
  76 #define SENSLOG_OUTPUTFLAG_ADD          (1)     /* Output Flag-Add */
  77 #define SENSLOG_PNAME_MAX               (16)    /* Maximum number of characters of process name */
  78
  79 #define SENSLOG_SEMAPHO_NAME            ("SENSLOG_SEMAPHO")   /* Semaphore name(MAX 32Byte) */
  80
  81 #define SENSLOG_CONFIG_FILE_PATH_1      "/var/local/lib/basesystem/nv/BS/vs/positioning/rwdata/"  /* Sensor log-Config filepath-1      */
  82 #define SENSLOG_CONFIG_FILE_PATH_2      "/mnt/sda1/"       /* Sensor log-Config filepath-2      */
  83 #define SENSLOG_CONFIG_FILE_NAME_SYS    "POS_sys_log.cfg"  /* Sensor log-Config filename-SYS      */
  84 #define SENSLOG_CONFIG_FILE_NAME_GPS    "POS_gps_log.cfg"  /* Sensor log-Config filename-GPS      */
  85 #define SENSLOG_CONFIG_FILE_NAME_NAVI   "POS_nav_log.cfg"  /* Sensor log-Config filename-NAVI     */
  86 #define SENSLOG_CONFIG_FILE_NAME_POS    "POS_pos_log.cfg"  /* Sensor log-Config filename-POS      */
  87 #define SENSLOG_CONFIG_FILE_NAME_CMD    "POS_cmd_log.cfg"  /* Sensor log-Config filename-CMD      */
  88 #define SENSLOG_CONFIG_KEY_LEN          "POS_log_len"      /* Sensor log-config file-Record length */
  89 #define SENSLOG_CONFIG_KEY_GEN          "POS_log_gen"      /* Sensor log-config file-Number of generations     */
  90 #define SENSLOG_CONFIG_KEY_BUF          "POS_log_buf"      /* Sensor log-config file-Buffer size */
  91 #define SENSLOG_NAV_SVINFO_FILE_NAME    "POS_NAV_SVINFO"   /* Sensor log-NAV-SVINFOFile name(Log output when file exists)*/
  92 #define SENSLOG_SEQ_START               ">>>>"             /* Sensor log sequence(Start) */
  93 #define SENSLOG_SEQ_END                 "<<<<"             /* Sensor log sequence(End)   */
  94 #define SENSLOG_SEQ_SIZE                (4)                /* Sensor Log Sequence Size       */
  95
  96 /*---------------------------------------------------------------------------------*
  97  * Structre                                                                        *
  98  *---------------------------------------------------------------------------------*/
  99 /*!
 100    @brief   Structure to create SensorLog data
 101 */
 102 typedef struct {
 103     uint16_t us_len;  /* Number of records */
 104     uint16_t uc_gen;  /* Number of generations */
 105 } SENSLOG_GEN;
 106
 107 /*!
 108    @brief   Structure to create SensorLog data
 109 */
 110 typedef struct {
 111     uint8_t      uc_valid_flag;                       /* Output enable flag            */
 112     SENSLOG_GEN  st_gen;                              /* Generation information                  */
 113     uint16_t     us_file_rec_count;                    /* Number of file output records    */
 114     uint16_t     us_rec_count;                        /* Number of output records            */
 115     uint16_t     us_gen_count;                        /* Number of generations                    */
 116     uint8_t      uc_file_path[SENSLOG_FILEPATH_SIZE]; /* Output path                  */
 117     uint8_t      uc_file_name[SENSLOG_FILENAME_SIZE]; /* Output file name            */
 118     uint8_t      uc_gen_fname[SENSLOG_FILENAME_SIZE]; /* Generation information output file name    */
 119     uint8_t      uc_text_buf[SENSLOG_BUF_MAX];        /* Buffering area(Static)  */
 120     uint32_t     ul_text_buf_size;                     /* Buffering area size  */
 121     uint32_t     ul_text_buf_len;                      /* Data size in the buffer  */
 122     uint8_t      uc_output_flag;                      /* Output flag */
 123     uint8_t      uc_temp_buf[SENSLOG_BUF_MAX];        /* Output data temporary area        */
 124     uint8_t      uc_positioninglog_buf[SENSLOG_BUF_MAX];      /* FRAMEWORKUNIFIEDLOG outputs          */
 125 } SENSLOG_INFO;
 126
 127 /*!
 128    @brief   Structure to get System time
 129 */
 130 typedef struct {
 131     uint16_t us_year;
 132     uint16_t us_month;
 133     uint16_t us_day_of_week;
 134     uint16_t us_day;
 135     uint16_t us_hour;
 136     uint16_t us_minute;
 137     uint16_t us_second;
 138     uint16_t us_milli_seconds;
 139 } SENSLOG_SYSTEMTIME;
 140
 141 /*!
 142    @brief   Structure to create SensorLog data
 143 */
 144 typedef struct {
 145     uint16_t            us_data_type;                 /* Data type         */
 146     SENSLOG_SYSTEMTIME  st_sys_time;                  /* Current time           */
 147     DID                 ul_did;                      /* Data ID           */
 148     int8_t              c_pname[SENSLOG_PNAME_MAX];  /* Destination information           */
 149     uint8_t             uc_unit_type;                 /* Hardware configuration type(GRADE1 / GRADE2) */
 150     uint8_t             uc_result;                   /* Send/Receive result(Success:0 / Fail:1) */
 151     uint16_t            us_data_size;                 /* Size of the data       */
 152 } SENSLOG_DATA_HEADER;
 153
 154
 155 /*!
 156    @brief   Structure to create SensorLog ID table
 157 */
 158 typedef struct {
 159     uint16_t            us_data_type;                 /* Data type         */
 160     DID                 ul_did;                      /* Data ID           */
 161     uint16_t            us_file_type;                 /* Sensor Log Type     */
 162     uint16_t            us_write_type;                /* FRAMEWORKUNIFIEDLOG Output Type     */
 163 } SENSLOG_ID_TBL;
 164
 165 /*---------------------------------------------------------------------------------*
 166  * Local Function Prototype                                                        *
 167  *---------------------------------------------------------------------------------*/
 168 static void SensLogGetConfig(const uint8_t*, SENSLOG_INFO*);
 169 static void SensLogGetConfigVal(uint8_t*, uint8_t*);
 170 static void SensLogCheckNAVSVINFOFile(void);
 171 static void SensLogWrite(uint16_t, uint16_t, uint16_t, DID did, PNO pno, uint8_t*, uint16_t, uint8_t, uint8_t, uint8_t);
 172 static uint16_t SensLogGetFileType(const SENSLOG_ID_TBL*, uint16_t*, uint16_t*, DID did);
 173 static void SensLogOutputFile(uint8_t);
 174 static void SensLogOutputGenFile(uint8_t);
 175 static void SensLogGetSystemTime(SENSLOG_SYSTEMTIME*);
 176 static void Num2String2Digit(uint8_t* buf, uint32_t num);
 177 static void Num2String3Digit(uint8_t* buf, uint32_t num);
 178 static void Num2String4Digit(uint8_t* buf, uint32_t num);
 179 static void Num2HexString(uint8_t* buf, uint8_t digits, uint32_t num);
 180 static void SensLogmakeHeader(uint8_t* buf, SENSLOG_DATA_HEADER data_header);
 181
 182 /*---------------------------------------------------------------------------------*
 183  * Grobal Value                                                                    *
 184  *---------------------------------------------------------------------------------*/
 185 /* Sensor log information */
 186 static SENSLOG_INFO g_sens_log_info[SENSLOG_TYPE_COUNT];    // NOLINT(readability/nolint)
 187 static uint8_t   g_navsv_info_flag = FALSE;
 188 uint8_t   g_mount_path[SENSLOG_FILEPATH_SIZE];  /* Mount path */
 189 UNIT_TYPE g_unit_type = UNIT_TYPE_NONE;         /* HW configuration type   */
 190 SemID     g_sem_id = 0;                         /* Lock semaphore ID */
 191
 192 /* Sensor log type definition table */
 193 const SENSLOG_ID_TBL kSensLogInputTbl[] = {
 194     /* Data type                DID                                Sensor Log Type             FRAMEWORKUNIFIEDLOG Output Type */
 195     {SENSLOG_DATA_I_SYS,         0,                                 SENSLOG_TYPE_SYS_INPUT,    POS_SENSLOG_TYPE_SYS  },
 196     {SENSLOG_DATA_I_SYS_STS,     0,                                 SENSLOG_TYPE_SYS_INPUT,    POS_SENSLOG_TYPE_SYS  },
 197     {SENSLOG_DATA_I_GPS,         0,                                 SENSLOG_TYPE_GPS_INPUT,    POS_SENSLOG_TYPE_GPS  },
 198     {SENSLOG_DATA_I_LOC,         POSHAL_DID_GPS_CUSTOMDATA_NAVI,    SENSLOG_TYPE_NAVI_INPUT,   POS_SENSLOG_TYPE_NAV  },
 199     {SENSLOG_DATA_I_SPEED,       VEHICLE_DID_MOTION_SPEED_NAVI,     SENSLOG_TYPE_NAVI_INPUT,   POS_SENSLOG_TYPE_NAV  },
 200     {SENSLOG_DATA_I_TIME,        VEHICLE_DID_SETTINGTIME,           SENSLOG_TYPE_NAVI_INPUT,   POS_SENSLOG_TYPE_NAV  },
 201     {SENSLOG_DATA_I_TIME,        POSHAL_DID_GPS_TIME,               SENSLOG_TYPE_GPS_INPUT,    POS_SENSLOG_TYPE_GPS  },
 202     {SENSLOG_DATA_I_GPSINF,      0,                                 SENSLOG_TYPE_NAVI_INPUT,   POS_SENSLOG_TYPE_NAV  },
 203     {SENSLOG_DATA_I_GPSRST,      0,                                 SENSLOG_TYPE_CMD_INPUT,    POS_SENSLOG_TYPE_CMD  },
 204     {SENSLOG_DATA_I_GPSSET,      0,                                 SENSLOG_TYPE_CMD_INPUT,    POS_SENSLOG_TYPE_CMD  },
 205     {SENSLOG_DATA_I_NAVSVINFO,   0,                                 SENSLOG_TYPE_GPS_INPUT,    POS_SENSLOG_TYPE_GPS  },
 206     {SENSLOG_DATA_I_SYS_ABNORMAL, 0,                                SENSLOG_TYPE_SYS_INPUT,    POS_SENSLOG_TYPE_SYS  },
 207     {SENSLOG_DATA_I_UNSPECIFIED, 0,                                 SENSLOG_TYPE_COUNT,        POS_SENSLOG_TYPE_NONE }
 208 };
 209
 210 const SENSLOG_ID_TBL kSensLogOutputTbl[] = {
 211     /* Data type                DID                                Sensor Log Type             FRAMEWORKUNIFIEDLOG Output Type */
 212     {SENSLOG_DATA_O_SYS,         POSHAL_DID_SPEED_PULSE,               SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 213     {SENSLOG_DATA_O_SYS,         POSHAL_DID_SPEED_KMPH,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 214     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_X,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 215     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_Y,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 216     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_Z,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 217     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_X,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 218     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_Y,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 219     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_Z,                    SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 220     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS_ANTENNA,               SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 221     {SENSLOG_DATA_O_SYS,         POSHAL_DID_SNS_COUNTER,               SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 222     {SENSLOG_DATA_O_SYS,         POSHAL_DID_SPEED_PULSE_FST,           SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 223     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_X_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 224     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_Y_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 225     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_Z_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 226     {SENSLOG_DATA_O_SYS,         VEHICLE_DID_GPS__CWORD82__NMEA,             SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 227     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS__CWORD82___CWORD44_GP4,          SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 228     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS__CWORD82__FULLBINARY,        SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 229     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS_NMEA,                  SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 230     {SENSLOG_DATA_O_SYS,         POSHAL_DID_REV,                       SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 231     {SENSLOG_DATA_O_SYS,         POSHAL_DID_REV_FST,                   SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 232     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_TEMP,                 SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 233     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GYRO_TEMP_FST,             SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 234     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_X_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 235     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_Y_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 236     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GSNS_Z_FST,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 237     {SENSLOG_DATA_O_SYS,         POSHAL_DID_PULSE_TIME,                SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 238     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS_CLOCK_DRIFT,           SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 239     {SENSLOG_DATA_O_SYS,         POSHAL_DID_GPS_CLOCK_FREQ,            SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 240     {SENSLOG_DATA_O_SYS_PKG,     0,                                 SENSLOG_TYPE_SYS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 241     {SENSLOG_DATA_O_GPS,         0,                                 SENSLOG_TYPE_CMD_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 242     {SENSLOG_DATA_O_LONLAT_N,    VEHICLE_DID_LOCATION_LONLAT_NAVI,  SENSLOG_TYPE_NAVI_OUTPUT,  POS_SENSLOG_TYPE_NONE },
 243     {SENSLOG_DATA_O_LONLAT_G,    VEHICLE_DID_LOCATION_LONLAT,       SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 244     {SENSLOG_DATA_O_ALT,         VEHICLE_DID_LOCATION_ALTITUDE,     SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 245     {SENSLOG_DATA_O_SPEED_N,     VEHICLE_DID_MOTION_SPEED_NAVI,     SENSLOG_TYPE_NAVI_OUTPUT,  POS_SENSLOG_TYPE_NONE },
 246     {SENSLOG_DATA_O_SPEED_P,     VEHICLE_DID_MOTION_SPEED_INTERNAL, SENSLOG_TYPE_POS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 247     {SENSLOG_DATA_O_HEAD_N,      VEHICLE_DID_MOTION_HEADING_NAVI,   SENSLOG_TYPE_NAVI_OUTPUT,  POS_SENSLOG_TYPE_NONE },
 248     {SENSLOG_DATA_O_HEAD_G,      VEHICLE_DID_MOTION_HEADING,        SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 249     {SENSLOG_DATA_O_TIME_SETREQ, VEHICLE_DID_SETTINGTIME,           SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 250     {SENSLOG_DATA_O_TIME,        POSHAL_DID_GPS_TIME,               SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 251     {SENSLOG_DATA_O_GPSINF,      VEHICLE_DID_NAVIINFO_DIAG_GPS,     SENSLOG_TYPE_NAVI_OUTPUT,  POS_SENSLOG_TYPE_NONE },
 252     {SENSLOG_DATA_O_TIME_CS,     0,                                 SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 253     {SENSLOG_DATA_O_GPSRST,      0,                                 SENSLOG_TYPE_GPS_OUTPUT,   POS_SENSLOG_TYPE_NONE },
 254
 255     {SENSLOG_DATA_O_UNSPECIFIED, 0,                                 SENSLOG_TYPE_COUNT,        POS_SENSLOG_TYPE_NONE }
 256 };
 257
 258 /*---------------------------------------------------------------------------------*
 259  * Function                                                                        *
 260  *---------------------------------------------------------------------------------*/
 261 /**
 262  * @brief
 263  *   Sensor Log Initial Processing
 264  *
 265  * @param[in]  p_mount_path Mount path
 266  */
 267 void SensLogInitialize(uint8_t *p_mount_path) {
 268     static SENSLOG_INFO st_sens_log_info; /* Coverity CID:23609 compliant */
 269     uint8_t      uc_hw[16];                       /* HW name */
 270     uint8_t      ret = 0;
 271     uint8_t      i;
 272     static uint8_t tzset_flag = 0; /* Not initialized */
 273
 274     FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
 275
 276     /* Not initialized */
 277     if (tzset_flag == 0) {
 278         tzset();
 279         tzset_flag = 1; /* Initialization complete */
 280     }
 281
 282     /* Initialization of sensor log information structure */
 283     memset(&g_sens_log_info, 0, sizeof(g_sens_log_info));
 284
 285     /* Get mount path */
 286     memset(&g_mount_path[0], 0, sizeof(g_mount_path));
 287     if (NULL == p_mount_path) {
 288         snprintf(reinterpret_cast<char*>(&g_mount_path[0]), sizeof(g_mount_path), SENSLOG_CONFIG_FILE_PATH_2);
 289     } else {
 290         snprintf(reinterpret_cast<char*>(&g_mount_path[0]), sizeof(g_mount_path), "%s/", p_mount_path);
 291     }
 292     FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "mount path[%s]", g_mount_path);
 293
 294     /* HW judgment */
 295     memset(&uc_hw[0], 0, sizeof(uc_hw));
 296     g_unit_type = GetEnvSupportInfo();
 297     if (UNIT_TYPE_GRADE1 == g_unit_type) {
 298         /* GRADE1 */
 299         snprintf(reinterpret_cast<char*>(&uc_hw[0]), sizeof(uc_hw), "GRADE1");
 300     } else if (UNIT_TYPE_GRADE2 == g_unit_type) {
 301       /*
 302        *  Note.
 303        *  This feature branches processing depending on the unit type.
 304        */
 305     } else {
 306         /* Environment error */
 307         /* Do not output sensor log */
 308         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Environment Error.");
 309         ret = 1;
 310     }
 311
 312     /* Get Semaphore ID */
 313     g_sem_id = _pb_CreateSemaphore(const_cast<char *>(SENSLOG_SEMAPHO_NAME));
 314     if (g_sem_id == 0) {  // LCOV_EXCL_BR_LINE 200: can not return zero
 315         // LCOV_EXCL_START 8: invalid
 316         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 317         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Semaphore create Error.(ID = 0)");
 318         ret = 1;
 319         // LCOV_EXCL_STOP
 320     }
 321
 322     if (ret == 0) {
 323         /* Read config files */
 324         /* SYS */
 325         memset(&st_sens_log_info, 0, sizeof(SENSLOG_INFO));
 326         SensLogGetConfig((const uint8_t*)SENSLOG_CONFIG_FILE_NAME_SYS, &st_sens_log_info);
 327         if (st_sens_log_info.uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 328             st_sens_log_info.us_gen_count = 1;
 329             memcpy(&g_sens_log_info[SENSLOG_TYPE_SYS_INPUT],  &st_sens_log_info, sizeof(SENSLOG_INFO));
 330             memcpy(&g_sens_log_info[SENSLOG_TYPE_SYS_OUTPUT], &st_sens_log_info, sizeof(SENSLOG_INFO));
 331             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_SYS_INPUT].uc_file_name[0])),
 332                      sizeof(g_sens_log_info[SENSLOG_TYPE_SYS_INPUT].uc_file_name), "POS_%s_sys_i_%%03d.log", uc_hw);
 333             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_SYS_OUTPUT].uc_file_name[0])),
 334                      sizeof(g_sens_log_info[SENSLOG_TYPE_SYS_OUTPUT].uc_file_name), "POS_%s_sys_o_%%03d.log", uc_hw);
 335             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_SYS_INPUT].uc_gen_fname[0])),
 336                      sizeof(g_sens_log_info[SENSLOG_TYPE_SYS_INPUT].uc_gen_fname), "POS_%s_sys_i_gen.dat", uc_hw);
 337             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_SYS_OUTPUT].uc_gen_fname[0])),
 338                      sizeof(g_sens_log_info[SENSLOG_TYPE_SYS_OUTPUT].uc_gen_fname), "POS_%s_sys_o_gen.dat", uc_hw);
 339             SensLogOutputGenFile(SENSLOG_TYPE_SYS_INPUT);
 340             SensLogOutputGenFile(SENSLOG_TYPE_SYS_OUTPUT);
 341         }
 342
 343         /* GPS */
 344         memset(&st_sens_log_info, 0, sizeof(SENSLOG_INFO));
 345         SensLogGetConfig((const uint8_t*)SENSLOG_CONFIG_FILE_NAME_GPS, &st_sens_log_info);
 346         if (st_sens_log_info.uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 347             st_sens_log_info.us_gen_count = 1;
 348             memcpy(&g_sens_log_info[SENSLOG_TYPE_GPS_INPUT],  &st_sens_log_info, sizeof(SENSLOG_INFO));
 349             memcpy(&g_sens_log_info[SENSLOG_TYPE_GPS_OUTPUT], &st_sens_log_info, sizeof(SENSLOG_INFO));
 350             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_GPS_INPUT].uc_file_name[0])),
 351                      sizeof(g_sens_log_info[SENSLOG_TYPE_GPS_INPUT].uc_file_name), "POS_%s_gps_i_%%03d.log", uc_hw);
 352             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_GPS_OUTPUT].uc_file_name[0])),
 353                      sizeof(g_sens_log_info[SENSLOG_TYPE_GPS_OUTPUT].uc_file_name), "POS_%s_gps_o_%%03d.log", uc_hw);
 354             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_GPS_INPUT].uc_gen_fname[0])),
 355                      sizeof(g_sens_log_info[SENSLOG_TYPE_GPS_INPUT].uc_gen_fname), "POS_%s_gps_i_gen.dat", uc_hw);
 356             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_GPS_OUTPUT].uc_gen_fname[0])),
 357                      sizeof(g_sens_log_info[SENSLOG_TYPE_GPS_OUTPUT].uc_gen_fname), "POS_%s_gps_o_gen.dat", uc_hw);
 358             SensLogOutputGenFile(SENSLOG_TYPE_GPS_INPUT);
 359             SensLogOutputGenFile(SENSLOG_TYPE_GPS_OUTPUT);
 360         }
 361
 362         /* NAVI */
 363         memset(&st_sens_log_info, 0, sizeof(SENSLOG_INFO));
 364         SensLogGetConfig((const uint8_t*)SENSLOG_CONFIG_FILE_NAME_NAVI, &st_sens_log_info);
 365         if (st_sens_log_info.uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 366             st_sens_log_info.us_gen_count = 1;
 367             memcpy(&g_sens_log_info[SENSLOG_TYPE_NAVI_INPUT],  &st_sens_log_info, sizeof(SENSLOG_INFO));
 368             memcpy(&g_sens_log_info[SENSLOG_TYPE_NAVI_OUTPUT], &st_sens_log_info, sizeof(SENSLOG_INFO));
 369             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_NAVI_INPUT].uc_file_name[0])),
 370                      sizeof(g_sens_log_info[SENSLOG_TYPE_NAVI_INPUT].uc_file_name), "POS_%s_nav_i_%%03d.log", uc_hw);
 371             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_NAVI_OUTPUT].uc_file_name[0])),
 372                      sizeof(g_sens_log_info[SENSLOG_TYPE_NAVI_OUTPUT].uc_file_name), "POS_%s_nav_o_%%03d.log", uc_hw);
 373             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_NAVI_INPUT].uc_gen_fname[0])),
 374                      sizeof(g_sens_log_info[SENSLOG_TYPE_NAVI_INPUT].uc_gen_fname), "POS_%s_nav_i_gen.dat", uc_hw);
 375             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_NAVI_OUTPUT].uc_gen_fname[0])),
 376                      sizeof(g_sens_log_info[SENSLOG_TYPE_NAVI_OUTPUT].uc_gen_fname), "POS_%s_nav_o_gen.dat", uc_hw);
 377             SensLogOutputGenFile(SENSLOG_TYPE_NAVI_INPUT);
 378             SensLogOutputGenFile(SENSLOG_TYPE_NAVI_OUTPUT);
 379         }
 380
 381         /* POS */
 382         memset(&st_sens_log_info, 0, sizeof(SENSLOG_INFO));
 383         SensLogGetConfig((const uint8_t*)SENSLOG_CONFIG_FILE_NAME_POS, &st_sens_log_info);
 384         if (st_sens_log_info.uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 385             st_sens_log_info.us_gen_count = 1;
 386             memcpy(&g_sens_log_info[SENSLOG_TYPE_POS_OUTPUT],  &st_sens_log_info, sizeof(SENSLOG_INFO));
 387             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_POS_OUTPUT].uc_file_name[0])),
 388                      sizeof(g_sens_log_info[SENSLOG_TYPE_POS_OUTPUT].uc_file_name), "POS_%s_pos_o_%%03d.log", uc_hw);
 389             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_POS_OUTPUT].uc_gen_fname[0])),
 390                      sizeof(g_sens_log_info[SENSLOG_TYPE_POS_OUTPUT].uc_gen_fname), "POS_%s_pos_o_gen.dat", uc_hw);
 391             SensLogOutputGenFile(SENSLOG_TYPE_POS_OUTPUT);
 392         }
 393
 394         /* CMD */
 395         memset(&st_sens_log_info, 0, sizeof(SENSLOG_INFO));
 396         SensLogGetConfig((const uint8_t*)SENSLOG_CONFIG_FILE_NAME_CMD, &st_sens_log_info);
 397         if (st_sens_log_info.uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 398             st_sens_log_info.us_gen_count = 1;
 399             memcpy(&g_sens_log_info[SENSLOG_TYPE_CMD_INPUT],  &st_sens_log_info, sizeof(SENSLOG_INFO));
 400             memcpy(&g_sens_log_info[SENSLOG_TYPE_CMD_OUTPUT], &st_sens_log_info, sizeof(SENSLOG_INFO));
 401             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_CMD_INPUT].uc_file_name[0])),
 402                      sizeof(g_sens_log_info[SENSLOG_TYPE_CMD_INPUT].uc_file_name), "POS_%s_cmd_i_%%03d.log", uc_hw);
 403             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_CMD_OUTPUT].uc_file_name[0])),
 404                      sizeof(g_sens_log_info[SENSLOG_TYPE_CMD_OUTPUT].uc_file_name), "POS_%s_cmd_o_%%03d.log", uc_hw);
 405             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_CMD_INPUT].uc_gen_fname[0])),
 406                      sizeof(g_sens_log_info[SENSLOG_TYPE_CMD_INPUT].uc_gen_fname), "POS_%s_cmd_i_gen.dat", uc_hw);
 407             snprintf(reinterpret_cast<char*>(&(g_sens_log_info[SENSLOG_TYPE_CMD_OUTPUT].uc_gen_fname[0])),
 408                      sizeof(g_sens_log_info[SENSLOG_TYPE_CMD_OUTPUT].uc_gen_fname), "POS_%s_cmd_o_gen.dat", uc_hw);
 409             SensLogOutputGenFile(SENSLOG_TYPE_CMD_INPUT);
 410             SensLogOutputGenFile(SENSLOG_TYPE_CMD_OUTPUT);
 411         }
 412
 413         /* NAV-SVINFO */
 414         SensLogCheckNAVSVINFOFile();
 415     }
 416
 417     for (i = 0; i < SENSLOG_TYPE_COUNT; i++) {
 418         if (g_sens_log_info[i].uc_valid_flag == SENSLOG_VALIDFLAG_ON) {
 419             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 420                 "g_sens_log_info[%d].uc_valid_flag:%d", i, g_sens_log_info[i].uc_valid_flag);
 421             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 422                 "g_sens_log_info[%d].st_gen.us_len:%d", i, g_sens_log_info[i].st_gen.us_len);
 423             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 424                 "g_sens_log_info[%d].st_gen.uc_gen:%d", i, g_sens_log_info[i].st_gen.uc_gen);
 425             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 426                 "g_sens_log_info[%d].us_file_rec_count:%d", i, g_sens_log_info[i].us_file_rec_count);
 427             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 428                 "g_sens_log_info[%d].us_rec_count:%d", i, g_sens_log_info[i].us_rec_count);
 429             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 430                 "g_sens_log_info[%d].us_gen_count:%d", i, g_sens_log_info[i].us_gen_count);
 431             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 432                 "g_sens_log_info[%d].uc_file_path:%s", i, g_sens_log_info[i].uc_file_path);
 433             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 434                 "g_sens_log_info[%d].uc_file_name:%s", i, g_sens_log_info[i].uc_file_name);
 435             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 436                 "g_sens_log_info[%d].uc_gen_fname:%s", i, g_sens_log_info[i].uc_gen_fname);
 437             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 438                 "g_sens_log_info[%d].ul_text_buf_size:%d", i, g_sens_log_info[i].ul_text_buf_size);
 439         }
 440     }
 441     FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
 442
 443     return;
 444 }
 445
 446 /**
 447  * @brief
 448  *   Sensor log stop processing
 449  */
 450 void SensLogTerminate(void) {
 451     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
 452
 453     /* Initialization of sensor log information structure */
 454     memset(&g_sens_log_info, 0, sizeof(g_sens_log_info));
 455
 456     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
 457
 458     return;
 459 }
 460
 461 /**
 462  * @brief
 463  *   Sensor log saving process
 464  */
 465 void SensLogStore(void) {  // LCOV_EXCL_START 8 : dead code
 466     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 467     uint8_t     i;
 468
 469     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
 470
 471     for (i = 0; i < SENSLOG_TYPE_COUNT; i++) {
 472         /* Output buffering log */
 473         if ((g_sens_log_info[i].uc_valid_flag == SENSLOG_VALIDFLAG_ON) &&
 474                 (g_sens_log_info[i].ul_text_buf_len > 0)) {
 475             SensLogOutputFile(i);
 476         }
 477     }
 478
 479     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
 480     return;
 481 }
 482 // LCOV_EXCL_STOP
 483
 484 /**
 485  * @brief
 486  *   Sensor log config file information acquisition
 487  *
 488  * @param[in]  uc_config_file  Config filename
 489  * @param[out] st_sens_log_info Sensor log information
 490  */
 491 static void SensLogGetConfig(const uint8_t* uc_config_file, SENSLOG_INFO* st_sens_log_info) {
 492     FILE*   fp;
 493     uint8_t uc_file_path[SENSLOG_FILEPATH_SIZE];
 494     uint8_t uc_file_name[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
 495     uint8_t ucBuf[SENSLOG_CONFIG_TEXT_SIZE];
 496     uint8_t uc_val[SENSLOG_CONFIG_TEXT_SIZE];
 497     uint8_t flag = 0;
 498
 499     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
 500
 501     if ((uc_config_file == NULL) || (st_sens_log_info == NULL)) {  // LCOV_EXCL_BR_LINE 200: can not NULL
 502         // LCOV_EXCL_START 8: invalid
 503         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 504         /* Unprocessed if the argument is invalid. */
 505         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Parameter Error.");
 506         // LCOV_EXCL_STOP
 507     } else {
 508         memset(&uc_file_path, 0, sizeof(uc_file_path));
 509         memset(&uc_file_name, 0, sizeof(uc_file_name));
 510
 511         /* Refer to the config files in the built-in memory. */
 512         snprintf(reinterpret_cast<char*>(&uc_file_path[0]), sizeof(uc_file_path), \
 513             SENSLOG_CONFIG_FILE_PATH_1);
 514         snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name), \
 515             "%s%s", uc_file_path, uc_config_file);
 516         fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "r");
 517         if (NULL == fp) {
 518             /* If there are no config files in the built-in memory, refer to the USB memory. */
 519             snprintf(reinterpret_cast<char*>(&uc_file_path[0]), sizeof(uc_file_path), \
 520                 "%s", (const char*)&g_mount_path[0]);
 521             snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name), \
 522                 "%s%s", uc_file_path, uc_config_file);
 523             fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "r");
 524         }
 525
 526         if (NULL == fp) {
 527             /* Do not print when there are no config files.(Console log output)*/
 528             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 529                 "Not SensorLog config file. [%s]", uc_file_name);
 530         } else {
 531             /* Read config files */
 532             for (;;) {
 533                 if (fgets(reinterpret_cast<char*>(&ucBuf), SENSLOG_CONFIG_TEXT_SIZE, fp) == NULL) {
 534                     /* EOF detection(Fail-safe:Normally it does not pass because it is break at the flag judgment place.)*/
 535                     break;
 536                 }
 537                 memset(&uc_val, 0, sizeof(uc_val));
 538                 if ((strncmp(reinterpret_cast<char*>(&ucBuf), SENSLOG_CONFIG_KEY_LEN, \
 539                     strlen(SENSLOG_CONFIG_KEY_LEN)) == 0) && ((flag & 0x01) != 0x01)) {
 540                     /* Get record length */
 541                     SensLogGetConfigVal(ucBuf, uc_val);
 542                     st_sens_log_info->st_gen.us_len = static_cast<uint16_t>(atoi((const char *)uc_val));
 543                     flag ^= 0x01;
 544                 } else if ((strncmp(reinterpret_cast<char*>(&ucBuf), SENSLOG_CONFIG_KEY_GEN, \
 545                     strlen(SENSLOG_CONFIG_KEY_GEN)) == 0) && ((flag & 0x02) != 0x02)) {
 546                     /* Get number of generations */
 547                     SensLogGetConfigVal(ucBuf, uc_val);
 548                     st_sens_log_info->st_gen.uc_gen = static_cast<uint16_t>(atoi((const char *)uc_val));
 549                     flag ^= 0x02;
 550                 } else {
 551                     /* nop */
 552                 }
 553
 554                 if (flag == 0x03) {
 555                     break;
 556                 }
 557             }
 558             fclose(fp);
 559
 560             FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, \
 561                 "SensorLog read : file[%s] : config[0x%02x]", uc_file_name, flag);
 562
 563             if ((st_sens_log_info->st_gen.us_len < SENSLOG_LEN_MIN) \
 564                 || (st_sens_log_info->st_gen.us_len > SENSLOG_LEN_MAX)) {
 565                 /* The default value is applied if it is outside the valid range. */
 566                 st_sens_log_info->st_gen.us_len = SENSLOG_LEN_DEFAULT;
 567             }
 568             if ((st_sens_log_info->st_gen.uc_gen < SENSLOG_GEN_MIN) \
 569                 || (st_sens_log_info->st_gen.uc_gen > SENSLOG_GEN_MAX)) {
 570                 /* The default value is applied if it is outside the valid range. */
 571                 st_sens_log_info->st_gen.uc_gen = SENSLOG_GEN_DEFAULT;
 572             }
 573             st_sens_log_info->ul_text_buf_size = SENSLOG_BUF_MAX; /* Static area(Maximum security) */
 574
 575             st_sens_log_info->uc_valid_flag = SENSLOG_VALIDFLAG_ON;
 576             st_sens_log_info->uc_output_flag = SENSLOG_OUTPUTFLAG_NEW;
 577             /* The log output path should be the same path as the config file. */
 578             memcpy(st_sens_log_info->uc_file_path, uc_file_path, SENSLOG_FILEPATH_SIZE);
 579         }
 580     }
 581     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
 582
 583     return;
 584 }
 585
 586 /**
 587  * @brief
 588  *   Sensor log config file setting value acquisition
 589  *
 590  * @param[in]  uc_text  Config setting information
 591  * @param[out] uc_val   Config setting
 592  */
 593 static void SensLogGetConfigVal(uint8_t* uc_text, uint8_t* uc_val) {
 594     uint8_t  ucBuf[SENSLOG_CONFIG_TEXT_SIZE];
 595     uint16_t i = 0;
 596     uint16_t j = 0;
 597
 598     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
 599
 600     if ((uc_text == NULL) || (uc_val == NULL)) {  // LCOV_EXCL_BR_LINE 200: can not NULL
 601         // LCOV_EXCL_START 8: invalid
 602         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 603         /* Unprocessed if the argument is invalid. */
 604         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Parameter Error.");
 605         // LCOV_EXCL_STOP
 606     } else {
 607         memset(ucBuf, 0, sizeof(ucBuf));
 608         while ((*uc_text != ':') && (*uc_text != '\0')) {
 609             uc_text++;
 610             i++;
 611             if (i >= (SENSLOG_CONFIG_TEXT_SIZE - 1)) {
 612                 break;
 613             }
 614         }
 615         while ((*uc_text != '\r') && (*uc_text != '\n') && (*uc_text != '\0')) {
 616             uc_text++;
 617             i++;
 618             ucBuf[j++] = *uc_text;
 619             if (i >= SENSLOG_CONFIG_TEXT_SIZE) {  // LCOV_EXCL_BR_LINE 200: can not exceed size
 620                 // LCOV_EXCL_START 8: invalid
 621                 AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 622                 memset(&ucBuf, 0, sizeof(ucBuf));
 623                 break;
 624                 // LCOV_EXCL_STOP
 625             }
 626         }
 627         memcpy(uc_val, ucBuf, sizeof(ucBuf));
 628     }
 629     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
 630
 631     return;
 632 }
 633
 634 /**
 635  * @brief
 636  *   Acquisition of sensor log NAV-SVINFO file information
 637  *
 638  * @param[in] none
 639  */
 640 static void SensLogCheckNAVSVINFOFile(void) {
 641     FILE*   fp;
 642     const uint8_t* uc_config_file;
 643     uint8_t uc_file_path[SENSLOG_FILEPATH_SIZE];
 644     uint8_t uc_file_name[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
 645
 646     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
 647
 648     uc_config_file = (const uint8_t*)SENSLOG_NAV_SVINFO_FILE_NAME;
 649
 650     memset(&uc_file_path, 0, sizeof(uc_file_path));
 651     memset(&uc_file_name, 0, sizeof(uc_file_name));
 652
 653     /* Refer to the config files in the built-in memory. */
 654     snprintf(reinterpret_cast<char*>(&uc_file_path[0]), sizeof(uc_file_path), SENSLOG_CONFIG_FILE_PATH_1);
 655     snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name), "%s%s", uc_file_path, uc_config_file);
 656     fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "r");
 657     if (NULL == fp) {
 658         /* If there are no config files in the built-in memory, refer to the USB memory. */
 659         snprintf(reinterpret_cast<char*>(&uc_file_path[0]), sizeof(uc_file_path), \
 660             "%s", (const char*)&g_mount_path[0]);
 661         snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name), \
 662             "%s%s", uc_file_path, uc_config_file);
 663         fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "r");
 664     }
 665
 666     if (NULL == fp) {
 667         /* Do not print when there are no config files.(Console log output)*/
 668         FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "Not SensorLog config file. [%s]", uc_file_name);
 669         g_navsv_info_flag = FALSE;
 670     } else {
 671         fclose(fp);
 672         FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "SensorLog read : file[%s]", uc_file_name);
 673         g_navsv_info_flag = TRUE;
 674     }
 675     FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
 676
 677     return;
 678 }
 679
 680 /**
 681  * @brief
 682  *   Acquisition of sensor log NAV-SVINFO file information
 683  *
 684  * @param[in] none
 685  *
 686  * @return Destination sensor log file type
 687  */
 688 uint8_t SensLogGetNavSvinfoFlag(void) {  // LCOV_EXCL_START 8: dead code.
 689     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 690     return g_navsv_info_flag;
 691 }
 692 // LCOV_EXCL_STOP
 693 /**
 694  * @brief
 695  *   Sensor log output(Input information)
 696  *
 697  *   Writes the specified log (input information) to the buffer area
 698  *
 699  * @param[in]  us_data_type   Data type
 700  * @param[in]  ul_did        Data ID
 701  * @param[in]  us_pno        Destination PNO
 702  * @param[in]  p_data        Write data pointer
 703  * @param[in]  us_size       Write data size
 704  * @param[in]  uc_result     Reception result
 705  * @param[in]  u_write_flag   ability to write sensor log
 706  * @param[in]  u_write_abnormal_flag   When an error occurs ability to write sensor log
 707  */
 708 void SensLogWriteInputData(uint16_t us_data_type, DID ul_did, PNO us_pno, uint8_t *p_data, \
 709         uint16_t us_size, uint8_t uc_result, uint8_t u_write_flag, uint8_t u_write_abnormal_flag) {
 710     uint16_t                file_type = 0;
 711     uint16_t                data_type = us_data_type;
 712     uint16_t                write_type = POS_SENSLOG_TYPE_NONE;
 713     RET_API                 lret_sem = RET_ERROR;
 714
 715     /* Sensor log file type determination */
 716     file_type = SensLogGetFileType(kSensLogInputTbl, &data_type, &write_type, ul_did);
 717
 718     /* For the target type,Perform exclusive control */
 719     /* Currently, only GPS input can be written from multiple threads. */
 720     if (file_type == SENSLOG_TYPE_GPS_INPUT) {
 721         /* Semaphore ID determination */
 722         if (g_sem_id != 0) {  // LCOV_EXCL_BR_LINE 200: can not zero
 723             lret_sem = _pb_SemLock(g_sem_id); /* Semaphore Lock */
 724             if (lret_sem != RET_NORMAL) {  // LCOV_EXCL_BR_LINE 200: can not return error
 725                 // LCOV_EXCL_START 8: invalid
 726                 AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 727                 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "SemLock Error.");
 728                 // LCOV_EXCL_STOP
 729             } else {
 730                 /* Sensor log output */
 731                 SensLogWrite(file_type, data_type, write_type, ul_did, us_pno, p_data, \
 732                     us_size, uc_result, u_write_flag, u_write_abnormal_flag);
 733                 (void)_pb_SemUnlock(g_sem_id); /* Semaphore unlock */
 734             }
 735         }
 736     } else {
 737         /* Sensor log output */
 738         SensLogWrite(file_type, data_type, write_type, ul_did, us_pno, p_data, us_size, \
 739             uc_result, u_write_flag, u_write_abnormal_flag);
 740     }
 741
 742     return;
 743 }
 744
 745 /**
 746  * @brief
 747  *   Sensor log output(Outputs the information)
 748  *
 749  *   Writes the specified log (output information) to the buffer area
 750  *
 751  * @param[in]  us_data_type   Data type
 752  * @param[in]  ul_did        Data ID
 753  * @param[in]  us_pno        Destination PNO
 754  * @param[in]  p_data        Write data pointer
 755  * @param[in]  us_size       Write data size
 756  * @param[in]  uc_result     Reception result
 757  */
 758 void SensLogWriteOutputData(uint16_t us_data_type, DID ul_did, PNO us_pno, uint8_t *p_data, \
 759         uint16_t us_size, uint8_t uc_result) {
 760     uint16_t                file_type = 0;
 761     uint16_t                data_type = us_data_type;
 762     uint16_t                write_type = POS_SENSLOG_TYPE_NONE;
 763     RET_API                 lret_sem = RET_ERROR;
 764
 765     /* Sensor log file type determination */
 766     file_type = SensLogGetFileType(kSensLogOutputTbl, &data_type, &write_type, ul_did);
 767
 768     /* For the target type,Perform exclusive control */
 769     /* Currently, only GPS output can be written from multiple threads. */
 770     if (file_type == SENSLOG_TYPE_GPS_OUTPUT) {
 771         /* Semaphore ID determination */
 772         if (g_sem_id != 0) {  // LCOV_EXCL_BR_LINE 200: can not zero
 773             lret_sem = _pb_SemLock(g_sem_id);  /* Semaphore Lock */
 774             if (lret_sem != RET_NORMAL) {  // LCOV_EXCL_BR_LINE 200: can not return error
 775                 // LCOV_EXCL_START 8: invalid
 776                 AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 777                 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "SemLock Error.");
 778                 // LCOV_EXCL_STOP
 779             } else {
 780                 /* Sensor log output */
 781                 SensLogWrite(file_type, data_type, write_type, ul_did, us_pno, p_data, \
 782                     us_size, uc_result, SENSLOG_ON, SENSLOG_OFF);
 783                 (void)_pb_SemUnlock(g_sem_id);  /* Semaphore unlock */
 784             }
 785         }
 786     } else {
 787         /* Sensor log output */
 788         SensLogWrite(file_type, data_type, write_type, ul_did, us_pno, p_data, us_size, \
 789             uc_result, SENSLOG_ON, SENSLOG_OFF);
 790     }
 791     return;
 792 }
 793
 794 /**
 795  * @brief
 796  *   Convert number to ASCII code(For two digits,Fill up to zero)
 797  *
 798  * @param[out] buf   Data saving
 799  * @param[in]  num   Numbers to be converted
 800  */
 801 static void Num2String2Digit(uint8_t* buf, uint32_t num) {
 802     int8_t c;
 803     if (num >= 100) {  // LCOV_EXCL_BR_LINE 200: can not exceed  size
 804         // LCOV_EXCL_START 8: invalid
 805         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 806         *buf++ = '0';
 807         *buf = '0';
 808         // LCOV_EXCL_STOP
 809     } else {
 810         c = static_cast<int8_t>(num / 10);
 811         *buf++ = static_cast<uint8_t>(c + '0');
 812         *buf = static_cast<uint8_t>(num - (c * 10) + '0');
 813     }
 814 }
 815
 816 /**
 817  * @brief
 818  *   Convert number to ASCII code(For 3 digits,Fill up to zero)
 819  *
 820  * @param[out] buf   Data saving
 821  * @param[in]  num   Numbers to be converted
 822  */
 823 static void Num2String3Digit(uint8_t* buf, uint32_t num) {
 824     int8_t c;
 825     if (num >= 1000) {  // LCOV_EXCL_BR_LINE 200: can not exceed  size
 826         // LCOV_EXCL_START 8: invalid
 827         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 828         *buf++ = '0';
 829         *buf++ = '0';
 830         *buf = '0';
 831         // LCOV_EXCL_STOP
 832     } else {
 833         c = static_cast<int8_t>(num / 100);
 834         *buf++ = static_cast<uint8_t>(c + '0');
 835         num = num - (c * 100);
 836         c = static_cast<int8_t>(num / 10);
 837         *buf++ = static_cast<uint8_t>(c + '0');
 838         *buf = static_cast<uint8_t>(num - (c * 10) + '0');
 839     }
 840 }
 841
 842 /**
 843  * @brief
 844  *   Convert number to ASCII code(For 4 digits,Fill up to zero)
 845  *
 846  * @param[out] buf   Data saving
 847  * @param[in]  num   Numbers to be converted
 848  */
 849 static void Num2String4Digit(uint8_t* buf, uint32_t num) {
 850     int8_t c;
 851     if (num >= 10000) {  // LCOV_EXCL_BR_LINE 200: can not exceed  size
 852         // LCOV_EXCL_START 8: invalid
 853         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 854         *buf++ = '0';
 855         *buf++ = '0';
 856         *buf++ = '0';
 857         *buf = '0';
 858         // LCOV_EXCL_STOP
 859     } else {
 860         c = static_cast<int8_t>(num / 1000);
 861         *buf++ = static_cast<uint8_t>(c + '0');
 862         num = num - (c * 1000);
 863         c = static_cast<int8_t>(num / 100);
 864         *buf++ = static_cast<uint8_t>(c + '0');
 865         num = num - (c * 100);
 866         c = static_cast<int8_t>(num / 10);
 867         *buf++ = static_cast<uint8_t>(c + '0');
 868         *buf = static_cast<uint8_t>(num - (c * 10) + '0');
 869     }
 870 }
 871
 872 /**
 873  * @brief
 874  *   Convert digits to hexadecimal ASCII code(Fill up to zero)
 875  *
 876  * @param[out] buf    Data saving
 877  * @param[in]  Number of digits to be converted to digits
 878  * @param[in]  num    Numbers to be converted
 879  */
 880 static void Num2HexString(uint8_t* buf, uint8_t digits, uint32_t num) {
 881     uint8_t* p = buf + digits;
 882     uint8_t calc;
 883     int32_t i;
 884
 885     /* Only within the displayable range,Convert  */
 886     if ((digits == 8) || (num <  (uint32_t)(1 << (4 *digits)))) {
 887         while (num) {
 888             calc = num % 16;
 889             if (10 > calc) {
 890                 calc = static_cast<uint8_t>(calc + 0x30);  // 0x30 is 0 character
 891             } else {
 892                 calc = static_cast<uint8_t>(calc + (0x61 - 0x0A));  // 0x41 is the letter of a
 893             }
 894             *(--p) = calc;
 895             num /= 16;
 896             digits--;
 897         }
 898     }
 899
 900     /* Insert 0 in the remaining significant digits.  */
 901     for (i = 0; i < digits; i++) {
 902         *(--p) = '0';
 903     }
 904 }
 905
 906 /**
 907  * @brief
 908  *   Sensor Log Header Creation
 909  *
 910  * @param[out] buf        Data saving
 911  * @param[in]  DataHeader data headers
 912  * @note For buf, Up to 62 bytes are used. As 64 bytes are allocated in the upper digit, Without current problems, dataHeader.c_pname size increase,
 913  *  Need to be reviewed when changing the format.
 914  */
 915 static void SensLogmakeHeader(uint8_t* buf, SENSLOG_DATA_HEADER dataHeader) {
 916     /* "%02d %04d/%02d/%02d %02d:%02d:%02d.%03d %08x %s %01x %01x %04d " */
 917     int8_t *p;
 918     uint16_t i = 0;
 919     Num2String2Digit(buf, dataHeader.us_data_type);
 920     buf += 2;
 921     *(buf++) = ' ';
 922     Num2String4Digit(buf, dataHeader.st_sys_time.us_year);
 923     buf += 4;
 924     *(buf++) = '/';
 925     Num2String2Digit(buf, dataHeader.st_sys_time.us_month);
 926     buf += 2;
 927     *(buf++) = '/';
 928     Num2String2Digit(buf, dataHeader.st_sys_time.us_day);
 929     buf += 2;
 930     *(buf++) = ' ';
 931     Num2String2Digit(buf, dataHeader.st_sys_time.us_hour);
 932     buf += 2;
 933     *(buf++) = ':';
 934     Num2String2Digit(buf, dataHeader.st_sys_time.us_minute);
 935     buf += 2;
 936     *(buf++) = ':';
 937     Num2String2Digit(buf, dataHeader.st_sys_time.us_second);
 938     buf += 2;
 939     *(buf++) = '.';
 940     Num2String3Digit(buf, dataHeader.st_sys_time.us_milli_seconds);
 941     buf += 3;
 942     *(buf++) = ' ';
 943     Num2HexString(buf, 8, dataHeader.ul_did);
 944     buf += 8;
 945     *(buf++) = ' ';
 946     p = dataHeader.c_pname;
 947     for (i = 0; i < sizeof(dataHeader.c_pname); i++) {
 948         if (*p == 0) {
 949             break;
 950         }
 951         *(buf++) = *(p++);
 952     }
 953     *(buf++) = ' ';
 954     Num2HexString((buf++), 1, dataHeader.uc_unit_type);
 955     *(buf++) = ' ';
 956     Num2HexString((buf++), 1, dataHeader.uc_result);
 957     *(buf++) = ' ';
 958     Num2String4Digit(buf, dataHeader.us_data_size);
 959     buf += 4;
 960     *(buf++) = ' ';
 961
 962     return;
 963 }
 964
 965 /**
 966  * @brief
 967  *   Sensor log output
 968  *
 969  *   Write specified log to buffer area(Common process)
 970  *
 971  * @param[in]  us_file_type   File type
 972  * @param[in]  us_data_type   Data type
 973  * @param[in]  us_write_type  FRAMEWORKUNIFIEDLOG Output Type
 974  * @param[in]  ul_did        Data ID
 975  * @param[in]  us_pno        Destination PNO
 976  * @param[in]  p_data        Write data pointer
 977  * @param[in]  us_size       Write data size
 978  * @param[in]  uc_result     Reception result
 979  * @param[in]  uWriteFlag   ability to write sensor log
 980  * @param[in]  u_write_abnormal_flag   When an error occursability to write sensor log
 981  */
 982 static void SensLogWrite(uint16_t us_file_type, uint16_t us_data_type, uint16_t us_write_type, \
 983         DID ul_did, PNO us_pno, uint8_t *p_data, uint16_t us_size, uint8_t uc_result, uint8_t uWriteFlag, \
 984         uint8_t u_write_abnormal_flag) {
 985     uint32_t                len = 0;
 986     SENSLOG_DATA_HEADER     dataHeader;
 987     uint16_t                headSize = sizeof(SENSLOG_DATA_HEADER);
 988     uint16_t                i = 0;
 989     uint8_t                 workBuf[64];
 990     uint16_t                workBufLen = 0;
 991     PCSTR                   pPname = NULL;
 992     uint32_t                ulTempBufLen;
 993     uint32_t                ulPositioninglogBufLen = SENSLOG_BUF_MAX;
 994     uint32_t                retComp;
 995
 996     if ((p_data == NULL) || (us_size == 0) || (us_size > SENSLOG_BUF_MIN)) {  // LCOV_EXCL_BR_LINE 200: can not NULL
 997         /* Unprocessed if write specified log data is invalid */
 998         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
 999                                           "Parameter Error. File[%d] Data[%d] DID[%d] Size[%d]",
1000                                           us_file_type, us_data_type, ul_did, us_size);
1001     } else {
1002         /* Sensor log file type determination */
1003         if (us_file_type < SENSLOG_TYPE_COUNT) {
1004             if ((g_sens_log_info[us_file_type].uc_valid_flag == SENSLOG_VALIDFLAG_ON) ||
1005                 (us_write_type != POS_SENSLOG_TYPE_NONE)) {
1006                 /* Setting of header information */
1007                 memset(&dataHeader, 0x00, sizeof(dataHeader));
1008                 dataHeader.us_data_type = us_data_type;
1009                 SensLogGetSystemTime(&dataHeader.st_sys_time);
1010                 dataHeader.ul_did = ul_did;
1011                 pPname = _pb_CnvPno2Name(us_pno);
1012                 if (pPname == NULL) {
1013                     dataHeader.c_pname[0] = '-';
1014                 } else {
1015                     snprintf(reinterpret_cast<char *>(&(dataHeader.c_pname[0])), \
1016                         sizeof(dataHeader.c_pname), "%s", pPname);
1017                 }
1018                 dataHeader.uc_unit_type = (uint8_t)g_unit_type;
1019                 dataHeader.uc_result = uc_result;
1020                 dataHeader.us_data_size = us_size;
1021
1022                 /* Buffer storage(Header)*/
1023                 memset(&workBuf[0], 0x00, sizeof(workBuf));
1024                 SensLogmakeHeader(workBuf, dataHeader);
1025                 workBufLen = static_cast<uint16_t>(strlen(reinterpret_cast<char *>(&(workBuf[0]))));
1026                 memcpy(reinterpret_cast<char *>(&(g_sens_log_info[us_file_type].uc_temp_buf[0])), \
1027                     &workBuf[0], workBufLen);
1028
1029                 /* Buffer storage(Data portion)*/
1030                 for (i = 0; i < us_size; i++) {
1031                     Num2HexString(&(g_sens_log_info[us_file_type].uc_temp_buf[workBufLen + i * 3]), 2, *p_data);
1032                     g_sens_log_info[us_file_type].uc_temp_buf[workBufLen + i * 3 + 2] = ' ';
1033                     g_sens_log_info[us_file_type].uc_temp_buf[workBufLen + i * 3 + 3] = 0; /* NULL */
1034                     p_data++;
1035                 }
1036                 g_sens_log_info[us_file_type].uc_temp_buf[workBufLen + (us_size * 3)]     = '\r';
1037                 g_sens_log_info[us_file_type].uc_temp_buf[workBufLen + (us_size * 3) + 1] = '\n';
1038                 ulTempBufLen = workBufLen + (us_size * 3) + 2;
1039
1040                 /* FRAMEWORKUNIFIEDLOG out */
1041                 if ((us_file_type == SENSLOG_TYPE_NAVI_INPUT) || (us_file_type == SENSLOG_TYPE_NAVI_OUTPUT)) {
1042                     if (g_unit_type != UNIT_TYPE_GRADE1) {
1043                         /* Sensor log is not output when an error occurs except for _CWORD80_ in NAV. */
1044                         u_write_abnormal_flag = 0;
1045                     }
1046                 }
1047                 if ((us_write_type != POS_SENSLOG_TYPE_NONE) && (u_write_abnormal_flag == SENSLOG_ON)) {
1048                     /* Data compression */
1049                     retComp = compress2(reinterpret_cast<Bytef*>(&(g_sens_log_info[us_file_type]. \
1050                                         uc_positioninglog_buf[SENSLOG_SEQ_SIZE + sizeof(ulPositioninglogBufLen)])), \
1051                                         reinterpret_cast<uLongf*>(&ulPositioninglogBufLen), \
1052                                         reinterpret_cast<Bytef*>(&(g_sens_log_info[us_file_type].uc_temp_buf[0])), \
1053                                         ulTempBufLen, Z_DEFAULT_COMPRESSION);
1054
1055                     if (retComp == Z_OK) {
1056                         memcpy(&(g_sens_log_info[us_file_type].uc_positioninglog_buf[0]), \
1057                                 SENSLOG_SEQ_START, SENSLOG_SEQ_SIZE);
1058                         memcpy(&(g_sens_log_info[us_file_type].uc_positioninglog_buf[SENSLOG_SEQ_SIZE]), \
1059                             &ulPositioninglogBufLen, sizeof(ulPositioninglogBufLen));
1060                         memcpy(&(g_sens_log_info[us_file_type].uc_positioninglog_buf[SENSLOG_SEQ_SIZE \
1061                             + sizeof(ulPositioninglogBufLen) + ulPositioninglogBufLen]), SENSLOG_SEQ_END, SENSLOG_SEQ_SIZE);
1062                         g_sens_log_info[us_file_type].uc_positioninglog_buf[SENSLOG_SEQ_SIZE + sizeof(ulPositioninglogBufLen) \
1063                             + ulPositioninglogBufLen + SENSLOG_SEQ_SIZE] = '\n';
1064                         ulPositioninglogBufLen = static_cast<uint32_t>(SENSLOG_SEQ_SIZE + sizeof(ulPositioninglogBufLen) \
1065                             + ulPositioninglogBufLen + SENSLOG_SEQ_SIZE + 1);
1066                         POS_SENSLOG(us_write_type, (PCSTR)&(g_sens_log_info[us_file_type].uc_positioninglog_buf[0]), \
1067                             ulPositioninglogBufLen);
1068                     } else {
1069                         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, \
1070                             "compress error[retComp = %d]", retComp);
1071                     }
1072                 }
1073
1074                 if ((g_sens_log_info[us_file_type].uc_valid_flag == SENSLOG_VALIDFLAG_ON) \
1075                         && (uWriteFlag == SENSLOG_ON)) {
1076                     /* For executing file output */
1077                     /* Buffer size determination */
1078                     len = g_sens_log_info[us_file_type].ul_text_buf_len;
1079                     if (g_sens_log_info[us_file_type].ul_text_buf_size <= (len + ((headSize + us_size) * 3))) {
1080                         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "[%d]:DataSize[%d]/BufLen[%d]",
1081                                                           us_data_type, us_size, len);
1082
1083                         /* In case of buffer upper limit,Write File */
1084                         SensLogOutputFile(static_cast<uint8_t>(us_file_type));
1085
1086                         /* Buffer clear */
1087                         memset(&(g_sens_log_info[us_file_type].uc_text_buf[0]), 0x00,
1088                             g_sens_log_info[us_file_type].ul_text_buf_size);
1089                         len = 0;
1090                     }
1091
1092                     /* Buffer storage */
1093                     memcpy(reinterpret_cast<char*>(&(g_sens_log_info[us_file_type].uc_text_buf[len])), \
1094                         &g_sens_log_info[us_file_type].uc_temp_buf[0], ulTempBufLen);
1095                     g_sens_log_info[us_file_type].ul_text_buf_len = len + ulTempBufLen;
1096                     g_sens_log_info[us_file_type].us_rec_count++;
1097
1098                     /* Determining whether the number of file write records is the upper limit (the number of records per file) */
1099                     if (g_sens_log_info[us_file_type].st_gen.us_len <= g_sens_log_info[us_file_type].us_rec_count) {
1100                         FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "[%d]:RecCnt[%d/%d]",
1101                             us_data_type, g_sens_log_info[us_file_type].us_rec_count, \
1102                             g_sens_log_info[us_file_type].st_gen.us_len);
1103
1104                         /* In case of buffer upper limit,Write File */
1105                         SensLogOutputFile(static_cast<uint8_t>(us_file_type));
1106
1107                         /* Buffer clear */
1108                         memset(&(g_sens_log_info[us_file_type].uc_text_buf[0]), 0x00, \
1109                             g_sens_log_info[us_file_type].ul_text_buf_size);
1110                         g_sens_log_info[us_file_type].ul_text_buf_len = 0;
1111                         g_sens_log_info[us_file_type].us_rec_count = 0;
1112                         /* Update the number of generations */
1113                         g_sens_log_info[us_file_type].us_gen_count++;
1114                         if (g_sens_log_info[us_file_type].st_gen.uc_gen < g_sens_log_info[us_file_type].us_gen_count) {
1115                             g_sens_log_info[us_file_type].us_gen_count = 1;
1116                         }
1117                         g_sens_log_info[us_file_type].uc_output_flag = SENSLOG_OUTPUTFLAG_NEW;
1118                     }
1119                 }
1120             }
1121         }
1122     }
1123
1124     return;
1125 }
1126
1127 /**
1128  * @brief
1129  *   Sensor log file type determination
1130  *
1131  *   Determine the type of the output destination sensor log file
1132  *
1133  * @param[in]   pstTbl       Sensor log type definition table
1134  * @param[in]   Pus_data_type Data type
1135  * @param[out]  pus_write_type FRAMEWORKUNIFIEDLOG Output Type
1136  * @param[in]   ul_did        Data ID
1137  *
1138  * @return Destination sensor log file type
1139  */
1140 static uint16_t SensLogGetFileType(const SENSLOG_ID_TBL *pstTbl, uint16_t *pus_data_type, \
1141         uint16_t *pus_write_type, DID ul_did) {
1142     uint16_t        file_type = SENSLOG_TYPE_COUNT;
1143     uint16_t        cnt = 0;
1144
1145     /* Determination of output log file type */
1146     /* DID,Prioritize the beginning of the table for both data types. */
1147     /* If DID is specified, it is judged by DID.*/
1148     if (ul_did != 0) {
1149         for (cnt = 0; pstTbl[cnt].us_file_type != SENSLOG_TYPE_COUNT; cnt++) {
1150             if (pstTbl[cnt].ul_did == ul_did) {
1151                 *pus_data_type = pstTbl[cnt].us_data_type;
1152                 file_type = pstTbl[cnt].us_file_type;
1153                 *pus_write_type = pstTbl[cnt].us_write_type;
1154                 break;
1155             }
1156         }
1157     }
1158     /* If no DID is specified or cannot be found, judge according to the data type. */
1159     if (file_type == SENSLOG_TYPE_COUNT) {
1160         for (cnt = 0; pstTbl[cnt].us_file_type != SENSLOG_TYPE_COUNT; cnt++) {
1161             if (pstTbl[cnt].us_data_type == *pus_data_type) {
1162                 file_type = pstTbl[cnt].us_file_type;
1163                 *pus_write_type = pstTbl[cnt].us_write_type;
1164                 break;
1165             }
1166         }
1167     }
1168     return file_type;
1169 }
1170
1171 /**
1172  * @brief
1173  *   Sensor log file output
1174  *
1175  *   Write the log data in the buffer area to a file
1176  *
1177  * @param[in]  ucFileType   File type
1178  */
1179 static void SensLogOutputFile(uint8_t ucFileType) {
1180     FILE    *fp;
1181     int     fd;
1182     uint8_t  uc_file_name_base[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
1183     uint8_t  uc_file_name[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
1184
1185     if (ucFileType < SENSLOG_TYPE_COUNT) {  // LCOV_EXCL_BR_LINE 200: can not exceed  type
1186         /* File path generation */
1187         snprintf(reinterpret_cast<char*>(&uc_file_name_base[0]), sizeof(uc_file_name_base),
1188                   "%s%s",
1189                   g_sens_log_info[ucFileType].uc_file_path, g_sens_log_info[ucFileType].uc_file_name);
1190         snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name),
1191                   reinterpret_cast<char*>(&uc_file_name_base[0]),
1192                   g_sens_log_info[ucFileType].us_gen_count);
1193
1194         /* Writing to a File */
1195         if (g_sens_log_info[ucFileType].uc_output_flag == SENSLOG_OUTPUTFLAG_NEW) {
1196             FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, \
1197                 "SensLog create file. : file[%s] : uc_output_flag[%d]", \
1198                 uc_file_name, g_sens_log_info[ucFileType].uc_output_flag);
1199
1200             /* Export New File(Write From Beginning)*/
1201             fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "w+");
1202             g_sens_log_info[ucFileType].uc_output_flag = SENSLOG_OUTPUTFLAG_ADD;
1203
1204             /* Update generation information file */
1205             SensLogOutputGenFile(ucFileType);
1206         } else {
1207             /* Append export */
1208             fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "a+");
1209         }
1210
1211         if (NULL != fp) {  // LCOV_EXCL_BR_LINE 200: can not NULL
1212             /* Log file output(ASCII)*/
1213             fd = fileno(fp);
1214             fwrite(&(g_sens_log_info[ucFileType].uc_text_buf[0]), g_sens_log_info[ucFileType].ul_text_buf_len, 1, fp);
1215             fflush(fp);    /* Flush the userspace buffers provided by the C library  */
1216             fdatasync(fd); /* Flush cache of files referenced by fd to disk */
1217             fclose(fp); /* Coverity CID:23371 compliant */
1218         } else {
1219             // LCOV_EXCL_START 8: invalid
1220             AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1221             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \
1222                 "SensLog fopen fail. : file[%s] : uc_output_flag[%d]", \
1223                 uc_file_name, g_sens_log_info[ucFileType].uc_output_flag);
1224             // LCOV_EXCL_STOP
1225         }
1226     }
1227     return;
1228 }
1229
1230 /**
1231  * @brief
1232  *   Generation information file output
1233  *
1234  *   Holds the number of generations being output in the generation information file.
1235  *
1236  * @param[in]  ucFileType   File type
1237  */
1238 static void SensLogOutputGenFile(uint8_t ucFileType) {
1239     FILE     *fp;
1240     int      fd;
1241     uint8_t  uc_file_name_base[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
1242     uint8_t  uc_file_name[SENSLOG_FILEPATH_SIZE + SENSLOG_FILENAME_SIZE];
1243
1244     if (ucFileType < SENSLOG_TYPE_COUNT) {  // LCOV_EXCL_BR_LINE 200: can not exceed  type
1245         /* File path generation */
1246         snprintf(reinterpret_cast<char*>(&uc_file_name_base[0]), sizeof(uc_file_name_base),
1247                   "%s%s",
1248                   g_sens_log_info[ucFileType].uc_file_path, g_sens_log_info[ucFileType].uc_gen_fname);
1249         snprintf(reinterpret_cast<char*>(&uc_file_name[0]), sizeof(uc_file_name),
1250                   reinterpret_cast<char*>(&uc_file_name_base[0]),
1251                   g_sens_log_info[ucFileType].us_gen_count);
1252
1253         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SensLog create file. : file[%s] : us_gen_count[%d]",
1254                       uc_file_name, g_sens_log_info[ucFileType].us_gen_count);
1255
1256         /* Export New File(Write From Beginning)*/
1257         fp = fopen(reinterpret_cast<char*>(&uc_file_name[0]), "w+");
1258         if (NULL != fp) {  // LCOV_EXCL_BR_LINE 200: can not NULL
1259             /* Generation control number output */
1260             fd = fileno(fp);
1261             fprintf(fp, "%03d", g_sens_log_info[ucFileType].us_gen_count);
1262             fflush(fp);    /* Flush the userspace buffers provided by the C library  */
1263             fdatasync(fd); /* Flush cache of files referenced by fd to disk */
1264             fclose(fp); /* Coverity CID:23372 compliant */
1265         } else {
1266             // LCOV_EXCL_START 8: invalid
1267             AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1268             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \
1269                 "SensLog fopen fail. : file[%s] : us_gen_count[%d]", \
1270                 uc_file_name, g_sens_log_info[ucFileType].us_gen_count);
1271             // LCOV_EXCL_STOP
1272         }
1273     }
1274     return;
1275 }
1276
1277 /**
1278  * @brief
1279  *   Get system time
1280  *
1281  *   Get the system time(Millisecond)
1282  *
1283  * @param[out] st_sys_time    System time
1284  */
1285 void SensLogGetSystemTime(SENSLOG_SYSTEMTIME *st_sys_time) {
1286     time_t time_sec = 0;
1287     struct timespec tp = {0};
1288     struct tm time_cal= {0};
1289
1290     if (NULL != st_sys_time) {  // LCOV_EXCL_BR_LINE 200: not NULL
1291         if (0 == clock_gettime(CLOCK_REALTIME, &tp)) {
1292             time_sec = tp.tv_sec;
1293             localtime_r(&time_sec, &time_cal);
1294             st_sys_time->us_year = static_cast<uint16_t>((WORD)time_cal.tm_year + 1900);
1295             st_sys_time->us_month = static_cast<uint16_t>((WORD)time_cal.tm_mon + 1);
1296             st_sys_time->us_day_of_week    = (WORD)time_cal.tm_wday;
1297             st_sys_time->us_day          = (WORD)time_cal.tm_mday;
1298             st_sys_time->us_hour         = (WORD)time_cal.tm_hour;
1299             st_sys_time->us_minute       = (WORD)time_cal.tm_min;
1300             st_sys_time->us_second       = (WORD)time_cal.tm_sec;
1301             st_sys_time->us_milli_seconds = (WORD)(static_cast<double>(tp.tv_nsec) * 1e-6); /* Calculating milliseconds */
1302         }
1303     }
1304     return;
1305 }
1306
1307 /* end of file */