etsi_its_messages v3.4.0
Loading...
Searching...
No Matches
cam_setters.h File Reference

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

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

Go to the source code of this file.

Classes

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

Functions

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

Detailed Description

Setter functions for the ETSI ITS CAM (EN).

Definition in file cam_setters.h.

Function Documentation

◆ confidenceEllipseFromCovMatrix()

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

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

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

Definition at line 411 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 452 of file cam_setters.h.

462 {
463
464#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
465
473inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
474 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
475}
476
483inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
484 auto accel_val = std::round(value * 1e1);
485 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
486 accel.value = static_cast<int16_t>(accel_val);
487 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
488 accel.value = LongitudinalAccelerationValue::MIN;
489 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
490 accel.value = LongitudinalAccelerationValue::MAX - 1;
491 }
492}
493
504inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
505 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
506 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
507}
508
515inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
516 int64_t accel_val = (int64_t)std::round(value * 1e1);
517 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
518 accel.value = accel_val;
519 } else if (accel_val < LateralAccelerationValue::MIN) {
520 accel.value = LateralAccelerationValue::MIN;
521 } else if (accel_val > LateralAccelerationValue::MAX) {
522 accel.value = LateralAccelerationValue::MAX - 1;
523 }
524}
525
536inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
537 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
538 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
539}
540
541#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
542
552inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
553 // First ensure, that the object has the correct heading by setting its value
554 double orientation = object_heading * 180 / M_PI; // Convert to degrees
555 // Normalize to [0, 360)
556 orientation = std::fmod(orientation + 360, 360);
557 while (orientation < 0) {
558 orientation += 360;
559 }
560 while (orientation >= 360) {
561 orientation -= 360;
562 }
563 setHeading(cam, orientation);
564 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
565 covariance_matrix, object_heading);
566}
567
576inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
577 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
578 covariance_matrix);
579}
580
581} // 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:85
etsi_its_cam_msgs::access::setLongitudinalAccelerationValue
void setLongitudinalAccelerationValue(LongitudinalAccelerationValue &accel, const double value)
Set the LongitudinalAccelerationValue object.
Definition cam_setters.h:32
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:395
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:25
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:101
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:53
etsi_its_cam_msgs::access::setLateralAccelerationValue
void setLateralAccelerationValue(LateralAccelerationValue &accel, const double value)
Set the LateralAccelerationValue object.
Definition cam_setters.h:64
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:483
etsi_its_cam_msgs::access::setAccelerationConfidence
void setAccelerationConfidence(AccelerationConfidence &accel_confidence, const double value)
Set the Acceleration Confidence object.
Definition cam_setters.h:210
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:66
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:125
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:40

◆ 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 38 of file cam_access.h.

71 {
72#include <etsi_its_msgs_utils/impl/cam/cam_utils.h>
73}
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 210 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

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

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

◆ setAccelerationMagnitude()

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

Set the AccelerationMagnitude object.

AccelerationConfidence is set to UNAVAILABLE

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

Definition at line 197 of file cam_setters.h.

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

◆ setAccelerationMagnitudeConfidence()

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

Set the AccelerationMagnitude Confidence object.

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

Definition at line 177 of file cam_setters.h.

187 {
188
189#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
190
198inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
199 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
200}
201
208inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
209 auto accel_val = std::round(value * 1e1);
210 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
211 accel.value = static_cast<int16_t>(accel_val);
212 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
213 accel.value = LongitudinalAccelerationValue::MIN;
214 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
215 accel.value = LongitudinalAccelerationValue::MAX - 1;
216 }
217}
218
229inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
230 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
231 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
232}
233
240inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
241 int64_t accel_val = (int64_t)std::round(value * 1e1);
242 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
243 accel.value = accel_val;
244 } else if (accel_val < LateralAccelerationValue::MIN) {
245 accel.value = LateralAccelerationValue::MIN;
246 } else if (accel_val > LateralAccelerationValue::MAX) {
247 accel.value = LateralAccelerationValue::MAX - 1;
248 }
249}
250
261inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
262 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
263 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
264}
265
266#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
267
277inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
278 // First ensure, that the object has the correct heading by setting its value
279 double orientation = object_heading * 180 / M_PI; // Convert to degrees
280 // Normalize to [0, 360)
281 orientation = std::fmod(orientation + 360, 360);
282 while (orientation < 0) {
283 orientation += 360;
284 }
285 while (orientation >= 360) {
286 orientation -= 360;
287 }
288 setHeading(cam, orientation);
289 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
290 covariance_matrix, object_heading);
291}
292
301inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
302 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
303 covariance_matrix);
304}
305
306} // namespace etsi_its_cam_msgs::access

