etsi_its_messages v3.3.0
 
Loading...
Searching...
No Matches
Classes | Macros | Functions
cam_setters.h File Reference

Setter functions for the ETSI ITS CAM (EN) More...

#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

Go to the source code of this file.

Classes

struct  etsi_its_cam_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, typename >
 
struct  etsi_its_cam_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, std::void_t< decltype(SemiAxisLength::ONE_CENTIMETER)> >
 

Functions

template<typename T1, typename T2>
void etsi_its_cam_msgs::access::throwIfOutOfRange (const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
 Throws an exception if a given value is out of a defined range.
 
void etsi_its_cam_msgs::access::throwIfNotPresent (const bool is_present, const std::string val_desc)
 Throws an exception if the given value is not present.
 
uint16_t etsi_its_cam_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 (const uint64_t unix_seconds)
 Get the leap second insertions since 2004 for given unix seconds.
 
void etsi_its_cam_msgs::access::setTimestampITS (TimestampIts &timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the TimestampITS object.
 
void etsi_its_cam_msgs::access::setLatitude (Latitude &latitude, const double deg)
 Set the Latitude object.
 
void etsi_its_cam_msgs::access::setLongitude (Longitude &longitude, const double deg)
 Set the Longitude object.
 
void etsi_its_cam_msgs::access::setAltitudeValue (AltitudeValue &altitude, const double value)
 Set the AltitudeValue object.
 
void etsi_its_cam_msgs::access::setAltitude (Altitude &altitude, const double value)
 Set the Altitude object.
 
void etsi_its_cam_msgs::access::setSpeedValue (SpeedValue &speed, const double value)
 Set the SpeedValue object.
 
void etsi_its_cam_msgs::access::setSpeedConfidence (SpeedConfidence &speed_confidence, const double value)
 Set the Speed Confidence object.
 
void etsi_its_cam_msgs::access::setSpeed (Speed &speed, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the Speed object.
 
template<typename AccelerationMagnitudeValue>
void etsi_its_cam_msgs::access::setAccelerationMagnitudeValue (AccelerationMagnitudeValue &accel_mag_value, const double value)
 Set the Acceleration Magnitude Value object.
 
template<typename AccelerationConfidence>
void etsi_its_cam_msgs::access::setAccelerationMagnitudeConfidence (AccelerationConfidence &accel_mag_confidence, const double value)
 Set the AccelerationMagnitude Confidence object.
 
template<typename AccelerationMagnitude>
void etsi_its_cam_msgs::access::setAccelerationMagnitude (AccelerationMagnitude &accel_mag, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the AccelerationMagnitude object.
 
template<typename AccelerationConfidence>
void etsi_its_cam_msgs::access::setAccelerationConfidence (AccelerationConfidence &accel_confidence, const double value)
 Set the Acceleration Confidence object.
 
template<typename T>
void etsi_its_cam_msgs::access::setReferencePosition (T &ref_position, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
 Sets the reference position in the given ReferencePostion object.
 
template<typename T>
void etsi_its_cam_msgs::access::setFromUTMPosition (T &reference_position, const gm::PointStamped &utm_position, const int zone, const bool northp)
 Set the ReferencePosition from a given UTM-Position.
 
template<typename HeadingValue>
void etsi_its_cam_msgs::access::setHeadingValue (HeadingValue &heading, const double value)
 Set the HeadingValue object.
 
template<typename HeadingConfidence>
void etsi_its_cam_msgs::access::setHeadingConfidence (HeadingConfidence &heading_confidence, const double value)
 Set the Heading Confidence object.
 
template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>
void etsi_its_cam_msgs::access::setHeadingCDD (Heading &heading, const double value, double confidence=std::numeric_limits< double >::infinity())
 Set the Heading object.
 
template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>
void etsi_its_cam_msgs::access::setYawRateCDD (YawRate &yaw_rate, const double value, double confidence=std::numeric_limits< double >::infinity())
 Set the Yaw Rate object.
 
template<typename SemiAxisLength>
void etsi_its_cam_msgs::access::setSemiAxis (SemiAxisLength &semi_axis_length, const double length)
 Set the Semi Axis length.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
 Set the Pos Confidence Ellipse object.
 
std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromCovMatrix (const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromWGSCovMatrix (const std::array< double, 4 > &covariance_matrix)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Set the Pos Confidence Ellipse object.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
 Set the Pos Confidence Ellipse object.
 
void etsi_its_cam_msgs::access::setStationId (StationID &station_id, const uint32_t id_value)
 Set the Station Id object.
 
void etsi_its_cam_msgs::access::setItsPduHeader (ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the Its Pdu Header object.
 
void etsi_its_cam_msgs::access::setStationType (StationType &station_type, const uint8_t value)
 Set the Station Type.
 
void etsi_its_cam_msgs::access::setItsPduHeader (CAM &cam, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the ItsPduHeader-object for a CAM.
 
void etsi_its_cam_msgs::access::setLongitudinalAccelerationValue (LongitudinalAccelerationValue &accel, const double value)
 Set the LongitudinalAccelerationValue object.
 
void etsi_its_cam_msgs::access::setLongitudinalAcceleration (LongitudinalAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the LongitudinalAcceleration object.
 
void etsi_its_cam_msgs::access::setLateralAccelerationValue (LateralAccelerationValue &accel, const double value)
 Set the LateralAccelerationValue object.
 
void etsi_its_cam_msgs::access::setLateralAcceleration (LateralAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the LateralAcceleration object.
 
template<typename T>
void etsi_its_cam_msgs::access::setBitString (T &bitstring, const std::vector< bool > &bits)
 Set a Bit String by a vector of bools.
 
void etsi_its_cam_msgs::access::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)
 Set the GenerationDeltaTime-Value.
 
void etsi_its_cam_msgs::access::setGenerationDeltaTime (CAM &cam, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the Generation Delta Time object.
 
void etsi_its_cam_msgs::access::setStationType (CAM &cam, const uint8_t value)
 Set the StationType for a CAM.
 
void etsi_its_cam_msgs::access::setHeading (CAM &cam, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
 Set the Heading for a CAM.
 
void etsi_its_cam_msgs::access::setYawRate (CAM &cam, const double yaw_rate_val, const double confidence=std::numeric_limits< double >::infinity())
 Set the Yaw Rate for a CAM.
 
void etsi_its_cam_msgs::access::setVehicleWidth (VehicleWidth &vehicle_width, const double value)
 Set the VehicleWidth object.
 
void etsi_its_cam_msgs::access::setVehicleLengthValue (VehicleLengthValue &vehicle_length, const double value)
 Set the VehicleLengthValue object.
 
void etsi_its_cam_msgs::access::setVehicleLength (VehicleLength &vehicle_length, const double value)
 Set the VehicleLength object.
 
void etsi_its_cam_msgs::access::setVehicleDimensions (CAM &cam, const double vehicle_length, const double vehicle_width)
 Set the vehicle dimensions.
 
void etsi_its_cam_msgs::access::setSpeed (CAM &cam, const double speed_val, const double confidence=SpeedConfidence::UNAVAILABLE)
 Set the vehicle speed.
 
void etsi_its_cam_msgs::access::setLongitudinalAcceleration (CAM &cam, const double lon_accel, const double confidence=std::numeric_limits< double >::infinity())
 Set the longitudinal acceleration.
 
void etsi_its_cam_msgs::access::setLateralAcceleration (CAM &cam, const double lat_accel, const double confidence=std::numeric_limits< double >::infinity())
 Set the lateral acceleration.
 
void etsi_its_cam_msgs::access::setReferencePosition (CAM &cam, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
 Set the ReferencePosition for a CAM.
 
void etsi_its_cam_msgs::access::setFromUTMPosition (CAM &cam, const gm::PointStamped &utm_position, const int &zone, const bool &northp)
 Set the ReferencePosition of a CAM from a given UTM-Position.
 
void etsi_its_cam_msgs::access::setExteriorLights (ExteriorLights &exterior_lights, const std::vector< bool > &bits)
 Set the Exterior Lights by a vector of bools.
 
void etsi_its_cam_msgs::access::setExteriorLights (CAM &cam, const std::vector< bool > &exterior_lights)
 Set the Exterior Lights by using a vector of bools.
 
void etsi_its_cam_msgs::access::setAccelerationControl (AccelerationControl &acceleration_control, const std::vector< bool > &bits)
 Set the Acceleration Control by a vector of bools.
 
void etsi_its_cam_msgs::access::setDrivingLaneStatus (DrivingLaneStatus &driving_lane_status, const std::vector< bool > &bits)
 Set the Driving Lane Status by a vector of bools.
 
void etsi_its_cam_msgs::access::setSpecialTransportType (SpecialTransportType &special_transport_type, const std::vector< bool > &bits)
 Set the Special Transport Type by a vector of bools.
 
void etsi_its_cam_msgs::access::setLightBarSirenInUse (LightBarSirenInUse &light_bar_siren_in_use, const std::vector< bool > &bits)
 Set the Lightbar Siren In Use by a vector of bools.
 
void etsi_its_cam_msgs::access::setEmergencyPriority (EmergencyPriority &emergency_priority, const std::vector< bool > &bits)
 Set the Emergency Priority by a vector of bools.
 
void etsi_its_cam_msgs::access::setRefPosConfidence (CAM &cam, const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Set the confidence of the reference position.
 
void etsi_its_cam_msgs::access::setWGSRefPosConfidence (CAM &cam, const std::array< double, 4 > &covariance_matrix)
 Set the confidence of the reference position.
 

Detailed Description

Setter functions for the ETSI ITS CAM (EN)

Definition in file cam_setters.h.

Function Documentation

◆ confidenceEllipseFromCovMatrix()

std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromCovMatrix ( const std::array< double, 4 > & covariance_matrix,
const double object_heading )
inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_headingThe heading of the object in rad, with respect to WGS84
Returns
std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 467 of file cam_setters.h.

◆ confidenceEllipseFromWGSCovMatrix()

std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromWGSCovMatrix ( const std::array< double, 4 > & covariance_matrix)
inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_headingThe heading of the object in rad, with respect to WGS84
Returns
std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 508 of file cam_setters.h.

541 {
542
543#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
544
552inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
553 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
554}
555
562inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
563 auto accel_val = std::round(value * 1e1);
564 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
565 accel.value = static_cast<int16_t>(accel_val);
566 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
567 accel.value = LongitudinalAccelerationValue::MIN;
568 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
569 accel.value = LongitudinalAccelerationValue::MAX - 1;
570 }
571}
572
583inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
584 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
585 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
586}
587
594inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
595 int64_t accel_val = (int64_t)std::round(value * 1e1);
596 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
597 accel.value = accel_val;
598 } else if (accel_val < LateralAccelerationValue::MIN) {
599 accel.value = LateralAccelerationValue::MIN;
600 } else if (accel_val > LateralAccelerationValue::MAX) {
601 accel.value = LateralAccelerationValue::MAX - 1;
602 }
603}
604
615inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
616 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
617 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
618}
619
620#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
621
631inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
632 // First ensure, that the object has the correct heading by setting its value
633 double orientation = object_heading * 180 / M_PI; // Convert to degrees
634 // Normalize to [0, 360)
635 orientation = std::fmod(orientation + 360, 360);
636 while (orientation < 0) {
637 orientation += 360;
638 }
639 while (orientation >= 360) {
640 orientation -= 360;
641 }
642 setHeading(cam, orientation);
643 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
644 covariance_matrix, object_heading);
645}
646
655inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
656 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
657 covariance_matrix);
658}
659
660} // namespace etsi_its_cam_msgs::access
etsi_its_cam_msgs::access::setLateralAcceleration
void setLateralAcceleration(LateralAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
Set the LateralAcceleration object.
Definition cam_setters.h:178
etsi_its_cam_msgs::access::setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(LongitudinalAccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cam_setters.h:125
etsi_its_cam_msgs::access::setPosConfidenceEllipse
void setPosConfidenceEllipse(PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
Set the Pos Confidence Ellipse object.
Definition cam_setters.h:451
etsi_its_cam_msgs::access::setItsPduHeader
void setItsPduHeader(ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
Set the Its Pdu Header object.
Definition cam_setters.h:85
etsi_its_cam_msgs::access::setRefPosConfidence
void setRefPosConfidence(CAM &cam, const std::array< double, 4 > &covariance_matrix, const double object_heading)
Set the confidence of the reference position.
Definition cam_setters.h:362
etsi_its_cam_msgs::access::setLongitudinalAcceleration
void setLongitudinalAcceleration(LongitudinalAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
Set the LongitudinalAcceleration object.
Definition cam_setters.h:146
etsi_its_cam_msgs::access::setLateralAccelerationValue
void setLateralAccelerationValue(LateralAccelerationValue &accel, const double value)
Set the LateralAccelerationValue object.
Definition cam_setters.h:157
etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse
void setWGSPosConfidenceEllipse(PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
Set the Pos Confidence Ellipse object.
Definition cam_setters.h:539
etsi_its_cam_msgs::access::setAccelerationConfidence
void setAccelerationConfidence(AccelerationConfidence &accel_confidence, const double value)
Set the Acceleration Confidence object.
Definition cam_setters.h:266
etsi_its_cam_msgs::access::setHeading
void setHeading(CAM &cam, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
Set the Heading for a CAM.
Definition cam_setters.h:123
etsi_its_cam_msgs::access::setWGSRefPosConfidence
void setWGSRefPosConfidence(CAM &cam, const std::array< double, 4 > &covariance_matrix)
Set the confidence of the reference position.
Definition cam_setters.h:386
cam_setters_common.h
Common setter functions for the ETSI ITS CAM (EN and TS)
cdd_v1-3-1_setters.h
Setter functions for the ETSI ITS Common Data Dictionary (CDD) v1.3.1.
setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(AccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cdd_v2-1-1_setters.h:85

◆ getLeapSecondInsertionsSince2004()

uint16_t etsi_its_cam_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 ( const uint64_t unix_seconds)
inline

Get the leap second insertions since 2004 for given unix seconds.

Parameters
unix_secondsthe current unix seconds for that the leap second insertions since 2004 shall be provided
Returns
uint16_t the number of leap second insertions since 2004 for unix_seconds

Definition at line 61 of file cam_access.h.

117 {
118#include <etsi_its_msgs_utils/impl/cam/cam_utils.h>
119}
cam_utils.h
Utility functions for the ETSI ITS CAM (EN and TS)

◆ setAccelerationConfidence()

template<typename AccelerationConfidence>
void etsi_its_cam_msgs::access::setAccelerationConfidence ( AccelerationConfidence & accel_confidence,
const double value )
inline

Set the Acceleration Confidence object.

Parameters
accel_confidenceobject to set
valuestandard deviation in m/s^2 as decimal number

Definition at line 266 of file cam_setters.h.

299 {
300
301#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
302
310inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
311 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
312}
313
320inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
321 auto accel_val = std::round(value * 1e1);
322 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
323 accel.value = static_cast<int16_t>(accel_val);
324 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
325 accel.value = LongitudinalAccelerationValue::MIN;
326 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
327 accel.value = LongitudinalAccelerationValue::MAX - 1;
328 }
329}
330
341inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
342 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
343 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
344}
345
352inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
353 int64_t accel_val = (int64_t)std::round(value * 1e1);
354 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
355 accel.value = accel_val;
356 } else if (accel_val < LateralAccelerationValue::MIN) {
357 accel.value = LateralAccelerationValue::MIN;
358 } else if (accel_val > LateralAccelerationValue::MAX) {
359 accel.value = LateralAccelerationValue::MAX - 1;
360 }
361}
362
373inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
374 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
375 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
376}
377
378#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
379
389inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
390 // First ensure, that the object has the correct heading by setting its value
391 double orientation = object_heading * 180 / M_PI; // Convert to degrees
392 // Normalize to [0, 360)
393 orientation = std::fmod(orientation + 360, 360);
394 while (orientation < 0) {
395 orientation += 360;
396 }
397 while (orientation >= 360) {
398 orientation -= 360;
399 }
400 setHeading(cam, orientation);
401 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
402 covariance_matrix, object_heading);
403}
404
413inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
414 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
415 covariance_matrix);
416}
417
418} // namespace etsi_its_cam_msgs::access

