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

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

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

Go to the source code of this file.

Classes

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

Functions

template<typename T1, typename T2>
void etsi_its_cam_msgs::access::throwIfOutOfRange (const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
 Throws an exception if a given value is out of a defined range.
 
void etsi_its_cam_msgs::access::throwIfNotPresent (const bool is_present, const std::string val_desc)
 Throws an exception if the given value is not present.
 
uint16_t etsi_its_cam_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 (const uint64_t unix_seconds)
 Get the leap second insertions since 2004 for given unix seconds.
 
void etsi_its_cam_msgs::access::setTimestampITS (TimestampIts &timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the TimestampITS object.
 
void etsi_its_cam_msgs::access::setLatitude (Latitude &latitude, const double deg)
 Set the Latitude object.
 
void etsi_its_cam_msgs::access::setLongitude (Longitude &longitude, const double deg)
 Set the Longitude object.
 
void etsi_its_cam_msgs::access::setAltitudeValue (AltitudeValue &altitude, const double value)
 Set the AltitudeValue object.
 
void etsi_its_cam_msgs::access::setAltitude (Altitude &altitude, const double value)
 Set the Altitude object.
 
void etsi_its_cam_msgs::access::setSpeedValue (SpeedValue &speed, const double value)
 Set the SpeedValue object.
 
void etsi_its_cam_msgs::access::setSpeedConfidence (SpeedConfidence &speed_confidence, const double value)
 Set the Speed Confidence object.
 
void etsi_its_cam_msgs::access::setSpeed (Speed &speed, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the Speed object.
 
template<typename 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 SemiAxisLength>
void etsi_its_cam_msgs::access::setSemiAxis (SemiAxisLength &semi_axis_length, const double length)
 Set the Semi Axis length.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
 Set the Pos Confidence Ellipse object.
 
std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromCovMatrix (const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromWGSCovMatrix (const std::array< double, 4 > &covariance_matrix)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Set the Pos Confidence Ellipse object.
 
template<typename PosConfidenceEllipse>
void etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
 Set the Pos Confidence Ellipse object.
 
void etsi_its_cam_msgs::access::setStationId (StationID &station_id, const uint32_t id_value)
 Set the Station Id object.
 
void etsi_its_cam_msgs::access::setItsPduHeader (ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the Its Pdu Header object.
 
void etsi_its_cam_msgs::access::setStationType (StationType &station_type, const uint8_t value)
 Set the Station Type.
 
void etsi_its_cam_msgs::access::setItsPduHeader (CAM &cam, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the ItsPduHeader-object for a CAM.
 
void etsi_its_cam_msgs::access::setLongitudinalAccelerationValue (LongitudinalAccelerationValue &accel, const double value)
 Set the LongitudinalAccelerationValue object.
 
void etsi_its_cam_msgs::access::setLongitudinalAcceleration (LongitudinalAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the LongitudinalAcceleration object.
 
void etsi_its_cam_msgs::access::setLateralAccelerationValue (LateralAccelerationValue &accel, const double value)
 Set the LateralAccelerationValue object.
 
void etsi_its_cam_msgs::access::setLateralAcceleration (LateralAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the LateralAcceleration object.
 
template<typename T>
void etsi_its_cam_msgs::access::setBitString (T &bitstring, const std::vector< bool > &bits)
 Set a Bit String by a vector of bools.
 
void etsi_its_cam_msgs::access::setGenerationDeltaTime (GenerationDeltaTime &generation_delta_time, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the GenerationDeltaTime-Value.
 
void etsi_its_cam_msgs::access::setGenerationDeltaTime (CAM &cam, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the Generation Delta Time object.
 
void etsi_its_cam_msgs::access::setStationType (CAM &cam, const uint8_t value)
 Set the StationType for a CAM.
 
void etsi_its_cam_msgs::access::setHeading (CAM &cam, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
 Set the Heading for a CAM.
 
void etsi_its_cam_msgs::access::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 376 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 417 of file cam_setters.h.

450 {
451
452#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
453
461inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
462 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
463}
464
471inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
472 auto accel_val = std::round(value * 1e1);
473 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
474 accel.value = static_cast<int16_t>(accel_val);
475 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
476 accel.value = LongitudinalAccelerationValue::MIN;
477 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
478 accel.value = LongitudinalAccelerationValue::MAX - 1;
479 }
480}
481
492inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
493 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
494 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
495}
496
503inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
504 int64_t accel_val = (int64_t)std::round(value * 1e1);
505 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
506 accel.value = accel_val;
507 } else if (accel_val < LateralAccelerationValue::MIN) {
508 accel.value = LateralAccelerationValue::MIN;
509 } else if (accel_val > LateralAccelerationValue::MAX) {
510 accel.value = LateralAccelerationValue::MAX - 1;
511 }
512}
513
524inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
525 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
526 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
527}
528
529#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
530
540inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
541 // First ensure, that the object has the correct heading by setting its value
542 double orientation = object_heading * 180 / M_PI; // Convert to degrees
543 // Normalize to [0, 360)
544 orientation = std::fmod(orientation + 360, 360);
545 while (orientation < 0) {
546 orientation += 360;
547 }
548 while (orientation >= 360) {
549 orientation -= 360;
550 }
551 setHeading(cam, orientation);
552 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
553 covariance_matrix, object_heading);
554}
555
564inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
565 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
566 covariance_matrix);
567}
568
569} // namespace etsi_its_cam_msgs::access
etsi_its_cam_msgs::access::setLateralAcceleration
void setLateralAcceleration(LateralAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
Set the LateralAcceleration object.
Definition cam_setters.h:178
etsi_its_cam_msgs::access::setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(LongitudinalAccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cam_setters.h:125
etsi_its_cam_msgs::access::setPosConfidenceEllipse
void setPosConfidenceEllipse(PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
Set the Pos Confidence Ellipse object.
Definition cam_setters.h:360
etsi_its_cam_msgs::access::setItsPduHeader
void setItsPduHeader(ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
Set the Its Pdu Header object.
Definition cam_setters.h:85
etsi_its_cam_msgs::access::setRefPosConfidence
void setRefPosConfidence(CAM &cam, const std::array< double, 4 > &covariance_matrix, const double object_heading)
Set the confidence of the reference position.
Definition cam_setters.h:349
etsi_its_cam_msgs::access::setLongitudinalAcceleration
void setLongitudinalAcceleration(LongitudinalAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
Set the LongitudinalAcceleration object.
Definition cam_setters.h:146
etsi_its_cam_msgs::access::setLateralAccelerationValue
void setLateralAccelerationValue(LateralAccelerationValue &accel, const double value)
Set the LateralAccelerationValue object.
Definition cam_setters.h:157
etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse
void setWGSPosConfidenceEllipse(PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
Set the Pos Confidence Ellipse object.
Definition cam_setters.h:448
etsi_its_cam_msgs::access::setAccelerationConfidence
void setAccelerationConfidence(AccelerationConfidence &accel_confidence, const double value)
Set the Acceleration Confidence object.
Definition cam_setters.h:220
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:124
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:373
cam_setters_common.h
Common setter functions for the ETSI ITS CAM (EN and TS)
cdd_v1-3-1_setters.h
Setter functions for the ETSI ITS Common Data Dictionary (CDD) v1.3.1.
setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(AccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cdd_v2-1-1_setters.h:85

◆ getLeapSecondInsertionsSince2004()

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

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

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

Definition at line 61 of file cam_access.h.

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

◆ setAccelerationConfidence()

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

Set the Acceleration Confidence object.

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

Definition at line 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

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

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

◆ setAltitude()

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

Set the Altitude object.

AltitudeConfidence is set to UNAVAILABLE

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

Definition at line 166 of file cam_setters.h.

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

◆ setAltitudeValue()

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

Set the AltitudeValue object.

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

Definition at line 147 of file cam_setters.h.

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

◆ setBitString()

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

Set a Bit String by a vector of bools.

Template Parameters
T
Parameters
bitstringBitString to set
bitsvector of bools

Definition at line 44 of file cam_setters.h.

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

◆ setDrivingLaneStatus()

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

Set the Driving Lane Status by a vector of bools.

Parameters
driving_lane_status
bits

Definition at line 304 of file cam_setters.h.

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

367 {
368
369#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
370
378inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
379 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
380}
381
388inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
389 auto accel_val = std::round(value * 1e1);
390 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
391 accel.value = static_cast<int16_t>(accel_val);
392 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
393 accel.value = LongitudinalAccelerationValue::MIN;
394 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
395 accel.value = LongitudinalAccelerationValue::MAX - 1;
396 }
397}
398
409inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
410 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
411 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
412}
413
420inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
421 int64_t accel_val = (int64_t)std::round(value * 1e1);
422 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
423 accel.value = accel_val;
424 } else if (accel_val < LateralAccelerationValue::MIN) {
425 accel.value = LateralAccelerationValue::MIN;
426 } else if (accel_val > LateralAccelerationValue::MAX) {
427 accel.value = LateralAccelerationValue::MAX - 1;
428 }
429}
430
441inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
442 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
443 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
444}
445
446#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
447
457inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
458 // First ensure, that the object has the correct heading by setting its value
459 double orientation = object_heading * 180 / M_PI; // Convert to degrees
460 // Normalize to [0, 360)
461 orientation = std::fmod(orientation + 360, 360);
462 while (orientation < 0) {
463 orientation += 360;
464 }
465 while (orientation >= 360) {
466 orientation -= 360;
467 }
468 setHeading(cam, orientation);
469 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
470 covariance_matrix, object_heading);
471}
472
481inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
482 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
483 covariance_matrix);
484}
485
486} // 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 269 of file cam_setters.h.

