etsi_its_messages v3.4.0
Loading...
Searching...
No Matches
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.
template<typename StationId>
void etsi_its_cam_msgs::access::setStationId (StationId &station_id, const uint32_t id_value)
 Set the Station Id object.
template<typename StationType>
void etsi_its_cam_msgs::access::setStationType (StationType &station_type, const uint8_t value)
 Set the Station Type.
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::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::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 434 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 475 of file cam_setters.h.

508 {
509
510#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
511
519inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
520 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
521}
522
529inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
530 auto accel_val = std::round(value * 1e1);
531 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
532 accel.value = static_cast<int16_t>(accel_val);
533 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
534 accel.value = LongitudinalAccelerationValue::MIN;
535 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
536 accel.value = LongitudinalAccelerationValue::MAX - 1;
537 }
538}
539
550inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
551 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
552 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
553}
554
561inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
562 int64_t accel_val = (int64_t)std::round(value * 1e1);
563 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
564 accel.value = accel_val;
565 } else if (accel_val < LateralAccelerationValue::MIN) {
566 accel.value = LateralAccelerationValue::MIN;
567 } else if (accel_val > LateralAccelerationValue::MAX) {
568 accel.value = LateralAccelerationValue::MAX - 1;
569 }
570}
571
582inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
583 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
584 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
585}
586
587#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
588
598inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
599 // First ensure, that the object has the correct heading by setting its value
600 double orientation = object_heading * 180 / M_PI; // Convert to degrees
601 // Normalize to [0, 360)
602 orientation = std::fmod(orientation + 360, 360);
603 while (orientation < 0) {
604 orientation += 360;
605 }
606 while (orientation >= 360) {
607 orientation -= 360;
608 }
609 setHeading(cam, orientation);
610 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
611 covariance_matrix, object_heading);
612}
613
622inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
623 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
624 covariance_matrix);
625}
626
627} // 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:108
etsi_its_cam_msgs::access::setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(LongitudinalAccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cam_setters.h:55
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:418
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:48
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:124
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:76
etsi_its_cam_msgs::access::setLateralAccelerationValue
void setLateralAccelerationValue(LateralAccelerationValue &accel, const double value)
Set the LateralAccelerationValue object.
Definition cam_setters.h:87
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:506
etsi_its_cam_msgs::access::setAccelerationConfidence
void setAccelerationConfidence(AccelerationConfidence &accel_confidence, const double value)
Set the Acceleration Confidence object.
Definition cam_setters.h:233
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:89
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:148
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:63

◆ 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 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

◆ 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 273 of file cam_setters.h.

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

◆ 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 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

◆ 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 187 of file cam_setters.h.

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

◆ 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 114 of file cam_setters.h.

◆ 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 283 of file cam_setters.h.

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

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

281 {
282
283#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
284
292inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
293 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
294}
295
302inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
303 auto accel_val = std::round(value * 1e1);
304 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
305 accel.value = static_cast<int16_t>(accel_val);
306 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
307 accel.value = LongitudinalAccelerationValue::MIN;
308 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
309 accel.value = LongitudinalAccelerationValue::MAX - 1;
310 }
311}
312
323inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
324 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
325 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
326}
327
334inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
335 int64_t accel_val = (int64_t)std::round(value * 1e1);
336 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
337 accel.value = accel_val;
338 } else if (accel_val < LateralAccelerationValue::MIN) {
339 accel.value = LateralAccelerationValue::MIN;
340 } else if (accel_val > LateralAccelerationValue::MAX) {
341 accel.value = LateralAccelerationValue::MAX - 1;
342 }
343}
344
355inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
356 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
357 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
358}
359
360#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
361
371inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
372 // First ensure, that the object has the correct heading by setting its value
373 double orientation = object_heading * 180 / M_PI; // Convert to degrees
374 // Normalize to [0, 360)
375 orientation = std::fmod(orientation + 360, 360);
376 while (orientation < 0) {
377 orientation += 360;
378 }
379 while (orientation >= 360) {
380 orientation -= 360;
381 }
382 setHeading(cam, orientation);
383 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
384 covariance_matrix, object_heading);
385}
386
395inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
396 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
397 covariance_matrix);
398}
399
400} // 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 238 of file cam_setters.h.