◆ setAccelerationControl()

void etsi_its_cam_msgs::access::setAccelerationControl ( AccelerationControl & acceleration_control,
const std::vector< bool > & bits )
inline

Set the Acceleration Control by a vector of bools.

Parameters
acceleration_control
bits

Definition at line 307 of file cam_setters.h.

340 {
341
342#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
343
351inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
352 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
353}
354
361inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
362 auto accel_val = std::round(value * 1e1);
363 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
364 accel.value = static_cast<int16_t>(accel_val);
365 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
366 accel.value = LongitudinalAccelerationValue::MIN;
367 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
368 accel.value = LongitudinalAccelerationValue::MAX - 1;
369 }
370}
371
382inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
383 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
384 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
385}
386
393inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
394 int64_t accel_val = (int64_t)std::round(value * 1e1);
395 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
396 accel.value = accel_val;
397 } else if (accel_val < LateralAccelerationValue::MIN) {
398 accel.value = LateralAccelerationValue::MIN;
399 } else if (accel_val > LateralAccelerationValue::MAX) {
400 accel.value = LateralAccelerationValue::MAX - 1;
401 }
402}
403
414inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
415 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
416 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
417}
418
419#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
420
430inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
431 // First ensure, that the object has the correct heading by setting its value
432 double orientation = object_heading * 180 / M_PI; // Convert to degrees
433 // Normalize to [0, 360)
434 orientation = std::fmod(orientation + 360, 360);
435 while (orientation < 0) {
436 orientation += 360;
437 }
438 while (orientation >= 360) {
439 orientation -= 360;
440 }
441 setHeading(cam, orientation);
442 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
443 covariance_matrix, object_heading);
444}
445
454inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
455 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
456 covariance_matrix);
457}
458
459} // namespace etsi_its_cam_msgs::access

◆ setAccelerationMagnitude()

template<typename AccelerationMagnitude>
void etsi_its_cam_msgs::access::setAccelerationMagnitude ( AccelerationMagnitude & accel_mag,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the AccelerationMagnitude object.

AccelerationConfidence is set to UNAVAILABLE

Parameters
accel_magobject to set
valueAccelerationMagnitudeValue in m/s^2 as decimal number
confidencestandard deviation in m/s^2 as decimal number (default: infinity, mapping to AccelerationConfidence::UNAVAILABLE)

Definition at line 253 of file cam_setters.h.

286 {
287
288#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
289
297inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
298 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
299}
300
307inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
308 auto accel_val = std::round(value * 1e1);
309 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
310 accel.value = static_cast<int16_t>(accel_val);
311 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
312 accel.value = LongitudinalAccelerationValue::MIN;
313 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
314 accel.value = LongitudinalAccelerationValue::MAX - 1;
315 }
316}
317
328inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
329 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
330 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
331}
332
339inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
340 int64_t accel_val = (int64_t)std::round(value * 1e1);
341 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
342 accel.value = accel_val;
343 } else if (accel_val < LateralAccelerationValue::MIN) {
344 accel.value = LateralAccelerationValue::MIN;
345 } else if (accel_val > LateralAccelerationValue::MAX) {
346 accel.value = LateralAccelerationValue::MAX - 1;
347 }
348}
349
360inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
361 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
362 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
363}
364
365#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
366
376inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
377 // First ensure, that the object has the correct heading by setting its value
378 double orientation = object_heading * 180 / M_PI; // Convert to degrees
379 // Normalize to [0, 360)
380 orientation = std::fmod(orientation + 360, 360);
381 while (orientation < 0) {
382 orientation += 360;
383 }
384 while (orientation >= 360) {
385 orientation -= 360;
386 }
387 setHeading(cam, orientation);
388 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
389 covariance_matrix, object_heading);
390}
391
400inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
401 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
402 covariance_matrix);
403}
404
405} // namespace etsi_its_cam_msgs::access

◆ setAccelerationMagnitudeConfidence()

template<typename AccelerationConfidence>
void etsi_its_cam_msgs::access::setAccelerationMagnitudeConfidence ( AccelerationConfidence & accel_mag_confidence,
const double value )
inline

Set the AccelerationMagnitude Confidence object.

Parameters
accel_mag_confidenceobject to set
valuestandard deviation in m/s^2 as decimal number

Definition at line 233 of file cam_setters.h.

266 {
267
268#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
269
277inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
278 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
279}
280
287inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
288 auto accel_val = std::round(value * 1e1);
289 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
290 accel.value = static_cast<int16_t>(accel_val);
291 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
292 accel.value = LongitudinalAccelerationValue::MIN;
293 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
294 accel.value = LongitudinalAccelerationValue::MAX - 1;
295 }
296}
297
308inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
309 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
310 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
311}
312
319inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
320 int64_t accel_val = (int64_t)std::round(value * 1e1);
321 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
322 accel.value = accel_val;
323 } else if (accel_val < LateralAccelerationValue::MIN) {
324 accel.value = LateralAccelerationValue::MIN;
325 } else if (accel_val > LateralAccelerationValue::MAX) {
326 accel.value = LateralAccelerationValue::MAX - 1;
327 }
328}
329
340inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
341 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
342 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
343}
344
345#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
346
356inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
357 // First ensure, that the object has the correct heading by setting its value
358 double orientation = object_heading * 180 / M_PI; // Convert to degrees
359 // Normalize to [0, 360)
360 orientation = std::fmod(orientation + 360, 360);
361 while (orientation < 0) {
362 orientation += 360;
363 }
364 while (orientation >= 360) {
365 orientation -= 360;
366 }
367 setHeading(cam, orientation);
368 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
369 covariance_matrix, object_heading);
370}
371
380inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
381 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
382 covariance_matrix);
383}
384
385} // namespace etsi_its_cam_msgs::access

◆ setAccelerationMagnitudeValue()

template<typename AccelerationMagnitudeValue>
void etsi_its_cam_msgs::access::setAccelerationMagnitudeValue ( AccelerationMagnitudeValue & accel_mag_value,
const double value )
inline

Set the Acceleration Magnitude Value object.

Parameters
accel_mag_valueobject to set
valueAccelerationMagnitudeValue in m/s^2 as decimal number

Definition at line 220 of file cam_setters.h.