302 {
303
304#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
305
313inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
314 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
315}
316
323inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
324 auto accel_val = std::round(value * 1e1);
325 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
326 accel.value = static_cast<int16_t>(accel_val);
327 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
328 accel.value = LongitudinalAccelerationValue::MIN;
329 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
330 accel.value = LongitudinalAccelerationValue::MAX - 1;
331 }
332}
333
344inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
345 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
346 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
347}
348
355inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
356 int64_t accel_val = (int64_t)std::round(value * 1e1);
357 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
358 accel.value = accel_val;
359 } else if (accel_val < LateralAccelerationValue::MIN) {
360 accel.value = LateralAccelerationValue::MIN;
361 } else if (accel_val > LateralAccelerationValue::MAX) {
362 accel.value = LateralAccelerationValue::MAX - 1;
363 }
364}
365
376inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
377 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
378 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
379}
380
381#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
382
392inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
393 // First ensure, that the object has the correct heading by setting its value
394 double orientation = object_heading * 180 / M_PI; // Convert to degrees
395 // Normalize to [0, 360)
396 orientation = std::fmod(orientation + 360, 360);
397 while (orientation < 0) {
398 orientation += 360;
399 }
400 while (orientation >= 360) {
401 orientation -= 360;
402 }
403 setHeading(cam, orientation);
404 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
405 covariance_matrix, object_heading);
406}
407
416inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
417 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
418 covariance_matrix);
419}
420
421} // 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 259 of file cam_setters.h.