◆ setAccelerationMagnitudeValue()

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

Set the Acceleration Magnitude Value object.

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

Definition at line 164 of file cam_setters.h.

174 {
175
176#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
177
185inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
186 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
187}
188
195inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
196 auto accel_val = std::round(value * 1e1);
197 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
198 accel.value = static_cast<int16_t>(accel_val);
199 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
200 accel.value = LongitudinalAccelerationValue::MIN;
201 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
202 accel.value = LongitudinalAccelerationValue::MAX - 1;
203 }
204}
205
216inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
217 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
218 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
219}
220
227inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
228 int64_t accel_val = (int64_t)std::round(value * 1e1);
229 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
230 accel.value = accel_val;
231 } else if (accel_val < LateralAccelerationValue::MIN) {
232 accel.value = LateralAccelerationValue::MIN;
233 } else if (accel_val > LateralAccelerationValue::MAX) {
234 accel.value = LateralAccelerationValue::MAX - 1;
235 }
236}
237
248inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
249 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
250 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
251}
252
253#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
254
264inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
265 // First ensure, that the object has the correct heading by setting its value
266 double orientation = object_heading * 180 / M_PI; // Convert to degrees
267 // Normalize to [0, 360)
268 orientation = std::fmod(orientation + 360, 360);
269 while (orientation < 0) {
270 orientation += 360;
271 }
272 while (orientation >= 360) {
273 orientation -= 360;
274 }
275 setHeading(cam, orientation);
276 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
277 covariance_matrix, object_heading);
278}
279
288inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
289 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
290 covariance_matrix);
291}
292
293} // 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 110 of file cam_setters.h.

◆ setAltitudeValue()

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

Set the AltitudeValue object.

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

Definition at line 91 of file cam_setters.h.

◆ setBitString()

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

Set a Bit String by a vector of bools.

Template Parameters
T
Parameters
bitstringBitString to set
bitsvector of bools

Definition at line 21 of file cam_setters.h.

22 {
23 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
24}
25
32inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
33 auto accel_val = std::round(value * 1e1);
34 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
35 accel.value = static_cast<int16_t>(accel_val);
36 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
37 accel.value = LongitudinalAccelerationValue::MIN;
38 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
39 accel.value = LongitudinalAccelerationValue::MAX - 1;
40 }
41}
42

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

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

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

235 {
236
237#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
238
246inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
247 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
248}
249
256inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
257 auto accel_val = std::round(value * 1e1);
258 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
259 accel.value = static_cast<int16_t>(accel_val);
260 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
261 accel.value = LongitudinalAccelerationValue::MIN;
262 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
263 accel.value = LongitudinalAccelerationValue::MAX - 1;
264 }
265}
266
277inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
278 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
279 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
280}
281
288inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
289 int64_t accel_val = (int64_t)std::round(value * 1e1);
290 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
291 accel.value = accel_val;
292 } else if (accel_val < LateralAccelerationValue::MIN) {
293 accel.value = LateralAccelerationValue::MIN;
294 } else if (accel_val > LateralAccelerationValue::MAX) {
295 accel.value = LateralAccelerationValue::MAX - 1;
296 }
297}
298
309inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
310 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
311 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
312}
313
314#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
315
325inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
326 // First ensure, that the object has the correct heading by setting its value
327 double orientation = object_heading * 180 / M_PI; // Convert to degrees
328 // Normalize to [0, 360)
329 orientation = std::fmod(orientation + 360, 360);
330 while (orientation < 0) {
331 orientation += 360;
332 }
333 while (orientation >= 360) {
334 orientation -= 360;
335 }
336 setHeading(cam, orientation);
337 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
338 covariance_matrix, object_heading);
339}
340
349inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
350 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
351 covariance_matrix);
352}
353
354} // 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 215 of file cam_setters.h.

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

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