271 {
272
273#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
274
282inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
283 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
284}
285
292inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
293 auto accel_val = std::round(value * 1e1);
294 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
295 accel.value = static_cast<int16_t>(accel_val);
296 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
297 accel.value = LongitudinalAccelerationValue::MIN;
298 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
299 accel.value = LongitudinalAccelerationValue::MAX - 1;
300 }
301}
302
313inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
314 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
315 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
316}
317
324inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
325 int64_t accel_val = (int64_t)std::round(value * 1e1);
326 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
327 accel.value = accel_val;
328 } else if (accel_val < LateralAccelerationValue::MIN) {
329 accel.value = LateralAccelerationValue::MIN;
330 } else if (accel_val > LateralAccelerationValue::MAX) {
331 accel.value = LateralAccelerationValue::MAX - 1;
332 }
333}
334
345inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
346 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
347 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
348}
349
350#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
351
361inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
362 // First ensure, that the object has the correct heading by setting its value
363 double orientation = object_heading * 180 / M_PI; // Convert to degrees
364 // Normalize to [0, 360)
365 orientation = std::fmod(orientation + 360, 360);
366 while (orientation < 0) {
367 orientation += 360;
368 }
369 while (orientation >= 360) {
370 orientation -= 360;
371 }
372 setHeading(cam, orientation);
373 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
374 covariance_matrix, object_heading);
375}
376
385inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
386 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
387 covariance_matrix);
388}
389
390} // 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 228 of file cam_setters.h.

261 {
262
263#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
264
272inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
273 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
274}
275
282inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
283 auto accel_val = std::round(value * 1e1);
284 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
285 accel.value = static_cast<int16_t>(accel_val);
286 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
287 accel.value = LongitudinalAccelerationValue::MIN;
288 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
289 accel.value = LongitudinalAccelerationValue::MAX - 1;
290 }
291}
292
303inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
304 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
305 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
306}
307
314inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
315 int64_t accel_val = (int64_t)std::round(value * 1e1);
316 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
317 accel.value = accel_val;
318 } else if (accel_val < LateralAccelerationValue::MIN) {
319 accel.value = LateralAccelerationValue::MIN;
320 } else if (accel_val > LateralAccelerationValue::MAX) {
321 accel.value = LateralAccelerationValue::MAX - 1;
322 }
323}
324
335inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
336 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
337 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
338}
339
340#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
341
351inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
352 // First ensure, that the object has the correct heading by setting its value
353 double orientation = object_heading * 180 / M_PI; // Convert to degrees
354 // Normalize to [0, 360)
355 orientation = std::fmod(orientation + 360, 360);
356 while (orientation < 0) {
357 orientation += 360;
358 }
359 while (orientation >= 360) {
360 orientation -= 360;
361 }
362 setHeading(cam, orientation);
363 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
364 covariance_matrix, object_heading);
365}
366
375inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
376 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
377 covariance_matrix);
378}
379
380} // 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 281 of file cam_setters.h.

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

◆ 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 89 of file cam_setters.h.

89 {
90 accel.value = accel_val;
91 } else if (accel_val < LateralAccelerationValue::MIN) {
92 accel.value = LateralAccelerationValue::MIN;

◆ 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 340 of file cam_setters.h.

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

352 {
353
354#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
355
363inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
364 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
365}
366
373inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
374 auto accel_val = std::round(value * 1e1);
375 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
376 accel.value = static_cast<int16_t>(accel_val);
377 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
378 accel.value = LongitudinalAccelerationValue::MIN;
379 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
380 accel.value = LongitudinalAccelerationValue::MAX - 1;
381 }
382}
383
394inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
395 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
396 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
397}
398
405inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
406 int64_t accel_val = (int64_t)std::round(value * 1e1);
407 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
408 accel.value = accel_val;
409 } else if (accel_val < LateralAccelerationValue::MIN) {
410 accel.value = LateralAccelerationValue::MIN;
411 } else if (accel_val > LateralAccelerationValue::MAX) {
412 accel.value = LateralAccelerationValue::MAX - 1;
413 }
414}
415
426inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
427 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
428 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
429}
430
431#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
432
442inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
443 // First ensure, that the object has the correct heading by setting its value
444 double orientation = object_heading * 180 / M_PI; // Convert to degrees
445 // Normalize to [0, 360)
446 orientation = std::fmod(orientation + 360, 360);
447 while (orientation < 0) {
448 orientation += 360;
449 }
450 while (orientation >= 360) {
451 orientation -= 360;
452 }
453 setHeading(cam, orientation);
454 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
455 covariance_matrix, object_heading);
456}
457
466inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
467 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
468 covariance_matrix);
469}
470
471} // 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 306 of file cam_setters.h.

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

45 {
46 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
47}

◆ 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 48 of file cam_setters.h.