292 {
293
294#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
295
303inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
304 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
305}
306
313inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
314 auto accel_val = std::round(value * 1e1);
315 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
316 accel.value = static_cast<int16_t>(accel_val);
317 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
318 accel.value = LongitudinalAccelerationValue::MIN;
319 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
320 accel.value = LongitudinalAccelerationValue::MAX - 1;
321 }
322}
323
334inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
335 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
336 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
337}
338
345inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
346 int64_t accel_val = (int64_t)std::round(value * 1e1);
347 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
348 accel.value = accel_val;
349 } else if (accel_val < LateralAccelerationValue::MIN) {
350 accel.value = LateralAccelerationValue::MIN;
351 } else if (accel_val > LateralAccelerationValue::MAX) {
352 accel.value = LateralAccelerationValue::MAX - 1;
353 }
354}
355
366inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
367 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
368 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
369}
370
371#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
372
382inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
383 // First ensure, that the object has the correct heading by setting its value
384 double orientation = object_heading * 180 / M_PI; // Convert to degrees
385 // Normalize to [0, 360)
386 orientation = std::fmod(orientation + 360, 360);
387 while (orientation < 0) {
388 orientation += 360;
389 }
390 while (orientation >= 360) {
391 orientation -= 360;
392 }
393 setHeading(cam, orientation);
394 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
395 covariance_matrix, object_heading);
396}
397
406inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
407 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
408 covariance_matrix);
409}
410
411} // 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 249 of file cam_setters.h.

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