215 {
216
217#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
218
226inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
227 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
228}
229
236inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
237 auto accel_val = std::round(value * 1e1);
238 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
239 accel.value = static_cast<int16_t>(accel_val);
240 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
241 accel.value = LongitudinalAccelerationValue::MIN;
242 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
243 accel.value = LongitudinalAccelerationValue::MAX - 1;
244 }
245}
246
257inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
258 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
259 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
260}
261
268inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
269 int64_t accel_val = (int64_t)std::round(value * 1e1);
270 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
271 accel.value = accel_val;
272 } else if (accel_val < LateralAccelerationValue::MIN) {
273 accel.value = LateralAccelerationValue::MIN;
274 } else if (accel_val > LateralAccelerationValue::MAX) {
275 accel.value = LateralAccelerationValue::MAX - 1;
276 }
277}
278
289inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
290 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
291 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
292}
293
294#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
295
305inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
306 // First ensure, that the object has the correct heading by setting its value
307 double orientation = object_heading * 180 / M_PI; // Convert to degrees
308 // Normalize to [0, 360)
309 orientation = std::fmod(orientation + 360, 360);
310 while (orientation < 0) {
311 orientation += 360;
312 }
313 while (orientation >= 360) {
314 orientation -= 360;
315 }
316 setHeading(cam, orientation);
317 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
318 covariance_matrix, object_heading);
319}
320
329inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
330 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
331 covariance_matrix);
332}
333
334} // 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 258 of file cam_setters.h.

268 {
269
270#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
271
279inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
280 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
281}
282
289inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
290 auto accel_val = std::round(value * 1e1);
291 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
292 accel.value = static_cast<int16_t>(accel_val);
293 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
294 accel.value = LongitudinalAccelerationValue::MIN;
295 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
296 accel.value = LongitudinalAccelerationValue::MAX - 1;
297 }
298}
299
310inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
311 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
312 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
313}
314
321inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
322 int64_t accel_val = (int64_t)std::round(value * 1e1);
323 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
324 accel.value = accel_val;
325 } else if (accel_val < LateralAccelerationValue::MIN) {
326 accel.value = LateralAccelerationValue::MIN;
327 } else if (accel_val > LateralAccelerationValue::MAX) {
328 accel.value = LateralAccelerationValue::MAX - 1;
329 }
330}
331
342inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
343 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
344 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
345}
346
347#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
348
358inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
359 // First ensure, that the object has the correct heading by setting its value
360 double orientation = object_heading * 180 / M_PI; // Convert to degrees
361 // Normalize to [0, 360)
362 orientation = std::fmod(orientation + 360, 360);
363 while (orientation < 0) {
364 orientation += 360;
365 }
366 while (orientation >= 360) {
367 orientation -= 360;
368 }
369 setHeading(cam, orientation);
370 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
371 covariance_matrix, object_heading);
372}
373
382inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
383 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
384 covariance_matrix);
385}
386
387} // 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 40 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 23 of file cam_setters.h.

◆ setHeading()

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

Set the Heading for a CAM.

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

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

Definition at line 66 of file cam_setters.h.

66 {
67 accel.value = accel_val;
68 } else if (accel_val < LateralAccelerationValue::MIN) {
69 accel.value = LateralAccelerationValue::MIN;

◆ setHeadingCDD()

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

Set the Heading object.

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

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

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

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

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

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

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

22 {
23 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
24}

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

32 {
33 auto accel_val = std::round(value * 1e1);

◆ setLateralAcceleration() [1/2]

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

Set the lateral acceleration.

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

Definition at line 169 of file cam_setters.h.

179 {
180
181#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
182
190inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
191 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
192}
193
200inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
201 auto accel_val = std::round(value * 1e1);
202 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
203 accel.value = static_cast<int16_t>(accel_val);
204 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
205 accel.value = LongitudinalAccelerationValue::MIN;
206 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
207 accel.value = LongitudinalAccelerationValue::MAX - 1;
208 }
209}
210
221inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
222 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
223 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
224}
225
232inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
233 int64_t accel_val = (int64_t)std::round(value * 1e1);
234 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
235 accel.value = accel_val;
236 } else if (accel_val < LateralAccelerationValue::MIN) {
237 accel.value = LateralAccelerationValue::MIN;
238 } else if (accel_val > LateralAccelerationValue::MAX) {
239 accel.value = LateralAccelerationValue::MAX - 1;
240 }
241}
242
253inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
254 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
255 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
256}
257
258#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
259
269inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
270 // First ensure, that the object has the correct heading by setting its value
271 double orientation = object_heading * 180 / M_PI; // Convert to degrees
272 // Normalize to [0, 360)
273 orientation = std::fmod(orientation + 360, 360);
274 while (orientation < 0) {
275 orientation += 360;
276 }
277 while (orientation >= 360) {
278 orientation -= 360;
279 }
280 setHeading(cam, orientation);
281 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
282 covariance_matrix, object_heading);
283}
284
293inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
294 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
295 covariance_matrix);
296}
297
298} // 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 85 of file cam_setters.h.

