From f4a2e61db9dbcb9ab963eb028de1043812222c6e Mon Sep 17 00:00:00 2001 From: dan-du-car <62157949+dan-du-car@users.noreply.github.com> Date: Thu, 10 Aug 2023 09:03:31 -0400 Subject: [PATCH] V2xHub: Update the code for ASN1.c parser to recognize SDSM message type + unit test (#555) # PR Details ## Description As an V2XHub developer, I want to update the code for ASN.1 parser to recognize these SDSM message type. https://github.com/usdot-fhwa-stol/CARMASensitive/commit/a11650b48e350f5c54a2dfc0eb0afe14125c4080 ## Related Issue NA ## Motivation and Context CDA research ## How Has This Been Tested? Unit test ## Types of changes - [ ] Defect fix (non-breaking change that fixes an issue) - [x] New feature (non-breaking change that adds functionality) - [ ] Breaking change (fix or feature that cause existing functionality to change) ## Checklist: - [ ] I have added any new packages to the sonar-scanner.properties file - [ ] My change requires a change to the documentation. - [ ] I have updated the documentation accordingly. - [x] I have read the **CONTRIBUTING** document. [V2XHUB Contributing Guide](https://github.com/usdot-fhwa-OPS/V2X-Hub/blob/develop/Contributing.md) - [ ] I have added tests to cover my changes. - [ ] All new and existing tests passed. --- .../include/asn_j2735_r63/AngularVelocity.h | 42 ++++ .../asn_j2735_r63/AngularVelocityConfidence.h | 42 ++++ .../include/asn_j2735_r63/Attitude.h | 44 ++++ .../asn_j2735_r63/AttitudeConfidence.h | 42 ++++ .../asn_j2735_r63/ClassificationConfidence.h | 44 ++++ .../asn_j2735_r63/DetectedObjectCommonData.h | 79 +++++++ .../asn_j2735_r63/DetectedObjectData.h | 47 ++++ .../asn_j2735_r63/DetectedObjectList.h | 47 ++++ .../DetectedObjectOptionalData.h | 56 +++++ .../asn_j2735_r63/DetectedObstacleData.h | 42 ++++ .../include/asn_j2735_r63/DetectedVRUData.h | 51 ++++ .../asn_j2735_r63/DetectedVehicleData.h | 72 ++++++ .../include/asn_j2735_r63/EquipmentType.h | 56 +++++ .../asn_j2735_r63/MeasurementTimeOffset.h | 44 ++++ .../include/asn_j2735_r63/MessageFrame.h | 9 +- .../include/asn_j2735_r63/ObjectDistance.h | 44 ++++ .../include/asn_j2735_r63/ObjectID.h | 44 ++++ .../include/asn_j2735_r63/ObjectType.h | 56 +++++ .../include/asn_j2735_r63/ObstacleSize.h | 42 ++++ .../asn_j2735_r63/ObstacleSizeConfidence.h | 42 ++++ .../include/asn_j2735_r63/PitchDetected.h | 44 ++++ .../include/asn_j2735_r63/PitchRate.h | 44 ++++ .../asn_j2735_r63/PitchRateConfidence.h | 57 +++++ .../include/asn_j2735_r63/PositionOffsetXYZ.h | 42 ++++ .../include/asn_j2735_r63/RollDetected.h | 44 ++++ .../include/asn_j2735_r63/RollRate.h | 44 ++++ .../asn_j2735_r63/RollRateConfidence.h | 57 +++++ .../asn_j2735_r63/SensorDataSharingMessage.h | 54 +++++ .../include/asn_j2735_r63/SizeValue.h | 44 ++++ .../asn_j2735_r63/SizeValueConfidence.h | 63 +++++ .../asn_j2735_r63/VehicleSizeConfidence.h | 42 ++++ .../include/asn_j2735_r63/YawDetected.h | 44 ++++ src/tmx/Asn_J2735/src/r63/AngularVelocity.c | 60 +++++ .../src/r63/AngularVelocityConfidence.c | 62 +++++ src/tmx/Asn_J2735/src/r63/Attitude.c | 70 ++++++ .../Asn_J2735/src/r63/AttitudeConfidence.c | 70 ++++++ .../src/r63/ClassificationConfidence.c | 64 +++++ .../src/r63/DetectedObjectCommonData.c | 222 ++++++++++++++++++ .../Asn_J2735/src/r63/DetectedObjectData.c | 62 +++++ .../Asn_J2735/src/r63/DetectedObjectList.c | 52 ++++ .../src/r63/DetectedObjectOptionalData.c | 75 ++++++ .../Asn_J2735/src/r63/DetectedObstacleData.c | 60 +++++ src/tmx/Asn_J2735/src/r63/DetectedVRUData.c | 82 +++++++ .../Asn_J2735/src/r63/DetectedVehicleData.c | 142 +++++++++++ src/tmx/Asn_J2735/src/r63/EquipmentType.c | 62 +++++ .../Asn_J2735/src/r63/MeasurementTimeOffset.c | 64 +++++ src/tmx/Asn_J2735/src/r63/MessageFrame.c | 87 ++++--- src/tmx/Asn_J2735/src/r63/ObjectDistance.c | 64 +++++ src/tmx/Asn_J2735/src/r63/ObjectID.c | 64 +++++ src/tmx/Asn_J2735/src/r63/ObjectType.c | 62 +++++ src/tmx/Asn_J2735/src/r63/ObstacleSize.c | 72 ++++++ .../src/r63/ObstacleSizeConfidence.c | 72 ++++++ src/tmx/Asn_J2735/src/r63/PitchDetected.c | 64 +++++ src/tmx/Asn_J2735/src/r63/PitchRate.c | 64 +++++ .../Asn_J2735/src/r63/PitchRateConfidence.c | 68 ++++++ src/tmx/Asn_J2735/src/r63/PositionOffsetXYZ.c | 72 ++++++ src/tmx/Asn_J2735/src/r63/RollDetected.c | 64 +++++ src/tmx/Asn_J2735/src/r63/RollRate.c | 64 +++++ .../Asn_J2735/src/r63/RollRateConfidence.c | 68 ++++++ .../src/r63/SensorDataSharingMessage.c | 122 ++++++++++ src/tmx/Asn_J2735/src/r63/SizeValue.c | 64 +++++ .../Asn_J2735/src/r63/SizeValueConfidence.c | 80 +++++++ .../Asn_J2735/src/r63/VehicleSizeConfidence.c | 72 ++++++ src/tmx/Asn_J2735/src/r63/YawDetected.c | 64 +++++ src/tmx/TmxApi/tmx/TmxApiMessages.h | 4 + .../j2735_messages/J2735MessageFactory.hpp | 5 +- .../SensorDataSharingMessage.hpp | 15 ++ src/tmx/TmxUtils/test/J2735MessageTest.cpp | 57 +++++ 68 files changed, 3998 insertions(+), 41 deletions(-) create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocity.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocityConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/Attitude.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/AttitudeConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ClassificationConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectCommonData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectList.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectOptionalData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObstacleData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVRUData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVehicleData.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/EquipmentType.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/MeasurementTimeOffset.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectDistance.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectID.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectType.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSize.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSizeConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/PitchDetected.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRate.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRateConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/PositionOffsetXYZ.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/RollDetected.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/RollRate.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/RollRateConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/SensorDataSharingMessage.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValue.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValueConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/VehicleSizeConfidence.h create mode 100644 src/tmx/Asn_J2735/include/asn_j2735_r63/YawDetected.h create mode 100644 src/tmx/Asn_J2735/src/r63/AngularVelocity.c create mode 100644 src/tmx/Asn_J2735/src/r63/AngularVelocityConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/Attitude.c create mode 100644 src/tmx/Asn_J2735/src/r63/AttitudeConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/ClassificationConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedObjectCommonData.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedObjectData.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedObjectList.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedObjectOptionalData.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedObstacleData.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedVRUData.c create mode 100644 src/tmx/Asn_J2735/src/r63/DetectedVehicleData.c create mode 100644 src/tmx/Asn_J2735/src/r63/EquipmentType.c create mode 100644 src/tmx/Asn_J2735/src/r63/MeasurementTimeOffset.c create mode 100644 src/tmx/Asn_J2735/src/r63/ObjectDistance.c create mode 100644 src/tmx/Asn_J2735/src/r63/ObjectID.c create mode 100644 src/tmx/Asn_J2735/src/r63/ObjectType.c create mode 100644 src/tmx/Asn_J2735/src/r63/ObstacleSize.c create mode 100644 src/tmx/Asn_J2735/src/r63/ObstacleSizeConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/PitchDetected.c create mode 100644 src/tmx/Asn_J2735/src/r63/PitchRate.c create mode 100644 src/tmx/Asn_J2735/src/r63/PitchRateConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/PositionOffsetXYZ.c create mode 100644 src/tmx/Asn_J2735/src/r63/RollDetected.c create mode 100644 src/tmx/Asn_J2735/src/r63/RollRate.c create mode 100644 src/tmx/Asn_J2735/src/r63/RollRateConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/SensorDataSharingMessage.c create mode 100644 src/tmx/Asn_J2735/src/r63/SizeValue.c create mode 100644 src/tmx/Asn_J2735/src/r63/SizeValueConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/VehicleSizeConfidence.c create mode 100644 src/tmx/Asn_J2735/src/r63/YawDetected.c create mode 100644 src/tmx/TmxApi/tmx/j2735_messages/SensorDataSharingMessage.hpp diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocity.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocity.h new file mode 100644 index 000000000..2cb35471e --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocity.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _AngularVelocity_H_ +#define _AngularVelocity_H_ + + +#include + +/* Including external dependencies */ +#include "PitchRate.h" +#include "RollRate.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* AngularVelocity */ +typedef struct AngularVelocity { + PitchRate_t pitchRate; + RollRate_t rollRate; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} AngularVelocity_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_AngularVelocity; +extern asn_SEQUENCE_specifics_t asn_SPC_AngularVelocity_specs_1; +extern asn_TYPE_member_t asn_MBR_AngularVelocity_1[2]; + +#ifdef __cplusplus +} +#endif + +#endif /* _AngularVelocity_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocityConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocityConfidence.h new file mode 100644 index 000000000..e1d1e73f1 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/AngularVelocityConfidence.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _AngularVelocityConfidence_H_ +#define _AngularVelocityConfidence_H_ + + +#include + +/* Including external dependencies */ +#include "PitchRateConfidence.h" +#include "RollRateConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* AngularVelocityConfidence */ +typedef struct AngularVelocityConfidence { + PitchRateConfidence_t *pitchRateConfidence /* OPTIONAL */; + RollRateConfidence_t *rollRateConfidence /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} AngularVelocityConfidence_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_AngularVelocityConfidence; +extern asn_SEQUENCE_specifics_t asn_SPC_AngularVelocityConfidence_specs_1; +extern asn_TYPE_member_t asn_MBR_AngularVelocityConfidence_1[2]; + +#ifdef __cplusplus +} +#endif + +#endif /* _AngularVelocityConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/Attitude.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/Attitude.h new file mode 100644 index 000000000..b2316ff61 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/Attitude.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _Attitude_H_ +#define _Attitude_H_ + + +#include + +/* Including external dependencies */ +#include "PitchDetected.h" +#include "RollDetected.h" +#include "YawDetected.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Attitude */ +typedef struct Attitude { + PitchDetected_t pitch; + RollDetected_t roll; + YawDetected_t yaw; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} Attitude_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_Attitude; +extern asn_SEQUENCE_specifics_t asn_SPC_Attitude_specs_1; +extern asn_TYPE_member_t asn_MBR_Attitude_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _Attitude_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/AttitudeConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/AttitudeConfidence.h new file mode 100644 index 000000000..b6377270b --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/AttitudeConfidence.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _AttitudeConfidence_H_ +#define _AttitudeConfidence_H_ + + +#include + +/* Including external dependencies */ +#include "HeadingConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* AttitudeConfidence */ +typedef struct AttitudeConfidence { + HeadingConfidence_t pitchConfidence; + HeadingConfidence_t rollConfidence; + HeadingConfidence_t yawConfidence; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} AttitudeConfidence_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_AttitudeConfidence; +extern asn_SEQUENCE_specifics_t asn_SPC_AttitudeConfidence_specs_1; +extern asn_TYPE_member_t asn_MBR_AttitudeConfidence_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _AttitudeConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ClassificationConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ClassificationConfidence.h new file mode 100644 index 000000000..155280700 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ClassificationConfidence.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ClassificationConfidence_H_ +#define _ClassificationConfidence_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ClassificationConfidence */ +typedef long ClassificationConfidence_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_ClassificationConfidence_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_ClassificationConfidence; +asn_struct_free_f ClassificationConfidence_free; +asn_struct_print_f ClassificationConfidence_print; +asn_constr_check_f ClassificationConfidence_constraint; +ber_type_decoder_f ClassificationConfidence_decode_ber; +der_type_encoder_f ClassificationConfidence_encode_der; +xer_type_decoder_f ClassificationConfidence_decode_xer; +xer_type_encoder_f ClassificationConfidence_encode_xer; +oer_type_decoder_f ClassificationConfidence_decode_oer; +oer_type_encoder_f ClassificationConfidence_encode_oer; +per_type_decoder_f ClassificationConfidence_decode_uper; +per_type_encoder_f ClassificationConfidence_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _ClassificationConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectCommonData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectCommonData.h new file mode 100644 index 000000000..47a21dd85 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectCommonData.h @@ -0,0 +1,79 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedObjectCommonData_H_ +#define _DetectedObjectCommonData_H_ + + +#include + +/* Including external dependencies */ +#include "ObjectType.h" +#include "ClassificationConfidence.h" +#include "ObjectID.h" +#include "MeasurementTimeOffset.h" +#include "TimeConfidence.h" +#include "PositionOffsetXYZ.h" +#include "PositionConfidenceSet.h" +#include "Speed.h" +#include "SpeedConfidence.h" +#include "Heading.h" +#include "HeadingConfidence.h" +#include "AccelerationConfidence.h" +#include "YawRateConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct AccelerationSet4Way; + +/* DetectedObjectCommonData */ +typedef struct DetectedObjectCommonData { + ObjectType_t objType; + ClassificationConfidence_t objTypeCfd; + ObjectID_t objectID; + MeasurementTimeOffset_t measurementTime; + TimeConfidence_t timeConfidence; + PositionOffsetXYZ_t pos; + PositionConfidenceSet_t posConfidence; + Speed_t speed; + SpeedConfidence_t speedConfidence; + Speed_t *speedZ /* OPTIONAL */; + SpeedConfidence_t *speedConfidenceZ /* OPTIONAL */; + Heading_t heading; + HeadingConfidence_t headingConf; + struct AccelerationSet4Way *accel4way /* OPTIONAL */; + AccelerationConfidence_t *accCfdX /* OPTIONAL */; + AccelerationConfidence_t *accCfdY /* OPTIONAL */; + AccelerationConfidence_t *accCfdZ /* OPTIONAL */; + YawRateConfidence_t *accCfdYaw /* OPTIONAL */; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedObjectCommonData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedObjectCommonData; +extern asn_SEQUENCE_specifics_t asn_SPC_DetectedObjectCommonData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedObjectCommonData_1[18]; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "AccelerationSet4Way.h" + +#endif /* _DetectedObjectCommonData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectData.h new file mode 100644 index 000000000..e856ddf5f --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectData.h @@ -0,0 +1,47 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedObjectData_H_ +#define _DetectedObjectData_H_ + + +#include + +/* Including external dependencies */ +#include "DetectedObjectCommonData.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct DetectedObjectOptionalData; + +/* DetectedObjectData */ +typedef struct DetectedObjectData { + DetectedObjectCommonData_t detObjCommon; + struct DetectedObjectOptionalData *detObjOptData /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedObjectData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedObjectData; +extern asn_SEQUENCE_specifics_t asn_SPC_DetectedObjectData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedObjectData_1[2]; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "DetectedObjectOptionalData.h" + +#endif /* _DetectedObjectData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectList.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectList.h new file mode 100644 index 000000000..c114380dd --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectList.h @@ -0,0 +1,47 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedObjectList_H_ +#define _DetectedObjectList_H_ + + +#include + +/* Including external dependencies */ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct DetectedObjectData; + +/* DetectedObjectList */ +typedef struct DetectedObjectList { + A_SEQUENCE_OF(struct DetectedObjectData) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedObjectList_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedObjectList; +extern asn_SET_OF_specifics_t asn_SPC_DetectedObjectList_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedObjectList_1[1]; +extern asn_per_constraints_t asn_PER_type_DetectedObjectList_constr_1; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "DetectedObjectData.h" + +#endif /* _DetectedObjectList_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectOptionalData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectOptionalData.h new file mode 100644 index 000000000..97b9624cf --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObjectOptionalData.h @@ -0,0 +1,56 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedObjectOptionalData_H_ +#define _DetectedObjectOptionalData_H_ + + +#include + +/* Including external dependencies */ +#include "DetectedVehicleData.h" +#include "DetectedVRUData.h" +#include "DetectedObstacleData.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum DetectedObjectOptionalData_PR { + DetectedObjectOptionalData_PR_NOTHING, /* No components present */ + DetectedObjectOptionalData_PR_detVeh, + DetectedObjectOptionalData_PR_detVRU, + DetectedObjectOptionalData_PR_detObst +} DetectedObjectOptionalData_PR; + +/* DetectedObjectOptionalData */ +typedef struct DetectedObjectOptionalData { + DetectedObjectOptionalData_PR present; + union DetectedObjectOptionalData_u { + DetectedVehicleData_t detVeh; + DetectedVRUData_t detVRU; + DetectedObstacleData_t detObst; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedObjectOptionalData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedObjectOptionalData; +extern asn_CHOICE_specifics_t asn_SPC_DetectedObjectOptionalData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedObjectOptionalData_1[3]; +extern asn_per_constraints_t asn_PER_type_DetectedObjectOptionalData_constr_1; + +#ifdef __cplusplus +} +#endif + +#endif /* _DetectedObjectOptionalData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObstacleData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObstacleData.h new file mode 100644 index 000000000..b6f5ad78e --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedObstacleData.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedObstacleData_H_ +#define _DetectedObstacleData_H_ + + +#include + +/* Including external dependencies */ +#include "ObstacleSize.h" +#include "ObstacleSizeConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* DetectedObstacleData */ +typedef struct DetectedObstacleData { + ObstacleSize_t obstSize; + ObstacleSizeConfidence_t obstSizeConfidence; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedObstacleData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedObstacleData; +extern asn_SEQUENCE_specifics_t asn_SPC_DetectedObstacleData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedObstacleData_1[2]; + +#ifdef __cplusplus +} +#endif + +#endif /* _DetectedObstacleData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVRUData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVRUData.h new file mode 100644 index 000000000..5bfaffda3 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVRUData.h @@ -0,0 +1,51 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedVRUData_H_ +#define _DetectedVRUData_H_ + + +#include + +/* Including external dependencies */ +#include "PersonalDeviceUserType.h" +#include "Attachment.h" +#include "AttachmentRadius.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct PropelledInformation; + +/* DetectedVRUData */ +typedef struct DetectedVRUData { + PersonalDeviceUserType_t *basicType /* OPTIONAL */; + struct PropelledInformation *propulsion /* OPTIONAL */; + Attachment_t *attachment /* OPTIONAL */; + AttachmentRadius_t *radius /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedVRUData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedVRUData; +extern asn_SEQUENCE_specifics_t asn_SPC_DetectedVRUData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedVRUData_1[4]; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "PropelledInformation.h" + +#endif /* _DetectedVRUData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVehicleData.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVehicleData.h new file mode 100644 index 000000000..49a988e5d --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/DetectedVehicleData.h @@ -0,0 +1,72 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _DetectedVehicleData_H_ +#define _DetectedVehicleData_H_ + + +#include + +/* Including external dependencies */ +#include "ExteriorLights.h" +#include "VehicleHeight.h" +#include "BasicVehicleClass.h" +#include "ClassificationConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declarations */ +struct Attitude; +struct AttitudeConfidence; +struct AngularVelocity; +struct AngularVelocityConfidence; +struct VehicleSize; +struct VehicleSizeConfidence; + +/* DetectedVehicleData */ +typedef struct DetectedVehicleData { + ExteriorLights_t *lights /* OPTIONAL */; + struct Attitude *vehAttitude /* OPTIONAL */; + struct AttitudeConfidence *vehAttitudeConfidence /* OPTIONAL */; + struct AngularVelocity *vehAngVel /* OPTIONAL */; + struct AngularVelocityConfidence *vehAngVelConfidence /* OPTIONAL */; + struct VehicleSize *size /* OPTIONAL */; + VehicleHeight_t *height /* OPTIONAL */; + struct VehicleSizeConfidence *vehicleSizeConfidence /* OPTIONAL */; + BasicVehicleClass_t *vehicleClass /* OPTIONAL */; + ClassificationConfidence_t *classConf /* OPTIONAL */; + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} DetectedVehicleData_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_DetectedVehicleData; +extern asn_SEQUENCE_specifics_t asn_SPC_DetectedVehicleData_specs_1; +extern asn_TYPE_member_t asn_MBR_DetectedVehicleData_1[10]; + +#ifdef __cplusplus +} +#endif + +/* Referred external types */ +#include "Attitude.h" +#include "AttitudeConfidence.h" +#include "AngularVelocity.h" +#include "AngularVelocityConfidence.h" +#include "VehicleSize.h" +#include "VehicleSizeConfidence.h" + +#endif /* _DetectedVehicleData_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/EquipmentType.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/EquipmentType.h new file mode 100644 index 000000000..2d1799bb4 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/EquipmentType.h @@ -0,0 +1,56 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _EquipmentType_H_ +#define _EquipmentType_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum EquipmentType { + EquipmentType_unknown = 0, + EquipmentType_rsu = 1, + EquipmentType_obu = 2, + EquipmentType_vru = 3 + /* + * Enumeration is extensible + */ +} e_EquipmentType; + +/* EquipmentType */ +typedef long EquipmentType_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_EquipmentType_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_EquipmentType; +extern const asn_INTEGER_specifics_t asn_SPC_EquipmentType_specs_1; +asn_struct_free_f EquipmentType_free; +asn_struct_print_f EquipmentType_print; +asn_constr_check_f EquipmentType_constraint; +ber_type_decoder_f EquipmentType_decode_ber; +der_type_encoder_f EquipmentType_encode_der; +xer_type_decoder_f EquipmentType_decode_xer; +xer_type_encoder_f EquipmentType_encode_xer; +oer_type_decoder_f EquipmentType_decode_oer; +oer_type_encoder_f EquipmentType_encode_oer; +per_type_decoder_f EquipmentType_decode_uper; +per_type_encoder_f EquipmentType_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _EquipmentType_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/MeasurementTimeOffset.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/MeasurementTimeOffset.h new file mode 100644 index 000000000..59c1c0f1f --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/MeasurementTimeOffset.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names` + */ + +#ifndef _MeasurementTimeOffset_H_ +#define _MeasurementTimeOffset_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* MeasurementTimeOffset */ +typedef long MeasurementTimeOffset_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_MeasurementTimeOffset_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_MeasurementTimeOffset; +asn_struct_free_f MeasurementTimeOffset_free; +asn_struct_print_f MeasurementTimeOffset_print; +asn_constr_check_f MeasurementTimeOffset_constraint; +ber_type_decoder_f MeasurementTimeOffset_decode_ber; +der_type_encoder_f MeasurementTimeOffset_encode_der; +xer_type_decoder_f MeasurementTimeOffset_decode_xer; +xer_type_encoder_f MeasurementTimeOffset_encode_xer; +oer_type_decoder_f MeasurementTimeOffset_decode_oer; +oer_type_encoder_f MeasurementTimeOffset_encode_oer; +per_type_decoder_f MeasurementTimeOffset_decode_uper; +per_type_encoder_f MeasurementTimeOffset_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _MeasurementTimeOffset_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/MessageFrame.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/MessageFrame.h index ff77ab6f5..422fc814a 100644 --- a/src/tmx/Asn_J2735/include/asn_j2735_r63/MessageFrame.h +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/MessageFrame.h @@ -1,8 +1,8 @@ /* * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) * From ASN.1 module "DSRC" - * found in "J2735_201603_ASN_CC.asn" - * `asn1c -gen-PER -fcompound-names -fincludes-quoted` + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names` */ #ifndef _MessageFrame_H_ @@ -46,6 +46,7 @@ #include "TestMessage13.h" #include "TestMessage14.h" #include "TestMessage15.h" +#include "SensorDataSharingMessage.h" #include "OPEN_TYPE.h" #include "constr_CHOICE.h" #include "constr_SEQUENCE.h" @@ -87,7 +88,8 @@ typedef enum value_PR { value_PR_TestMessage12, value_PR_TestMessage13, value_PR_TestMessage14, - value_PR_TestMessage15 + value_PR_TestMessage15, + value_PR_SensorDataSharingMessage } value_PR; /* MessageFrame */ @@ -127,6 +129,7 @@ typedef struct MessageFrame { TestMessage13_t TestMessage13; TestMessage14_t TestMessage14; TestMessage15_t TestMessage15; + SensorDataSharingMessage_t SensorDataSharingMessage; } choice; /* Context for parsing across buffer boundaries */ diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectDistance.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectDistance.h new file mode 100644 index 000000000..db97608e2 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectDistance.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ObjectDistance_H_ +#define _ObjectDistance_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ObjectDistance */ +typedef long ObjectDistance_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_ObjectDistance_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_ObjectDistance; +asn_struct_free_f ObjectDistance_free; +asn_struct_print_f ObjectDistance_print; +asn_constr_check_f ObjectDistance_constraint; +ber_type_decoder_f ObjectDistance_decode_ber; +der_type_encoder_f ObjectDistance_encode_der; +xer_type_decoder_f ObjectDistance_decode_xer; +xer_type_encoder_f ObjectDistance_encode_xer; +oer_type_decoder_f ObjectDistance_decode_oer; +oer_type_encoder_f ObjectDistance_encode_oer; +per_type_decoder_f ObjectDistance_decode_uper; +per_type_encoder_f ObjectDistance_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObjectDistance_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectID.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectID.h new file mode 100644 index 000000000..3b0a53b78 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectID.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ObjectID_H_ +#define _ObjectID_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ObjectID */ +typedef long ObjectID_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_ObjectID_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_ObjectID; +asn_struct_free_f ObjectID_free; +asn_struct_print_f ObjectID_print; +asn_constr_check_f ObjectID_constraint; +ber_type_decoder_f ObjectID_decode_ber; +der_type_encoder_f ObjectID_encode_der; +xer_type_decoder_f ObjectID_decode_xer; +xer_type_encoder_f ObjectID_encode_xer; +oer_type_decoder_f ObjectID_decode_oer; +oer_type_encoder_f ObjectID_encode_oer; +per_type_decoder_f ObjectID_decode_uper; +per_type_encoder_f ObjectID_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObjectID_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectType.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectType.h new file mode 100644 index 000000000..52837430b --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObjectType.h @@ -0,0 +1,56 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ObjectType_H_ +#define _ObjectType_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum ObjectType { + ObjectType_unknown = 0, + ObjectType_vehicle = 1, + ObjectType_vru = 2, + ObjectType_animal = 3 + /* + * Enumeration is extensible + */ +} e_ObjectType; + +/* ObjectType */ +typedef long ObjectType_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_ObjectType_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_ObjectType; +extern const asn_INTEGER_specifics_t asn_SPC_ObjectType_specs_1; +asn_struct_free_f ObjectType_free; +asn_struct_print_f ObjectType_print; +asn_constr_check_f ObjectType_constraint; +ber_type_decoder_f ObjectType_decode_ber; +der_type_encoder_f ObjectType_encode_der; +xer_type_decoder_f ObjectType_decode_xer; +xer_type_encoder_f ObjectType_encode_xer; +oer_type_decoder_f ObjectType_decode_oer; +oer_type_encoder_f ObjectType_encode_oer; +per_type_decoder_f ObjectType_decode_uper; +per_type_encoder_f ObjectType_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObjectType_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSize.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSize.h new file mode 100644 index 000000000..12206d92c --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSize.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ObstacleSize_H_ +#define _ObstacleSize_H_ + + +#include + +/* Including external dependencies */ +#include "SizeValue.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ObstacleSize */ +typedef struct ObstacleSize { + SizeValue_t width; + SizeValue_t length; + SizeValue_t *height /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ObstacleSize_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ObstacleSize; +extern asn_SEQUENCE_specifics_t asn_SPC_ObstacleSize_specs_1; +extern asn_TYPE_member_t asn_MBR_ObstacleSize_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObstacleSize_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSizeConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSizeConfidence.h new file mode 100644 index 000000000..1ef36fbc5 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/ObstacleSizeConfidence.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _ObstacleSizeConfidence_H_ +#define _ObstacleSizeConfidence_H_ + + +#include + +/* Including external dependencies */ +#include "SizeValueConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ObstacleSizeConfidence */ +typedef struct ObstacleSizeConfidence { + SizeValueConfidence_t widthConfidence; + SizeValueConfidence_t lengthConfidence; + SizeValueConfidence_t *heightConfidence /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ObstacleSizeConfidence_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_ObstacleSizeConfidence; +extern asn_SEQUENCE_specifics_t asn_SPC_ObstacleSizeConfidence_specs_1; +extern asn_TYPE_member_t asn_MBR_ObstacleSizeConfidence_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _ObstacleSizeConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchDetected.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchDetected.h new file mode 100644 index 000000000..a028235b2 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchDetected.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _PitchDetected_H_ +#define _PitchDetected_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PitchDetected */ +typedef long PitchDetected_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_PitchDetected_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_PitchDetected; +asn_struct_free_f PitchDetected_free; +asn_struct_print_f PitchDetected_print; +asn_constr_check_f PitchDetected_constraint; +ber_type_decoder_f PitchDetected_decode_ber; +der_type_encoder_f PitchDetected_encode_der; +xer_type_decoder_f PitchDetected_decode_xer; +xer_type_encoder_f PitchDetected_encode_xer; +oer_type_decoder_f PitchDetected_decode_oer; +oer_type_encoder_f PitchDetected_encode_oer; +per_type_decoder_f PitchDetected_decode_uper; +per_type_encoder_f PitchDetected_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _PitchDetected_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRate.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRate.h new file mode 100644 index 000000000..145045cd2 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRate.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _PitchRate_H_ +#define _PitchRate_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PitchRate */ +typedef long PitchRate_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_PitchRate_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_PitchRate; +asn_struct_free_f PitchRate_free; +asn_struct_print_f PitchRate_print; +asn_constr_check_f PitchRate_constraint; +ber_type_decoder_f PitchRate_decode_ber; +der_type_encoder_f PitchRate_encode_der; +xer_type_decoder_f PitchRate_decode_xer; +xer_type_encoder_f PitchRate_encode_xer; +oer_type_decoder_f PitchRate_decode_oer; +oer_type_encoder_f PitchRate_encode_oer; +per_type_decoder_f PitchRate_decode_uper; +per_type_encoder_f PitchRate_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _PitchRate_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRateConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRateConfidence.h new file mode 100644 index 000000000..df6f4e7a0 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/PitchRateConfidence.h @@ -0,0 +1,57 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _PitchRateConfidence_H_ +#define _PitchRateConfidence_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum PitchRateConfidence { + PitchRateConfidence_unavailable = 0, + PitchRateConfidence_degSec_100_00 = 1, + PitchRateConfidence_degSec_010_00 = 2, + PitchRateConfidence_degSec_005_00 = 3, + PitchRateConfidence_degSec_001_00 = 4, + PitchRateConfidence_degSec_000_10 = 5, + PitchRateConfidence_degSec_000_05 = 6, + PitchRateConfidence_degSec_000_01 = 7 +} e_PitchRateConfidence; + +/* PitchRateConfidence */ +typedef long PitchRateConfidence_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_PitchRateConfidence_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_PitchRateConfidence; +extern const asn_INTEGER_specifics_t asn_SPC_PitchRateConfidence_specs_1; +asn_struct_free_f PitchRateConfidence_free; +asn_struct_print_f PitchRateConfidence_print; +asn_constr_check_f PitchRateConfidence_constraint; +ber_type_decoder_f PitchRateConfidence_decode_ber; +der_type_encoder_f PitchRateConfidence_encode_der; +xer_type_decoder_f PitchRateConfidence_decode_xer; +xer_type_encoder_f PitchRateConfidence_encode_xer; +oer_type_decoder_f PitchRateConfidence_decode_oer; +oer_type_encoder_f PitchRateConfidence_encode_oer; +per_type_decoder_f PitchRateConfidence_decode_uper; +per_type_encoder_f PitchRateConfidence_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _PitchRateConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/PositionOffsetXYZ.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/PositionOffsetXYZ.h new file mode 100644 index 000000000..9a9890818 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/PositionOffsetXYZ.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _PositionOffsetXYZ_H_ +#define _PositionOffsetXYZ_H_ + + +#include + +/* Including external dependencies */ +#include "ObjectDistance.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PositionOffsetXYZ */ +typedef struct PositionOffsetXYZ { + ObjectDistance_t offsetX; + ObjectDistance_t offsetY; + ObjectDistance_t *offsetZ /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} PositionOffsetXYZ_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_PositionOffsetXYZ; +extern asn_SEQUENCE_specifics_t asn_SPC_PositionOffsetXYZ_specs_1; +extern asn_TYPE_member_t asn_MBR_PositionOffsetXYZ_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _PositionOffsetXYZ_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/RollDetected.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollDetected.h new file mode 100644 index 000000000..5326257bd --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollDetected.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _RollDetected_H_ +#define _RollDetected_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RollDetected */ +typedef long RollDetected_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_RollDetected_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_RollDetected; +asn_struct_free_f RollDetected_free; +asn_struct_print_f RollDetected_print; +asn_constr_check_f RollDetected_constraint; +ber_type_decoder_f RollDetected_decode_ber; +der_type_encoder_f RollDetected_encode_der; +xer_type_decoder_f RollDetected_decode_xer; +xer_type_encoder_f RollDetected_encode_xer; +oer_type_decoder_f RollDetected_decode_oer; +oer_type_encoder_f RollDetected_encode_oer; +per_type_decoder_f RollDetected_decode_uper; +per_type_encoder_f RollDetected_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _RollDetected_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRate.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRate.h new file mode 100644 index 000000000..86d4d3b25 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRate.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _RollRate_H_ +#define _RollRate_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* RollRate */ +typedef long RollRate_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_RollRate_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_RollRate; +asn_struct_free_f RollRate_free; +asn_struct_print_f RollRate_print; +asn_constr_check_f RollRate_constraint; +ber_type_decoder_f RollRate_decode_ber; +der_type_encoder_f RollRate_encode_der; +xer_type_decoder_f RollRate_decode_xer; +xer_type_encoder_f RollRate_encode_xer; +oer_type_decoder_f RollRate_decode_oer; +oer_type_encoder_f RollRate_encode_oer; +per_type_decoder_f RollRate_decode_uper; +per_type_encoder_f RollRate_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _RollRate_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRateConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRateConfidence.h new file mode 100644 index 000000000..9fbfec7fd --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/RollRateConfidence.h @@ -0,0 +1,57 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _RollRateConfidence_H_ +#define _RollRateConfidence_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum RollRateConfidence { + RollRateConfidence_unavailable = 0, + RollRateConfidence_degSec_100_00 = 1, + RollRateConfidence_degSec_010_00 = 2, + RollRateConfidence_degSec_005_00 = 3, + RollRateConfidence_degSec_001_00 = 4, + RollRateConfidence_degSec_000_10 = 5, + RollRateConfidence_degSec_000_05 = 6, + RollRateConfidence_degSec_000_01 = 7 +} e_RollRateConfidence; + +/* RollRateConfidence */ +typedef long RollRateConfidence_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_RollRateConfidence_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_RollRateConfidence; +extern const asn_INTEGER_specifics_t asn_SPC_RollRateConfidence_specs_1; +asn_struct_free_f RollRateConfidence_free; +asn_struct_print_f RollRateConfidence_print; +asn_constr_check_f RollRateConfidence_constraint; +ber_type_decoder_f RollRateConfidence_decode_ber; +der_type_encoder_f RollRateConfidence_encode_der; +xer_type_decoder_f RollRateConfidence_decode_xer; +xer_type_encoder_f RollRateConfidence_encode_xer; +oer_type_decoder_f RollRateConfidence_decode_oer; +oer_type_encoder_f RollRateConfidence_encode_oer; +per_type_decoder_f RollRateConfidence_decode_uper; +per_type_encoder_f RollRateConfidence_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _RollRateConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/SensorDataSharingMessage.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/SensorDataSharingMessage.h new file mode 100644 index 000000000..5a4d08db2 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/SensorDataSharingMessage.h @@ -0,0 +1,54 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _SensorDataSharingMessage_H_ +#define _SensorDataSharingMessage_H_ + + +#include + +/* Including external dependencies */ +#include "DSRC_MsgCount.h" +#include "TemporaryID.h" +#include "EquipmentType.h" +#include "DDateTime.h" +#include "Position3D.h" +#include "PositionalAccuracy.h" +#include "ElevationConfidence.h" +#include "DetectedObjectList.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* SensorDataSharingMessage */ +typedef struct SensorDataSharingMessage { + DSRC_MsgCount_t msgCnt; + TemporaryID_t sourceID; + EquipmentType_t equipmentType; + DDateTime_t sDSMTimeStamp; + Position3D_t refPos; + PositionalAccuracy_t refPosXYConf; + ElevationConfidence_t *refPosElConf /* OPTIONAL */; + DetectedObjectList_t objects; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SensorDataSharingMessage_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_SensorDataSharingMessage; +extern asn_SEQUENCE_specifics_t asn_SPC_SensorDataSharingMessage_specs_1; +extern asn_TYPE_member_t asn_MBR_SensorDataSharingMessage_1[8]; + +#ifdef __cplusplus +} +#endif + +#endif /* _SensorDataSharingMessage_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValue.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValue.h new file mode 100644 index 000000000..7b35e76ef --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValue.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _SizeValue_H_ +#define _SizeValue_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* SizeValue */ +typedef long SizeValue_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_SizeValue_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_SizeValue; +asn_struct_free_f SizeValue_free; +asn_struct_print_f SizeValue_print; +asn_constr_check_f SizeValue_constraint; +ber_type_decoder_f SizeValue_decode_ber; +der_type_encoder_f SizeValue_encode_der; +xer_type_decoder_f SizeValue_decode_xer; +xer_type_encoder_f SizeValue_encode_xer; +oer_type_decoder_f SizeValue_decode_oer; +oer_type_encoder_f SizeValue_encode_oer; +per_type_decoder_f SizeValue_decode_uper; +per_type_encoder_f SizeValue_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _SizeValue_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValueConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValueConfidence.h new file mode 100644 index 000000000..b719b5570 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/SizeValueConfidence.h @@ -0,0 +1,63 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _SizeValueConfidence_H_ +#define _SizeValueConfidence_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Dependencies */ +typedef enum SizeValueConfidence { + SizeValueConfidence_unavailable = 0, + SizeValueConfidence_size_100_00 = 1, + SizeValueConfidence_size_050_00 = 2, + SizeValueConfidence_size_020_00 = 3, + SizeValueConfidence_size_010_00 = 4, + SizeValueConfidence_size_005_00 = 5, + SizeValueConfidence_size_002_00 = 6, + SizeValueConfidence_size_001_00 = 7, + SizeValueConfidence_size_000_50 = 8, + SizeValueConfidence_size_000_20 = 9, + SizeValueConfidence_size_000_10 = 10, + SizeValueConfidence_size_000_05 = 11, + SizeValueConfidence_size_000_02 = 12, + SizeValueConfidence_size_000_01 = 13 +} e_SizeValueConfidence; + +/* SizeValueConfidence */ +typedef long SizeValueConfidence_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_SizeValueConfidence_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_SizeValueConfidence; +extern const asn_INTEGER_specifics_t asn_SPC_SizeValueConfidence_specs_1; +asn_struct_free_f SizeValueConfidence_free; +asn_struct_print_f SizeValueConfidence_print; +asn_constr_check_f SizeValueConfidence_constraint; +ber_type_decoder_f SizeValueConfidence_decode_ber; +der_type_encoder_f SizeValueConfidence_encode_der; +xer_type_decoder_f SizeValueConfidence_decode_xer; +xer_type_encoder_f SizeValueConfidence_encode_xer; +oer_type_decoder_f SizeValueConfidence_decode_oer; +oer_type_encoder_f SizeValueConfidence_encode_oer; +per_type_decoder_f SizeValueConfidence_decode_uper; +per_type_encoder_f SizeValueConfidence_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _SizeValueConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/VehicleSizeConfidence.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/VehicleSizeConfidence.h new file mode 100644 index 000000000..7ab00134d --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/VehicleSizeConfidence.h @@ -0,0 +1,42 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _VehicleSizeConfidence_H_ +#define _VehicleSizeConfidence_H_ + + +#include + +/* Including external dependencies */ +#include "SizeValueConfidence.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* VehicleSizeConfidence */ +typedef struct VehicleSizeConfidence { + SizeValueConfidence_t vehicleWidthConfidence; + SizeValueConfidence_t vehicleLengthConfidence; + SizeValueConfidence_t *vehicleHeightConfidence /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} VehicleSizeConfidence_t; + +/* Implementation */ +extern asn_TYPE_descriptor_t asn_DEF_VehicleSizeConfidence; +extern asn_SEQUENCE_specifics_t asn_SPC_VehicleSizeConfidence_specs_1; +extern asn_TYPE_member_t asn_MBR_VehicleSizeConfidence_1[3]; + +#ifdef __cplusplus +} +#endif + +#endif /* _VehicleSizeConfidence_H_ */ +#include diff --git a/src/tmx/Asn_J2735/include/asn_j2735_r63/YawDetected.h b/src/tmx/Asn_J2735/include/asn_j2735_r63/YawDetected.h new file mode 100644 index 000000000..394867a92 --- /dev/null +++ b/src/tmx/Asn_J2735/include/asn_j2735_r63/YawDetected.h @@ -0,0 +1,44 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#ifndef _YawDetected_H_ +#define _YawDetected_H_ + + +#include + +/* Including external dependencies */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* YawDetected */ +typedef long YawDetected_t; + +/* Implementation */ +extern asn_per_constraints_t asn_PER_type_YawDetected_constr_1; +extern asn_TYPE_descriptor_t asn_DEF_YawDetected; +asn_struct_free_f YawDetected_free; +asn_struct_print_f YawDetected_print; +asn_constr_check_f YawDetected_constraint; +ber_type_decoder_f YawDetected_decode_ber; +der_type_encoder_f YawDetected_encode_der; +xer_type_decoder_f YawDetected_decode_xer; +xer_type_encoder_f YawDetected_encode_xer; +oer_type_decoder_f YawDetected_decode_oer; +oer_type_encoder_f YawDetected_encode_oer; +per_type_decoder_f YawDetected_decode_uper; +per_type_encoder_f YawDetected_encode_uper; + +#ifdef __cplusplus +} +#endif + +#endif /* _YawDetected_H_ */ +#include diff --git a/src/tmx/Asn_J2735/src/r63/AngularVelocity.c b/src/tmx/Asn_J2735/src/r63/AngularVelocity.c new file mode 100644 index 000000000..eedd75054 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/AngularVelocity.c @@ -0,0 +1,60 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "AngularVelocity.h" + +asn_TYPE_member_t asn_MBR_AngularVelocity_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct AngularVelocity, pitchRate), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PitchRate, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "pitchRate" + }, + { ATF_NOFLAGS, 0, offsetof(struct AngularVelocity, rollRate), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_RollRate, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "rollRate" + }, +}; +static const ber_tlv_tag_t asn_DEF_AngularVelocity_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_AngularVelocity_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pitchRate */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* rollRate */ +}; +asn_SEQUENCE_specifics_t asn_SPC_AngularVelocity_specs_1 = { + sizeof(struct AngularVelocity), + offsetof(struct AngularVelocity, _asn_ctx), + asn_MAP_AngularVelocity_tag2el_1, + 2, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_AngularVelocity = { + "AngularVelocity", + "AngularVelocity", + &asn_OP_SEQUENCE, + asn_DEF_AngularVelocity_tags_1, + sizeof(asn_DEF_AngularVelocity_tags_1) + /sizeof(asn_DEF_AngularVelocity_tags_1[0]), /* 1 */ + asn_DEF_AngularVelocity_tags_1, /* Same as above */ + sizeof(asn_DEF_AngularVelocity_tags_1) + /sizeof(asn_DEF_AngularVelocity_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_AngularVelocity_1, + 2, /* Elements count */ + &asn_SPC_AngularVelocity_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/AngularVelocityConfidence.c b/src/tmx/Asn_J2735/src/r63/AngularVelocityConfidence.c new file mode 100644 index 000000000..8ff44510f --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/AngularVelocityConfidence.c @@ -0,0 +1,62 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "AngularVelocityConfidence.h" + +asn_TYPE_member_t asn_MBR_AngularVelocityConfidence_1[] = { + { ATF_POINTER, 2, offsetof(struct AngularVelocityConfidence, pitchRateConfidence), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PitchRateConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "pitchRateConfidence" + }, + { ATF_POINTER, 1, offsetof(struct AngularVelocityConfidence, rollRateConfidence), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_RollRateConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "rollRateConfidence" + }, +}; +static const int asn_MAP_AngularVelocityConfidence_oms_1[] = { 0, 1 }; +static const ber_tlv_tag_t asn_DEF_AngularVelocityConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_AngularVelocityConfidence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pitchRateConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* rollRateConfidence */ +}; +asn_SEQUENCE_specifics_t asn_SPC_AngularVelocityConfidence_specs_1 = { + sizeof(struct AngularVelocityConfidence), + offsetof(struct AngularVelocityConfidence, _asn_ctx), + asn_MAP_AngularVelocityConfidence_tag2el_1, + 2, /* Count of tags in the map */ + asn_MAP_AngularVelocityConfidence_oms_1, /* Optional members */ + 2, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_AngularVelocityConfidence = { + "AngularVelocityConfidence", + "AngularVelocityConfidence", + &asn_OP_SEQUENCE, + asn_DEF_AngularVelocityConfidence_tags_1, + sizeof(asn_DEF_AngularVelocityConfidence_tags_1) + /sizeof(asn_DEF_AngularVelocityConfidence_tags_1[0]), /* 1 */ + asn_DEF_AngularVelocityConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_AngularVelocityConfidence_tags_1) + /sizeof(asn_DEF_AngularVelocityConfidence_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_AngularVelocityConfidence_1, + 2, /* Elements count */ + &asn_SPC_AngularVelocityConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/Attitude.c b/src/tmx/Asn_J2735/src/r63/Attitude.c new file mode 100644 index 000000000..4af80a825 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/Attitude.c @@ -0,0 +1,70 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "Attitude.h" + +asn_TYPE_member_t asn_MBR_Attitude_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct Attitude, pitch), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PitchDetected, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "pitch" + }, + { ATF_NOFLAGS, 0, offsetof(struct Attitude, roll), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_RollDetected, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "roll" + }, + { ATF_NOFLAGS, 0, offsetof(struct Attitude, yaw), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_YawDetected, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "yaw" + }, +}; +static const ber_tlv_tag_t asn_DEF_Attitude_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_Attitude_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pitch */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* roll */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* yaw */ +}; +asn_SEQUENCE_specifics_t asn_SPC_Attitude_specs_1 = { + sizeof(struct Attitude), + offsetof(struct Attitude, _asn_ctx), + asn_MAP_Attitude_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_Attitude = { + "Attitude", + "Attitude", + &asn_OP_SEQUENCE, + asn_DEF_Attitude_tags_1, + sizeof(asn_DEF_Attitude_tags_1) + /sizeof(asn_DEF_Attitude_tags_1[0]), /* 1 */ + asn_DEF_Attitude_tags_1, /* Same as above */ + sizeof(asn_DEF_Attitude_tags_1) + /sizeof(asn_DEF_Attitude_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_Attitude_1, + 3, /* Elements count */ + &asn_SPC_Attitude_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/AttitudeConfidence.c b/src/tmx/Asn_J2735/src/r63/AttitudeConfidence.c new file mode 100644 index 000000000..f521222c5 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/AttitudeConfidence.c @@ -0,0 +1,70 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "AttitudeConfidence.h" + +asn_TYPE_member_t asn_MBR_AttitudeConfidence_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct AttitudeConfidence, pitchConfidence), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_HeadingConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "pitchConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct AttitudeConfidence, rollConfidence), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_HeadingConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "rollConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct AttitudeConfidence, yawConfidence), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_HeadingConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "yawConfidence" + }, +}; +static const ber_tlv_tag_t asn_DEF_AttitudeConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_AttitudeConfidence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* pitchConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* rollConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* yawConfidence */ +}; +asn_SEQUENCE_specifics_t asn_SPC_AttitudeConfidence_specs_1 = { + sizeof(struct AttitudeConfidence), + offsetof(struct AttitudeConfidence, _asn_ctx), + asn_MAP_AttitudeConfidence_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_AttitudeConfidence = { + "AttitudeConfidence", + "AttitudeConfidence", + &asn_OP_SEQUENCE, + asn_DEF_AttitudeConfidence_tags_1, + sizeof(asn_DEF_AttitudeConfidence_tags_1) + /sizeof(asn_DEF_AttitudeConfidence_tags_1[0]), /* 1 */ + asn_DEF_AttitudeConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_AttitudeConfidence_tags_1) + /sizeof(asn_DEF_AttitudeConfidence_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_AttitudeConfidence_1, + 3, /* Elements count */ + &asn_SPC_AttitudeConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/ClassificationConfidence.c b/src/tmx/Asn_J2735/src/r63/ClassificationConfidence.c new file mode 100644 index 000000000..423fdca04 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ClassificationConfidence.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ClassificationConfidence.h" + +int +ClassificationConfidence_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 101)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_ClassificationConfidence_constr_1 CC_NOTUSED = { + { 1, 1 } /* (0..101) */, + -1}; +asn_per_constraints_t asn_PER_type_ClassificationConfidence_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 7, 7, 0, 101 } /* (0..101) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_ClassificationConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ClassificationConfidence = { + "ClassificationConfidence", + "ClassificationConfidence", + &asn_OP_NativeInteger, + asn_DEF_ClassificationConfidence_tags_1, + sizeof(asn_DEF_ClassificationConfidence_tags_1) + /sizeof(asn_DEF_ClassificationConfidence_tags_1[0]), /* 1 */ + asn_DEF_ClassificationConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_ClassificationConfidence_tags_1) + /sizeof(asn_DEF_ClassificationConfidence_tags_1[0]), /* 1 */ + { &asn_OER_type_ClassificationConfidence_constr_1, &asn_PER_type_ClassificationConfidence_constr_1, ClassificationConfidence_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedObjectCommonData.c b/src/tmx/Asn_J2735/src/r63/DetectedObjectCommonData.c new file mode 100644 index 000000000..d22ee61a2 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedObjectCommonData.c @@ -0,0 +1,222 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedObjectCommonData.h" + +asn_TYPE_member_t asn_MBR_DetectedObjectCommonData_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, objType), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObjectType, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "objType" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, objTypeCfd), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ClassificationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "objTypeCfd" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, objectID), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObjectID, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "objectID" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, measurementTime), + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_MeasurementTimeOffset, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "measurementTime" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, timeConfidence), + (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_TimeConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "timeConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, pos), + (ASN_TAG_CLASS_CONTEXT | (5 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PositionOffsetXYZ, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "pos" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, posConfidence), + (ASN_TAG_CLASS_CONTEXT | (6 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PositionConfidenceSet, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "posConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, speed), + (ASN_TAG_CLASS_CONTEXT | (7 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Speed, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "speed" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, speedConfidence), + (ASN_TAG_CLASS_CONTEXT | (8 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SpeedConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "speedConfidence" + }, + { ATF_POINTER, 2, offsetof(struct DetectedObjectCommonData, speedZ), + (ASN_TAG_CLASS_CONTEXT | (9 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Speed, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "speedZ" + }, + { ATF_POINTER, 1, offsetof(struct DetectedObjectCommonData, speedConfidenceZ), + (ASN_TAG_CLASS_CONTEXT | (10 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SpeedConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "speedConfidenceZ" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, heading), + (ASN_TAG_CLASS_CONTEXT | (11 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Heading, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "heading" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectCommonData, headingConf), + (ASN_TAG_CLASS_CONTEXT | (12 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_HeadingConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "headingConf" + }, + { ATF_POINTER, 5, offsetof(struct DetectedObjectCommonData, accel4way), + (ASN_TAG_CLASS_CONTEXT | (13 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AccelerationSet4Way, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "accel4way" + }, + { ATF_POINTER, 4, offsetof(struct DetectedObjectCommonData, accCfdX), + (ASN_TAG_CLASS_CONTEXT | (14 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AccelerationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "accCfdX" + }, + { ATF_POINTER, 3, offsetof(struct DetectedObjectCommonData, accCfdY), + (ASN_TAG_CLASS_CONTEXT | (15 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AccelerationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "accCfdY" + }, + { ATF_POINTER, 2, offsetof(struct DetectedObjectCommonData, accCfdZ), + (ASN_TAG_CLASS_CONTEXT | (16 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AccelerationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "accCfdZ" + }, + { ATF_POINTER, 1, offsetof(struct DetectedObjectCommonData, accCfdYaw), + (ASN_TAG_CLASS_CONTEXT | (17 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_YawRateConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "accCfdYaw" + }, +}; +static const int asn_MAP_DetectedObjectCommonData_oms_1[] = { 9, 10, 13, 14, 15, 16, 17 }; +static const ber_tlv_tag_t asn_DEF_DetectedObjectCommonData_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedObjectCommonData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* objType */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* objTypeCfd */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* objectID */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* measurementTime */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* timeConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* pos */ + { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* posConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* speed */ + { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* speedConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* speedZ */ + { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* speedConfidenceZ */ + { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* heading */ + { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 }, /* headingConf */ + { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 13, 0, 0 }, /* accel4way */ + { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 14, 0, 0 }, /* accCfdX */ + { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 15, 0, 0 }, /* accCfdY */ + { (ASN_TAG_CLASS_CONTEXT | (16 << 2)), 16, 0, 0 }, /* accCfdZ */ + { (ASN_TAG_CLASS_CONTEXT | (17 << 2)), 17, 0, 0 } /* accCfdYaw */ +}; +asn_SEQUENCE_specifics_t asn_SPC_DetectedObjectCommonData_specs_1 = { + sizeof(struct DetectedObjectCommonData), + offsetof(struct DetectedObjectCommonData, _asn_ctx), + asn_MAP_DetectedObjectCommonData_tag2el_1, + 18, /* Count of tags in the map */ + asn_MAP_DetectedObjectCommonData_oms_1, /* Optional members */ + 7, 0, /* Root/Additions */ + 18, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedObjectCommonData = { + "DetectedObjectCommonData", + "DetectedObjectCommonData", + &asn_OP_SEQUENCE, + asn_DEF_DetectedObjectCommonData_tags_1, + sizeof(asn_DEF_DetectedObjectCommonData_tags_1) + /sizeof(asn_DEF_DetectedObjectCommonData_tags_1[0]), /* 1 */ + asn_DEF_DetectedObjectCommonData_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedObjectCommonData_tags_1) + /sizeof(asn_DEF_DetectedObjectCommonData_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_DetectedObjectCommonData_1, + 18, /* Elements count */ + &asn_SPC_DetectedObjectCommonData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedObjectData.c b/src/tmx/Asn_J2735/src/r63/DetectedObjectData.c new file mode 100644 index 000000000..f15b14725 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedObjectData.c @@ -0,0 +1,62 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedObjectData.h" + +asn_TYPE_member_t asn_MBR_DetectedObjectData_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectData, detObjCommon), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DetectedObjectCommonData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "detObjCommon" + }, + { ATF_POINTER, 1, offsetof(struct DetectedObjectData, detObjOptData), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + +1, /* EXPLICIT tag at current level */ + &asn_DEF_DetectedObjectOptionalData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "detObjOptData" + }, +}; +static const int asn_MAP_DetectedObjectData_oms_1[] = { 1 }; +static const ber_tlv_tag_t asn_DEF_DetectedObjectData_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedObjectData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* detObjCommon */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* detObjOptData */ +}; +asn_SEQUENCE_specifics_t asn_SPC_DetectedObjectData_specs_1 = { + sizeof(struct DetectedObjectData), + offsetof(struct DetectedObjectData, _asn_ctx), + asn_MAP_DetectedObjectData_tag2el_1, + 2, /* Count of tags in the map */ + asn_MAP_DetectedObjectData_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedObjectData = { + "DetectedObjectData", + "DetectedObjectData", + &asn_OP_SEQUENCE, + asn_DEF_DetectedObjectData_tags_1, + sizeof(asn_DEF_DetectedObjectData_tags_1) + /sizeof(asn_DEF_DetectedObjectData_tags_1[0]), /* 1 */ + asn_DEF_DetectedObjectData_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedObjectData_tags_1) + /sizeof(asn_DEF_DetectedObjectData_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_DetectedObjectData_1, + 2, /* Elements count */ + &asn_SPC_DetectedObjectData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedObjectList.c b/src/tmx/Asn_J2735/src/r63/DetectedObjectList.c new file mode 100644 index 000000000..9cf444254 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedObjectList.c @@ -0,0 +1,52 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedObjectList.h" + +static asn_oer_constraints_t asn_OER_type_DetectedObjectList_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1 /* (SIZE(1..256)) */}; +asn_per_constraints_t asn_PER_type_DetectedObjectList_constr_1 CC_NOTUSED = { + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + { APC_CONSTRAINED, 8, 8, 1, 256 } /* (SIZE(1..256)) */, + 0, 0 /* No PER value map */ +}; +asn_TYPE_member_t asn_MBR_DetectedObjectList_1[] = { + { ATF_POINTER, 0, 0, + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + 0, + &asn_DEF_DetectedObjectData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "" + }, +}; +static const ber_tlv_tag_t asn_DEF_DetectedObjectList_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +asn_SET_OF_specifics_t asn_SPC_DetectedObjectList_specs_1 = { + sizeof(struct DetectedObjectList), + offsetof(struct DetectedObjectList, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedObjectList = { + "DetectedObjectList", + "DetectedObjectList", + &asn_OP_SEQUENCE_OF, + asn_DEF_DetectedObjectList_tags_1, + sizeof(asn_DEF_DetectedObjectList_tags_1) + /sizeof(asn_DEF_DetectedObjectList_tags_1[0]), /* 1 */ + asn_DEF_DetectedObjectList_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedObjectList_tags_1) + /sizeof(asn_DEF_DetectedObjectList_tags_1[0]), /* 1 */ + { &asn_OER_type_DetectedObjectList_constr_1, &asn_PER_type_DetectedObjectList_constr_1, SEQUENCE_OF_constraint }, + asn_MBR_DetectedObjectList_1, + 1, /* Single element */ + &asn_SPC_DetectedObjectList_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedObjectOptionalData.c b/src/tmx/Asn_J2735/src/r63/DetectedObjectOptionalData.c new file mode 100644 index 000000000..c00b24eeb --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedObjectOptionalData.c @@ -0,0 +1,75 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedObjectOptionalData.h" + +static asn_oer_constraints_t asn_OER_type_DetectedObjectOptionalData_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_DetectedObjectOptionalData_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 2, 2, 0, 2 } /* (0..2) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +asn_TYPE_member_t asn_MBR_DetectedObjectOptionalData_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectOptionalData, choice.detVeh), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DetectedVehicleData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "detVeh" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectOptionalData, choice.detVRU), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DetectedVRUData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "detVRU" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObjectOptionalData, choice.detObst), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DetectedObstacleData, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "detObst" + }, +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedObjectOptionalData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* detVeh */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* detVRU */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* detObst */ +}; +asn_CHOICE_specifics_t asn_SPC_DetectedObjectOptionalData_specs_1 = { + sizeof(struct DetectedObjectOptionalData), + offsetof(struct DetectedObjectOptionalData, _asn_ctx), + offsetof(struct DetectedObjectOptionalData, present), + sizeof(((struct DetectedObjectOptionalData *)0)->present), + asn_MAP_DetectedObjectOptionalData_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, + -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedObjectOptionalData = { + "DetectedObjectOptionalData", + "DetectedObjectOptionalData", + &asn_OP_CHOICE, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + { &asn_OER_type_DetectedObjectOptionalData_constr_1, &asn_PER_type_DetectedObjectOptionalData_constr_1, CHOICE_constraint }, + asn_MBR_DetectedObjectOptionalData_1, + 3, /* Elements count */ + &asn_SPC_DetectedObjectOptionalData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedObstacleData.c b/src/tmx/Asn_J2735/src/r63/DetectedObstacleData.c new file mode 100644 index 000000000..fafab50a5 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedObstacleData.c @@ -0,0 +1,60 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedObstacleData.h" + +asn_TYPE_member_t asn_MBR_DetectedObstacleData_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct DetectedObstacleData, obstSize), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObstacleSize, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "obstSize" + }, + { ATF_NOFLAGS, 0, offsetof(struct DetectedObstacleData, obstSizeConfidence), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObstacleSizeConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "obstSizeConfidence" + }, +}; +static const ber_tlv_tag_t asn_DEF_DetectedObstacleData_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedObstacleData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* obstSize */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* obstSizeConfidence */ +}; +asn_SEQUENCE_specifics_t asn_SPC_DetectedObstacleData_specs_1 = { + sizeof(struct DetectedObstacleData), + offsetof(struct DetectedObstacleData, _asn_ctx), + asn_MAP_DetectedObstacleData_tag2el_1, + 2, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedObstacleData = { + "DetectedObstacleData", + "DetectedObstacleData", + &asn_OP_SEQUENCE, + asn_DEF_DetectedObstacleData_tags_1, + sizeof(asn_DEF_DetectedObstacleData_tags_1) + /sizeof(asn_DEF_DetectedObstacleData_tags_1[0]), /* 1 */ + asn_DEF_DetectedObstacleData_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedObstacleData_tags_1) + /sizeof(asn_DEF_DetectedObstacleData_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_DetectedObstacleData_1, + 2, /* Elements count */ + &asn_SPC_DetectedObstacleData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedVRUData.c b/src/tmx/Asn_J2735/src/r63/DetectedVRUData.c new file mode 100644 index 000000000..29d981cbe --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedVRUData.c @@ -0,0 +1,82 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedVRUData.h" + +asn_TYPE_member_t asn_MBR_DetectedVRUData_1[] = { + { ATF_POINTER, 4, offsetof(struct DetectedVRUData, basicType), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PersonalDeviceUserType, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "basicType" + }, + { ATF_POINTER, 3, offsetof(struct DetectedVRUData, propulsion), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + +1, /* EXPLICIT tag at current level */ + &asn_DEF_PropelledInformation, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "propulsion" + }, + { ATF_POINTER, 2, offsetof(struct DetectedVRUData, attachment), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Attachment, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "attachment" + }, + { ATF_POINTER, 1, offsetof(struct DetectedVRUData, radius), + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AttachmentRadius, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "radius" + }, +}; +static const int asn_MAP_DetectedVRUData_oms_1[] = { 0, 1, 2, 3 }; +static const ber_tlv_tag_t asn_DEF_DetectedVRUData_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedVRUData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* basicType */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* propulsion */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* attachment */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* radius */ +}; +asn_SEQUENCE_specifics_t asn_SPC_DetectedVRUData_specs_1 = { + sizeof(struct DetectedVRUData), + offsetof(struct DetectedVRUData, _asn_ctx), + asn_MAP_DetectedVRUData_tag2el_1, + 4, /* Count of tags in the map */ + asn_MAP_DetectedVRUData_oms_1, /* Optional members */ + 4, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedVRUData = { + "DetectedVRUData", + "DetectedVRUData", + &asn_OP_SEQUENCE, + asn_DEF_DetectedVRUData_tags_1, + sizeof(asn_DEF_DetectedVRUData_tags_1) + /sizeof(asn_DEF_DetectedVRUData_tags_1[0]), /* 1 */ + asn_DEF_DetectedVRUData_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedVRUData_tags_1) + /sizeof(asn_DEF_DetectedVRUData_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_DetectedVRUData_1, + 4, /* Elements count */ + &asn_SPC_DetectedVRUData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/DetectedVehicleData.c b/src/tmx/Asn_J2735/src/r63/DetectedVehicleData.c new file mode 100644 index 000000000..6fdf3e2e1 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/DetectedVehicleData.c @@ -0,0 +1,142 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "DetectedVehicleData.h" + +asn_TYPE_member_t asn_MBR_DetectedVehicleData_1[] = { + { ATF_POINTER, 10, offsetof(struct DetectedVehicleData, lights), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ExteriorLights, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "lights" + }, + { ATF_POINTER, 9, offsetof(struct DetectedVehicleData, vehAttitude), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Attitude, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehAttitude" + }, + { ATF_POINTER, 8, offsetof(struct DetectedVehicleData, vehAttitudeConfidence), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AttitudeConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehAttitudeConfidence" + }, + { ATF_POINTER, 7, offsetof(struct DetectedVehicleData, vehAngVel), + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AngularVelocity, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehAngVel" + }, + { ATF_POINTER, 6, offsetof(struct DetectedVehicleData, vehAngVelConfidence), + (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_AngularVelocityConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehAngVelConfidence" + }, + { ATF_POINTER, 5, offsetof(struct DetectedVehicleData, size), + (ASN_TAG_CLASS_CONTEXT | (5 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_VehicleSize, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "size" + }, + { ATF_POINTER, 4, offsetof(struct DetectedVehicleData, height), + (ASN_TAG_CLASS_CONTEXT | (6 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_VehicleHeight, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "height" + }, + { ATF_POINTER, 3, offsetof(struct DetectedVehicleData, vehicleSizeConfidence), + (ASN_TAG_CLASS_CONTEXT | (7 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_VehicleSizeConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehicleSizeConfidence" + }, + { ATF_POINTER, 2, offsetof(struct DetectedVehicleData, vehicleClass), + (ASN_TAG_CLASS_CONTEXT | (8 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_BasicVehicleClass, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehicleClass" + }, + { ATF_POINTER, 1, offsetof(struct DetectedVehicleData, classConf), + (ASN_TAG_CLASS_CONTEXT | (9 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ClassificationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "classConf" + }, +}; +static const int asn_MAP_DetectedVehicleData_oms_1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; +static const ber_tlv_tag_t asn_DEF_DetectedVehicleData_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_DetectedVehicleData_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* lights */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* vehAttitude */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* vehAttitudeConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* vehAngVel */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* vehAngVelConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* size */ + { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* height */ + { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* vehicleSizeConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* vehicleClass */ + { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* classConf */ +}; +asn_SEQUENCE_specifics_t asn_SPC_DetectedVehicleData_specs_1 = { + sizeof(struct DetectedVehicleData), + offsetof(struct DetectedVehicleData, _asn_ctx), + asn_MAP_DetectedVehicleData_tag2el_1, + 10, /* Count of tags in the map */ + asn_MAP_DetectedVehicleData_oms_1, /* Optional members */ + 10, 0, /* Root/Additions */ + 10, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_DetectedVehicleData = { + "DetectedVehicleData", + "DetectedVehicleData", + &asn_OP_SEQUENCE, + asn_DEF_DetectedVehicleData_tags_1, + sizeof(asn_DEF_DetectedVehicleData_tags_1) + /sizeof(asn_DEF_DetectedVehicleData_tags_1[0]), /* 1 */ + asn_DEF_DetectedVehicleData_tags_1, /* Same as above */ + sizeof(asn_DEF_DetectedVehicleData_tags_1) + /sizeof(asn_DEF_DetectedVehicleData_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_DetectedVehicleData_1, + 10, /* Elements count */ + &asn_SPC_DetectedVehicleData_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/EquipmentType.c b/src/tmx/Asn_J2735/src/r63/EquipmentType.c new file mode 100644 index 000000000..7707fbfe9 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/EquipmentType.c @@ -0,0 +1,62 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "EquipmentType.h" + +/* + * This type is implemented using NativeEnumerated, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_EquipmentType_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_EquipmentType_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED | APC_EXTENSIBLE, 2, 2, 0, 3 } /* (0..3,...) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const asn_INTEGER_enum_map_t asn_MAP_EquipmentType_value2enum_1[] = { + { 0, 7, "unknown" }, + { 1, 3, "rsu" }, + { 2, 3, "obu" }, + { 3, 3, "vru" } + /* This list is extensible */ +}; +static const unsigned int asn_MAP_EquipmentType_enum2value_1[] = { + 2, /* obu(2) */ + 1, /* rsu(1) */ + 0, /* unknown(0) */ + 3 /* vru(3) */ + /* This list is extensible */ +}; +const asn_INTEGER_specifics_t asn_SPC_EquipmentType_specs_1 = { + asn_MAP_EquipmentType_value2enum_1, /* "tag" => N; sorted by tag */ + asn_MAP_EquipmentType_enum2value_1, /* N => "tag"; sorted by N */ + 4, /* Number of elements in the maps */ + 5, /* Extensions before this member */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static const ber_tlv_tag_t asn_DEF_EquipmentType_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_EquipmentType = { + "EquipmentType", + "EquipmentType", + &asn_OP_NativeEnumerated, + asn_DEF_EquipmentType_tags_1, + sizeof(asn_DEF_EquipmentType_tags_1) + /sizeof(asn_DEF_EquipmentType_tags_1[0]), /* 1 */ + asn_DEF_EquipmentType_tags_1, /* Same as above */ + sizeof(asn_DEF_EquipmentType_tags_1) + /sizeof(asn_DEF_EquipmentType_tags_1[0]), /* 1 */ + { &asn_OER_type_EquipmentType_constr_1, &asn_PER_type_EquipmentType_constr_1, NativeEnumerated_constraint }, + 0, 0, /* Defined elsewhere */ + &asn_SPC_EquipmentType_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/MeasurementTimeOffset.c b/src/tmx/Asn_J2735/src/r63/MeasurementTimeOffset.c new file mode 100644 index 000000000..604caf91c --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/MeasurementTimeOffset.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "MeasurementTimeOffset.h" + +int +MeasurementTimeOffset_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -1500 && value <= 1500)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_MeasurementTimeOffset_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-1500..1500) */, + -1}; +asn_per_constraints_t asn_PER_type_MeasurementTimeOffset_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 12, 12, -1500, 1500 } /* (-1500..1500) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_MeasurementTimeOffset_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_MeasurementTimeOffset = { + "MeasurementTimeOffset", + "MeasurementTimeOffset", + &asn_OP_NativeInteger, + asn_DEF_MeasurementTimeOffset_tags_1, + sizeof(asn_DEF_MeasurementTimeOffset_tags_1) + /sizeof(asn_DEF_MeasurementTimeOffset_tags_1[0]), /* 1 */ + asn_DEF_MeasurementTimeOffset_tags_1, /* Same as above */ + sizeof(asn_DEF_MeasurementTimeOffset_tags_1) + /sizeof(asn_DEF_MeasurementTimeOffset_tags_1[0]), /* 1 */ + { &asn_OER_type_MeasurementTimeOffset_constr_1, &asn_PER_type_MeasurementTimeOffset_constr_1, MeasurementTimeOffset_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/MessageFrame.c b/src/tmx/Asn_J2735/src/r63/MessageFrame.c index edd668078..b3925827e 100644 --- a/src/tmx/Asn_J2735/src/r63/MessageFrame.c +++ b/src/tmx/Asn_J2735/src/r63/MessageFrame.c @@ -1,8 +1,8 @@ /* * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) * From ASN.1 module "DSRC" - * found in "J2735_201603_ASN_CC.asn" - * `asn1c -gen-PER -fcompound-names -fincludes-quoted` + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names` */ #include "MessageFrame.h" @@ -38,6 +38,7 @@ static const long asn_VAL_28_testMessage12 = 252; static const long asn_VAL_29_testMessage13 = 253; static const long asn_VAL_30_testMessage14 = 254; static const long asn_VAL_31_testMessage15 = 255; +static const long asn_VAL_32_sensorDataSharingMessage = 41; static const asn_ioc_cell_t asn_IOS_MessageTypes_1_rows[] = { { "&id", aioc__value, &asn_DEF_DSRCmsgID, &asn_VAL_1_basicSafetyMessage }, { "&Type", aioc__type, &asn_DEF_BasicSafetyMessage }, @@ -100,10 +101,12 @@ static const asn_ioc_cell_t asn_IOS_MessageTypes_1_rows[] = { { "&id", aioc__value, &asn_DEF_DSRCmsgID, &asn_VAL_30_testMessage14 }, { "&Type", aioc__type, &asn_DEF_TestMessage14 }, { "&id", aioc__value, &asn_DEF_DSRCmsgID, &asn_VAL_31_testMessage15 }, - { "&Type", aioc__type, &asn_DEF_TestMessage15 } + { "&Type", aioc__type, &asn_DEF_TestMessage15 }, + { "&id", aioc__value, &asn_DEF_DSRCmsgID, &asn_VAL_32_sensorDataSharingMessage }, + { "&Type", aioc__type, &asn_DEF_SensorDataSharingMessage } }; static const asn_ioc_set_t asn_IOS_MessageTypes_1[] = { - { 31, 2, asn_IOS_MessageTypes_1_rows } + 32, 2, asn_IOS_MessageTypes_1_rows }; static int memb_messageId_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr, @@ -472,39 +475,49 @@ static asn_TYPE_member_t asn_MBR_value_3[] = { 0, 0, /* No default value */ "TestMessage15" }, + { ATF_NOFLAGS, 0, offsetof(struct value, choice.SensorDataSharingMessage), + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + 0, + &asn_DEF_SensorDataSharingMessage, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "SensorDataSharingMessage" + }, }; static const asn_TYPE_tag2member_t asn_MAP_value_tag2el_3[] = { - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 30 }, /* BasicSafetyMessage */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 29 }, /* MapData */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 28 }, /* SPAT */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -3, 27 }, /* CommonSafetyRequest */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 4, -4, 26 }, /* EmergencyVehicleAlert */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 5, -5, 25 }, /* IntersectionCollision */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 6, -6, 24 }, /* NMEAcorrections */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 7, -7, 23 }, /* ProbeDataManagement */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 8, -8, 22 }, /* ProbeVehicleData */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 9, -9, 21 }, /* RoadSideAlert */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 10, -10, 20 }, /* RTCMcorrections */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 11, -11, 19 }, /* SignalRequestMessage */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 12, -12, 18 }, /* SignalStatusMessage */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 13, -13, 17 }, /* TravelerInformation */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 14, -14, 16 }, /* PersonalSafetyMessage */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 15, -15, 15 }, /* TestMessage00 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 16, -16, 14 }, /* TestMessage01 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 17, -17, 13 }, /* TestMessage02 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 18, -18, 12 }, /* TestMessage03 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 19, -19, 11 }, /* TestMessage04 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 20, -20, 10 }, /* TestMessage05 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 21, -21, 9 }, /* TestMessage06 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 22, -22, 8 }, /* TestMessage07 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 23, -23, 7 }, /* TestMessage08 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 24, -24, 6 }, /* TestMessage09 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 25, -25, 5 }, /* TestMessage10 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 26, -26, 4 }, /* TestMessage11 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 27, -27, 3 }, /* TestMessage12 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 28, -28, 2 }, /* TestMessage13 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 29, -29, 1 }, /* TestMessage14 */ - { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 30, -30, 0 } /* TestMessage15 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 31 }, /* BasicSafetyMessage */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 30 }, /* MapData */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -2, 29 }, /* SPAT */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, -3, 28 }, /* CommonSafetyRequest */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 4, -4, 27 }, /* EmergencyVehicleAlert */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 5, -5, 26 }, /* IntersectionCollision */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 6, -6, 25 }, /* NMEAcorrections */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 7, -7, 24 }, /* ProbeDataManagement */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 8, -8, 23 }, /* ProbeVehicleData */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 9, -9, 22 }, /* RoadSideAlert */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 10, -10, 21 }, /* RTCMcorrections */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 11, -11, 20 }, /* SignalRequestMessage */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 12, -12, 19 }, /* SignalStatusMessage */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 13, -13, 18 }, /* TravelerInformation */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 14, -14, 17 }, /* PersonalSafetyMessage */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 15, -15, 16 }, /* TestMessage00 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 16, -16, 15 }, /* TestMessage01 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 17, -17, 14 }, /* TestMessage02 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 18, -18, 13 }, /* TestMessage03 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 19, -19, 12 }, /* TestMessage04 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 20, -20, 11 }, /* TestMessage05 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 21, -21, 10 }, /* TestMessage06 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 22, -22, 9 }, /* TestMessage07 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 23, -23, 8 }, /* TestMessage08 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 24, -24, 7 }, /* TestMessage09 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 25, -25, 6 }, /* TestMessage10 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 26, -26, 5 }, /* TestMessage11 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 27, -27, 4 }, /* TestMessage12 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 28, -28, 3 }, /* TestMessage13 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 29, -29, 2 }, /* TestMessage14 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 30, -30, 1 }, /* TestMessage15 */ + { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 31, -31, 0 } /* SensorDataSharingMessage */ }; static asn_CHOICE_specifics_t asn_SPC_value_specs_3 = { sizeof(struct value), @@ -512,7 +525,7 @@ static asn_CHOICE_specifics_t asn_SPC_value_specs_3 = { offsetof(struct value, present), sizeof(((struct value *)0)->present), asn_MAP_value_tag2el_3, - 31, /* Count of tags in the map */ + 32, /* Count of tags in the map */ 0, 0, -1 /* Extensions start */ }; @@ -527,7 +540,7 @@ asn_TYPE_descriptor_t asn_DEF_value_3 = { 0, /* No tags (count) */ { 0, 0, OPEN_TYPE_constraint }, asn_MBR_value_3, - 31, /* Elements count */ + 32, /* Elements count */ &asn_SPC_value_specs_3 /* Additional specs */ }; diff --git a/src/tmx/Asn_J2735/src/r63/ObjectDistance.c b/src/tmx/Asn_J2735/src/r63/ObjectDistance.c new file mode 100644 index 000000000..79ec8c88b --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ObjectDistance.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ObjectDistance.h" + +int +ObjectDistance_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -32767 && value <= 32767)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_ObjectDistance_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-32767..32767) */, + -1}; +asn_per_constraints_t asn_PER_type_ObjectDistance_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 16, 16, -32767, 32767 } /* (-32767..32767) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_ObjectDistance_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ObjectDistance = { + "ObjectDistance", + "ObjectDistance", + &asn_OP_NativeInteger, + asn_DEF_ObjectDistance_tags_1, + sizeof(asn_DEF_ObjectDistance_tags_1) + /sizeof(asn_DEF_ObjectDistance_tags_1[0]), /* 1 */ + asn_DEF_ObjectDistance_tags_1, /* Same as above */ + sizeof(asn_DEF_ObjectDistance_tags_1) + /sizeof(asn_DEF_ObjectDistance_tags_1[0]), /* 1 */ + { &asn_OER_type_ObjectDistance_constr_1, &asn_PER_type_ObjectDistance_constr_1, ObjectDistance_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/ObjectID.c b/src/tmx/Asn_J2735/src/r63/ObjectID.c new file mode 100644 index 000000000..5b46a3671 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ObjectID.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ObjectID.h" + +int +ObjectID_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 65535)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_ObjectID_constr_1 CC_NOTUSED = { + { 2, 1 } /* (0..65535) */, + -1}; +asn_per_constraints_t asn_PER_type_ObjectID_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 16, 16, 0, 65535 } /* (0..65535) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_ObjectID_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ObjectID = { + "ObjectID", + "ObjectID", + &asn_OP_NativeInteger, + asn_DEF_ObjectID_tags_1, + sizeof(asn_DEF_ObjectID_tags_1) + /sizeof(asn_DEF_ObjectID_tags_1[0]), /* 1 */ + asn_DEF_ObjectID_tags_1, /* Same as above */ + sizeof(asn_DEF_ObjectID_tags_1) + /sizeof(asn_DEF_ObjectID_tags_1[0]), /* 1 */ + { &asn_OER_type_ObjectID_constr_1, &asn_PER_type_ObjectID_constr_1, ObjectID_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/ObjectType.c b/src/tmx/Asn_J2735/src/r63/ObjectType.c new file mode 100644 index 000000000..43ce3726e --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ObjectType.c @@ -0,0 +1,62 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ObjectType.h" + +/* + * This type is implemented using NativeEnumerated, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_ObjectType_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_ObjectType_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED | APC_EXTENSIBLE, 2, 2, 0, 3 } /* (0..3,...) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const asn_INTEGER_enum_map_t asn_MAP_ObjectType_value2enum_1[] = { + { 0, 7, "unknown" }, + { 1, 7, "vehicle" }, + { 2, 3, "vru" }, + { 3, 6, "animal" } + /* This list is extensible */ +}; +static const unsigned int asn_MAP_ObjectType_enum2value_1[] = { + 3, /* animal(3) */ + 0, /* unknown(0) */ + 1, /* vehicle(1) */ + 2 /* vru(2) */ + /* This list is extensible */ +}; +const asn_INTEGER_specifics_t asn_SPC_ObjectType_specs_1 = { + asn_MAP_ObjectType_value2enum_1, /* "tag" => N; sorted by tag */ + asn_MAP_ObjectType_enum2value_1, /* N => "tag"; sorted by N */ + 4, /* Number of elements in the maps */ + 5, /* Extensions before this member */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static const ber_tlv_tag_t asn_DEF_ObjectType_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_ObjectType = { + "ObjectType", + "ObjectType", + &asn_OP_NativeEnumerated, + asn_DEF_ObjectType_tags_1, + sizeof(asn_DEF_ObjectType_tags_1) + /sizeof(asn_DEF_ObjectType_tags_1[0]), /* 1 */ + asn_DEF_ObjectType_tags_1, /* Same as above */ + sizeof(asn_DEF_ObjectType_tags_1) + /sizeof(asn_DEF_ObjectType_tags_1[0]), /* 1 */ + { &asn_OER_type_ObjectType_constr_1, &asn_PER_type_ObjectType_constr_1, NativeEnumerated_constraint }, + 0, 0, /* Defined elsewhere */ + &asn_SPC_ObjectType_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/ObstacleSize.c b/src/tmx/Asn_J2735/src/r63/ObstacleSize.c new file mode 100644 index 000000000..8edc1baf8 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ObstacleSize.c @@ -0,0 +1,72 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ObstacleSize.h" + +asn_TYPE_member_t asn_MBR_ObstacleSize_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct ObstacleSize, width), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValue, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "width" + }, + { ATF_NOFLAGS, 0, offsetof(struct ObstacleSize, length), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValue, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "length" + }, + { ATF_POINTER, 1, offsetof(struct ObstacleSize, height), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValue, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "height" + }, +}; +static const int asn_MAP_ObstacleSize_oms_1[] = { 2 }; +static const ber_tlv_tag_t asn_DEF_ObstacleSize_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_ObstacleSize_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* width */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* length */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* height */ +}; +asn_SEQUENCE_specifics_t asn_SPC_ObstacleSize_specs_1 = { + sizeof(struct ObstacleSize), + offsetof(struct ObstacleSize, _asn_ctx), + asn_MAP_ObstacleSize_tag2el_1, + 3, /* Count of tags in the map */ + asn_MAP_ObstacleSize_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_ObstacleSize = { + "ObstacleSize", + "ObstacleSize", + &asn_OP_SEQUENCE, + asn_DEF_ObstacleSize_tags_1, + sizeof(asn_DEF_ObstacleSize_tags_1) + /sizeof(asn_DEF_ObstacleSize_tags_1[0]), /* 1 */ + asn_DEF_ObstacleSize_tags_1, /* Same as above */ + sizeof(asn_DEF_ObstacleSize_tags_1) + /sizeof(asn_DEF_ObstacleSize_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_ObstacleSize_1, + 3, /* Elements count */ + &asn_SPC_ObstacleSize_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/ObstacleSizeConfidence.c b/src/tmx/Asn_J2735/src/r63/ObstacleSizeConfidence.c new file mode 100644 index 000000000..d5ddfbc43 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/ObstacleSizeConfidence.c @@ -0,0 +1,72 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "ObstacleSizeConfidence.h" + +asn_TYPE_member_t asn_MBR_ObstacleSizeConfidence_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct ObstacleSizeConfidence, widthConfidence), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "widthConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct ObstacleSizeConfidence, lengthConfidence), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "lengthConfidence" + }, + { ATF_POINTER, 1, offsetof(struct ObstacleSizeConfidence, heightConfidence), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "heightConfidence" + }, +}; +static const int asn_MAP_ObstacleSizeConfidence_oms_1[] = { 2 }; +static const ber_tlv_tag_t asn_DEF_ObstacleSizeConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_ObstacleSizeConfidence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* widthConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* lengthConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* heightConfidence */ +}; +asn_SEQUENCE_specifics_t asn_SPC_ObstacleSizeConfidence_specs_1 = { + sizeof(struct ObstacleSizeConfidence), + offsetof(struct ObstacleSizeConfidence, _asn_ctx), + asn_MAP_ObstacleSizeConfidence_tag2el_1, + 3, /* Count of tags in the map */ + asn_MAP_ObstacleSizeConfidence_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_ObstacleSizeConfidence = { + "ObstacleSizeConfidence", + "ObstacleSizeConfidence", + &asn_OP_SEQUENCE, + asn_DEF_ObstacleSizeConfidence_tags_1, + sizeof(asn_DEF_ObstacleSizeConfidence_tags_1) + /sizeof(asn_DEF_ObstacleSizeConfidence_tags_1[0]), /* 1 */ + asn_DEF_ObstacleSizeConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_ObstacleSizeConfidence_tags_1) + /sizeof(asn_DEF_ObstacleSizeConfidence_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_ObstacleSizeConfidence_1, + 3, /* Elements count */ + &asn_SPC_ObstacleSizeConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/PitchDetected.c b/src/tmx/Asn_J2735/src/r63/PitchDetected.c new file mode 100644 index 000000000..531398fb6 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/PitchDetected.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "PitchDetected.h" + +int +PitchDetected_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -7200 && value <= 7200)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_PitchDetected_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-7200..7200) */, + -1}; +asn_per_constraints_t asn_PER_type_PitchDetected_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 14, 14, -7200, 7200 } /* (-7200..7200) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_PitchDetected_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_PitchDetected = { + "PitchDetected", + "PitchDetected", + &asn_OP_NativeInteger, + asn_DEF_PitchDetected_tags_1, + sizeof(asn_DEF_PitchDetected_tags_1) + /sizeof(asn_DEF_PitchDetected_tags_1[0]), /* 1 */ + asn_DEF_PitchDetected_tags_1, /* Same as above */ + sizeof(asn_DEF_PitchDetected_tags_1) + /sizeof(asn_DEF_PitchDetected_tags_1[0]), /* 1 */ + { &asn_OER_type_PitchDetected_constr_1, &asn_PER_type_PitchDetected_constr_1, PitchDetected_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/PitchRate.c b/src/tmx/Asn_J2735/src/r63/PitchRate.c new file mode 100644 index 000000000..368ba352d --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/PitchRate.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "PitchRate.h" + +int +PitchRate_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -32767 && value <= 32767)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_PitchRate_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-32767..32767) */, + -1}; +asn_per_constraints_t asn_PER_type_PitchRate_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 16, 16, -32767, 32767 } /* (-32767..32767) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_PitchRate_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_PitchRate = { + "PitchRate", + "PitchRate", + &asn_OP_NativeInteger, + asn_DEF_PitchRate_tags_1, + sizeof(asn_DEF_PitchRate_tags_1) + /sizeof(asn_DEF_PitchRate_tags_1[0]), /* 1 */ + asn_DEF_PitchRate_tags_1, /* Same as above */ + sizeof(asn_DEF_PitchRate_tags_1) + /sizeof(asn_DEF_PitchRate_tags_1[0]), /* 1 */ + { &asn_OER_type_PitchRate_constr_1, &asn_PER_type_PitchRate_constr_1, PitchRate_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/PitchRateConfidence.c b/src/tmx/Asn_J2735/src/r63/PitchRateConfidence.c new file mode 100644 index 000000000..d510e4c1f --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/PitchRateConfidence.c @@ -0,0 +1,68 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "PitchRateConfidence.h" + +/* + * This type is implemented using NativeEnumerated, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_PitchRateConfidence_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_PitchRateConfidence_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 3, 3, 0, 7 } /* (0..7) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const asn_INTEGER_enum_map_t asn_MAP_PitchRateConfidence_value2enum_1[] = { + { 0, 11, "unavailable" }, + { 1, 13, "degSec-100-00" }, + { 2, 13, "degSec-010-00" }, + { 3, 13, "degSec-005-00" }, + { 4, 13, "degSec-001-00" }, + { 5, 13, "degSec-000-10" }, + { 6, 13, "degSec-000-05" }, + { 7, 13, "degSec-000-01" } +}; +static const unsigned int asn_MAP_PitchRateConfidence_enum2value_1[] = { + 7, /* degSec-000-01(7) */ + 6, /* degSec-000-05(6) */ + 5, /* degSec-000-10(5) */ + 4, /* degSec-001-00(4) */ + 3, /* degSec-005-00(3) */ + 2, /* degSec-010-00(2) */ + 1, /* degSec-100-00(1) */ + 0 /* unavailable(0) */ +}; +const asn_INTEGER_specifics_t asn_SPC_PitchRateConfidence_specs_1 = { + asn_MAP_PitchRateConfidence_value2enum_1, /* "tag" => N; sorted by tag */ + asn_MAP_PitchRateConfidence_enum2value_1, /* N => "tag"; sorted by N */ + 8, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static const ber_tlv_tag_t asn_DEF_PitchRateConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_PitchRateConfidence = { + "PitchRateConfidence", + "PitchRateConfidence", + &asn_OP_NativeEnumerated, + asn_DEF_PitchRateConfidence_tags_1, + sizeof(asn_DEF_PitchRateConfidence_tags_1) + /sizeof(asn_DEF_PitchRateConfidence_tags_1[0]), /* 1 */ + asn_DEF_PitchRateConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_PitchRateConfidence_tags_1) + /sizeof(asn_DEF_PitchRateConfidence_tags_1[0]), /* 1 */ + { &asn_OER_type_PitchRateConfidence_constr_1, &asn_PER_type_PitchRateConfidence_constr_1, NativeEnumerated_constraint }, + 0, 0, /* Defined elsewhere */ + &asn_SPC_PitchRateConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/PositionOffsetXYZ.c b/src/tmx/Asn_J2735/src/r63/PositionOffsetXYZ.c new file mode 100644 index 000000000..fd2d344d1 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/PositionOffsetXYZ.c @@ -0,0 +1,72 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "PositionOffsetXYZ.h" + +asn_TYPE_member_t asn_MBR_PositionOffsetXYZ_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct PositionOffsetXYZ, offsetX), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObjectDistance, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "offsetX" + }, + { ATF_NOFLAGS, 0, offsetof(struct PositionOffsetXYZ, offsetY), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObjectDistance, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "offsetY" + }, + { ATF_POINTER, 1, offsetof(struct PositionOffsetXYZ, offsetZ), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ObjectDistance, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "offsetZ" + }, +}; +static const int asn_MAP_PositionOffsetXYZ_oms_1[] = { 2 }; +static const ber_tlv_tag_t asn_DEF_PositionOffsetXYZ_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_PositionOffsetXYZ_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* offsetX */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* offsetY */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* offsetZ */ +}; +asn_SEQUENCE_specifics_t asn_SPC_PositionOffsetXYZ_specs_1 = { + sizeof(struct PositionOffsetXYZ), + offsetof(struct PositionOffsetXYZ, _asn_ctx), + asn_MAP_PositionOffsetXYZ_tag2el_1, + 3, /* Count of tags in the map */ + asn_MAP_PositionOffsetXYZ_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_PositionOffsetXYZ = { + "PositionOffsetXYZ", + "PositionOffsetXYZ", + &asn_OP_SEQUENCE, + asn_DEF_PositionOffsetXYZ_tags_1, + sizeof(asn_DEF_PositionOffsetXYZ_tags_1) + /sizeof(asn_DEF_PositionOffsetXYZ_tags_1[0]), /* 1 */ + asn_DEF_PositionOffsetXYZ_tags_1, /* Same as above */ + sizeof(asn_DEF_PositionOffsetXYZ_tags_1) + /sizeof(asn_DEF_PositionOffsetXYZ_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_PositionOffsetXYZ_1, + 3, /* Elements count */ + &asn_SPC_PositionOffsetXYZ_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/RollDetected.c b/src/tmx/Asn_J2735/src/r63/RollDetected.c new file mode 100644 index 000000000..017e10e77 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/RollDetected.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "RollDetected.h" + +int +RollDetected_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -14400 && value <= 14400)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_RollDetected_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-14400..14400) */, + -1}; +asn_per_constraints_t asn_PER_type_RollDetected_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 15, 15, -14400, 14400 } /* (-14400..14400) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_RollDetected_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_RollDetected = { + "RollDetected", + "RollDetected", + &asn_OP_NativeInteger, + asn_DEF_RollDetected_tags_1, + sizeof(asn_DEF_RollDetected_tags_1) + /sizeof(asn_DEF_RollDetected_tags_1[0]), /* 1 */ + asn_DEF_RollDetected_tags_1, /* Same as above */ + sizeof(asn_DEF_RollDetected_tags_1) + /sizeof(asn_DEF_RollDetected_tags_1[0]), /* 1 */ + { &asn_OER_type_RollDetected_constr_1, &asn_PER_type_RollDetected_constr_1, RollDetected_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/RollRate.c b/src/tmx/Asn_J2735/src/r63/RollRate.c new file mode 100644 index 000000000..d5c525e3a --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/RollRate.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "RollRate.h" + +int +RollRate_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -32767 && value <= 32767)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_RollRate_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-32767..32767) */, + -1}; +asn_per_constraints_t asn_PER_type_RollRate_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 16, 16, -32767, 32767 } /* (-32767..32767) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_RollRate_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_RollRate = { + "RollRate", + "RollRate", + &asn_OP_NativeInteger, + asn_DEF_RollRate_tags_1, + sizeof(asn_DEF_RollRate_tags_1) + /sizeof(asn_DEF_RollRate_tags_1[0]), /* 1 */ + asn_DEF_RollRate_tags_1, /* Same as above */ + sizeof(asn_DEF_RollRate_tags_1) + /sizeof(asn_DEF_RollRate_tags_1[0]), /* 1 */ + { &asn_OER_type_RollRate_constr_1, &asn_PER_type_RollRate_constr_1, RollRate_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/RollRateConfidence.c b/src/tmx/Asn_J2735/src/r63/RollRateConfidence.c new file mode 100644 index 000000000..3b578a211 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/RollRateConfidence.c @@ -0,0 +1,68 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "RollRateConfidence.h" + +/* + * This type is implemented using NativeEnumerated, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_RollRateConfidence_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_RollRateConfidence_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 3, 3, 0, 7 } /* (0..7) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const asn_INTEGER_enum_map_t asn_MAP_RollRateConfidence_value2enum_1[] = { + { 0, 11, "unavailable" }, + { 1, 13, "degSec-100-00" }, + { 2, 13, "degSec-010-00" }, + { 3, 13, "degSec-005-00" }, + { 4, 13, "degSec-001-00" }, + { 5, 13, "degSec-000-10" }, + { 6, 13, "degSec-000-05" }, + { 7, 13, "degSec-000-01" } +}; +static const unsigned int asn_MAP_RollRateConfidence_enum2value_1[] = { + 7, /* degSec-000-01(7) */ + 6, /* degSec-000-05(6) */ + 5, /* degSec-000-10(5) */ + 4, /* degSec-001-00(4) */ + 3, /* degSec-005-00(3) */ + 2, /* degSec-010-00(2) */ + 1, /* degSec-100-00(1) */ + 0 /* unavailable(0) */ +}; +const asn_INTEGER_specifics_t asn_SPC_RollRateConfidence_specs_1 = { + asn_MAP_RollRateConfidence_value2enum_1, /* "tag" => N; sorted by tag */ + asn_MAP_RollRateConfidence_enum2value_1, /* N => "tag"; sorted by N */ + 8, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static const ber_tlv_tag_t asn_DEF_RollRateConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_RollRateConfidence = { + "RollRateConfidence", + "RollRateConfidence", + &asn_OP_NativeEnumerated, + asn_DEF_RollRateConfidence_tags_1, + sizeof(asn_DEF_RollRateConfidence_tags_1) + /sizeof(asn_DEF_RollRateConfidence_tags_1[0]), /* 1 */ + asn_DEF_RollRateConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_RollRateConfidence_tags_1) + /sizeof(asn_DEF_RollRateConfidence_tags_1[0]), /* 1 */ + { &asn_OER_type_RollRateConfidence_constr_1, &asn_PER_type_RollRateConfidence_constr_1, NativeEnumerated_constraint }, + 0, 0, /* Defined elsewhere */ + &asn_SPC_RollRateConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/SensorDataSharingMessage.c b/src/tmx/Asn_J2735/src/r63/SensorDataSharingMessage.c new file mode 100644 index 000000000..d45d92e5a --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/SensorDataSharingMessage.c @@ -0,0 +1,122 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "SensorDataSharingMessage.h" + +asn_TYPE_member_t asn_MBR_SensorDataSharingMessage_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, msgCnt), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DSRC_MsgCount, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "msgCnt" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, sourceID), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_TemporaryID, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "sourceID" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, equipmentType), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_EquipmentType, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "equipmentType" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, sDSMTimeStamp), + (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DDateTime, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "sDSMTimeStamp" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, refPos), + (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_Position3D, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "refPos" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, refPosXYConf), + (ASN_TAG_CLASS_CONTEXT | (5 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_PositionalAccuracy, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "refPosXYConf" + }, + { ATF_POINTER, 1, offsetof(struct SensorDataSharingMessage, refPosElConf), + (ASN_TAG_CLASS_CONTEXT | (6 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_ElevationConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "refPosElConf" + }, + { ATF_NOFLAGS, 0, offsetof(struct SensorDataSharingMessage, objects), + (ASN_TAG_CLASS_CONTEXT | (7 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_DetectedObjectList, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "objects" + }, +}; +static const int asn_MAP_SensorDataSharingMessage_oms_1[] = { 6 }; +static const ber_tlv_tag_t asn_DEF_SensorDataSharingMessage_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_SensorDataSharingMessage_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* msgCnt */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* sourceID */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* equipmentType */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* sDSMTimeStamp */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* refPos */ + { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* refPosXYConf */ + { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* refPosElConf */ + { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 } /* objects */ +}; +asn_SEQUENCE_specifics_t asn_SPC_SensorDataSharingMessage_specs_1 = { + sizeof(struct SensorDataSharingMessage), + offsetof(struct SensorDataSharingMessage, _asn_ctx), + asn_MAP_SensorDataSharingMessage_tag2el_1, + 8, /* Count of tags in the map */ + asn_MAP_SensorDataSharingMessage_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_SensorDataSharingMessage = { + "SensorDataSharingMessage", + "SensorDataSharingMessage", + &asn_OP_SEQUENCE, + asn_DEF_SensorDataSharingMessage_tags_1, + sizeof(asn_DEF_SensorDataSharingMessage_tags_1) + /sizeof(asn_DEF_SensorDataSharingMessage_tags_1[0]), /* 1 */ + asn_DEF_SensorDataSharingMessage_tags_1, /* Same as above */ + sizeof(asn_DEF_SensorDataSharingMessage_tags_1) + /sizeof(asn_DEF_SensorDataSharingMessage_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_SensorDataSharingMessage_1, + 8, /* Elements count */ + &asn_SPC_SensorDataSharingMessage_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/SizeValue.c b/src/tmx/Asn_J2735/src/r63/SizeValue.c new file mode 100644 index 000000000..19ec9d837 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/SizeValue.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "SizeValue.h" + +int +SizeValue_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= 0 && value <= 1023)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_SizeValue_constr_1 CC_NOTUSED = { + { 2, 1 } /* (0..1023) */, + -1}; +asn_per_constraints_t asn_PER_type_SizeValue_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 10, 10, 0, 1023 } /* (0..1023) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_SizeValue_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_SizeValue = { + "SizeValue", + "SizeValue", + &asn_OP_NativeInteger, + asn_DEF_SizeValue_tags_1, + sizeof(asn_DEF_SizeValue_tags_1) + /sizeof(asn_DEF_SizeValue_tags_1[0]), /* 1 */ + asn_DEF_SizeValue_tags_1, /* Same as above */ + sizeof(asn_DEF_SizeValue_tags_1) + /sizeof(asn_DEF_SizeValue_tags_1[0]), /* 1 */ + { &asn_OER_type_SizeValue_constr_1, &asn_PER_type_SizeValue_constr_1, SizeValue_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/SizeValueConfidence.c b/src/tmx/Asn_J2735/src/r63/SizeValueConfidence.c new file mode 100644 index 000000000..ac70f8af5 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/SizeValueConfidence.c @@ -0,0 +1,80 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "SizeValueConfidence.h" + +/* + * This type is implemented using NativeEnumerated, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_SizeValueConfidence_constr_1 CC_NOTUSED = { + { 0, 0 }, + -1}; +asn_per_constraints_t asn_PER_type_SizeValueConfidence_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 4, 4, 0, 13 } /* (0..13) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const asn_INTEGER_enum_map_t asn_MAP_SizeValueConfidence_value2enum_1[] = { + { 0, 11, "unavailable" }, + { 1, 11, "size-100-00" }, + { 2, 11, "size-050-00" }, + { 3, 11, "size-020-00" }, + { 4, 11, "size-010-00" }, + { 5, 11, "size-005-00" }, + { 6, 11, "size-002-00" }, + { 7, 11, "size-001-00" }, + { 8, 11, "size-000-50" }, + { 9, 11, "size-000-20" }, + { 10, 11, "size-000-10" }, + { 11, 11, "size-000-05" }, + { 12, 11, "size-000-02" }, + { 13, 11, "size-000-01" } +}; +static const unsigned int asn_MAP_SizeValueConfidence_enum2value_1[] = { + 13, /* size-000-01(13) */ + 12, /* size-000-02(12) */ + 11, /* size-000-05(11) */ + 10, /* size-000-10(10) */ + 9, /* size-000-20(9) */ + 8, /* size-000-50(8) */ + 7, /* size-001-00(7) */ + 6, /* size-002-00(6) */ + 5, /* size-005-00(5) */ + 4, /* size-010-00(4) */ + 3, /* size-020-00(3) */ + 2, /* size-050-00(2) */ + 1, /* size-100-00(1) */ + 0 /* unavailable(0) */ +}; +const asn_INTEGER_specifics_t asn_SPC_SizeValueConfidence_specs_1 = { + asn_MAP_SizeValueConfidence_value2enum_1, /* "tag" => N; sorted by tag */ + asn_MAP_SizeValueConfidence_enum2value_1, /* N => "tag"; sorted by N */ + 14, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static const ber_tlv_tag_t asn_DEF_SizeValueConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_SizeValueConfidence = { + "SizeValueConfidence", + "SizeValueConfidence", + &asn_OP_NativeEnumerated, + asn_DEF_SizeValueConfidence_tags_1, + sizeof(asn_DEF_SizeValueConfidence_tags_1) + /sizeof(asn_DEF_SizeValueConfidence_tags_1[0]), /* 1 */ + asn_DEF_SizeValueConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_SizeValueConfidence_tags_1) + /sizeof(asn_DEF_SizeValueConfidence_tags_1[0]), /* 1 */ + { &asn_OER_type_SizeValueConfidence_constr_1, &asn_PER_type_SizeValueConfidence_constr_1, NativeEnumerated_constraint }, + 0, 0, /* Defined elsewhere */ + &asn_SPC_SizeValueConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/VehicleSizeConfidence.c b/src/tmx/Asn_J2735/src/r63/VehicleSizeConfidence.c new file mode 100644 index 000000000..1e1b5b372 --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/VehicleSizeConfidence.c @@ -0,0 +1,72 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "VehicleSizeConfidence.h" + +asn_TYPE_member_t asn_MBR_VehicleSizeConfidence_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct VehicleSizeConfidence, vehicleWidthConfidence), + (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehicleWidthConfidence" + }, + { ATF_NOFLAGS, 0, offsetof(struct VehicleSizeConfidence, vehicleLengthConfidence), + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehicleLengthConfidence" + }, + { ATF_POINTER, 1, offsetof(struct VehicleSizeConfidence, vehicleHeightConfidence), + (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + -1, /* IMPLICIT tag at current level */ + &asn_DEF_SizeValueConfidence, + 0, + { 0, 0, 0 }, + 0, 0, /* No default value */ + "vehicleHeightConfidence" + }, +}; +static const int asn_MAP_VehicleSizeConfidence_oms_1[] = { 2 }; +static const ber_tlv_tag_t asn_DEF_VehicleSizeConfidence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static const asn_TYPE_tag2member_t asn_MAP_VehicleSizeConfidence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* vehicleWidthConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* vehicleLengthConfidence */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* vehicleHeightConfidence */ +}; +asn_SEQUENCE_specifics_t asn_SPC_VehicleSizeConfidence_specs_1 = { + sizeof(struct VehicleSizeConfidence), + offsetof(struct VehicleSizeConfidence, _asn_ctx), + asn_MAP_VehicleSizeConfidence_tag2el_1, + 3, /* Count of tags in the map */ + asn_MAP_VehicleSizeConfidence_oms_1, /* Optional members */ + 1, 0, /* Root/Additions */ + -1, /* First extension addition */ +}; +asn_TYPE_descriptor_t asn_DEF_VehicleSizeConfidence = { + "VehicleSizeConfidence", + "VehicleSizeConfidence", + &asn_OP_SEQUENCE, + asn_DEF_VehicleSizeConfidence_tags_1, + sizeof(asn_DEF_VehicleSizeConfidence_tags_1) + /sizeof(asn_DEF_VehicleSizeConfidence_tags_1[0]), /* 1 */ + asn_DEF_VehicleSizeConfidence_tags_1, /* Same as above */ + sizeof(asn_DEF_VehicleSizeConfidence_tags_1) + /sizeof(asn_DEF_VehicleSizeConfidence_tags_1[0]), /* 1 */ + { 0, 0, SEQUENCE_constraint }, + asn_MBR_VehicleSizeConfidence_1, + 3, /* Elements count */ + &asn_SPC_VehicleSizeConfidence_specs_1 /* Additional specs */ +}; + diff --git a/src/tmx/Asn_J2735/src/r63/YawDetected.c b/src/tmx/Asn_J2735/src/r63/YawDetected.c new file mode 100644 index 000000000..bc7c0018b --- /dev/null +++ b/src/tmx/Asn_J2735/src/r63/YawDetected.c @@ -0,0 +1,64 @@ +/* + * Generated by asn1c-0.9.29 (http://lionet.info/asn1c) + * From ASN.1 module "SDSM" + * found in "J2735_201603_2023-06-22.asn" + * `asn1c -fcompound-names ` + */ + +#include "YawDetected.h" + +int +YawDetected_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, + asn_app_constraint_failed_f *ctfailcb, void *app_key) { + long value; + + if(!sptr) { + ASN__CTFAIL(app_key, td, sptr, + "%s: value not given (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } + + value = *(const long *)sptr; + + if((value >= -14400 && value <= 14400)) { + /* Constraint check succeeded */ + return 0; + } else { + ASN__CTFAIL(app_key, td, sptr, + "%s: constraint failed (%s:%d)", + td->name, __FILE__, __LINE__); + return -1; + } +} + +/* + * This type is implemented using NativeInteger, + * so here we adjust the DEF accordingly. + */ +static asn_oer_constraints_t asn_OER_type_YawDetected_constr_1 CC_NOTUSED = { + { 2, 0 } /* (-14400..14400) */, + -1}; +asn_per_constraints_t asn_PER_type_YawDetected_constr_1 CC_NOTUSED = { + { APC_CONSTRAINED, 15, 15, -14400, 14400 } /* (-14400..14400) */, + { APC_UNCONSTRAINED, -1, -1, 0, 0 }, + 0, 0 /* No PER value map */ +}; +static const ber_tlv_tag_t asn_DEF_YawDetected_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)) +}; +asn_TYPE_descriptor_t asn_DEF_YawDetected = { + "YawDetected", + "YawDetected", + &asn_OP_NativeInteger, + asn_DEF_YawDetected_tags_1, + sizeof(asn_DEF_YawDetected_tags_1) + /sizeof(asn_DEF_YawDetected_tags_1[0]), /* 1 */ + asn_DEF_YawDetected_tags_1, /* Same as above */ + sizeof(asn_DEF_YawDetected_tags_1) + /sizeof(asn_DEF_YawDetected_tags_1[0]), /* 1 */ + { &asn_OER_type_YawDetected_constr_1, &asn_PER_type_YawDetected_constr_1, YawDetected_constraint }, + 0, 0, /* No members */ + 0 /* No specifics */ +}; + diff --git a/src/tmx/TmxApi/tmx/TmxApiMessages.h b/src/tmx/TmxApi/tmx/TmxApiMessages.h index b680329ff..f44406061 100644 --- a/src/tmx/TmxApi/tmx/TmxApiMessages.h +++ b/src/tmx/TmxApi/tmx/TmxApiMessages.h @@ -88,6 +88,7 @@ enum MsgSubType signalStatusMessage = 30, travelerInformation = 31, personalSafetyMessage = 32, + sensorDataSharingMessage = 41, personalMobilityMessage = 245, testMessage00 = 240, testMessage01 = 241, @@ -143,6 +144,7 @@ static CONSTEXPR const char *MSGSUBTYPE_TESTMESSAGE02_STRING = "TMSG02-P"; static CONSTEXPR const char *MSGSUBTYPE_TESTMESSAGE03_STRING = "TMSG03-P"; static CONSTEXPR const char *MSGSUBTYPE_J2735_END_STRING = "J2735_end"; static CONSTEXPR const char *MSGSUBTYPE_GID_STRING = "GID"; +static CONSTEXPR const char *MSGSUBTYPE_SENSORDATASHARINGMESSAGE_STRING = "SDSM"; enum Encoding { @@ -194,6 +196,7 @@ enum msgPSID rtcmCorrections_PSID = 0x8000, signalRequestMessage_PSID = 0xE0000016, signalStatusMessage_PSID = 0x8002, + sensorDataSharingMessage_PSID = 0x8002, travelerInformation_PSID = 0x8003, personalSafetyMessage_PSID = 0x27, testMessage00_PSID = 0xBFEE, @@ -218,6 +221,7 @@ static CONSTEXPR const char *MSGPSID_ROADSIDEALERT_PSID_STRING = "0x8003"; static CONSTEXPR const char *MSGPSID_RTCMCORRECTIONS_PSID_STRING = "0x8000"; static CONSTEXPR const char *MSGPSID_SIGNALREQUESTMESSAGE_PSID_STRING = "0xE0000016"; static CONSTEXPR const char *MSGPSID_SIGNALSTATUSMESSAGE_PSID_STRING = "0x8002"; +static CONSTEXPR const char *MSGPSID_SENSORDATASHARINGMESSAGE_PSID_STRING = "0x8002"; static CONSTEXPR const char *MSGPSID_TRAVELERINFORMATION_PSID_STRING = "0x8003"; static CONSTEXPR const char *MSGPSID_PERSONALSAFETYMESSAGE_PSID_STRING = "0x27"; static CONSTEXPR const char *MSGPSID_TESTMESSAGE00_PSID_STRING = "0xBFEE"; diff --git a/src/tmx/TmxApi/tmx/j2735_messages/J2735MessageFactory.hpp b/src/tmx/TmxApi/tmx/j2735_messages/J2735MessageFactory.hpp index 88609ec81..1fa6eadf8 100644 --- a/src/tmx/TmxApi/tmx/j2735_messages/J2735MessageFactory.hpp +++ b/src/tmx/TmxApi/tmx/j2735_messages/J2735MessageFactory.hpp @@ -43,6 +43,7 @@ #include #include #include +#include namespace tmx { namespace messages { @@ -78,7 +79,8 @@ using message_types = message_type_list< tsm0Message, tsm1Message, tsm2Message, - tsm3Message + tsm3Message, + SdsmMessage >; /// Base allocator type @@ -203,6 +205,7 @@ class J2735MessageFactory add_allocator_to_maps(); add_allocator_to_maps(); add_allocator_to_maps(); + add_allocator_to_maps(); #if SAEJ2735_SPEC < 63 add_allocator_to_maps(); #endif diff --git a/src/tmx/TmxApi/tmx/j2735_messages/SensorDataSharingMessage.hpp b/src/tmx/TmxApi/tmx/j2735_messages/SensorDataSharingMessage.hpp new file mode 100644 index 000000000..66b910e51 --- /dev/null +++ b/src/tmx/TmxApi/tmx/j2735_messages/SensorDataSharingMessage.hpp @@ -0,0 +1,15 @@ +/* + * @file SensorDataSharingMessage.hpp + * + * Created on: August 4, 2023 + */ +#ifndef TMX_J2735_MESSAGES_SENSORDATASHARINGMESSAGE_HPP_ +#define TMX_J2735_MESSAGES_SENSORDATASHARINGMESSAGE_HPP_ + +#include +#include +#include + +TMX_J2735_DECLARE(Sdsm, SensorDataSharingMessage, api::sensorDataSharingMessage, api::MSGSUBTYPE_SENSORDATASHARINGMESSAGE_STRING) + +#endif /* TMX_J2735_MESSAGES_SENSORDATASHARINGMESSAGE_HPP_ */ diff --git a/src/tmx/TmxUtils/test/J2735MessageTest.cpp b/src/tmx/TmxUtils/test/J2735MessageTest.cpp index 5a72f9458..c885ecdd9 100644 --- a/src/tmx/TmxUtils/test/J2735MessageTest.cpp +++ b/src/tmx/TmxUtils/test/J2735MessageTest.cpp @@ -748,4 +748,61 @@ TEST_F(J2735MessageTest, EncodeTravelerInformation){ string expectedHex = "001f526011c35d000000000023667bac0407299b9ef9e7a9b9408230dfffe4386ba00078005a53373df3cf5372810461b90ffff53373df3cf53728104618129800010704a04c7d7976ca3501872e1bb66ad19b2620"; ASSERT_EQ(expectedHex, timEnc.get_payload_str()); } + +TEST_F(J2735MessageTest, EncodeSDSM) +{ + auto message = (SensorDataSharingMessage_t*)calloc(1, sizeof(SensorDataSharingMessage_t)); + message->msgCnt = 10; + uint8_t my_bytes_id[4] = {(uint8_t)1, (uint8_t)12, (uint8_t)12, (uint8_t)10}; + message->sourceID.buf = my_bytes_id; + message->sourceID.size = sizeof(my_bytes_id); + message->equipmentType = EquipmentType_unknown; + + + auto sDSMTimeStamp = (DDateTime_t*) calloc(1, sizeof(DDateTime_t)); + auto year = (DYear_t*) calloc(1, sizeof(DYear_t)); + *year= 2023; + sDSMTimeStamp->year = year; + message->sDSMTimeStamp = *sDSMTimeStamp; + + message->refPos.lat = 38.121212; + message->refPos.Long = -77.121212; + + message->refPosXYConf.orientation = 10; + message->refPosXYConf.semiMajor = 12; + message->refPosXYConf.semiMinor = 52; + + auto objects = (DetectedObjectList_t*) calloc(1, sizeof(DetectedObjectList_t)); + auto objectData = (DetectedObjectData_t*) calloc(1, sizeof(DetectedObjectData_t)); + objectData->detObjCommon.objType = ObjectType_unknown; + objectData->detObjCommon.objTypeCfd = 1; + objectData->detObjCommon.measurementTime = 1; + objectData->detObjCommon.timeConfidence = 1; + objectData->detObjCommon.pos.offsetX = 1; + objectData->detObjCommon.pos.offsetY = 1; + objectData->detObjCommon.posConfidence.elevation = 1; + objectData->detObjCommon.posConfidence.pos = 1; + objectData->detObjCommon.speed = 1; + objectData->detObjCommon.speedConfidence = 1; + objectData->detObjCommon.heading = 1; + objectData->detObjCommon.headingConf = 1; + ASN_SEQUENCE_ADD(&objects->list.array, objectData); + message->objects = *objects; + xer_fprint(stdout, &asn_DEF_SensorDataSharingMessage, message); + + //Encode SDSM + tmx::messages::SdsmEncodedMessage SdsmEncodeMessage; + auto _sdsmMessage = new tmx::messages::SdsmMessage(message); + tmx::messages::MessageFrameMessage frame_msg(_sdsmMessage->get_j2735_data()); + SdsmEncodeMessage.set_data(TmxJ2735EncodedMessage::encode_j2735_message>(frame_msg)); + free(message); + free(frame_msg.get_j2735_data().get()); + ASSERT_EQ(41, SdsmEncodeMessage.get_msgId()); + std::string expectedSDSMEncHex = "0029250a010c0c0a101f9c35a4e9266b49d1b20c34000a00000020000bba0a000200004400240009"; + ASSERT_EQ(expectedSDSMEncHex, SdsmEncodeMessage.get_payload_str()); + + //Decode SDSM + auto sdsm_ptr = SdsmEncodeMessage.decode_j2735_message().get_j2735_data(); + ASSERT_EQ(10, sdsm_ptr->msgCnt); +} }