301 {
302
303#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
304
312inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
313 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
314}
315
322inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
323 auto accel_val = std::round(value * 1e1);
324 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
325 accel.value = static_cast<int16_t>(accel_val);
326 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
327 accel.value = LongitudinalAccelerationValue::MIN;
328 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
329 accel.value = LongitudinalAccelerationValue::MAX - 1;
330 }
331}
332
343inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
344 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
345 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
346}
347
354inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
355 int64_t accel_val = (int64_t)std::round(value * 1e1);
356 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
357 accel.value = accel_val;
358 } else if (accel_val < LateralAccelerationValue::MIN) {
359 accel.value = LateralAccelerationValue::MIN;
360 } else if (accel_val > LateralAccelerationValue::MAX) {
361 accel.value = LateralAccelerationValue::MAX - 1;
362 }
363}
364
375inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
376 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
377 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
378}
379
380#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
381
391inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
392 // First ensure, that the object has the correct heading by setting its value
393 double orientation = object_heading * 180 / M_PI; // Convert to degrees
394 // Normalize to [0, 360)
395 orientation = std::fmod(orientation + 360, 360);
396 while (orientation < 0) {
397 orientation += 360;
398 }
399 while (orientation >= 360) {
400 orientation -= 360;
401 }
402 setHeading(cam, orientation);
403 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
404 covariance_matrix, object_heading);
405}
406
415inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
416 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
417 covariance_matrix);
418}
419
420} // 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 98 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 81 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) {

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

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

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

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

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

◆ setItsPduHeader() [1/2]

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

Set the ItsPduHeader-object for a CAM.

Parameters
camCAM-Message to set the ItsPduHeader
station_id
protocol_version

Definition at line 115 of file cam_setters.h.

◆ setItsPduHeader() [2/2]

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

Set the Its Pdu Header object.

Parameters
headerItsPduHeader to be set
message_idID of the message
station_id
protocol_version

Definition at line 85 of file cam_setters.h.

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

◆ setLateralAcceleration() [1/2]

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

Set the lateral acceleration.

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

Definition at line 213 of file cam_setters.h.

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

◆ setLateralAcceleration() [2/2]

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

Set the LateralAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

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

Definition at line 178 of file cam_setters.h.

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

◆ setLateralAccelerationValue()

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

Set the LateralAccelerationValue object.

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

Definition at line 157 of file cam_setters.h.

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

◆ setLatitude()

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

Set the Latitude object.

Parameters
latitudeobject to set
degLatitude value in degree as decimal number

Definition at line 123 of file cam_setters.h.

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

◆ setLightBarSirenInUse()

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

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

Parameters
light_bar_siren_in_use
bits

Definition at line 324 of file cam_setters.h.