85 {
86 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
87 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
88}

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

64 {
65 int64_t accel_val = (int64_t)std::round(value * 1e1);
66 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
67 accel.value = accel_val;
68 } else if (accel_val < LateralAccelerationValue::MIN) {
69 accel.value = LateralAccelerationValue::MIN;
70 } else if (accel_val > LateralAccelerationValue::MAX) {
71 accel.value = LateralAccelerationValue::MAX - 1;
72 }
73}

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

68 {
69 accel.value = LateralAccelerationValue::MIN;
70 } else if (accel_val > LateralAccelerationValue::MAX) {
71 accel.value = LateralAccelerationValue::MAX - 1;

◆ setLightBarSirenInUse()

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

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

Parameters
light_bar_siren_in_use
bits

Definition at line 280 of file cam_setters.h.

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

165 {
166
167#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
168
176inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
177 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
178}
179
186inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
187 auto accel_val = std::round(value * 1e1);
188 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
189 accel.value = static_cast<int16_t>(accel_val);
190 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
191 accel.value = LongitudinalAccelerationValue::MIN;
192 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
193 accel.value = LongitudinalAccelerationValue::MAX - 1;
194 }
195}
196
207inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
208 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
209 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
210}
211
218inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
219 int64_t accel_val = (int64_t)std::round(value * 1e1);
220 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
221 accel.value = accel_val;
222 } else if (accel_val < LateralAccelerationValue::MIN) {
223 accel.value = LateralAccelerationValue::MIN;
224 } else if (accel_val > LateralAccelerationValue::MAX) {
225 accel.value = LateralAccelerationValue::MAX - 1;
226 }
227}
228
239inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
240 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
241 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
242}
243
244#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
245
255inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
256 // First ensure, that the object has the correct heading by setting its value
257 double orientation = object_heading * 180 / M_PI; // Convert to degrees
258 // Normalize to [0, 360)
259 orientation = std::fmod(orientation + 360, 360);
260 while (orientation < 0) {
261 orientation += 360;
262 }
263 while (orientation >= 360) {
264 orientation -= 360;
265 }
266 setHeading(cam, orientation);
267 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
268 covariance_matrix, object_heading);
269}
270
279inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
280 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
281 covariance_matrix);
282}
283
284} // 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 53 of file cam_setters.h.

53 {
54 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
55 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
56}

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

32 {
33 auto accel_val = std::round(value * 1e1);
34 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
35 accel.value = static_cast<int16_t>(accel_val);
36 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
37 accel.value = LongitudinalAccelerationValue::MIN;
38 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
39 accel.value = LongitudinalAccelerationValue::MAX - 1;
40 }
41}

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

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

478 {
479
480#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
481
489inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
490 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
491}
492
499inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
500 auto accel_val = std::round(value * 1e1);
501 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
502 accel.value = static_cast<int16_t>(accel_val);
503 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
504 accel.value = LongitudinalAccelerationValue::MIN;
505 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
506 accel.value = LongitudinalAccelerationValue::MAX - 1;
507 }
508}
509
520inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
521 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
522 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
523}
524
531inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
532 int64_t accel_val = (int64_t)std::round(value * 1e1);
533 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
534 accel.value = accel_val;
535 } else if (accel_val < LateralAccelerationValue::MIN) {
536 accel.value = LateralAccelerationValue::MIN;
537 } else if (accel_val > LateralAccelerationValue::MAX) {
538 accel.value = LateralAccelerationValue::MAX - 1;
539 }
540}
541
552inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
553 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
554 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
555}
556
557#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
558
568inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
569 // First ensure, that the object has the correct heading by setting its value
570 double orientation = object_heading * 180 / M_PI; // Convert to degrees
571 // Normalize to [0, 360)
572 orientation = std::fmod(orientation + 360, 360);
573 while (orientation < 0) {
574 orientation += 360;
575 }
576 while (orientation >= 360) {
577 orientation -= 360;
578 }
579 setHeading(cam, orientation);
580 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
581 covariance_matrix, object_heading);
582}
583
592inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
593 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
594 covariance_matrix);
595}
596
597} // 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 188 of file cam_setters.h.

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

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