253 {
254
255#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
256
264inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
265 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
266}
267
274inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
275 auto accel_val = std::round(value * 1e1);
276 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
277 accel.value = static_cast<int16_t>(accel_val);
278 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
279 accel.value = LongitudinalAccelerationValue::MIN;
280 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
281 accel.value = LongitudinalAccelerationValue::MAX - 1;
282 }
283}
284
295inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
296 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
297 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
298}
299
306inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
307 int64_t accel_val = (int64_t)std::round(value * 1e1);
308 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
309 accel.value = accel_val;
310 } else if (accel_val < LateralAccelerationValue::MIN) {
311 accel.value = LateralAccelerationValue::MIN;
312 } else if (accel_val > LateralAccelerationValue::MAX) {
313 accel.value = LateralAccelerationValue::MAX - 1;
314 }
315}
316
327inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
328 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
329 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
330}
331
332#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
333
343inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
344 // First ensure, that the object has the correct heading by setting its value
345 double orientation = object_heading * 180 / M_PI; // Convert to degrees
346 // Normalize to [0, 360)
347 orientation = std::fmod(orientation + 360, 360);
348 while (orientation < 0) {
349 orientation += 360;
350 }
351 while (orientation >= 360) {
352 orientation -= 360;
353 }
354 setHeading(cam, orientation);
355 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
356 covariance_matrix, object_heading);
357}
358
367inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
368 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
369 covariance_matrix);
370}
371
372} // namespace etsi_its_cam_msgs::access

◆ setAltitude()

void etsi_its_cam_msgs::access::setAltitude ( Altitude & altitude,
const double value )
inline

Set the Altitude object.

AltitudeConfidence is set to UNAVAILABLE

Parameters
altitudeobject to set
valueAltitude value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 166 of file cam_setters.h.

199 {
200
201#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
202
210inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
211 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
212}
213
220inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
221 auto accel_val = std::round(value * 1e1);
222 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
223 accel.value = static_cast<int16_t>(accel_val);
224 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
225 accel.value = LongitudinalAccelerationValue::MIN;
226 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
227 accel.value = LongitudinalAccelerationValue::MAX - 1;
228 }
229}
230
241inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
242 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
243 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
244}
245
252inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
253 int64_t accel_val = (int64_t)std::round(value * 1e1);
254 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
255 accel.value = accel_val;
256 } else if (accel_val < LateralAccelerationValue::MIN) {
257 accel.value = LateralAccelerationValue::MIN;
258 } else if (accel_val > LateralAccelerationValue::MAX) {
259 accel.value = LateralAccelerationValue::MAX - 1;
260 }
261}
262
273inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
274 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
275 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
276}
277
278#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
279
289inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
290 // First ensure, that the object has the correct heading by setting its value
291 double orientation = object_heading * 180 / M_PI; // Convert to degrees
292 // Normalize to [0, 360)
293 orientation = std::fmod(orientation + 360, 360);
294 while (orientation < 0) {
295 orientation += 360;
296 }
297 while (orientation >= 360) {
298 orientation -= 360;
299 }
300 setHeading(cam, orientation);
301 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
302 covariance_matrix, object_heading);
303}
304
313inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
314 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
315 covariance_matrix);
316}
317
318} // namespace etsi_its_cam_msgs::access

◆ setAltitudeValue()

void etsi_its_cam_msgs::access::setAltitudeValue ( AltitudeValue & altitude,
const double value )
inline

Set the AltitudeValue object.

Parameters
altitudeobject to set
valueAltitudeValue value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 147 of file cam_setters.h.

148 {
149 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
150 covariance_matrix);
151}
152
153} // namespace etsi_its_cam_msgs::access

◆ setBitString()

template<typename T>
void etsi_its_cam_msgs::access::setBitString ( T & bitstring,
const std::vector< bool > & bits )
inline

Set a Bit String by a vector of bools.

Template Parameters
T
Parameters
bitstringBitString to set
bitsvector of bools

Definition at line 44 of file cam_setters.h.

45 {
46 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
47}
48
55inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
56 auto accel_val = std::round(value * 1e1);
57 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
58 accel.value = static_cast<int16_t>(accel_val);
59 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
60 accel.value = LongitudinalAccelerationValue::MIN;
61 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
62 accel.value = LongitudinalAccelerationValue::MAX - 1;
63 }
64}
65

◆ setDrivingLaneStatus()

void etsi_its_cam_msgs::access::setDrivingLaneStatus ( DrivingLaneStatus & driving_lane_status,
const std::vector< bool > & bits )
inline

Set the Driving Lane Status by a vector of bools.

Parameters
driving_lane_status
bits

Definition at line 317 of file cam_setters.h.

361inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
362 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
363}
364
371inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
372 auto accel_val = std::round(value * 1e1);
373 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
374 accel.value = static_cast<int16_t>(accel_val);
375 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
376 accel.value = LongitudinalAccelerationValue::MIN;
377 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
378 accel.value = LongitudinalAccelerationValue::MAX - 1;
379 }
380}
381
392inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
393 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
394 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
395}
396
403inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
404 int64_t accel_val = (int64_t)std::round(value * 1e1);
405 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
406 accel.value = accel_val;
407 } else if (accel_val < LateralAccelerationValue::MIN) {
408 accel.value = LateralAccelerationValue::MIN;
409 } else if (accel_val > LateralAccelerationValue::MAX) {
410 accel.value = LateralAccelerationValue::MAX - 1;
411 }
412}
413
424inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
425 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
426 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
427}
428
429#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
430
440inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
441 // First ensure, that the object has the correct heading by setting its value
442 double orientation = object_heading * 180 / M_PI; // Convert to degrees
443 // Normalize to [0, 360)
444 orientation = std::fmod(orientation + 360, 360);
445 while (orientation < 0) {
446 orientation += 360;
447 }
448 while (orientation >= 360) {
449 orientation -= 360;
450 }
451 setHeading(cam, orientation);
452 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
453 covariance_matrix, object_heading);
454}
455
464inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
465 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
466 covariance_matrix);
467}
468
469} // namespace etsi_its_cam_msgs::access

◆ setEmergencyPriority()

void etsi_its_cam_msgs::access::setEmergencyPriority ( EmergencyPriority & emergency_priority,
const std::vector< bool > & bits )
inline

Set the Emergency Priority by a vector of bools.

Parameters
emergency_priority
bits

Definition at line 347 of file cam_setters.h.

380 {
381
382#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
383
391inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
392 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
393}
394
401inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
402 auto accel_val = std::round(value * 1e1);
403 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
404 accel.value = static_cast<int16_t>(accel_val);
405 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
406 accel.value = LongitudinalAccelerationValue::MIN;
407 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
408 accel.value = LongitudinalAccelerationValue::MAX - 1;
409 }
410}
411
422inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
423 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
424 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
425}
426
433inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
434 int64_t accel_val = (int64_t)std::round(value * 1e1);
435 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
436 accel.value = accel_val;
437 } else if (accel_val < LateralAccelerationValue::MIN) {
438 accel.value = LateralAccelerationValue::MIN;
439 } else if (accel_val > LateralAccelerationValue::MAX) {
440 accel.value = LateralAccelerationValue::MAX - 1;
441 }
442}
443
454inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
455 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
456 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
457}
458
459#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
460
470inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
471 // First ensure, that the object has the correct heading by setting its value
472 double orientation = object_heading * 180 / M_PI; // Convert to degrees
473 // Normalize to [0, 360)
474 orientation = std::fmod(orientation + 360, 360);
475 while (orientation < 0) {
476 orientation += 360;
477 }
478 while (orientation >= 360) {
479 orientation -= 360;
480 }
481 setHeading(cam, orientation);
482 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
483 covariance_matrix, object_heading);
484}
485
494inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
495 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
496 covariance_matrix);
497}
498
499} // namespace etsi_its_cam_msgs::access

◆ setExteriorLights() [1/2]

void etsi_its_cam_msgs::access::setExteriorLights ( CAM & cam,
const std::vector< bool > & exterior_lights )
inline

Set the Exterior Lights by using a vector of bools.

Parameters
camCAM to set the exterior lights
exterior_lightsvector of bools to set the exterior lights

Definition at line 282 of file cam_setters.h.

315 {
316
317#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
318
326inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
327 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
328}
329
336inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
337 auto accel_val = std::round(value * 1e1);
338 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
339 accel.value = static_cast<int16_t>(accel_val);
340 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
341 accel.value = LongitudinalAccelerationValue::MIN;
342 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
343 accel.value = LongitudinalAccelerationValue::MAX - 1;
344 }
345}
346
357inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
358 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
359 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
360}
361
368inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
369 int64_t accel_val = (int64_t)std::round(value * 1e1);
370 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
371 accel.value = accel_val;
372 } else if (accel_val < LateralAccelerationValue::MIN) {
373 accel.value = LateralAccelerationValue::MIN;
374 } else if (accel_val > LateralAccelerationValue::MAX) {
375 accel.value = LateralAccelerationValue::MAX - 1;
376 }
377}
378
389inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
390 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
391 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
392}
393
394#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
395
405inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
406 // First ensure, that the object has the correct heading by setting its value
407 double orientation = object_heading * 180 / M_PI; // Convert to degrees
408 // Normalize to [0, 360)
409 orientation = std::fmod(orientation + 360, 360);
410 while (orientation < 0) {
411 orientation += 360;
412 }
413 while (orientation >= 360) {
414 orientation -= 360;
415 }
416 setHeading(cam, orientation);
417 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
418 covariance_matrix, object_heading);
419}
420
429inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
430 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
431 covariance_matrix);
432}
433
434} // namespace etsi_its_cam_msgs::access

◆ setExteriorLights() [2/2]

void etsi_its_cam_msgs::access::setExteriorLights ( ExteriorLights & exterior_lights,
const std::vector< bool > & bits )
inline

Set the Exterior Lights by a vector of bools.

Parameters
exterior_lights
bits

Definition at line 272 of file cam_setters.h.

305 {
306
307#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
308
316inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
317 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
318}
319
326inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
327 auto accel_val = std::round(value * 1e1);
328 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
329 accel.value = static_cast<int16_t>(accel_val);
330 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
331 accel.value = LongitudinalAccelerationValue::MIN;
332 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
333 accel.value = LongitudinalAccelerationValue::MAX - 1;
334 }
335}
336
347inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
348 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
349 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
350}
351
358inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
359 int64_t accel_val = (int64_t)std::round(value * 1e1);
360 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
361 accel.value = accel_val;
362 } else if (accel_val < LateralAccelerationValue::MIN) {
363 accel.value = LateralAccelerationValue::MIN;
364 } else if (accel_val > LateralAccelerationValue::MAX) {
365 accel.value = LateralAccelerationValue::MAX - 1;
366 }
367}
368
379inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
380 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
381 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
382}
383
384#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
385
395inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
396 // First ensure, that the object has the correct heading by setting its value
397 double orientation = object_heading * 180 / M_PI; // Convert to degrees
398 // Normalize to [0, 360)
399 orientation = std::fmod(orientation + 360, 360);
400 while (orientation < 0) {
401 orientation += 360;
402 }
403 while (orientation >= 360) {
404 orientation -= 360;
405 }
406 setHeading(cam, orientation);
407 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
408 covariance_matrix, object_heading);
409}
410
419inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
420 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
421 covariance_matrix);
422}
423
424} // namespace etsi_its_cam_msgs::access

◆ setFromUTMPosition() [1/2]

void etsi_its_cam_msgs::access::setFromUTMPosition ( CAM & cam,
const gm::PointStamped & utm_position,
const int & zone,
const bool & northp )
inline