55 {
56 auto accel_val = std::round(value * 1e1);

◆ 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 192 of file cam_setters.h.

225 {
226
227#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
228
236inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
237 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
238}
239
246inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
247 auto accel_val = std::round(value * 1e1);
248 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
249 accel.value = static_cast<int16_t>(accel_val);
250 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
251 accel.value = LongitudinalAccelerationValue::MIN;
252 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
253 accel.value = LongitudinalAccelerationValue::MAX - 1;
254 }
255}
256
267inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
268 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
269 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
270}
271
278inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
279 int64_t accel_val = (int64_t)std::round(value * 1e1);
280 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
281 accel.value = accel_val;
282 } else if (accel_val < LateralAccelerationValue::MIN) {
283 accel.value = LateralAccelerationValue::MIN;
284 } else if (accel_val > LateralAccelerationValue::MAX) {
285 accel.value = LateralAccelerationValue::MAX - 1;
286 }
287}
288
299inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
300 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
301 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
302}
303
304#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
305
315inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
316 // First ensure, that the object has the correct heading by setting its value
317 double orientation = object_heading * 180 / M_PI; // Convert to degrees
318 // Normalize to [0, 360)
319 orientation = std::fmod(orientation + 360, 360);
320 while (orientation < 0) {
321 orientation += 360;
322 }
323 while (orientation >= 360) {
324 orientation -= 360;
325 }
326 setHeading(cam, orientation);
327 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
328 covariance_matrix, object_heading);
329}
330
339inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
340 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
341 covariance_matrix);
342}
343
344} // 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 108 of file cam_setters.h.

108 {
109 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
110 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
111}

◆ 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 87 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) {
94 accel.value = LateralAccelerationValue::MAX - 1;
95 }
96}

◆ 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 90 of file cam_setters.h.

91 {
92 accel.value = LateralAccelerationValue::MIN;
93 } else if (accel_val > LateralAccelerationValue::MAX) {
94 accel.value = LateralAccelerationValue::MAX - 1;

◆ 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 303 of file cam_setters.h.

336 {
337
338#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
339
347inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
348 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
349}
350
357inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
358 auto accel_val = std::round(value * 1e1);
359 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
360 accel.value = static_cast<int16_t>(accel_val);
361 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
362 accel.value = LongitudinalAccelerationValue::MIN;
363 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
364 accel.value = LongitudinalAccelerationValue::MAX - 1;
365 }
366}
367
378inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
379 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
380 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
381}
382
389inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
390 int64_t accel_val = (int64_t)std::round(value * 1e1);
391 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
392 accel.value = accel_val;
393 } else if (accel_val < LateralAccelerationValue::MIN) {
394 accel.value = LateralAccelerationValue::MIN;
395 } else if (accel_val > LateralAccelerationValue::MAX) {
396 accel.value = LateralAccelerationValue::MAX - 1;
397 }
398}
399
410inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
411 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
412 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
413}
414
415#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
416
426inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
427 // First ensure, that the object has the correct heading by setting its value
428 double orientation = object_heading * 180 / M_PI; // Convert to degrees
429 // Normalize to [0, 360)
430 orientation = std::fmod(orientation + 360, 360);
431 while (orientation < 0) {
432 orientation += 360;
433 }
434 while (orientation >= 360) {
435 orientation -= 360;
436 }
437 setHeading(cam, orientation);
438 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
439 covariance_matrix, object_heading);
440}
441
450inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
451 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
452 covariance_matrix);
453}
454
455} // 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 102 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 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

◆ 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 76 of file cam_setters.h.

76 {
77 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
78 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
79}

◆ 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 55 of file cam_setters.h.

55 {
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}

◆ 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 418 of file cam_setters.h.

451 {
452
453#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
454
462inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
463 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
464}
465
472inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
473 auto accel_val = std::round(value * 1e1);
474 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
475 accel.value = static_cast<int16_t>(accel_val);
476 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
477 accel.value = LongitudinalAccelerationValue::MIN;
478 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
479 accel.value = LongitudinalAccelerationValue::MAX - 1;
480 }
481}
482
493inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
494 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
495 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
496}
497
504inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
505 int64_t accel_val = (int64_t)std::round(value * 1e1);
506 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
507 accel.value = accel_val;
508 } else if (accel_val < LateralAccelerationValue::MIN) {
509 accel.value = LateralAccelerationValue::MIN;
510 } else if (accel_val > LateralAccelerationValue::MAX) {
511 accel.value = LateralAccelerationValue::MAX - 1;
512 }
513}
514
525inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
526 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
527 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
528}
529
530#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
531
541inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
542 // First ensure, that the object has the correct heading by setting its value
543 double orientation = object_heading * 180 / M_PI; // Convert to degrees
544 // Normalize to [0, 360)
545 orientation = std::fmod(orientation + 360, 360);
546 while (orientation < 0) {
547 orientation += 360;
548 }
549 while (orientation >= 360) {
550 orientation -= 360;
551 }
552 setHeading(cam, orientation);
553 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
554 covariance_matrix, object_heading);
555}
556
565inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
566 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
567 covariance_matrix);
568}
569
570} // 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 491 of file cam_setters.h.

