spatem_ts_utils.h File Reference

Utility functions for the ETSI ITS SPATEM. More...

#include <ctime>

Go to the source code of this file.

Enumerations
enum	time_mark_value_interpretation { normal , undefined , over_an_hour , leap_second }

Functions
uint64_t	etsi_its_spatem_ts_msgs::access::getUnixSecondsOfYear (const uint64_t unixSecond)
	Get the unix seconds of the beginning of a year that corresponds to a given unix timestamp.
uint64_t	etsi_its_spatem_ts_msgs::access::getUnixNanosecondsFromMinuteOfTheYear (const MinuteOfTheYear &moy, const uint64_t unix_nanoseconds_estimate)
	Get the unix nanoseconds from MinuteOfTheYear object.
float	etsi_its_spatem_ts_msgs::access::interpretTimeIntervalConfidenceAsFloat (const uint16_t encoded_probability)
	Interprets the TimeIntervalConfidence type as a float value (see etsi definition).
std::array< float, 4 >	etsi_its_spatem_ts_msgs::access::interpretMovementPhaseStateAsColor (const uint8_t value)
	Interprets the MovementPhaseState type as a color (see etsi definition).
time_mark_value_interpretation	etsi_its_spatem_ts_msgs::access::interpretTimeMarkValueType (const uint16_t time)
	Interprets the type of a TimeMark message See etsi ASNI1 - IS TS 103 301 documentation for for the encoding of "TimeMark".
int64_t	etsi_its_spatem_ts_msgs::access::interpretTimeMarkDeltaTimeAsNanoSeconds (const uint16_t time, const uint64_t nanosec)
	Calculates the delta between a TimeMark and a given unix timestamp in nanoseconds.
float	etsi_its_spatem_ts_msgs::access::interpretTimeMarkDeltaTimeValueAsSeconds (const uint16_t time, const int32_t seconds, const uint32_t nanosec)
	Calculates the delta between a TimeMark and a given timestamp.
std::string	etsi_its_spatem_ts_msgs::access::parseTimeMarkValueToString (const uint16_t time, const int32_t seconds, const uint32_t nanosec)
	Converts a value from message type TimeMarkValue into a string representation.

Detailed Description

Utility functions for the ETSI ITS SPATEM.

Definition in file spatem_ts_utils.h.

Enumeration Type Documentation

time_mark_value_interpretation

enum etsi_its_spatem_ts_msgs::access::time_mark_value_interpretation

Definition at line 29 of file spatem_ts_utils.h.

{ normal, undefined, over_an_hour, leap_second };

Function Documentation

getUnixNanosecondsFromMinuteOfTheYear()

uint64_t etsi_its_spatem_ts_msgs::access::getUnixNanosecondsFromMinuteOfTheYear ( const MinuteOfTheYear & moy, const uint64_t unix_nanoseconds_estimate )

inline

Get the unix nanoseconds from MinuteOfTheYear object.

Parameters

moy	given MinuteOfTheYear object
unix_nanoseconds_estimate	unix timestamp to derive the current year from in nanoseconds

Returns

uint64_t unix timestamp according to the given MinuteOfTheYear in nanoseconds

Definition at line 61 of file spatem_ts_utils.h.

                                                                                                {
  return ((uint64_t)(moy.value * 60) + getUnixSecondsOfYear(unix_nanoseconds_estimate * 1e-9)) * 1e9;
}

getUnixSecondsOfYear()

uint64_t etsi_its_spatem_ts_msgs::access::getUnixSecondsOfYear ( const uint64_t unixSecond )

inline

Get the unix seconds of the beginning of a year that corresponds to a given unix timestamp.

Parameters

unixSecond

timestamp that defines the year for that the unix seconds for the beginning of the year should be derived

Returns

uint64_t unix seconds of the beginning of the year

Definition at line 37 of file spatem_ts_utils.h.

                                                                {
  // Get current time as a time_point
  time_t ts = static_cast<time_t>(unixSecond);  // Convert uint64_t to time_t
 
  struct tm* timeinfo;
  timeinfo = gmtime(&ts);
 
  // Set the timeinfo to the beginning of the year
  timeinfo->tm_sec = 0;
  timeinfo->tm_min = 0;
  timeinfo->tm_hour = 0;
  timeinfo->tm_mday = 1;
  timeinfo->tm_mon = 0;
 
  return timegm(timeinfo);  // Convert struct tm back to Unix timestamp
}