Set the ReferencePosition of a CAM from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters
[out]camCAM for which to set the ReferencePosition
[in]utm_positiongeometry_msgs::PointStamped describing the given utm position
[in]zonethe UTM zone (zero means UPS) of the given position
[in]northphemisphere (true means north, false means south)

Definition at line 262 of file cam_setters.h.

295 {
296
297#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
298
306inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
307 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
308}
309
316inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
317 auto accel_val = std::round(value * 1e1);
318 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
319 accel.value = static_cast<int16_t>(accel_val);
320 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
321 accel.value = LongitudinalAccelerationValue::MIN;
322 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
323 accel.value = LongitudinalAccelerationValue::MAX - 1;
324 }
325}
326
337inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
338 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
339 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
340}
341
348inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
349 int64_t accel_val = (int64_t)std::round(value * 1e1);
350 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
351 accel.value = accel_val;
352 } else if (accel_val < LateralAccelerationValue::MIN) {
353 accel.value = LateralAccelerationValue::MIN;
354 } else if (accel_val > LateralAccelerationValue::MAX) {
355 accel.value = LateralAccelerationValue::MAX - 1;
356 }
357}
358
369inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
370 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
371 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
372}
373
374#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
375
385inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
386 // First ensure, that the object has the correct heading by setting its value
387 double orientation = object_heading * 180 / M_PI; // Convert to degrees
388 // Normalize to [0, 360)
389 orientation = std::fmod(orientation + 360, 360);
390 while (orientation < 0) {
391 orientation += 360;
392 }
393 while (orientation >= 360) {
394 orientation -= 360;
395 }
396 setHeading(cam, orientation);
397 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
398 covariance_matrix, object_heading);
399}
400
409inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
410 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
411 covariance_matrix);
412}
413
414} // namespace etsi_its_cam_msgs::access

◆ setFromUTMPosition() [2/2]

template<typename T>
void etsi_its_cam_msgs::access::setFromUTMPosition ( T & reference_position,
const gm::PointStamped & utm_position,
const int zone,
const bool northp )
inline

Set the ReferencePosition from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters
[out]reference_positionReferencePostion or ReferencePositionWithConfidence to set
[in]utm_positiongeometry_msgs::PointStamped describing the given utm position
[in]zonethe UTM zone (zero means UPS) of the given position
[in]northphemisphere (true means north, false means south)

Definition at line 314 of file cam_setters.h.

347 {
348
349#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
350
358inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
359 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
360}
361
368inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
369 auto accel_val = std::round(value * 1e1);
370 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
371 accel.value = static_cast<int16_t>(accel_val);
372 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
373 accel.value = LongitudinalAccelerationValue::MIN;
374 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
375 accel.value = LongitudinalAccelerationValue::MAX - 1;
376 }
377}
378
389inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
390 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
391 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
392}
393
400inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
401 int64_t accel_val = (int64_t)std::round(value * 1e1);
402 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
403 accel.value = accel_val;
404 } else if (accel_val < LateralAccelerationValue::MIN) {
405 accel.value = LateralAccelerationValue::MIN;
406 } else if (accel_val > LateralAccelerationValue::MAX) {
407 accel.value = LateralAccelerationValue::MAX - 1;
408 }
409}
410
421inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
422 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
423 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
424}
425
426#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
427
437inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
438 // First ensure, that the object has the correct heading by setting its value
439 double orientation = object_heading * 180 / M_PI; // Convert to degrees
440 // Normalize to [0, 360)
441 orientation = std::fmod(orientation + 360, 360);
442 while (orientation < 0) {
443 orientation += 360;
444 }
445 while (orientation >= 360) {
446 orientation -= 360;
447 }
448 setHeading(cam, orientation);
449 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
450 covariance_matrix, object_heading);
451}
452
461inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
462 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
463 covariance_matrix);
464}
465
466} // namespace etsi_its_cam_msgs::access

◆ setGenerationDeltaTime() [1/2]

void etsi_its_cam_msgs::access::setGenerationDeltaTime ( CAM & cam,
const uint64_t unix_nanosecs,
const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )
inline

Set the Generation Delta Time object.

Parameters
camCAM to set the GenerationDeltaTime-Value for
unix_nanosecsTimestamp in unix-nanoseconds to set the GenerationDeltaTime-Value from
n_leap_secondsNumber of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 97 of file cam_setters.h.

◆ setGenerationDeltaTime() [2/2]

void etsi_its_cam_msgs::access::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 )
inline

Set the GenerationDeltaTime-Value.

Parameters
generation_delta_timeGenerationDeltaTime to set the GenerationDeltaTime-Value for
unix_nanosecsTimestamp in unix-nanoseconds to set the GenerationDeltaTime-Value from
n_leap_secondsNumber of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 80 of file cam_setters.h.

87 {
88 int64_t accel_val = (int64_t)std::round(value * 1e1);

◆ setHeading()

void etsi_its_cam_msgs::access::setHeading ( CAM & cam,
const double heading_val,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Heading for a CAM.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters
camCAM to set the ReferencePosition
valueHeading value in degree as decimal number
confidencestandard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 123 of file cam_setters.h.

124 {
125 // First ensure, that the object has the correct heading by setting its value
126 double orientation = object_heading * 180 / M_PI; // Convert to degrees

◆ setHeadingCDD()

template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>
void etsi_its_cam_msgs::access::setHeadingCDD ( Heading & heading,
const double value,
double confidence = std::numeric_limits<double>::infinity() )

Set the Heading object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters
headingobject to set
valueHeading value in degree as decimal number
confidencestandard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 373 of file cam_setters.h.

406 {
407
408#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
409
417inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
418 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
419}
420
427inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
428 auto accel_val = std::round(value * 1e1);
429 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
430 accel.value = static_cast<int16_t>(accel_val);
431 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
432 accel.value = LongitudinalAccelerationValue::MIN;
433 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
434 accel.value = LongitudinalAccelerationValue::MAX - 1;
435 }
436}
437
448inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
449 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
450 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
451}
452
459inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
460 int64_t accel_val = (int64_t)std::round(value * 1e1);
461 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
462 accel.value = accel_val;
463 } else if (accel_val < LateralAccelerationValue::MIN) {
464 accel.value = LateralAccelerationValue::MIN;
465 } else if (accel_val > LateralAccelerationValue::MAX) {
466 accel.value = LateralAccelerationValue::MAX - 1;
467 }
468}
469
480inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
481 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
482 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
483}
484
485#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
486
496inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
497 // First ensure, that the object has the correct heading by setting its value
498 double orientation = object_heading * 180 / M_PI; // Convert to degrees
499 // Normalize to [0, 360)
500 orientation = std::fmod(orientation + 360, 360);
501 while (orientation < 0) {
502 orientation += 360;
503 }
504 while (orientation >= 360) {
505 orientation -= 360;
506 }
507 setHeading(cam, orientation);
508 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
509 covariance_matrix, object_heading);
510}
511
520inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
521 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
522 covariance_matrix);
523}
524
525} // namespace etsi_its_cam_msgs::access

◆ setHeadingConfidence()

template<typename HeadingConfidence>
void etsi_its_cam_msgs::access::setHeadingConfidence ( HeadingConfidence & heading_confidence,
const double value )
inline

Set the Heading Confidence object.

Parameters
heading_confidenceobject to set
valuestandard deviation of heading in degree as decimal number

Definition at line 352 of file cam_setters.h.

385 {
386
387#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
388
396inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
397 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
398}
399
406inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
407 auto accel_val = std::round(value * 1e1);
408 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
409 accel.value = static_cast<int16_t>(accel_val);
410 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
411 accel.value = LongitudinalAccelerationValue::MIN;
412 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
413 accel.value = LongitudinalAccelerationValue::MAX - 1;
414 }
415}
416
427inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
428 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
429 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
430}
431
438inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
439 int64_t accel_val = (int64_t)std::round(value * 1e1);
440 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
441 accel.value = accel_val;
442 } else if (accel_val < LateralAccelerationValue::MIN) {
443 accel.value = LateralAccelerationValue::MIN;
444 } else if (accel_val > LateralAccelerationValue::MAX) {
445 accel.value = LateralAccelerationValue::MAX - 1;
446 }
447}
448
459inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
460 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
461 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
462}
463
464#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
465
475inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
476 // First ensure, that the object has the correct heading by setting its value
477 double orientation = object_heading * 180 / M_PI; // Convert to degrees
478 // Normalize to [0, 360)
479 orientation = std::fmod(orientation + 360, 360);
480 while (orientation < 0) {
481 orientation += 360;
482 }
483 while (orientation >= 360) {
484 orientation -= 360;
485 }
486 setHeading(cam, orientation);
487 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
488 covariance_matrix, object_heading);
489}
490
499inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
500 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
501 covariance_matrix);
502}
503
504} // namespace etsi_its_cam_msgs::access

◆ setHeadingValue()

template<typename HeadingValue>
void etsi_its_cam_msgs::access::setHeadingValue ( HeadingValue & heading,
const double value )
inline

Set the HeadingValue object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West

Parameters
headingobject to set
valueHeading value in degree as decimal number

Definition at line 339 of file cam_setters.h.

372 {
373
374#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
375
383inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
384 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
385}
386
393inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
394 auto accel_val = std::round(value * 1e1);
395 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
396 accel.value = static_cast<int16_t>(accel_val);
397 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
398 accel.value = LongitudinalAccelerationValue::MIN;
399 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
400 accel.value = LongitudinalAccelerationValue::MAX - 1;
401 }
402}
403
414inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
415 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
416 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
417}
418
425inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
426 int64_t accel_val = (int64_t)std::round(value * 1e1);
427 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
428 accel.value = accel_val;
429 } else if (accel_val < LateralAccelerationValue::MIN) {
430 accel.value = LateralAccelerationValue::MIN;
431 } else if (accel_val > LateralAccelerationValue::MAX) {
432 accel.value = LateralAccelerationValue::MAX - 1;
433 }
434}
435
446inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
447 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
448 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
449}
450
451#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
452
462inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
463 // First ensure, that the object has the correct heading by setting its value
464 double orientation = object_heading * 180 / M_PI; // Convert to degrees
465 // Normalize to [0, 360)
466 orientation = std::fmod(orientation + 360, 360);
467 while (orientation < 0) {
468 orientation += 360;
469 }
470 while (orientation >= 360) {
471 orientation -= 360;
472 }
473 setHeading(cam, orientation);
474 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
475 covariance_matrix, object_heading);
476}
477
486inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
487 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
488 covariance_matrix);
489}
490
491} // namespace etsi_its_cam_msgs::access

◆ setItsPduHeader() [1/2]

void etsi_its_cam_msgs::access::setItsPduHeader ( CAM & cam,
const uint32_t station_id,
const uint8_t protocol_version = 0 )
inline

Set the ItsPduHeader-object for a CAM.

Parameters
camCAM-Message to set the ItsPduHeader
station_id
protocol_version

Definition at line 115 of file cam_setters.h.

◆ setItsPduHeader() [2/2]

void etsi_its_cam_msgs::access::setItsPduHeader ( ItsPduHeader & header,
const uint8_t message_id,
const uint32_t station_id,
const uint8_t protocol_version = 0 )
inline

Set the Its Pdu Header object.

Parameters
headerItsPduHeader to be set
message_idID of the message
station_id
protocol_version