101 {
102 // First ensure, that the object has the correct heading by setting its value
103 double orientation = object_heading * 180 / M_PI; // Convert to degrees
104 // Normalize to [0, 360)
105 orientation = std::fmod(orientation + 360, 360);
106 while (orientation < 0) {
107 orientation += 360;
108 }
109 while (orientation >= 360) {
110 orientation -= 360;
111 }
112 setHeading(cam, orientation);
113 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
114 covariance_matrix, object_heading);
115}
setHeading
void setHeading(CAM &cam, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
Set the Heading for a CAM.
Definition cam_setters_common.h:66
setPosConfidenceEllipse
void setPosConfidenceEllipse(PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
Set the Pos Confidence Ellipse object.
Definition cdd_setters_common.h:395

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

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

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

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

153 {
154
155#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
156
164inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
165 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
166}
167
174inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
175 auto accel_val = std::round(value * 1e1);
176 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
177 accel.value = static_cast<int16_t>(accel_val);
178 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
179 accel.value = LongitudinalAccelerationValue::MIN;
180 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
181 accel.value = LongitudinalAccelerationValue::MAX - 1;
182 }
183}
184
195inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
196 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
197 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
198}
199
206inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
207 int64_t accel_val = (int64_t)std::round(value * 1e1);
208 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
209 accel.value = accel_val;
210 } else if (accel_val < LateralAccelerationValue::MIN) {
211 accel.value = LateralAccelerationValue::MIN;
212 } else if (accel_val > LateralAccelerationValue::MAX) {
213 accel.value = LateralAccelerationValue::MAX - 1;
214 }
215}
216
227inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
228 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
229 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
230}
231
232#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
233
243inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
244 // First ensure, that the object has the correct heading by setting its value
245 double orientation = object_heading * 180 / M_PI; // Convert to degrees
246 // Normalize to [0, 360)
247 orientation = std::fmod(orientation + 360, 360);
248 while (orientation < 0) {
249 orientation += 360;
250 }
251 while (orientation >= 360) {
252 orientation -= 360;
253 }
254 setHeading(cam, orientation);
255 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
256 covariance_matrix, object_heading);
257}
258
267inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
268 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
269 covariance_matrix);
270}
271
272} // 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 152 of file cam_setters.h.

162 {
163
164#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
165
173inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
174 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
175}
176
183inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
184 auto accel_val = std::round(value * 1e1);
185 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
186 accel.value = static_cast<int16_t>(accel_val);
187 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
188 accel.value = LongitudinalAccelerationValue::MIN;
189 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
190 accel.value = LongitudinalAccelerationValue::MAX - 1;
191 }
192}
193
204inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
205 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
206 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
207}
208
215inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
216 int64_t accel_val = (int64_t)std::round(value * 1e1);
217 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
218 accel.value = accel_val;
219 } else if (accel_val < LateralAccelerationValue::MIN) {
220 accel.value = LateralAccelerationValue::MIN;
221 } else if (accel_val > LateralAccelerationValue::MAX) {
222 accel.value = LateralAccelerationValue::MAX - 1;
223 }
224}
225
236inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
237 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
238 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
239}
240
241#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
242
252inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
253 // First ensure, that the object has the correct heading by setting its value
254 double orientation = object_heading * 180 / M_PI; // Convert to degrees
255 // Normalize to [0, 360)
256 orientation = std::fmod(orientation + 360, 360);
257 while (orientation < 0) {
258 orientation += 360;
259 }
260 while (orientation >= 360) {
261 orientation -= 360;
262 }
263 setHeading(cam, orientation);
264 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
265 covariance_matrix, object_heading);
266}
267
276inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
277 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
278 covariance_matrix);
279}
280
281} // 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 133 of file cam_setters.h.