interpretMovementPhaseStateAsColor()

std::array< float, 4 > etsi_its_spatem_ts_msgs::access::interpretMovementPhaseStateAsColor ( const uint8_t value )

inline

Interprets the MovementPhaseState type as a color (see etsi definition).

Parameters

value

Encoded color value from msg type MovementPhaseState

Returns

4-dimensional array with color values as follows: r, g, b, a, each of these values within a range between [0, 1]

Definition at line 135 of file spatem_ts_utils.h.

                                                                                  {
  std::array<float, 4> color;
 
  switch (value) {
    case MovementPhaseState::UNAVAILABLE:
      color = COLOR_GREY;
      break;
 
    case MovementPhaseState::DARK:
      color = COLOR_GREY;
      break;
    case MovementPhaseState::STOP_THEN_PROCEED:
      color = COLOR_RED;
      break;
    case MovementPhaseState::STOP_AND_REMAIN:
      color = COLOR_RED;
      break;
    case MovementPhaseState::PRE_MOVEMENT:
      color = COLOR_ORANGE;
      break;
    case MovementPhaseState::PERMISSIVE_MOVEMENT_ALLOWED:
      color = COLOR_GREEN;
      break;
    case MovementPhaseState::PROTECTED_MOVEMENT_ALLOWED:
      color = COLOR_GREEN;
      break;
    case MovementPhaseState::PERMISSIVE_CLEARANCE:
      color = COLOR_ORANGE;
      break;
    case MovementPhaseState::PROTECTED_CLEARANCE:
      color = COLOR_ORANGE;
      break;
    case MovementPhaseState::CAUTION_CONFLICTING_TRAFFIC:
      color = COLOR_ORANGE;
      break;
    default:
      color = COLOR_GREY;
      break;
  }
 
  return color;
}

interpretTimeIntervalConfidenceAsFloat()

float etsi_its_spatem_ts_msgs::access::interpretTimeIntervalConfidenceAsFloat ( const uint16_t encoded_probability )

inline

Interprets the TimeIntervalConfidence type as a float value (see etsi definition).

Parameters

encoded_probability

Value from msg type TimeIntervalConfidence

Returns

confidence as float value [0, 1]

Definition at line 72 of file spatem_ts_utils.h.

                                                                                        {
  float probability = 0;
 
  switch (encoded_probability) {
    case 0:
      probability = 0.21;
      break;
    case 1:
      probability = 0.36;
      break;
    case 2:
      probability = 0.47;
      break;
    case 3:
      probability = 0.56;
      break;
    case 4:
      probability = 0.62;
      break;
    case 5:
      probability = 0.68;
      break;
    case 6:
      probability = 0.73;
      break;
    case 7:
      probability = 0.77;
      break;
    case 8:
      probability = 0.81;
      break;
    case 9:
      probability = 0.85;
      break;
    case 10:
      probability = 0.88;
      break;
    case 11:
      probability = 0.91;
      break;
    case 12:
      probability = 0.94;
      break;
    case 13:
      probability = 0.96;
      break;
    case 14:
      probability = 0.98;
      break;
    case 15:
      probability = 1.0;
      break;
  }
 
  return probability;
}

interpretTimeMarkDeltaTimeAsNanoSeconds()

int64_t etsi_its_spatem_ts_msgs::access::interpretTimeMarkDeltaTimeAsNanoSeconds ( const uint16_t time, const uint64_t nanosec )

inline

Calculates the delta between a TimeMark and a given unix timestamp in nanoseconds.

Parameters

time	TimeMark value since the start of the last full hour in 0.1 seconds
nanosec	Unix timestamp in nanoseconds

Returns

Delta time between the timestamp and the given TimeMark in nanoseconds