Definition at line 85 of file cam_setters.h.

87 {
88 int64_t accel_val = (int64_t)std::round(value * 1e1);
89 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
90 accel.value = accel_val;
91 } else if (accel_val < LateralAccelerationValue::MIN) {
92 accel.value = LateralAccelerationValue::MIN;
93 } else if (accel_val > LateralAccelerationValue::MAX) {

◆ setLateralAcceleration() [1/2]

void etsi_its_cam_msgs::access::setLateralAcceleration ( CAM & cam,
const double lat_accel,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the lateral acceleration.

Parameters
camCAM to set the acceleration value s
lat_accellateral acceleration to set in m/s^2 as decimal number (left is positiv), if not available use 16.1 m/s^2
confidencestandard deviation of the lateral acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 226 of file cam_setters.h.

259 {
260
261#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
262
270inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
271 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
272}
273
280inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
281 auto accel_val = std::round(value * 1e1);
282 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
283 accel.value = static_cast<int16_t>(accel_val);
284 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
285 accel.value = LongitudinalAccelerationValue::MIN;
286 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
287 accel.value = LongitudinalAccelerationValue::MAX - 1;
288 }
289}
290
301inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
302 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
303 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
304}
305
312inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
313 int64_t accel_val = (int64_t)std::round(value * 1e1);
314 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
315 accel.value = accel_val;
316 } else if (accel_val < LateralAccelerationValue::MIN) {
317 accel.value = LateralAccelerationValue::MIN;
318 } else if (accel_val > LateralAccelerationValue::MAX) {
319 accel.value = LateralAccelerationValue::MAX - 1;
320 }
321}
322
333inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
334 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
335 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
336}
337
338#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
339
349inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
350 // First ensure, that the object has the correct heading by setting its value
351 double orientation = object_heading * 180 / M_PI; // Convert to degrees
352 // Normalize to [0, 360)
353 orientation = std::fmod(orientation + 360, 360);
354 while (orientation < 0) {
355 orientation += 360;
356 }
357 while (orientation >= 360) {
358 orientation -= 360;
359 }
360 setHeading(cam, orientation);
361 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
362 covariance_matrix, object_heading);
363}
364
373inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
374 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
375 covariance_matrix);
376}
377
378} // namespace etsi_its_cam_msgs::access

◆ setLateralAcceleration() [2/2]

void etsi_its_cam_msgs::access::setLateralAcceleration ( LateralAcceleration & accel,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the LateralAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

Parameters
accelobject to set
valueLaterallAccelerationValue in m/s^2 as decimal number (left is positive)
confidencestandard deviation of the lateral acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 178 of file cam_setters.h.

211 {
212
213#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
214
222inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
223 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
224}
225
232inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
233 auto accel_val = std::round(value * 1e1);
234 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
235 accel.value = static_cast<int16_t>(accel_val);
236 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
237 accel.value = LongitudinalAccelerationValue::MIN;
238 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
239 accel.value = LongitudinalAccelerationValue::MAX - 1;
240 }
241}
242
253inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
254 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
255 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
256}
257
264inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
265 int64_t accel_val = (int64_t)std::round(value * 1e1);
266 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
267 accel.value = accel_val;
268 } else if (accel_val < LateralAccelerationValue::MIN) {
269 accel.value = LateralAccelerationValue::MIN;
270 } else if (accel_val > LateralAccelerationValue::MAX) {
271 accel.value = LateralAccelerationValue::MAX - 1;
272 }
273}
274
285inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
286 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
287 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
288}
289
290#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
291
301inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
302 // First ensure, that the object has the correct heading by setting its value
303 double orientation = object_heading * 180 / M_PI; // Convert to degrees
304 // Normalize to [0, 360)
305 orientation = std::fmod(orientation + 360, 360);
306 while (orientation < 0) {
307 orientation += 360;
308 }
309 while (orientation >= 360) {
310 orientation -= 360;
311 }
312 setHeading(cam, orientation);
313 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
314 covariance_matrix, object_heading);
315}
316
325inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
326 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
327 covariance_matrix);
328}
329
330} // namespace etsi_its_cam_msgs::access

◆ setLateralAccelerationValue()

void etsi_its_cam_msgs::access::setLateralAccelerationValue ( LateralAccelerationValue & accel,
const double value )
inline

Set the LateralAccelerationValue object.

Parameters
accelobject to set
valueLateralAccelerationValue in m/s^2 as decimal number (left is positive)

Definition at line 157 of file cam_setters.h.

190 {
191
192#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
193
201inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
202 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
203}
204
211inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
212 auto accel_val = std::round(value * 1e1);
213 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
214 accel.value = static_cast<int16_t>(accel_val);
215 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
216 accel.value = LongitudinalAccelerationValue::MIN;
217 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
218 accel.value = LongitudinalAccelerationValue::MAX - 1;
219 }
220}
221
232inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
233 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
234 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
235}
236
243inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
244 int64_t accel_val = (int64_t)std::round(value * 1e1);
245 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
246 accel.value = accel_val;
247 } else if (accel_val < LateralAccelerationValue::MIN) {
248 accel.value = LateralAccelerationValue::MIN;
249 } else if (accel_val > LateralAccelerationValue::MAX) {
250 accel.value = LateralAccelerationValue::MAX - 1;
251 }
252}
253
264inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
265 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
266 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
267}
268
269#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
270
280inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
281 // First ensure, that the object has the correct heading by setting its value
282 double orientation = object_heading * 180 / M_PI; // Convert to degrees
283 // Normalize to [0, 360)
284 orientation = std::fmod(orientation + 360, 360);
285 while (orientation < 0) {
286 orientation += 360;
287 }
288 while (orientation >= 360) {
289 orientation -= 360;
290 }
291 setHeading(cam, orientation);
292 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
293 covariance_matrix, object_heading);
294}
295
304inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
305 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
306 covariance_matrix);
307}
308
309} // namespace etsi_its_cam_msgs::access

◆ setLatitude()

void etsi_its_cam_msgs::access::setLatitude ( Latitude & latitude,
const double deg )
inline

Set the Latitude object.

Parameters
latitudeobject to set
degLatitude value in degree as decimal number

Definition at line 123 of file cam_setters.h.

124 {
125 // First ensure, that the object has the correct heading by setting its value
126 double orientation = object_heading * 180 / M_PI; // Convert to degrees
127 // Normalize to [0, 360)

◆ setLightBarSirenInUse()

void etsi_its_cam_msgs::access::setLightBarSirenInUse ( LightBarSirenInUse & light_bar_siren_in_use,
const std::vector< bool > & bits )
inline

Set the Lightbar Siren In Use by a vector of bools.

Parameters
light_bar_siren_in_use
bits

Definition at line 337 of file cam_setters.h.

370 {
371
372#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
373
381inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
382 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
383}
384
391inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
392 auto accel_val = std::round(value * 1e1);
393 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
394 accel.value = static_cast<int16_t>(accel_val);
395 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
396 accel.value = LongitudinalAccelerationValue::MIN;
397 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
398 accel.value = LongitudinalAccelerationValue::MAX - 1;
399 }
400}
401
412inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
413 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
414 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
415}
416
423inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
424 int64_t accel_val = (int64_t)std::round(value * 1e1);
425 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
426 accel.value = accel_val;
427 } else if (accel_val < LateralAccelerationValue::MIN) {
428 accel.value = LateralAccelerationValue::MIN;
429 } else if (accel_val > LateralAccelerationValue::MAX) {
430 accel.value = LateralAccelerationValue::MAX - 1;
431 }
432}
433
444inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
445 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
446 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
447}
448
449#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
450
460inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
461 // First ensure, that the object has the correct heading by setting its value
462 double orientation = object_heading * 180 / M_PI; // Convert to degrees
463 // Normalize to [0, 360)
464 orientation = std::fmod(orientation + 360, 360);
465 while (orientation < 0) {
466 orientation += 360;
467 }
468 while (orientation >= 360) {
469 orientation -= 360;
470 }
471 setHeading(cam, orientation);
472 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
473 covariance_matrix, object_heading);
474}
475
484inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
485 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
486 covariance_matrix);
487}
488
489} // namespace etsi_its_cam_msgs::access

◆ setLongitude()

void etsi_its_cam_msgs::access::setLongitude ( Longitude & longitude,
const double deg )
inline

Set the Longitude object.

Parameters
longitudeobject to set
degLongitude value in degree as decimal number

Definition at line 135 of file cam_setters.h.

◆ setLongitudinalAcceleration() [1/2]

void etsi_its_cam_msgs::access::setLongitudinalAcceleration ( CAM & cam,
const double lon_accel,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the longitudinal acceleration.

Parameters
camCAM to set the acceleration value s
lon_accellongitudinal acceleration to set in m/s^2 as decimal number (braking is negative), if not available use 16.1 m/s^2
confidencestandard deviation of the longitudinal acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 212 of file cam_setters.h.

245 {
246
247#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
248
256inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
257 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
258}
259
266inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
267 auto accel_val = std::round(value * 1e1);
268 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
269 accel.value = static_cast<int16_t>(accel_val);
270 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
271 accel.value = LongitudinalAccelerationValue::MIN;
272 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
273 accel.value = LongitudinalAccelerationValue::MAX - 1;
274 }
275}
276
287inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
288 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
289 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
290}
291
298inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
299 int64_t accel_val = (int64_t)std::round(value * 1e1);
300 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
301 accel.value = accel_val;
302 } else if (accel_val < LateralAccelerationValue::MIN) {
303 accel.value = LateralAccelerationValue::MIN;
304 } else if (accel_val > LateralAccelerationValue::MAX) {
305 accel.value = LateralAccelerationValue::MAX - 1;
306 }
307}
308
319inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
320 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
321 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
322}
323
324#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
325
335inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
336 // First ensure, that the object has the correct heading by setting its value
337 double orientation = object_heading * 180 / M_PI; // Convert to degrees
338 // Normalize to [0, 360)
339 orientation = std::fmod(orientation + 360, 360);
340 while (orientation < 0) {
341 orientation += 360;
342 }
343 while (orientation >= 360) {
344 orientation -= 360;
345 }
346 setHeading(cam, orientation);
347 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
348 covariance_matrix, object_heading);
349}
350
359inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
360 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
361 covariance_matrix);
362}
363
364} // namespace etsi_its_cam_msgs::access

◆ setLongitudinalAcceleration() [2/2]