524 {
525
526#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
527
535inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
536 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
537}
538
545inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
546 auto accel_val = std::round(value * 1e1);
547 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
548 accel.value = static_cast<int16_t>(accel_val);
549 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
550 accel.value = LongitudinalAccelerationValue::MIN;
551 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
552 accel.value = LongitudinalAccelerationValue::MAX - 1;
553 }
554}
555
566inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
567 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
568 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
569}
570
577inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
578 int64_t accel_val = (int64_t)std::round(value * 1e1);
579 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
580 accel.value = accel_val;
581 } else if (accel_val < LateralAccelerationValue::MIN) {
582 accel.value = LateralAccelerationValue::MIN;
583 } else if (accel_val > LateralAccelerationValue::MAX) {
584 accel.value = LateralAccelerationValue::MAX - 1;
585 }
586}
587
598inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
599 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
600 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
601}
602
603#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
604
614inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
615 // First ensure, that the object has the correct heading by setting its value
616 double orientation = object_heading * 180 / M_PI; // Convert to degrees
617 // Normalize to [0, 360)
618 orientation = std::fmod(orientation + 360, 360);
619 while (orientation < 0) {
620 orientation += 360;
621 }
622 while (orientation >= 360) {
623 orientation -= 360;
624 }
625 setHeading(cam, orientation);
626 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
627 covariance_matrix, object_heading);
628}
629
638inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
639 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
640 covariance_matrix);
641}
642
643} // 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 211 of file cam_setters.h.

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

288 {
289
290#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
291
299inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
300 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
301}
302
309inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
310 auto accel_val = std::round(value * 1e1);
311 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
312 accel.value = static_cast<int16_t>(accel_val);
313 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
314 accel.value = LongitudinalAccelerationValue::MIN;
315 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
316 accel.value = LongitudinalAccelerationValue::MAX - 1;
317 }
318}
319
330inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
331 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
332 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
333}
334
341inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
342 int64_t accel_val = (int64_t)std::round(value * 1e1);
343 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
344 accel.value = accel_val;
345 } else if (accel_val < LateralAccelerationValue::MIN) {
346 accel.value = LateralAccelerationValue::MIN;
347 } else if (accel_val > LateralAccelerationValue::MAX) {
348 accel.value = LateralAccelerationValue::MAX - 1;
349 }
350}
351
362inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
363 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
364 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
365}
366
367#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
368
378inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
379 // First ensure, that the object has the correct heading by setting its value
380 double orientation = object_heading * 180 / M_PI; // Convert to degrees
381 // Normalize to [0, 360)
382 orientation = std::fmod(orientation + 360, 360);
383 while (orientation < 0) {
384 orientation += 360;
385 }
386 while (orientation >= 360) {
387 orientation -= 360;
388 }
389 setHeading(cam, orientation);
390 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
391 covariance_matrix, object_heading);
392}
393
402inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
403 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
404 covariance_matrix);
405}
406
407} // 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 124 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)
128 orientation = std::fmod(orientation + 360, 360);
129 while (orientation < 0) {
130 orientation += 360;
131 }
132 while (orientation >= 360) {
133 orientation -= 360;
134 }
135 setHeading(cam, orientation);
136 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
137 covariance_matrix, object_heading);
138}
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_common.h:89
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 cdd_setters_common.h:418

◆ 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 399 of file cam_setters.h.