Definition at line 210 of file spatem_ts_utils.h.

                                                                                                    {
  // calculate elapsed nanoseconds since the start of the last full hour
  int64_t timestamp_hour_nanosec = ((nanosec) % (HOUR_IN_SECONDS * FACTOR_SECONDS_TO_NANOSECONDS));
  // convert TimeMark value to nanoseconds
  int64_t timemark_in_nanosec =
      static_cast<int64_t>(time) * FACTOR_ETSI_TIMEMARK_TO_SECONDS * FACTOR_SECONDS_TO_NANOSECONDS;
  // calculate relative time until the next change occurs
  int64_t rel_time_until_change = timemark_in_nanosec - timestamp_hour_nanosec;
 
  // adjust relative time if a jump to the next hour occurs (relative time should be inside the interval [0, 3600e9) )
  if (rel_time_until_change < 0) {
    rel_time_until_change += HOUR_IN_SECONDS * FACTOR_SECONDS_TO_NANOSECONDS;
  }
 
  return rel_time_until_change;
}

interpretTimeMarkDeltaTimeValueAsSeconds()

float etsi_its_spatem_ts_msgs::access::interpretTimeMarkDeltaTimeValueAsSeconds ( const uint16_t time, const int32_t seconds, const uint32_t nanosec )

inline

Calculates the delta between a TimeMark and a given timestamp.

Parameters

time	TimeMark value since the start of the last full hour in 0.1 seconds
seconds	seconds of current timestamp
nanosec	nanoseconds of current timestamp [0, 999999999]

Returns

Delta time between the timestamp and the given TimeMark in seconds

Definition at line 235 of file spatem_ts_utils.h.

                                                                              {
  uint64_t timestamp_in_nanoseconds = seconds * FACTOR_SECONDS_TO_NANOSECONDS + nanosec;
  return interpretTimeMarkDeltaTimeAsNanoSeconds(time, timestamp_in_nanoseconds) /
         static_cast<float>(FACTOR_SECONDS_TO_NANOSECONDS);
}

interpretTimeMarkValueType()

time_mark_value_interpretation etsi_its_spatem_ts_msgs::access::interpretTimeMarkValueType ( const uint16_t time )

inline

Interprets the type of a TimeMark message See etsi ASNI1 - IS TS 103 301 documentation for for the encoding of "TimeMark".

Parameters

time	The value inside the TimeMark message

Returns

Type as time_mark_value_interpretation

Definition at line 184 of file spatem_ts_utils.h.

                                                                                      {
  time_mark_value_interpretation type;
 
  if (time == 36001) {
    // value is undefined or unknown
    type = time_mark_value_interpretation::undefined;
  } else if (time == 36000) {
    // used to indicate time >3600 seconds
    type = time_mark_value_interpretation::over_an_hour;
  } else if (time >= 35991 && time <= 35999) {
    // leap second
    type = time_mark_value_interpretation::leap_second;
  } else {  // time >= 0 && time <= 36000
    type = time_mark_value_interpretation::normal;
  }
 
  return type;
}

parseTimeMarkValueToString()

std::string etsi_its_spatem_ts_msgs::access::parseTimeMarkValueToString ( const uint16_t time, const int32_t seconds, const uint32_t nanosec )

inline

Converts a value from message type TimeMarkValue into a string representation.

Parameters

time	Time in 0.1 seconds until the next change occours in the future, counting from the last started hour
seconds	seconds of current timestamp
nanosec	nanoseconds of current timestamp [0, 999999999]

Returns

Decoded String representation of the encoded time

Definition at line 250 of file spatem_ts_utils.h.

                                                                                                                {
  time_mark_value_interpretation time_type = interpretTimeMarkValueType(time);
 
  std::string text_content;
 
  switch (time_type) {
    case time_mark_value_interpretation::undefined:
      text_content = "undefined";
      break;
    case time_mark_value_interpretation::over_an_hour:
      text_content = ">36000s";
      break;
    case time_mark_value_interpretation::leap_second:
      text_content = "leap second";
      break;
    case time_mark_value_interpretation::normal:
      float rel_time_until_change = interpretTimeMarkDeltaTimeValueAsSeconds(time, seconds, nanosec);
 
      // set displayed precision to 0.1
      std::stringstream ss;
      ss << std::fixed << std::setprecision(1) << rel_time_until_change << "s";
      text_content = ss.str();
      break;
  }
 
  return text_content;
}