void etsi_its_cam_msgs::access::setLongitudinalAcceleration ( LongitudinalAcceleration & accel,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the LongitudinalAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

Parameters
accelobject to set
valueLongitudinalAccelerationValue in m/s^2 as decimal number (braking is negative)
confidencestandard deviation of the longitudinal acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 146 of file cam_setters.h.

148 {
149 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,

◆ setLongitudinalAccelerationValue()

void etsi_its_cam_msgs::access::setLongitudinalAccelerationValue ( LongitudinalAccelerationValue & accel,
const double value )
inline

Set the LongitudinalAccelerationValue object.

Parameters
accelobject to set
valueLongitudinalAccelerationValue in m/s^2 as decimal number (braking is negative)

Definition at line 125 of file cam_setters.h.

129 {
130 orientation += 360;
131 }
132 while (orientation >= 360) {
133 orientation -= 360;
134 }

◆ setPosConfidenceEllipse() [1/2]

template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const double semi_major_axis,
const double semi_minor_axis,
const double orientation )
inline

Set the Pos Confidence Ellipse object.

Parameters
[out]position_confidence_ellipseThe PosConfidenceEllipse to set
[in]semi_major_axislength of the semi-major axis in meters
[in]semi_minor_axislength of the semi-minor axis in meters
[in]orientationof the semi-major axis in degrees, with respect to WGS84

Definition at line 451 of file cam_setters.h.

484 {
485
486#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
487
495inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
496 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
497}
498
505inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
506 auto accel_val = std::round(value * 1e1);
507 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
508 accel.value = static_cast<int16_t>(accel_val);
509 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
510 accel.value = LongitudinalAccelerationValue::MIN;
511 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
512 accel.value = LongitudinalAccelerationValue::MAX - 1;
513 }
514}
515
526inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
527 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
528 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
529}
530
537inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
538 int64_t accel_val = (int64_t)std::round(value * 1e1);
539 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
540 accel.value = accel_val;
541 } else if (accel_val < LateralAccelerationValue::MIN) {
542 accel.value = LateralAccelerationValue::MIN;
543 } else if (accel_val > LateralAccelerationValue::MAX) {
544 accel.value = LateralAccelerationValue::MAX - 1;
545 }
546}
547
558inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
559 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
560 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
561}
562
563#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
564
574inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
575 // First ensure, that the object has the correct heading by setting its value
576 double orientation = object_heading * 180 / M_PI; // Convert to degrees
577 // Normalize to [0, 360)
578 orientation = std::fmod(orientation + 360, 360);
579 while (orientation < 0) {
580 orientation += 360;
581 }
582 while (orientation >= 360) {
583 orientation -= 360;
584 }
585 setHeading(cam, orientation);
586 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
587 covariance_matrix, object_heading);
588}
589
598inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
599 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
600 covariance_matrix);
601}
602
603} // namespace etsi_its_cam_msgs::access

◆ setPosConfidenceEllipse() [2/2]

template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const std::array< double, 4 > & covariance_matrix,
const double object_heading )
inline

Set the Pos Confidence Ellipse object.

Parameters
position_confidence_ellipse
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_headingThe heading of the object in rad, with respect to WGS84

Definition at line 524 of file cam_setters.h.

557 {
558
559#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
560
568inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
569 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
570}
571
578inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
579 auto accel_val = std::round(value * 1e1);
580 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
581 accel.value = static_cast<int16_t>(accel_val);
582 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
583 accel.value = LongitudinalAccelerationValue::MIN;
584 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
585 accel.value = LongitudinalAccelerationValue::MAX - 1;
586 }
587}
588
599inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
600 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
601 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
602}
603
610inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
611 int64_t accel_val = (int64_t)std::round(value * 1e1);
612 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
613 accel.value = accel_val;
614 } else if (accel_val < LateralAccelerationValue::MIN) {
615 accel.value = LateralAccelerationValue::MIN;
616 } else if (accel_val > LateralAccelerationValue::MAX) {
617 accel.value = LateralAccelerationValue::MAX - 1;
618 }
619}
620
631inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
632 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
633 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
634}
635
636#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
637
647inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
648 // First ensure, that the object has the correct heading by setting its value
649 double orientation = object_heading * 180 / M_PI; // Convert to degrees
650 // Normalize to [0, 360)
651 orientation = std::fmod(orientation + 360, 360);
652 while (orientation < 0) {
653 orientation += 360;
654 }
655 while (orientation >= 360) {
656 orientation -= 360;
657 }
658 setHeading(cam, orientation);
659 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
660 covariance_matrix, object_heading);
661}
662
671inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
672 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
673 covariance_matrix);
674}
675
676} // namespace etsi_its_cam_msgs::access

◆ setReferencePosition() [1/2]

void etsi_its_cam_msgs::access::setReferencePosition ( CAM & cam,
const double latitude,
const double longitude,
const double altitude = AltitudeValue::UNAVAILABLE )
inline

Set the ReferencePosition for a CAM.

This function sets the latitude, longitude, and altitude of the CAMs reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters
camCAM to set the ReferencePosition
latitudeThe latitude value position in degree as decimal number.
longitudeThe longitude value in degree as decimal number.
altitudeThe altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 245 of file cam_setters.h.

278 {
279
280#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
281
289inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
290 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
291}
292
299inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
300 auto accel_val = std::round(value * 1e1);
301 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
302 accel.value = static_cast<int16_t>(accel_val);
303 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
304 accel.value = LongitudinalAccelerationValue::MIN;
305 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
306 accel.value = LongitudinalAccelerationValue::MAX - 1;
307 }
308}
309
320inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
321 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
322 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
323}
324
331inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
332 int64_t accel_val = (int64_t)std::round(value * 1e1);
333 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
334 accel.value = accel_val;
335 } else if (accel_val < LateralAccelerationValue::MIN) {
336 accel.value = LateralAccelerationValue::MIN;
337 } else if (accel_val > LateralAccelerationValue::MAX) {
338 accel.value = LateralAccelerationValue::MAX - 1;
339 }
340}
341
352inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
353 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
354 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
355}
356
357#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
358
368inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
369 // First ensure, that the object has the correct heading by setting its value
370 double orientation = object_heading * 180 / M_PI; // Convert to degrees
371 // Normalize to [0, 360)
372 orientation = std::fmod(orientation + 360, 360);
373 while (orientation < 0) {
374 orientation += 360;
375 }
376 while (orientation >= 360) {
377 orientation -= 360;
378 }
379 setHeading(cam, orientation);
380 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
381 covariance_matrix, object_heading);
382}
383
392inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
393 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
394 covariance_matrix);
395}
396
397} // namespace etsi_its_cam_msgs::access

◆ setReferencePosition() [2/2]

template<typename T>
void etsi_its_cam_msgs::access::setReferencePosition ( T & ref_position,
const double latitude,
const double longitude,
const double altitude = AltitudeValue::UNAVAILABLE )
inline

Sets the reference position in the given ReferencePostion object.

This function sets the latitude, longitude, and altitude of the reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters
ref_positionReferencePostion or ReferencePositionWithConfidence object to set the reference position in.
latitudeThe latitude value position in degree as decimal number.
longitudeThe longitude value in degree as decimal number.
altitudeThe altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 288 of file cam_setters.h.

321 {
322
323#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
324
332inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
333 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
334}
335
342inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
343 auto accel_val = std::round(value * 1e1);
344 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
345 accel.value = static_cast<int16_t>(accel_val);
346 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
347 accel.value = LongitudinalAccelerationValue::MIN;
348 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
349 accel.value = LongitudinalAccelerationValue::MAX - 1;
350 }
351}
352
363inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
364 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
365 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
366}
367
374inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
375 int64_t accel_val = (int64_t)std::round(value * 1e1);
376 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
377 accel.value = accel_val;
378 } else if (accel_val < LateralAccelerationValue::MIN) {
379 accel.value = LateralAccelerationValue::MIN;
380 } else if (accel_val > LateralAccelerationValue::MAX) {
381 accel.value = LateralAccelerationValue::MAX - 1;
382 }
383}
384
395inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
396 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
397 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
398}
399
400#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
401
411inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
412 // First ensure, that the object has the correct heading by setting its value
413 double orientation = object_heading * 180 / M_PI; // Convert to degrees
414 // Normalize to [0, 360)
415 orientation = std::fmod(orientation + 360, 360);
416 while (orientation < 0) {
417 orientation += 360;
418 }
419 while (orientation >= 360) {
420 orientation -= 360;
421 }
422 setHeading(cam, orientation);
423 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
424 covariance_matrix, object_heading);
425}
426
435inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
436 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
437 covariance_matrix);
438}
439
440} // namespace etsi_its_cam_msgs::access

◆ setRefPosConfidence()

void etsi_its_cam_msgs::access::setRefPosConfidence ( CAM & cam,
const std::array< double, 4 > & covariance_matrix,
const double object_heading )
inline

Set the confidence of the reference position.

Parameters
camCAM-Message to set the confidence
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_headingheading of the object in rad, with respect to WGS84

Definition at line 362 of file cam_setters.h.

395 {
396
397#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
398
406inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
407 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
408}
409
416inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
417 auto accel_val = std::round(value * 1e1);
418 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
419 accel.value = static_cast<int16_t>(accel_val);
420 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
421 accel.value = LongitudinalAccelerationValue::MIN;
422 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
423 accel.value = LongitudinalAccelerationValue::MAX - 1;
424 }
425}
426
437inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
438 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
439 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
440}
441
448inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
449 int64_t accel_val = (int64_t)std::round(value * 1e1);
450 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
451 accel.value = accel_val;
452 } else if (accel_val < LateralAccelerationValue::MIN) {
453 accel.value = LateralAccelerationValue::MIN;
454 } else if (accel_val > LateralAccelerationValue::MAX) {
455 accel.value = LateralAccelerationValue::MAX - 1;
456 }
457}
458
469inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
470 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
471 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
472}
473
474#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
475
485inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
486 // First ensure, that the object has the correct heading by setting its value
487 double orientation = object_heading * 180 / M_PI; // Convert to degrees
488 // Normalize to [0, 360)
489 orientation = std::fmod(orientation + 360, 360);
490 while (orientation < 0) {
491 orientation += 360;
492 }
493 while (orientation >= 360) {
494 orientation -= 360;
495 }
496 setHeading(cam, orientation);
497 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
498 covariance_matrix, object_heading);
499}
500
509inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
510 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
511 covariance_matrix);
512}
513
514} // namespace etsi_its_cam_msgs::access

◆ setSemiAxis()

template<typename SemiAxisLength>
void etsi_its_cam_msgs::access::setSemiAxis ( SemiAxisLength & semi_axis_length,
const double length )
inline

Set the Semi Axis length.

// See https://godbolt.org/z/Eceavfo99 on how the OneCentimeterHelper works with this template

Parameters
semi_axis_lengthThe SemiAxisLength to set
lengththe desired length in meters

Definition at line 432 of file cam_setters.h.

465 {
466
467#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
468
476inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
477 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
478}
479
486inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
487 auto accel_val = std::round(value * 1e1);
488 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
489 accel.value = static_cast<int16_t>(accel_val);
490 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
491 accel.value = LongitudinalAccelerationValue::MIN;
492 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
493 accel.value = LongitudinalAccelerationValue::MAX - 1;
494 }
495}
496
507inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
508 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
509 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
510}
511
518inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
519 int64_t accel_val = (int64_t)std::round(value * 1e1);
520 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
521 accel.value = accel_val;
522 } else if (accel_val < LateralAccelerationValue::MIN) {
523 accel.value = LateralAccelerationValue::MIN;
524 } else if (accel_val > LateralAccelerationValue::MAX) {
525 accel.value = LateralAccelerationValue::MAX - 1;
526 }
527}
528
539inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
540 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
541 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
542}
543
544#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
545
555inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
556 // First ensure, that the object has the correct heading by setting its value
557 double orientation = object_heading * 180 / M_PI; // Convert to degrees
558 // Normalize to [0, 360)
559 orientation = std::fmod(orientation + 360, 360);
560 while (orientation < 0) {
561 orientation += 360;
562 }
563 while (orientation >= 360) {
564 orientation -= 360;
565 }
566 setHeading(cam, orientation);
567 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
568 covariance_matrix, object_heading);
569}
570
579inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
580 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
581 covariance_matrix);
582}
583
584} // namespace etsi_its_cam_msgs::access

