cam_setters_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_SETTERS_COMMON_H
#define ETSI_ITS_MSGS_UTILS_IMPL_CAM_CAM_SETTERS_COMMON_H
 
#include <etsi_its_msgs_utils/impl/checks.h>
#include <etsi_its_msgs_utils/impl/constants.h>
#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>

inline void setGenerationDeltaTime(
    GenerationDeltaTime& generation_delta_time, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  uint16_t gdt_value = t_its.value % 65536;
  throwIfOutOfRange(gdt_value, GenerationDeltaTime::MIN, GenerationDeltaTime::MAX, "GenerationDeltaTime");
  generation_delta_time.value = gdt_value;
}

inline void setGenerationDeltaTime(
    CAM& cam, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
  setGenerationDeltaTime(cam.cam.generation_delta_time, unix_nanosecs, n_leap_seconds);
}

inline void setStationType(CAM& cam, const uint8_t value) {
  setStationType(cam.cam.cam_parameters.basic_container.station_type, value);
}

inline void setHeading(CAM& cam, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  setHeadingCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.heading,
             heading_val, confidence);
}

 
inline void setYawRate(CAM& cam, const double yaw_rate_val,
                     const double confidence = std::numeric_limits<double>::infinity()) {
  setYawRateCDD(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.yaw_rate,
                yaw_rate_val, confidence);
}

inline void setVehicleWidth(VehicleWidth& vehicle_width, const double value) {
  int64_t width = (int64_t)std::round(value * 1e1);
  throwIfOutOfRange(width, VehicleWidth::MIN, VehicleWidth::MAX, "VehicleWidthValue");
  vehicle_width.value = width;
}

inline void setVehicleLengthValue(VehicleLengthValue& vehicle_length, const double value) {
  int64_t length = (int64_t)std::round(value * 1e1);
  throwIfOutOfRange(length, VehicleLengthValue::MIN, VehicleLengthValue::MAX, "VehicleLengthValue");
  vehicle_length.value = length;
}

inline void setVehicleLength(VehicleLength& vehicle_length, const double value) {
  vehicle_length.vehicle_length_confidence_indication.value = VehicleLengthConfidenceIndication::UNAVAILABLE;
  setVehicleLengthValue(vehicle_length.vehicle_length_value, value);
}

inline void setVehicleDimensions(CAM& cam, const double vehicle_length, const double vehicle_width) {
  setVehicleLength(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.vehicle_length,
      vehicle_length);
  setVehicleWidth(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.vehicle_width,
                  vehicle_width);
}

inline void setSpeed(CAM& cam, const double speed_val, const double confidence = SpeedConfidence::UNAVAILABLE) {
  setSpeed(cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.speed, speed_val, confidence);
}

inline void setLongitudinalAcceleration(CAM& cam, const double lon_accel, const double confidence = std::numeric_limits<double>::infinity()) {
  setLongitudinalAcceleration(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.longitudinal_acceleration,
      lon_accel, confidence);
}

inline void setLateralAcceleration(CAM& cam, const double lat_accel, const double confidence = std::numeric_limits<double>::infinity()) {
  setLateralAcceleration(
      cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency.lateral_acceleration,
      lat_accel, confidence);
  cam.cam.cam_parameters.high_frequency_container.basic_vehicle_container_high_frequency
      .lateral_acceleration_is_present = true;
}

inline void setReferencePosition(CAM& cam, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cam.cam.cam_parameters.basic_container.reference_position, latitude, longitude, altitude);
}

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

inline void setExteriorLights(ExteriorLights& exterior_lights, const std::vector<bool>& bits) {
  setBitString(exterior_lights, bits);
}

inline void setExteriorLights(CAM& cam, const std::vector<bool>& exterior_lights) {
  if (ExteriorLights::SIZE_BITS != exterior_lights.size()) {
    throw std::invalid_argument("Vector has wrong size. (" + std::to_string(exterior_lights.size()) +
                                " != " + std::to_string(ExteriorLights::SIZE_BITS) + ")");
  }
  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) {
      setExteriorLights(
          cam.cam.cam_parameters.low_frequency_container.basic_vehicle_container_low_frequency.exterior_lights,
          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 void setAccelerationControl(AccelerationControl& acceleration_control, const std::vector<bool>& bits) {
  setBitString(acceleration_control, bits);
}

inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
  setBitString(driving_lane_status, bits);
}

inline void setSpecialTransportType(SpecialTransportType& special_transport_type, const std::vector<bool>& bits) {
  setBitString(special_transport_type, bits);
}

inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
  setBitString(light_bar_siren_in_use, bits);
}

inline void setEmergencyPriority(EmergencyPriority& emergency_priority, const std::vector<bool>& bits) {
  setBitString(emergency_priority, bits);
}
 
#endif  // ETSI_ITS_MSGS_UTILS_IMPL_CAM_CAM_SETTERS_COMMON_H