cam_getters_common.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright Institute for Automotive Engineering (ika), RWTH Aachen University

 
#ifndef ETSI_ITS_MSGS_UTILS_IMPL_CAM_CAM_GETTERS_COMMON_H
#define ETSI_ITS_MSGS_UTILS_IMPL_CAM_CAM_GETTERS_COMMON_H
 
#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_getters.h>

inline uint32_t getStationID(const CAM& cam) { return getStationID(cam.header); }

inline GenerationDeltaTime getGenerationDeltaTime(const CAM& cam) { return cam.cam.generation_delta_time; }

inline uint16_t getGenerationDeltaTimeValue(const CAM& cam) { return getGenerationDeltaTime(cam).value; }

inline uint8_t getStationType(const CAM& cam) { return cam.cam.cam_parameters.basic_container.station_type.value; }

inline double getLatitude(const CAM& cam) {
  return getLatitude(cam.cam.cam_parameters.basic_container.reference_position.latitude);
}

inline double getLongitude(const CAM& cam) {
  return getLongitude(cam.cam.cam_parameters.basic_container.reference_position.longitude);
}

inline double getAltitude(const CAM& cam) {
  return getAltitude(cam.cam.cam_parameters.basic_container.reference_position.altitude);
}

inline double getHeading(const CAM& cam) {
  return getHeadingCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.heading);
}

inline double getHeadingConfidence(const CAM& cam) {
  return getHeadingConfidenceCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.heading);
}

inline double getYawRate(const CAM& cam) {
  return getYawRateCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.yaw_rate);
}

inline double getYawRateConfidence(const CAM& cam) {
  return getYawRateConfidenceCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.yaw_rate);
}

inline double getVehicleLength(const VehicleLength& vehicle_length) {
  return ((double)vehicle_length.vehicle_length_value.value) * 1e-1;
}

inline double getVehicleLength(const CAM& cam) {
  return getVehicleLength(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.vehicle_length);
}

inline double getVehicleWidth(const VehicleWidth& vehicle_width) { return ((double)vehicle_width.value) * 1e-1; }

inline double getVehicleWidth(const CAM& cam) {
  return getVehicleWidth(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.vehicle_width);
}

inline double getSpeed(const CAM& cam) {
  return getSpeed(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.speed);
}

inline double getSpeedConfidence(const CAM& cam) {
  return getSpeedConfidence(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.speed);
}

inline double getLongitudinalAcceleration(const CAM& cam) {
  return getLongitudinalAcceleration(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.longitudinal_acceleration);
}

inline double getLongitudinalAccelerationConfidence(const CAM& cam) {
  return getLongitudinalAccelerationConfidence(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.longitudinal_acceleration);
}

inline double getLateralAcceleration(const CAM& cam) {
  if (cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency
          .lateral_acceleration_is_present) {
    return getLateralAcceleration(
        cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.lateral_acceleration);
  } else {
    throw std::invalid_argument("LateralAcceleration is not present!");
  }
}

inline double getLateralAccelerationConfidence(const CAM& cam) {
  if (cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency
          .lateral_acceleration_is_present) {
    return getLateralAccelerationConfidence(
        cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.lateral_acceleration);
  } else {
    throw std::invalid_argument("LateralAccelerationConfidence is not present!");
  }
}

inline gm::PointStamped getUTMPosition(const CAM& cam, int& zone, bool& northp) {
  return getUTMPosition(cam.cam.cam_parameters.basic_container.reference_position, zone, northp);
}

inline gm::PointStamped getUTMPosition(const CAM& cam) {
  int zone;
  bool northp;
  return getUTMPosition(cam.cam.cam_parameters.basic_container.reference_position, zone, northp);
}

inline std::vector<bool> getExteriorLights(const ExteriorLights& exterior_lights) {
  return getBitString(exterior_lights.value, exterior_lights.bits_unused);
}

inline std::vector<bool> getExteriorLights(const CAM& cam) {
  if (cam.cam.cam_parameters.low_frequency_container_is_present) {
    if (cam.cam.cam_parameters.low_frequency_container.choice ==
        LowFrequencyContainer::CHOICE_BASIC_VEHICLE_CONTAINER_LOW_FREQUENCY) {
      return getExteriorLights(
          cam.cam.cam_parameters.low_frequency_container.basic_vehicle_container_low_frequency.exterior_lights);
    } else {
      throw std::invalid_argument("LowFrequencyContainer is not BASIC_VEHICLE_CONTAINER_LOW_FREQUENCY!");
    }
  } else {
    throw std::invalid_argument("LowFrequencyContainer is not present!");
  }
}

inline std::vector<bool> getAccelerationControl(const AccelerationControl& acceleration_control) {
  return getBitString(acceleration_control.value, acceleration_control.bits_unused);
}

inline std::vector<bool> getDrivingLaneStatus(const DrivingLaneStatus& driving_lane_status) {
  return getBitString(driving_lane_status.value, driving_lane_status.bits_unused);
}

inline std::vector<bool> getSpecialTransportType(const SpecialTransportType& special_transport_type) {
  return getBitString(special_transport_type.value, special_transport_type.bits_unused);
}

inline std::vector<bool> getLightBarSirenInUse(const LightBarSirenInUse& light_bar_siren_in_use) {
  return getBitString(light_bar_siren_in_use.value, light_bar_siren_in_use.bits_unused);
}

inline std::vector<bool> getEmergencyPriority(const EmergencyPriority& emergency_priority) {
  return getBitString(emergency_priority.value, emergency_priority.bits_unused);
}
 
#endif  // ETSI_ITS_MSGS_UTILS_IMPL_CAM_CAM_GETTERS_COMMON_H