◆ setSpecialTransportType()

void etsi_its_cam_msgs::access::setSpecialTransportType ( SpecialTransportType & special_transport_type,
const std::vector< bool > & bits )
inline

Set the Special Transport Type by a vector of bools.

Parameters
special_transport_type
bits

Definition at line 327 of file cam_setters.h.

360 {
361
362#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
363
371inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
372 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
373}
374
381inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
382 auto accel_val = std::round(value * 1e1);
383 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
384 accel.value = static_cast<int16_t>(accel_val);
385 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
386 accel.value = LongitudinalAccelerationValue::MIN;
387 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
388 accel.value = LongitudinalAccelerationValue::MAX - 1;
389 }
390}
391
402inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
403 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
404 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
405}
406
413inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
414 int64_t accel_val = (int64_t)std::round(value * 1e1);
415 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
416 accel.value = accel_val;
417 } else if (accel_val < LateralAccelerationValue::MIN) {
418 accel.value = LateralAccelerationValue::MIN;
419 } else if (accel_val > LateralAccelerationValue::MAX) {
420 accel.value = LateralAccelerationValue::MAX - 1;
421 }
422}
423
434inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
435 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
436 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
437}
438
439#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
440
450inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
451 // First ensure, that the object has the correct heading by setting its value
452 double orientation = object_heading * 180 / M_PI; // Convert to degrees
453 // Normalize to [0, 360)
454 orientation = std::fmod(orientation + 360, 360);
455 while (orientation < 0) {
456 orientation += 360;
457 }
458 while (orientation >= 360) {
459 orientation -= 360;
460 }
461 setHeading(cam, orientation);
462 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
463 covariance_matrix, object_heading);
464}
465
474inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
475 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
476 covariance_matrix);
477}
478
479} // namespace etsi_its_cam_msgs::access

◆ setSpeed() [1/2]

void etsi_its_cam_msgs::access::setSpeed ( CAM & cam,
const double speed_val,
const double confidence = SpeedConfidence::UNAVAILABLE )
inline

Set the vehicle speed.

Parameters
camCAM to set the speed value
speed_valspeed value to set in m/s as decimal number

Definition at line 200 of file cam_setters.h.

233 {
234
235#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
236
244inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
245 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
246}
247
254inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
255 auto accel_val = std::round(value * 1e1);
256 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
257 accel.value = static_cast<int16_t>(accel_val);
258 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
259 accel.value = LongitudinalAccelerationValue::MIN;
260 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
261 accel.value = LongitudinalAccelerationValue::MAX - 1;
262 }
263}
264
275inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
276 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
277 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
278}
279
286inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
287 int64_t accel_val = (int64_t)std::round(value * 1e1);
288 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
289 accel.value = accel_val;
290 } else if (accel_val < LateralAccelerationValue::MIN) {
291 accel.value = LateralAccelerationValue::MIN;
292 } else if (accel_val > LateralAccelerationValue::MAX) {
293 accel.value = LateralAccelerationValue::MAX - 1;
294 }
295}
296
307inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
308 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
309 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
310}
311
312#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
313
323inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
324 // First ensure, that the object has the correct heading by setting its value
325 double orientation = object_heading * 180 / M_PI; // Convert to degrees
326 // Normalize to [0, 360)
327 orientation = std::fmod(orientation + 360, 360);
328 while (orientation < 0) {
329 orientation += 360;
330 }
331 while (orientation >= 360) {
332 orientation -= 360;
333 }
334 setHeading(cam, orientation);
335 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
336 covariance_matrix, object_heading);
337}
338
347inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
348 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
349 covariance_matrix);
350}
351
352} // namespace etsi_its_cam_msgs::access

◆ setSpeed() [2/2]

void etsi_its_cam_msgs::access::setSpeed ( Speed & speed,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Speed object.

SpeedConfidence is set to UNAVAILABLE

Parameters
speedobject to set
valueSpeed in in m/s as decimal number
confidencestandard deviation in m/s as decimal number (Optional. Default is std::numeric_limits<double>::infinity(), mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 208 of file cam_setters.h.

241 {
242
243#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
244
252inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
253 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
254}
255
262inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
263 auto accel_val = std::round(value * 1e1);
264 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
265 accel.value = static_cast<int16_t>(accel_val);
266 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
267 accel.value = LongitudinalAccelerationValue::MIN;
268 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
269 accel.value = LongitudinalAccelerationValue::MAX - 1;
270 }
271}
272
283inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
284 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
285 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
286}
287
294inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
295 int64_t accel_val = (int64_t)std::round(value * 1e1);
296 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
297 accel.value = accel_val;
298 } else if (accel_val < LateralAccelerationValue::MIN) {
299 accel.value = LateralAccelerationValue::MIN;
300 } else if (accel_val > LateralAccelerationValue::MAX) {
301 accel.value = LateralAccelerationValue::MAX - 1;
302 }
303}
304
315inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
316 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
317 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
318}
319
320#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
321
331inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
332 // First ensure, that the object has the correct heading by setting its value
333 double orientation = object_heading * 180 / M_PI; // Convert to degrees
334 // Normalize to [0, 360)
335 orientation = std::fmod(orientation + 360, 360);
336 while (orientation < 0) {
337 orientation += 360;
338 }
339 while (orientation >= 360) {
340 orientation -= 360;
341 }
342 setHeading(cam, orientation);
343 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
344 covariance_matrix, object_heading);
345}
346
355inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
356 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
357 covariance_matrix);
358}
359
360} // namespace etsi_its_cam_msgs::access

◆ setSpeedConfidence()

void etsi_its_cam_msgs::access::setSpeedConfidence ( SpeedConfidence & speed_confidence,
const double value )
inline

Set the Speed Confidence object.

Parameters
speed_confidenceobject to set
valuestandard deviation in m/s as decimal number

Definition at line 189 of file cam_setters.h.

222 {
223
224#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
225
233inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
234 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
235}
236
243inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
244 auto accel_val = std::round(value * 1e1);
245 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
246 accel.value = static_cast<int16_t>(accel_val);
247 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
248 accel.value = LongitudinalAccelerationValue::MIN;
249 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
250 accel.value = LongitudinalAccelerationValue::MAX - 1;
251 }
252}
253
264inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
265 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
266 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
267}
268
275inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
276 int64_t accel_val = (int64_t)std::round(value * 1e1);
277 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
278 accel.value = accel_val;
279 } else if (accel_val < LateralAccelerationValue::MIN) {
280 accel.value = LateralAccelerationValue::MIN;
281 } else if (accel_val > LateralAccelerationValue::MAX) {
282 accel.value = LateralAccelerationValue::MAX - 1;
283 }
284}
285
296inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
297 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
298 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
299}
300
301#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
302
312inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
313 // First ensure, that the object has the correct heading by setting its value
314 double orientation = object_heading * 180 / M_PI; // Convert to degrees
315 // Normalize to [0, 360)
316 orientation = std::fmod(orientation + 360, 360);
317 while (orientation < 0) {
318 orientation += 360;
319 }
320 while (orientation >= 360) {
321 orientation -= 360;
322 }
323 setHeading(cam, orientation);
324 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
325 covariance_matrix, object_heading);
326}
327
336inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
337 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
338 covariance_matrix);
339}
340
341} // namespace etsi_its_cam_msgs::access

◆ setSpeedValue()

void etsi_its_cam_msgs::access::setSpeedValue ( SpeedValue & speed,
const double value )
inline

Set the SpeedValue object.

Parameters
speedobject to set
valueSpeedValue in m/s as decimal number

Definition at line 177 of file cam_setters.h.

210 {
211
212#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
213
221inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
222 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
223}
224
231inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
232 auto accel_val = std::round(value * 1e1);
233 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
234 accel.value = static_cast<int16_t>(accel_val);
235 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
236 accel.value = LongitudinalAccelerationValue::MIN;
237 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
238 accel.value = LongitudinalAccelerationValue::MAX - 1;
239 }
240}
241
252inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
253 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
254 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
255}
256
263inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
264 int64_t accel_val = (int64_t)std::round(value * 1e1);
265 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
266 accel.value = accel_val;
267 } else if (accel_val < LateralAccelerationValue::MIN) {
268 accel.value = LateralAccelerationValue::MIN;
269 } else if (accel_val > LateralAccelerationValue::MAX) {
270 accel.value = LateralAccelerationValue::MAX - 1;
271 }
272}
273
284inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
285 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
286 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
287}
288
289#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
290
300inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
301 // First ensure, that the object has the correct heading by setting its value
302 double orientation = object_heading * 180 / M_PI; // Convert to degrees
303 // Normalize to [0, 360)
304 orientation = std::fmod(orientation + 360, 360);
305 while (orientation < 0) {
306 orientation += 360;
307 }
308 while (orientation >= 360) {
309 orientation -= 360;
310 }
311 setHeading(cam, orientation);
312 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
313 covariance_matrix, object_heading);
314}
315
324inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
325 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
326 covariance_matrix);
327}
328
329} // namespace etsi_its_cam_msgs::access

◆ setStationId()

void etsi_its_cam_msgs::access::setStationId ( StationID & station_id,
const uint32_t id_value )
inline

Set the Station Id object.

Parameters
station_id
id_value

Definition at line 72 of file cam_setters.h.

◆ setStationType() [1/2]

void etsi_its_cam_msgs::access::setStationType ( CAM & cam,
const uint8_t value )
inline

Set the StationType for a CAM.

Parameters
camCAM-Message to set the station_type value
valuestation_type value to set

Definition at line 109 of file cam_setters.h.

◆ setStationType() [2/2]

void etsi_its_cam_msgs::access::setStationType ( StationType & station_type,
const uint8_t value )
inline

Set the Station Type.

Parameters
station_type
value

Definition at line 101 of file cam_setters.h.

◆ setTimestampITS()

void etsi_its_cam_msgs::access::setTimestampITS ( TimestampIts & timestamp_its,
const uint64_t unix_nanosecs,
const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )
inline

Set the TimestampITS object.

Parameters
[in]timestamp_itsTimestampITS object to set the timestamp
[in]unix_nanosecsUnix-Nanoseconds to set the timestamp for
[in]n_leap_secondsNumber of leap-seconds since 2004. (Defaults to the todays number of leap seconds since 2004.)
[in]epoch_offsetUnix-Timestamp in seconds for the 01.01.2004 at 00:00:00

Definition at line 109 of file cam_setters.h.

◆ setVehicleDimensions()

void etsi_its_cam_msgs::access::setVehicleDimensions ( CAM & cam,
const double vehicle_length,
const double vehicle_width )
inline

Set the vehicle dimensions.

Parameters
camCAM to set the vehicle dimensions
vehicle_lengthvehicle length in meter as decimal number
vehicle_widthvehicle width in meter as decimal number

Definition at line 186 of file cam_setters.h.