432 {
433
434#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
435
443inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
444 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
445}
446
453inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
454 auto accel_val = std::round(value * 1e1);
455 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
456 accel.value = static_cast<int16_t>(accel_val);
457 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
458 accel.value = LongitudinalAccelerationValue::MIN;
459 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
460 accel.value = LongitudinalAccelerationValue::MAX - 1;
461 }
462}
463
474inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
475 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
476 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
477}
478
485inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
486 int64_t accel_val = (int64_t)std::round(value * 1e1);
487 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
488 accel.value = accel_val;
489 } else if (accel_val < LateralAccelerationValue::MIN) {
490 accel.value = LateralAccelerationValue::MIN;
491 } else if (accel_val > LateralAccelerationValue::MAX) {
492 accel.value = LateralAccelerationValue::MAX - 1;
493 }
494}
495
506inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
507 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
508 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
509}
510
511#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
512
522inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
523 // First ensure, that the object has the correct heading by setting its value
524 double orientation = object_heading * 180 / M_PI; // Convert to degrees
525 // Normalize to [0, 360)
526 orientation = std::fmod(orientation + 360, 360);
527 while (orientation < 0) {
528 orientation += 360;
529 }
530 while (orientation >= 360) {
531 orientation -= 360;
532 }
533 setHeading(cam, orientation);
534 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
535 covariance_matrix, object_heading);
536}
537
546inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
547 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
548 covariance_matrix);
549}
550
551} // 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 293 of file cam_setters.h.

326 {
327
328#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
329
337inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
338 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
339}
340
347inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
348 auto accel_val = std::round(value * 1e1);
349 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
350 accel.value = static_cast<int16_t>(accel_val);
351 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
352 accel.value = LongitudinalAccelerationValue::MIN;
353 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
354 accel.value = LongitudinalAccelerationValue::MAX - 1;
355 }
356}
357
368inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
369 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
370 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
371}
372
379inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
380 int64_t accel_val = (int64_t)std::round(value * 1e1);
381 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
382 accel.value = accel_val;
383 } else if (accel_val < LateralAccelerationValue::MIN) {
384 accel.value = LateralAccelerationValue::MIN;
385 } else if (accel_val > LateralAccelerationValue::MAX) {
386 accel.value = LateralAccelerationValue::MAX - 1;
387 }
388}
389
400inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
401 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
402 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
403}
404
405#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
406
416inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
417 // First ensure, that the object has the correct heading by setting its value
418 double orientation = object_heading * 180 / M_PI; // Convert to degrees
419 // Normalize to [0, 360)
420 orientation = std::fmod(orientation + 360, 360);
421 while (orientation < 0) {
422 orientation += 360;
423 }
424 while (orientation >= 360) {
425 orientation -= 360;
426 }
427 setHeading(cam, orientation);
428 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
429 covariance_matrix, object_heading);
430}
431
440inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
441 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
442 covariance_matrix);
443}
444
445} // 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 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

◆ 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 175 of file cam_setters.h.

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

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

144 : cov_xx, cov_xy, cov_yx, cov_yy
145 * The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown.
146 * Its coordinate system is WGS84 (x = North, y = East)
147 */
148inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {

◆ setStationId()

template<typename StationId>
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 51 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 75 of file cam_setters.h.

76 {
77 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);

◆ setStationType() [2/2]

template<typename StationType>
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 63 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 76 of file cam_setters.h.

76 {
77 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
78 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
79}
80

◆ 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 152 of file cam_setters.h.

◆ 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 140 of file cam_setters.h.

◆ 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 126 of file cam_setters.h.

◆ 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 114 of file cam_setters.h.

◆ 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 506 of file cam_setters.h.

550inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
551 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
552}
553
560inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
561 auto accel_val = std::round(value * 1e1);
562 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
563 accel.value = static_cast<int16_t>(accel_val);
564 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
565 accel.value = LongitudinalAccelerationValue::MIN;
566 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
567 accel.value = LongitudinalAccelerationValue::MAX - 1;
568 }
569}
570
581inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
582 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
583 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
584}
585
592inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
593 int64_t accel_val = (int64_t)std::round(value * 1e1);
594 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
595 accel.value = accel_val;
596 } else if (accel_val < LateralAccelerationValue::MIN) {
597 accel.value = LateralAccelerationValue::MIN;
598 } else if (accel_val > LateralAccelerationValue::MAX) {
599 accel.value = LateralAccelerationValue::MAX - 1;
600 }
601}
602
613inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
614 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
615 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
616}
617
618#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
619
629inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
630 // First ensure, that the object has the correct heading by setting its value
631 double orientation = object_heading * 180 / M_PI; // Convert to degrees
632 // Normalize to [0, 360)
633 orientation = std::fmod(orientation + 360, 360);
634 while (orientation < 0) {
635 orientation += 360;
636 }
637 while (orientation >= 360) {
638 orientation -= 360;
639 }
640 setHeading(cam, orientation);
641 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
642 covariance_matrix, object_heading);
643}
644
653inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
654 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
655 covariance_matrix);
656}
657
658} // 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 148 of file cam_setters.h.

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

◆ 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 102 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 353 of file cam_setters.h.

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