143 {
144
145#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
146
154inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
155 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
156}
157
164inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
165 auto accel_val = std::round(value * 1e1);
166 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
167 accel.value = static_cast<int16_t>(accel_val);
168 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
169 accel.value = LongitudinalAccelerationValue::MIN;
170 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
171 accel.value = LongitudinalAccelerationValue::MAX - 1;
172 }
173}
174
185inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
186 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
187 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
188}
189
196inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
197 int64_t accel_val = (int64_t)std::round(value * 1e1);
198 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
199 accel.value = accel_val;
200 } else if (accel_val < LateralAccelerationValue::MIN) {
201 accel.value = LateralAccelerationValue::MIN;
202 } else if (accel_val > LateralAccelerationValue::MAX) {
203 accel.value = LateralAccelerationValue::MAX - 1;
204 }
205}
206
217inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
218 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
219 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
220}
221
222#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
223
233inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
234 // First ensure, that the object has the correct heading by setting its value
235 double orientation = object_heading * 180 / M_PI; // Convert to degrees
236 // Normalize to [0, 360)
237 orientation = std::fmod(orientation + 360, 360);
238 while (orientation < 0) {
239 orientation += 360;
240 }
241 while (orientation >= 360) {
242 orientation -= 360;
243 }
244 setHeading(cam, orientation);
245 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
246 covariance_matrix, object_heading);
247}
248
257inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
258 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
259 covariance_matrix);
260}
261
262} // 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 121 of file cam_setters.h.

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

◆ setStationId()

template<typename StationId>
void etsi_its_cam_msgs::access::setStationId ( StationId & station_id,
const uint32_t id_value )
inline

Set the Station Id object.

Parameters
station_id
id_value

Definition at line 28 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 52 of file cam_setters.h.

53 {
54 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);

◆ setStationType() [2/2]

template<typename StationType>
void etsi_its_cam_msgs::access::setStationType ( StationType & station_type,
const uint8_t value )
inline

Set the Station Type.

Parameters
station_type
value

Definition at line 40 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 53 of file cam_setters.h.

53 {
54 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
55 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
56}
57

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

◆ setVehicleLength()

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

Set the VehicleLength object.

VehicleLengthConfidenceIndication is set to UNAVAILABLE

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 117 of file cam_setters.h.

◆ setVehicleLengthValue()

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

Set the VehicleLengthValue object.

Parameters
vehicle_lengthobject to set
valueVehicleLengthValue in meter as decimal number

Definition at line 103 of file cam_setters.h.

◆ setVehicleWidth()

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

Set the VehicleWidth object.

Parameters
vehicle_widthobject to set
valueVehicleWidth in meter as decimal number

Definition at line 91 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 483 of file cam_setters.h.

504inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
505 setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
506}
507
514inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
515 auto accel_val = std::round(value * 1e1);
516 if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
517 accel.value = static_cast<int16_t>(accel_val);
518 } else if (accel_val < LongitudinalAccelerationValue::MIN) {
519 accel.value = LongitudinalAccelerationValue::MIN;
520 } else if (accel_val > LongitudinalAccelerationValue::MAX) {
521 accel.value = LongitudinalAccelerationValue::MAX - 1;
522 }
523}
524
535inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
536 setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
537 setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
538}
539
546inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
547 int64_t accel_val = (int64_t)std::round(value * 1e1);
548 if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
549 accel.value = accel_val;
550 } else if (accel_val < LateralAccelerationValue::MIN) {
551 accel.value = LateralAccelerationValue::MIN;
552 } else if (accel_val > LateralAccelerationValue::MAX) {
553 accel.value = LateralAccelerationValue::MAX - 1;
554 }
555}
556
567inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
568 setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
569 setLateralAccelerationValue(accel.lateral_acceleration_value, value);
570}
571
572#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>
573
583inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
584 // First ensure, that the object has the correct heading by setting its value
585 double orientation = object_heading * 180 / M_PI; // Convert to degrees
586 // Normalize to [0, 360)
587 orientation = std::fmod(orientation + 360, 360);
588 while (orientation < 0) {
589 orientation += 360;
590 }
591 while (orientation >= 360) {
592 orientation -= 360;
593 }
594 setHeading(cam, orientation);
595 setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
596 covariance_matrix, object_heading);
597}
598
607inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
608 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
609 covariance_matrix);
610}
611
612} // 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 125 of file cam_setters.h.

125 {
126 setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
127 covariance_matrix);
128}

◆ setYawRate()

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

Set the Yaw Rate for a CAM.

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

Definition at line 79 of file cam_setters.h.

◆ setYawRateCDD()

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

Set the Yaw Rate object.

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

Definition at line 330 of file cam_setters.h.

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

◆ 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 35 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 24 of file cam_access.h.