357 {
358
359#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
360
368inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
369 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
370}
371
378inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
379 auto accel_val = std::round(value * 1e1);
380 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
381 accel.value = static_cast<int16_t>(accel_val);
382 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
383 accel.value = LongitudinalAccelerationValue::MIN;
384 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
385 accel.value = LongitudinalAccelerationValue::MAX - 1;
386 }
387}
388
399inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
400 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
401 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
402}
403
410inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
411 int64_t accel_val = (int64_t)std::round(value * 1e1);
412 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
413 accel.value = accel_val;
414 } else if (accel_val < LateralAccelerationValue::MIN) {
415 accel.value = LateralAccelerationValue::MIN;
416 } else if (accel_val > LateralAccelerationValue::MAX) {
417 accel.value = LateralAccelerationValue::MAX - 1;
418 }
419}
420
431inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
432 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
433 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
434}
435
436#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
437
447inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
448 // First ensure, that the object has the correct heading by setting its value
449 double orientation = object_heading * 180 / M_PI; // Convert to degrees
450 // Normalize to [0, 360)
451 orientation = std::fmod(orientation + 360, 360);
452 while (orientation < 0) {
453 orientation += 360;
454 }
455 while (orientation >= 360) {
456 orientation -= 360;
457 }
458 setHeading(cam, orientation);
459 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
460 covariance_matrix, object_heading);
461}
462
471inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
472 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
473 covariance_matrix);
474}
475
476} // namespace etsi_its_cam_msgs::access

◆ setLongitude()

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

Set the Longitude object.

Parameters
longitudeobject to set
degLongitude value in degree as decimal number

Definition at line 135 of file cam_setters.h.

◆ setLongitudinalAcceleration() [1/2]

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

Set the longitudinal acceleration.

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

Definition at line 199 of file cam_setters.h.

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

◆ setLongitudinalAcceleration() [2/2]

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

Set the LongitudinalAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

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

Definition at line 146 of file cam_setters.h.

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

◆ setLongitudinalAccelerationValue()

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

Set the LongitudinalAccelerationValue object.

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

Definition at line 125 of file cam_setters.h.

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

◆ setPosConfidenceEllipse() [1/2]

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

Set the Pos Confidence Ellipse object.

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

Definition at line 360 of file cam_setters.h.

393 {
394
395#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
396
404inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
405 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
406}
407
414inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
415 auto accel_val = std::round(value * 1e1);
416 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
417 accel.value = static_cast<int16_t>(accel_val);
418 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
419 accel.value = LongitudinalAccelerationValue::MIN;
420 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
421 accel.value = LongitudinalAccelerationValue::MAX - 1;
422 }
423}
424
435inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
436 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
437 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
438}
439
446inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
447 int64_t accel_val = (int64_t)std::round(value * 1e1);
448 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
449 accel.value = accel_val;
450 } else if (accel_val < LateralAccelerationValue::MIN) {
451 accel.value = LateralAccelerationValue::MIN;
452 } else if (accel_val > LateralAccelerationValue::MAX) {
453 accel.value = LateralAccelerationValue::MAX - 1;
454 }
455}
456
467inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
468 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
469 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
470}
471
472#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
473
483inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
484 // First ensure, that the object has the correct heading by setting its value
485 double orientation = object_heading * 180 / M_PI; // Convert to degrees
486 // Normalize to [0, 360)
487 orientation = std::fmod(orientation + 360, 360);
488 while (orientation < 0) {
489 orientation += 360;
490 }
491 while (orientation >= 360) {
492 orientation -= 360;
493 }
494 setHeading(cam, orientation);
495 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
496 covariance_matrix, object_heading);
497}
498
507inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
508 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
509 covariance_matrix);
510}
511
512} // 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 433 of file cam_setters.h.

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

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

