LCOV - code coverage report
Current view: top level - message/msg_gps.c (source / functions) Coverage Total Hit
Test: coverage-filtered.info Lines: 91.6 % 119 109
Test Date: 2026-04-29 08:47:32 Functions: 100.0 % 10 10
Branches: 86.1 % 72 62
MC/DC: 86.1 % 72 62

             Branch data      MC/DC data    Line data    Source code
       1                 :              :             : #include <stdbool.h>
       2                 :              :             : #include <stdint.h>
       3                 :              :             : 
       4                 :              :             : #include "common.h"
       5                 :              :             : 
       6                 :              :             : #include "can.h"
       7                 :              :             : #include "message_types.h"
       8                 :              :             : #include "msg_common.h"
       9                 :              :             : #include "msg_gps.h"
      10                 :              :             : 
      11                 :              :           2 : void build_gps_time_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t utc_hours,
      12                 :              :             :                                                 uint8_t utc_mins, uint8_t utc_secs, uint8_t utc_dsecs, can_msg_t *output) {
      13         [ +  + ]:      [ T  F ]:           2 :         w_assert(output);
      14                 :              :             : 
      15                 :              :           1 :         output->sid = build_sid(prio, MSG_GPS_TIMESTAMP, 0);
      16                 :              :           1 :         write_timestamp(timestamp, output);
      17                 :              :             : 
      18                 :              :           1 :         output->data[2] = utc_hours;
      19                 :              :           1 :         output->data[3] = utc_mins;
      20                 :              :           1 :         output->data[4] = utc_secs;
      21                 :              :           1 :         output->data[5] = utc_dsecs;
      22                 :              :             : 
      23                 :              :           1 :         output->data_len = 6;
      24                 :              :           1 : }
      25                 :              :             : 
      26                 :              :           2 : void build_gps_lat_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t degrees, uint8_t minutes,
      27                 :              :             :                                            uint16_t dminutes, uint8_t direction, can_msg_t *output) {
      28         [ +  + ]:      [ T  F ]:           2 :         w_assert(output);
      29                 :              :             : 
      30                 :              :           1 :         output->sid = build_sid(prio, MSG_GPS_LATITUDE, 0);
      31                 :              :           1 :         write_timestamp(timestamp, output);
      32                 :              :             : 
      33                 :              :           1 :         output->data[2] = degrees;
      34                 :              :           1 :         output->data[3] = minutes;
      35                 :              :           1 :         output->data[4] = dminutes >> 8;
      36                 :              :           1 :         output->data[5] = dminutes & 0xFF;
      37                 :              :           1 :         output->data[6] = direction;
      38                 :              :             : 
      39                 :              :           1 :         output->data_len = 7;
      40                 :              :           1 : }
      41                 :              :             : 
      42                 :              :           2 : void build_gps_lon_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t degrees, uint8_t minutes,
      43                 :              :             :                                            uint16_t dminutes, uint8_t direction, can_msg_t *output) {
      44         [ +  + ]:      [ T  F ]:           2 :         w_assert(output);
      45                 :              :             : 
      46                 :              :           1 :         output->sid = build_sid(prio, MSG_GPS_LONGITUDE, 0);
      47                 :              :           1 :         write_timestamp(timestamp, output);
      48                 :              :             : 
      49                 :              :           1 :         output->data[2] = degrees;
      50                 :              :           1 :         output->data[3] = minutes;
      51                 :              :           1 :         output->data[4] = dminutes >> 8;
      52                 :              :           1 :         output->data[5] = dminutes & 0xFF;
      53                 :              :           1 :         output->data[6] = direction;
      54                 :              :             : 
      55                 :              :           1 :         output->data_len = 7;
      56                 :              :           1 : }
      57                 :              :             : 
      58                 :              :           2 : void build_gps_alt_msg(can_msg_prio_t prio, uint16_t timestamp, uint32_t altitude,
      59                 :              :             :                                            uint8_t daltitude, can_msg_t *output) {
      60         [ +  + ]:      [ T  F ]:           2 :         w_assert(output);
      61                 :              :             : 
      62                 :              :           1 :         output->sid = build_sid(prio, MSG_GPS_ALTITUDE, 0);
      63                 :              :           1 :         write_timestamp(timestamp, output);
      64                 :              :             : 
      65                 :              :           1 :         output->data[2] = (altitude >> 24) & 0xff;
      66                 :              :           1 :         output->data[3] = (altitude >> 16) & 0xff;
      67                 :              :           1 :         output->data[4] = (altitude >> 8) & 0xff;
      68                 :              :           1 :         output->data[5] = altitude;
      69                 :              :           1 :         output->data[6] = daltitude;
      70                 :              :             : 
      71                 :              :           1 :         output->data_len = 7;
      72                 :              :           1 : }
      73                 :              :             : 
      74                 :              :           2 : void build_gps_info_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t num_sat, uint8_t quality,
      75                 :              :             :                                                 can_msg_t *output) {
      76         [ +  + ]:      [ T  F ]:           2 :         w_assert(output);
      77                 :              :             : 
      78                 :              :           1 :         output->sid = build_sid(prio, MSG_GPS_INFO, 0);
      79                 :              :           1 :         write_timestamp(timestamp, output);
      80                 :              :             : 
      81                 :              :           1 :         output->data[2] = num_sat;
      82                 :              :           1 :         output->data[3] = quality;
      83                 :              :             : 
      84                 :              :           1 :         output->data_len = 4;
      85                 :              :           1 : }
      86                 :              :             : 
      87                 :              :           7 : w_status_t get_gps_time(const can_msg_t *msg, uint8_t *utc_hours, uint8_t *utc_mins,
      88                 :              :             :                                                 uint8_t *utc_secs, uint8_t *utc_dsecs) {
      89         [ +  + ]:      [ T  F ]:           7 :         w_assert(msg);
      90         [ +  + ]:      [ T  F ]:           5 :         w_assert(utc_hours);
      91         [ +  + ]:      [ T  F ]:           4 :         w_assert(utc_mins);
      92         [ +  + ]:      [ T  F ]:           3 :         w_assert(utc_secs);
      93         [ +  + ]:      [ T  F ]:           2 :         w_assert(utc_dsecs);
      94                 :              :             : 
      95                 :              :           1 :         *utc_hours = msg->data[2];
      96                 :              :           1 :         *utc_mins = msg->data[3];
      97                 :              :           1 :         *utc_secs = msg->data[4];
      98                 :              :           1 :         *utc_dsecs = msg->data[5];
      99                 :              :             : 
     100         [ -  + ]:      [ t  F ]:           1 :         if (get_message_type(msg) != MSG_GPS_TIMESTAMP) {
     101                 :              :           0 :                 return W_INVALID_PARAM;
     102                 :              :             :         }
     103                 :              :             : 
     104         [ -  + ]:      [ t  F ]:           1 :         if (msg->data_len != 6) {
     105                 :              :           0 :                 return W_DATA_FORMAT_ERROR;
     106                 :              :             :         }
     107                 :              :             : 
     108                 :              :           1 :         return W_SUCCESS;
     109                 :              :             : }
     110                 :              :             : 
     111                 :              :           7 : w_status_t get_gps_lat(const can_msg_t *msg, uint8_t *degrees, uint8_t *minutes, uint16_t *dminutes,
     112                 :              :             :                                            uint8_t *direction) {
     113         [ +  + ]:      [ T  F ]:           7 :         w_assert(msg);
     114         [ +  + ]:      [ T  F ]:           5 :         w_assert(degrees);
     115         [ +  + ]:      [ T  F ]:           4 :         w_assert(minutes);
     116         [ +  + ]:      [ T  F ]:           3 :         w_assert(dminutes);
     117         [ +  + ]:      [ T  F ]:           2 :         w_assert(direction);
     118                 :              :             : 
     119                 :              :           1 :         *degrees = msg->data[2];
     120                 :              :           1 :         *minutes = msg->data[3];
     121                 :              :           1 :         *dminutes = ((uint16_t)msg->data[4] << 8) | msg->data[5];
     122                 :              :           1 :         *direction = msg->data[6];
     123                 :              :             : 
     124         [ -  + ]:      [ t  F ]:           1 :         if (get_message_type(msg) != MSG_GPS_LATITUDE) {
     125                 :              :           0 :                 return W_INVALID_PARAM;
     126                 :              :             :         }
     127                 :              :             : 
     128         [ -  + ]:      [ t  F ]:           1 :         if (msg->data_len != 7) {
     129                 :              :           0 :                 return W_DATA_FORMAT_ERROR;
     130                 :              :             :         }
     131                 :              :             : 
     132                 :              :           1 :         return W_SUCCESS;
     133                 :              :             : }
     134                 :              :             : 
     135                 :              :           7 : w_status_t get_gps_lon(const can_msg_t *msg, uint8_t *degrees, uint8_t *minutes, uint16_t *dminutes,
     136                 :              :             :                                            uint8_t *direction) {
     137         [ +  + ]:      [ T  F ]:           7 :         w_assert(msg);
     138         [ +  + ]:      [ T  F ]:           5 :         w_assert(degrees);
     139         [ +  + ]:      [ T  F ]:           4 :         w_assert(minutes);
     140         [ +  + ]:      [ T  F ]:           3 :         w_assert(dminutes);
     141         [ +  + ]:      [ T  F ]:           2 :         w_assert(direction);
     142                 :              :             : 
     143                 :              :           1 :         *degrees = msg->data[2];
     144                 :              :           1 :         *minutes = msg->data[3];
     145                 :              :           1 :         *dminutes = ((uint16_t)msg->data[4] << 8) | msg->data[5];
     146                 :              :           1 :         *direction = msg->data[6];
     147                 :              :             : 
     148         [ -  + ]:      [ t  F ]:           1 :         if (get_message_type(msg) != MSG_GPS_LONGITUDE) {
     149                 :              :           0 :                 return W_INVALID_PARAM;
     150                 :              :             :         }
     151                 :              :             : 
     152         [ -  + ]:      [ t  F ]:           1 :         if (msg->data_len != 7) {
     153                 :              :           0 :                 return W_DATA_FORMAT_ERROR;
     154                 :              :             :         }
     155                 :              :             : 
     156                 :              :           1 :         return W_SUCCESS;
     157                 :              :             : }
     158                 :              :             : 
     159                 :              :           5 : w_status_t get_gps_alt(const can_msg_t *msg, uint32_t *altitude, uint8_t *daltitude) {
     160         [ +  + ]:      [ T  F ]:           5 :         w_assert(msg);
     161         [ +  + ]:      [ T  F ]:           3 :         w_assert(altitude);
     162         [ +  + ]:      [ T  F ]:           2 :         w_assert(daltitude);
     163                 :              :             : 
     164                 :              :           1 :         *altitude = ((uint32_t)msg->data[2] << 24) | ((uint32_t)msg->data[3] << 16) |
     165                 :              :           1 :                                 ((uint32_t)msg->data[4] << 8) | msg->data[5];
     166                 :              :           1 :         *daltitude = msg->data[6];
     167                 :              :             : 
     168         [ -  + ]:      [ t  F ]:           1 :         if (get_message_type(msg) != MSG_GPS_ALTITUDE) {
     169                 :              :           0 :                 return W_INVALID_PARAM;
     170                 :              :             :         }
     171                 :              :             : 
     172         [ -  + ]:      [ t  F ]:           1 :         if (msg->data_len != 7) {
     173                 :              :           0 :                 return W_DATA_FORMAT_ERROR;
     174                 :              :             :         }
     175                 :              :             : 
     176                 :              :           1 :         return W_SUCCESS;
     177                 :              :             : }
     178                 :              :             : 
     179                 :              :           5 : w_status_t get_gps_info(const can_msg_t *msg, uint8_t *num_sat, uint8_t *quality) {
     180         [ +  + ]:      [ T  F ]:           5 :         w_assert(msg);
     181         [ +  + ]:      [ T  F ]:           3 :         w_assert(num_sat);
     182         [ +  + ]:      [ T  F ]:           2 :         w_assert(quality);
     183                 :              :             : 
     184                 :              :           1 :         *num_sat = msg->data[2];
     185                 :              :           1 :         *quality = msg->data[3];
     186                 :              :             : 
     187         [ -  + ]:      [ t  F ]:           1 :         if (get_message_type(msg) != MSG_GPS_INFO) {
     188                 :              :           0 :                 return W_INVALID_PARAM;
     189                 :              :             :         }
     190                 :              :             : 
     191         [ -  + ]:      [ t  F ]:           1 :         if (msg->data_len != 4) {
     192                 :              :           0 :                 return W_DATA_FORMAT_ERROR;
     193                 :              :             :         }
     194                 :              :             : 
     195                 :              :           1 :         return W_SUCCESS;
     196                 :              :             : }
        

Generated by: LCOV version 2.0-1