219 {
220
221#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
222
230inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
231 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
232}
233
240inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
241 auto accel_val = std::round(value * 1e1);
242 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
243 accel.value = static_cast<int16_t>(accel_val);
244 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
245 accel.value = LongitudinalAccelerationValue::MIN;
246 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
247 accel.value = LongitudinalAccelerationValue::MAX - 1;
248 }
249}
250
261inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
262 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
263 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
264}
265
272inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
273 int64_t accel_val = (int64_t)std::round(value * 1e1);
274 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
275 accel.value = accel_val;
276 } else if (accel_val < LateralAccelerationValue::MIN) {
277 accel.value = LateralAccelerationValue::MIN;
278 } else if (accel_val > LateralAccelerationValue::MAX) {
279 accel.value = LateralAccelerationValue::MAX - 1;
280 }
281}
282
293inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
294 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
295 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
296}
297
298#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
299
309inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
310 // First ensure, that the object has the correct heading by setting its value
311 double orientation = object_heading * 180 / M_PI; // Convert to degrees
312 // Normalize to [0, 360)
313 orientation = std::fmod(orientation + 360, 360);
314 while (orientation < 0) {
315 orientation += 360;
316 }
317 while (orientation >= 360) {
318 orientation -= 360;
319 }
320 setHeading(cam, orientation);
321 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
322 covariance_matrix, object_heading);
323}
324
333inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
334 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
335 covariance_matrix);
336}
337
338} // namespace etsi_its_cam_msgs::access

◆ setVehicleLength()

void etsi_its_cam_msgs::access::setVehicleLength ( VehicleLength & vehicle_length,
const double value )
inline

Set the VehicleLength object.

VehicleLengthConfidenceIndication is set to UNAVAILABLE

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 174 of file cam_setters.h.

207 {
208
209#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
210
218inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
219 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
220}
221
228inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
229 auto accel_val = std::round(value * 1e1);
230 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
231 accel.value = static_cast<int16_t>(accel_val);
232 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
233 accel.value = LongitudinalAccelerationValue::MIN;
234 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
235 accel.value = LongitudinalAccelerationValue::MAX - 1;
236 }
237}
238
249inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
250 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
251 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
252}
253
260inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
261 int64_t accel_val = (int64_t)std::round(value * 1e1);
262 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
263 accel.value = accel_val;
264 } else if (accel_val < LateralAccelerationValue::MIN) {
265 accel.value = LateralAccelerationValue::MIN;
266 } else if (accel_val > LateralAccelerationValue::MAX) {
267 accel.value = LateralAccelerationValue::MAX - 1;
268 }
269}
270
281inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
282 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
283 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
284}
285
286#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
287
297inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
298 // First ensure, that the object has the correct heading by setting its value
299 double orientation = object_heading * 180 / M_PI; // Convert to degrees
300 // Normalize to [0, 360)
301 orientation = std::fmod(orientation + 360, 360);
302 while (orientation < 0) {
303 orientation += 360;
304 }
305 while (orientation >= 360) {
306 orientation -= 360;
307 }
308 setHeading(cam, orientation);
309 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
310 covariance_matrix, object_heading);
311}
312
321inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
322 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
323 covariance_matrix);
324}
325
326} // namespace etsi_its_cam_msgs::access

◆ setVehicleLengthValue()

void etsi_its_cam_msgs::access::setVehicleLengthValue ( VehicleLengthValue & vehicle_length,
const double value )
inline

Set the VehicleLengthValue object.

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 160 of file cam_setters.h.

193 {
194
195#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
196
204inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
205 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
206}
207
214inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
215 auto accel_val = std::round(value * 1e1);
216 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
217 accel.value = static_cast<int16_t>(accel_val);
218 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
219 accel.value = LongitudinalAccelerationValue::MIN;
220 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
221 accel.value = LongitudinalAccelerationValue::MAX - 1;
222 }
223}
224
235inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
236 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
237 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
238}
239
246inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
247 int64_t accel_val = (int64_t)std::round(value * 1e1);
248 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
249 accel.value = accel_val;
250 } else if (accel_val < LateralAccelerationValue::MIN) {
251 accel.value = LateralAccelerationValue::MIN;
252 } else if (accel_val > LateralAccelerationValue::MAX) {
253 accel.value = LateralAccelerationValue::MAX - 1;
254 }
255}
256
267inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
268 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
269 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
270}
271
272#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
273
283inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
284 // First ensure, that the object has the correct heading by setting its value
285 double orientation = object_heading * 180 / M_PI; // Convert to degrees
286 // Normalize to [0, 360)
287 orientation = std::fmod(orientation + 360, 360);
288 while (orientation < 0) {
289 orientation += 360;
290 }
291 while (orientation >= 360) {
292 orientation -= 360;
293 }
294 setHeading(cam, orientation);
295 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
296 covariance_matrix, object_heading);
297}
298
307inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
308 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
309 covariance_matrix);
310}
311
312} // namespace etsi_its_cam_msgs::access

◆ setVehicleWidth()

void etsi_its_cam_msgs::access::setVehicleWidth ( VehicleWidth & vehicle_width,
const double value )
inline

Set the VehicleWidth object.

Parameters
vehicle_widthobject to set
valueVehicleWidth in meter as decimal number

Definition at line 148 of file cam_setters.h.

148 {
149 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
150 covariance_matrix);
151}
152

◆ setWGSPosConfidenceEllipse()

template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const std::array< double, 4 > & covariance_matrix )
inline

Set the Pos Confidence Ellipse object.

Parameters
position_confidence_ellipse
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_headingThe heading of the object in rad, with respect to WGS84

Definition at line 539 of file cam_setters.h.

572 {
573
574#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
575
583inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
584 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
585}
586
593inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
594 auto accel_val = std::round(value * 1e1);
595 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
596 accel.value = static_cast<int16_t>(accel_val);
597 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
598 accel.value = LongitudinalAccelerationValue::MIN;
599 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
600 accel.value = LongitudinalAccelerationValue::MAX - 1;
601 }
602}
603
614inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
615 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
616 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
617}
618
625inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
626 int64_t accel_val = (int64_t)std::round(value * 1e1);
627 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
628 accel.value = accel_val;
629 } else if (accel_val < LateralAccelerationValue::MIN) {
630 accel.value = LateralAccelerationValue::MIN;
631 } else if (accel_val > LateralAccelerationValue::MAX) {
632 accel.value = LateralAccelerationValue::MAX - 1;
633 }
634}
635
646inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
647 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
648 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
649}
650
651#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
652
662inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
663 // First ensure, that the object has the correct heading by setting its value
664 double orientation = object_heading * 180 / M_PI; // Convert to degrees
665 // Normalize to [0, 360)
666 orientation = std::fmod(orientation + 360, 360);
667 while (orientation < 0) {
668 orientation += 360;
669 }
670 while (orientation >= 360) {
671 orientation -= 360;
672 }
673 setHeading(cam, orientation);
674 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
675 covariance_matrix, object_heading);
676}
677
686inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
687 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
688 covariance_matrix);
689}
690
691} // namespace etsi_its_cam_msgs::access

◆ setWGSRefPosConfidence()

void etsi_its_cam_msgs::access::setWGSRefPosConfidence ( CAM & cam,
const std::array< double, 4 > & covariance_matrix )
inline

Set the confidence of the reference position.

Parameters
camCAM-Message to set the confidence
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is WGS84 (x = North, y = East)

Definition at line 386 of file cam_setters.h.

419 {
420
421#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
422
430inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
431 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
432}
433
440inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
441 auto accel_val = std::round(value * 1e1);
442 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
443 accel.value = static_cast<int16_t>(accel_val);
444 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
445 accel.value = LongitudinalAccelerationValue::MIN;
446 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
447 accel.value = LongitudinalAccelerationValue::MAX - 1;
448 }
449}
450
461inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
462 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
463 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
464}
465
472inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
473 int64_t accel_val = (int64_t)std::round(value * 1e1);
474 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
475 accel.value = accel_val;
476 } else if (accel_val < LateralAccelerationValue::MIN) {
477 accel.value = LateralAccelerationValue::MIN;
478 } else if (accel_val > LateralAccelerationValue::MAX) {
479 accel.value = LateralAccelerationValue::MAX - 1;
480 }
481}
482
493inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
494 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
495 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
496}
497
498#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
499
509inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
510 // First ensure, that the object has the correct heading by setting its value
511 double orientation = object_heading * 180 / M_PI; // Convert to degrees
512 // Normalize to [0, 360)
513 orientation = std::fmod(orientation + 360, 360);
514 while (orientation < 0) {
515 orientation += 360;
516 }
517 while (orientation >= 360) {
518 orientation -= 360;
519 }
520 setHeading(cam, orientation);
521 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
522 covariance_matrix, object_heading);
523}
524
533inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
534 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
535 covariance_matrix);
536}
537
538} // namespace etsi_its_cam_msgs::access

◆ setYawRate()

void etsi_its_cam_msgs::access::setYawRate ( CAM & cam,
const double yaw_rate_val,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Yaw Rate for a CAM.

Parameters
camCAM to set the YawRate
yaw_rate_valYaw rate value in degrees per second as decimal number
confidencestandard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 136 of file cam_setters.h.

◆ setYawRateCDD()

template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>
void etsi_its_cam_msgs::access::setYawRateCDD ( YawRate & yaw_rate,
const double value,
double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Yaw Rate object.

Parameters
yaw_rateobject to set
valueYaw rate in degrees per second as decimal number
confidencestandard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 386 of file cam_setters.h.

419 {
420
421#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
422
430inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
431 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
432}
433
440inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
441 auto accel_val = std::round(value * 1e1);
442 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
443 accel.value = static_cast<int16_t>(accel_val);
444 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
445 accel.value = LongitudinalAccelerationValue::MIN;
446 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
447 accel.value = LongitudinalAccelerationValue::MAX - 1;
448 }
449}
450
461inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
462 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
463 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
464}
465
472inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
473 int64_t accel_val = (int64_t)std::round(value * 1e1);
474 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
475 accel.value = accel_val;
476 } else if (accel_val < LateralAccelerationValue::MIN) {
477 accel.value = LateralAccelerationValue::MIN;
478 } else if (accel_val > LateralAccelerationValue::MAX) {
479 accel.value = LateralAccelerationValue::MAX - 1;
480 }
481}
482
493inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
494 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
495 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
496}
497
498#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
499
509inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
510 // First ensure, that the object has the correct heading by setting its value
511 double orientation = object_heading * 180 / M_PI; // Convert to degrees
512 // Normalize to [0, 360)
513 orientation = std::fmod(orientation + 360, 360);
514 while (orientation < 0) {
515 orientation += 360;
516 }
517 while (orientation >= 360) {
518 orientation -= 360;
519 }
520 setHeading(cam, orientation);
521 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
522 covariance_matrix, object_heading);
523}
524
533inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
534 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
535 covariance_matrix);
536}
537
538} // namespace etsi_its_cam_msgs::access

◆ throwIfNotPresent()

void etsi_its_cam_msgs::access::throwIfNotPresent ( const bool is_present,
const std::string val_desc )
inline

Throws an exception if the given value is not present.

Parameters
is_presentWhether the value is present.
val_descDescription of the value for the exception message.

Definition at line 58 of file cam_access.h.

◆ throwIfOutOfRange()

template<typename T1, typename T2>
void etsi_its_cam_msgs::access::throwIfOutOfRange ( const T1 & val,
const T2 & min,
const T2 & max,
const std::string val_desc )

Throws an exception if a given value is out of a defined range.

Template Parameters
T1
T2
Parameters
valThe value to check if it is in the range.
minThe minimum value of the range.
maxThe maximum value of the range.
val_descDescription of the value for the exception message.

Definition at line 47 of file cam_access.h.