275 {
276
277#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
278
286inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
287 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
288}
289
296inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
297 auto accel_val = std::round(value * 1e1);
298 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
299 accel.value = static_cast<int16_t>(accel_val);
300 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
301 accel.value = LongitudinalAccelerationValue::MIN;
302 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
303 accel.value = LongitudinalAccelerationValue::MAX - 1;
304 }
305}
306
317inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
318 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
319 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
320}
321
328inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
329 int64_t accel_val = (int64_t)std::round(value * 1e1);
330 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
331 accel.value = accel_val;
332 } else if (accel_val < LateralAccelerationValue::MIN) {
333 accel.value = LateralAccelerationValue::MIN;
334 } else if (accel_val > LateralAccelerationValue::MAX) {
335 accel.value = LateralAccelerationValue::MAX - 1;
336 }
337}
338
349inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
350 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
351 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
352}
353
354#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
355
365inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
366 // First ensure, that the object has the correct heading by setting its value
367 double orientation = object_heading * 180 / M_PI; // Convert to degrees
368 // Normalize to [0, 360)
369 orientation = std::fmod(orientation + 360, 360);
370 while (orientation < 0) {
371 orientation += 360;
372 }
373 while (orientation >= 360) {
374 orientation -= 360;
375 }
376 setHeading(cam, orientation);
377 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
378 covariance_matrix, object_heading);
379}
380
389inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
390 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
391 covariance_matrix);
392}
393
394} // 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 349 of file cam_setters.h.

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

◆ setSemiAxis()

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

Set the Semi Axis length.

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

Parameters
semi_axis_lengthThe SemiAxisLength to set
lengththe desired length in meters

Definition at line 341 of file cam_setters.h.

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

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

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

◆ setSpeed() [2/2]

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

Set the Speed object.

SpeedConfidence is set to UNAVAILABLE

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

Definition at line 208 of file cam_setters.h.

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

◆ setSpeedConfidence()

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

Set the Speed Confidence object.

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

Definition at line 189 of file cam_setters.h.

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

◆ setSpeedValue()

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

Set the SpeedValue object.

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

Definition at line 177 of file cam_setters.h.

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

◆ setStationId()

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

Set the Station Id object.

Parameters
station_id
id_value

Definition at line 72 of file cam_setters.h.

◆ setStationType() [1/2]

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

Set the StationType for a CAM.

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

Definition at line 110 of file cam_setters.h.

◆ setStationType() [2/2]

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

Set the Station Type.

Parameters
station_type
value

Definition at line 101 of file cam_setters.h.

◆ setTimestampITS()

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

Set the TimestampITS object.

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

Definition at line 109 of file cam_setters.h.

◆ setVehicleDimensions()

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

Set the vehicle dimensions.

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

Definition at line 173 of file cam_setters.h.

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

◆ setVehicleLength()

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

Set the VehicleLength object.

VehicleLengthConfidenceIndication is set to UNAVAILABLE

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 161 of file cam_setters.h.

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

◆ setVehicleLengthValue()

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

Set the VehicleLengthValue object.

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 147 of file cam_setters.h.

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

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

481 {
482
483#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
484
492inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
493 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
494}
495
502inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
503 auto accel_val = std::round(value * 1e1);
504 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
505 accel.value = static_cast<int16_t>(accel_val);
506 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
507 accel.value = LongitudinalAccelerationValue::MIN;
508 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
509 accel.value = LongitudinalAccelerationValue::MAX - 1;
510 }
511}
512
523inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
524 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
525 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
526}
527
534inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
535 int64_t accel_val = (int64_t)std::round(value * 1e1);
536 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
537 accel.value = accel_val;
538 } else if (accel_val < LateralAccelerationValue::MIN) {
539 accel.value = LateralAccelerationValue::MIN;
540 } else if (accel_val > LateralAccelerationValue::MAX) {
541 accel.value = LateralAccelerationValue::MAX - 1;
542 }
543}
544
555inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
556 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
557 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
558}
559
560#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
561
571inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
572 // First ensure, that the object has the correct heading by setting its value
573 double orientation = object_heading * 180 / M_PI; // Convert to degrees
574 // Normalize to [0, 360)
575 orientation = std::fmod(orientation + 360, 360);
576 while (orientation < 0) {
577 orientation += 360;
578 }
579 while (orientation >= 360) {
580 orientation -= 360;
581 }
582 setHeading(cam, orientation);
583 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
584 covariance_matrix, object_heading);
585}
586
595inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
596 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
597 covariance_matrix);
598}
599
600} // 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 373 of file cam_setters.h.

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

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