diff options
Diffstat (limited to 'epan/dissectors/asn1/its')
33 files changed, 11188 insertions, 0 deletions
diff --git a/epan/dissectors/asn1/its/CAM-PDU-Descriptions.asn b/epan/dissectors/asn1/its/CAM-PDU-Descriptions.asn new file mode 100644 index 00000000..80a3a5bb --- /dev/null +++ b/epan/dissectors/asn1/its/CAM-PDU-Descriptions.asn @@ -0,0 +1,336 @@ +CAM-PDU-Descriptions {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) camPduRelease2 (103900) major-version-2 (2) minor-version-1 (1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS +ItsPduHeader, CauseCodeV2, ReferencePosition, AccelerationControl, Curvature, CurvatureCalculationMode, Heading, LanePosition, EmergencyPriority, EmbarkationStatus, Speed, +DriveDirection, AccelerationComponent, StationType, ExteriorLights, DangerousGoodsBasic, SpecialTransportType, LightBarSirenInUse, +VehicleRole, VehicleLength, VehicleWidth, Path, RoadworksSubCauseCode, ClosedLanes, TrafficRule, SpeedLimit, SteeringWheelAngle, PerformanceClass, YawRate, +PtActivation, ProtectedCommunicationZonesRSU, CenDsrcTollingZone, GenerationDeltaTime, BasicContainer + +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-4 (4) minor-version-1 (1)} WITH SUCCESSORS +; + + +-- The root data frame for cooperative awareness messages + +/** +* This type represents the CAM PDU. +* +* It shall include the following componenets: +* +* @field header: the header of the CAM PDU. +* +* @field cam: the payload of the CAM PDU. +*/ + +CAM ::= SEQUENCE { + header ItsPduHeader (WITH COMPONENTS {... , protocolVersion (2), messageId(cam)}), + cam CamPayload +} + +/** +* This type represents the CAM payload. +* +* It shall include the following components: +* +* @field generationDeltaTime: Time corresponding to the time of the reference position in the CAM, considered as time of the CAM generation. +* +* @field camParameters: The sequence of CAM mandatory and optional container. +* +*/ +CamPayload ::= SEQUENCE { + generationDeltaTime GenerationDeltaTime, + camParameters CamParameters +} + +/** +* @field basicContainer: the mandatory basic container of the CAM. +* +* @field highFrequencyContainer: the mandatory container represents the high frequency of the CAM. +* +* @field lowFrequencyContainer: the optional conatainer represents the low frequency of the CAM. +* +* @field specialVehicleContainer: The special container of the CAM shall be present as defined in clause 6.1.2. +* The content of the container shall be set according to the value of the vehicleRole component as specified in Table 5. +*/ +CamParameters ::= SEQUENCE { + basicContainer BasicContainer, + highFrequencyContainer HighFrequencyContainer, + lowFrequencyContainer LowFrequencyContainer OPTIONAL, + specialVehicleContainer SpecialVehicleContainer OPTIONAL, + ... +} + +/** +* This type represents the high frequency container. +* +* It shall include the following components: +* +* @field basicVehicleContainerHighFrequency: The mandatory high frequency container of the CAM when the originating ITS-S is of the type vehicle ITS-S. +* +* @field rsuContainerHighFrequency: The mandatory high frequency container of CAM when the type of the originating ITS-S is RSU ITS-S. +*/ +HighFrequencyContainer ::= CHOICE { + basicVehicleContainerHighFrequency BasicVehicleContainerHighFrequency, + rsuContainerHighFrequency RSUContainerHighFrequency, + ... +} + +/** +* This type represents the low frequency container. +* +* It shall include the following components: +* +* The low frequency container of the CAM when the originating ITS-S is of the type vehicle ITS-S. It shall be present as defined in clause 6.1.2. +*/ + LowFrequencyContainer ::= CHOICE { + basicVehicleContainerLowFrequency BasicVehicleContainerLowFrequency (WITH COMPONENTS {..., pathHistory (SIZE (0..23))}), + ... +} + +/** +* This type represent the Special Vehicle Container. +* +* It shall include the following components: +* +* @field publicTransportContainer: If the vehicleRole component is set to publicTransport(1) this container shall be present. +* +* @field specialTransportContainer: If the vehicleRole component is set to specialTransport(2) this container shall be present. +* +* @field dangerousGoodsContainer: If the vehicleRole component is set to dangerousGoods(3) this container shall be present. +* +* @field roadWorksContainerBasic: If the vehicleRole component is set to roadWork(4) this container shall be present. +* +* @field rescueContainer: If the vehicleRole component is set to rescue(5) this container shall be present. +* +* @field emergencyContainer: If the vehicleRole component is set to emergency(6) this container shall be present. +* +* @field safetyCarContainer: If the vehicleRole component is set to safetyCar(7) this container shall be present. +*/ +SpecialVehicleContainer ::= CHOICE { + publicTransportContainer PublicTransportContainer, + specialTransportContainer SpecialTransportContainer, + dangerousGoodsContainer DangerousGoodsContainer, + roadWorksContainerBasic RoadWorksContainerBasic, + rescueContainer RescueContainer, + emergencyContainer EmergencyContainer, + safetyCarContainer SafetyCarContainer, + ... +} + +/** +* This type contains detaild information of the Basic Vehicle Container High Frequency. +* +* It shall include the following components: +* +* @field heading: It represent the heading and heading accuracy of the vehicle movement of the originating ITS-S with regards to the true north. +* The heading accuracy provided in the heading Confidence value shall provide the accuracy of the measured vehicle heading with a confidence level +* of 95 %. Otherwise, the value of the headingConfidence shall be set to unavailable. +* +* @field speed: It represent driving speed and speed accuracy of the originating ITS-S. The speed accuracy provided in the speedConfidence shall +* provide the accuracy of the speed value with a confidence level of 95 %. Otherwise, the speedConfidence shall be set to unavailable. +* +* @field driveDirection: This component represent the vehicle drive direction (forward or backward) of the originating ITS-S. +* +* @field vehicleLength: This component represent the vehicle length value and vehicle length confidence indication of the vehicle ITS-S that +* originate the CAM. +* +* @field vehicleWidth: This component represents the Vehicle Width of the vehicle ITS-S that originates the CAM excluding side mirrors and possible +* similar extensions. +* +* @field longitudinalAcceleration: It represent the vehicle Longitudinal Acceleration of the originating ITS-S in the centre of the mass of the +* empty vehicle. It shall include the measured vehicle longitudinal acceleration and its accuracy value with the confidence level of 95 %. +* Otherwise, the longitudinalAccelerationConfidence shall be set to unavailable. +* +* @field curvature: this component reppresent the actual trajectory of the vehicle. +* +* @field curvatureCalculationMode: It indicates whether vehicle yaw-rate is used in the calculation of the curvature of the vehicle ITS-S that +* originates the CAM. +* +* @field yawRate: It denotes the vehicle rotation around the centre of mass of the empty vehicle. The leading sign denotes the direction of +* rotation. The value is negative if the motion is clockwise when viewing from the top. +* yawRateConfidence denotes the accuracy for the 95 % confidence level for the measured yawRateValue. Otherwise, the value of yawRateConfidence +* shall be set to unavailable. +* +* @field accelerationControl: an optional component which represents the current status of the vehcile mechnanisms controlling the longitudinal movement of the vehcile ITS-S +* (e.g. brake pedal, gas pedal, etc. engaged) that originate the CAM. +* +* @field lanePosition: an optional component which represents the lanePosition of the referencePosition of a vehicle. This component shall be present if the data is +* available at the originating ITS-S. +* +* @field steeringWheelAngle: an optional component which indicates the steering wheel angle and accuracy as measured at the vehicle ITS-S that originates the CAM. +* +* @field lateralAcceleration: an optional component which represents the vehicle lateral acceleration of the originating ITS-S in the centre of the mass of the empty vehicle. +* It shall include the measured vehicle lateral acceleration and its accuracy value with the confidence level of 95%. +* +* @field verticalAcceleration: an optional component which indicates the originating ITS-S in the centre of the mass of the empty vehicle. +* +* @field performanceClass: an optional component characterizes the maximum age of the CAM data elements with regard to the generation delta time. +* +* @field cenDsrcTollingZone: an optional component which represents the information about the position of a CEN DSRC Tolling Station operating in the 5,8 GHz frequency band. +*/ +BasicVehicleContainerHighFrequency ::= SEQUENCE { + heading Heading, + speed Speed, + driveDirection DriveDirection, + vehicleLength VehicleLength, + vehicleWidth VehicleWidth, + longitudinalAcceleration AccelerationComponent, + curvature Curvature, + curvatureCalculationMode CurvatureCalculationMode, + yawRate YawRate, + accelerationControl AccelerationControl OPTIONAL, + lanePosition LanePosition OPTIONAL, + steeringWheelAngle SteeringWheelAngle OPTIONAL, + lateralAcceleration AccelerationComponent OPTIONAL, + verticalAcceleration AccelerationComponent OPTIONAL, + performanceClass PerformanceClass OPTIONAL, + cenDsrcTollingZone CenDsrcTollingZone OPTIONAL +} + +/** +* This type contains detaild information of the Basic Vehicle Container Low Frequency. +* +* It shall include the following components: +* +* @field vehicleRole: represent the role of the vehicle ITS-S that originates the CAM. Only values 0 to 7 shall be used. +* +* @field exteriorLights: represent the status of the most important exterior lights switches of the vehicle ITS-S that originates the CAM. +* +* @field pathHistory: which represents the vehicle's recent movement over some past time and/or distance. It consists of a list of path points, +* each represented as DF PathPoint. The list of path points may consist of up to 23 elements. +*/ +BasicVehicleContainerLowFrequency ::= SEQUENCE { + vehicleRole VehicleRole, + exteriorLights ExteriorLights, + pathHistory Path +} + +/** +* This type contains detaild information of the Public Transport Container. +* +* It shall include the following components: +* +* @field embarkationStatus: It indicates whether the passenger embarkation is currently ongoing. +* +* @field ptActivation: an optional component used for controlling traffic lights, barriers, bollards, etc. +*/ +PublicTransportContainer ::= SEQUENCE { + embarkationStatus EmbarkationStatus, + ptActivation PtActivation OPTIONAL +} + +/** +* This type contains detaild information of the Special Transport Container. +* +* It shall include the following components: +* +* @field specialTransportType: which indicates whether the originating ITS-S is mounted on a special transport vehicle with heavy or oversized load +* or both. It shall be present if the data is available in originating ITS-S. +* +* @field lightBarSirenInUse: indicates whether light-bar or a siren is in use by the vehicle originating the CAM. +*/ +SpecialTransportContainer ::= SEQUENCE { + specialTransportType SpecialTransportType, + lightBarSirenInUse LightBarSirenInUse +} + +/** +* This type contains detaild information of the Dangerous Goods Container. +* +* It shall include the following components: +* +* @field dangerousGoodsBasic: identifies the type of the dangerous goods transported by the vehicle that originates the CAM. It shall be present if +* the data is available in the originating ITS S. +*/ + DangerousGoodsContainer ::= SEQUENCE { + dangerousGoodsBasic DangerousGoodsBasic + } + + /** +* This type contains detaild information of the Road Works Container Basic. +* +* It shall include the following components: +* +* @field roadworksSubCauseCode: The optional component, in case the originating ITS-S is mounted to a vehicle ITS-S participating to roadwork. It +* provides information on the type of roadwork that it is currently undertaking. This component shall be present if the data is available in +* originating ITS S. +* +* @field lightBarSirenInUse: it indicates whether light-bar or a siren is in use by the vehicle originating the CAM. +* +* @field closedLanes: an optional component which provides information about the opening/closure status of the lanes ahead. Lanes are counted from +* the outside boarder of the road. If a lane is closed to traffic, the corresponding bit shall be set to 1. +*/ + RoadWorksContainerBasic ::= SEQUENCE { + roadworksSubCauseCode RoadworksSubCauseCode OPTIONAL, + lightBarSirenInUse LightBarSirenInUse, + closedLanes ClosedLanes OPTIONAL + } + +/** +* This type contains detaild information of the Rescue Container. +* +* It shall include the following components: +* +* @field lightBarSirenInUse: it indicates whether light-bar or a siren is in use by the vehicle originating the CAM. +*/ +RescueContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse +} + +/** +* This type contains detaild information of the Emergency Container. +* +* It shall include the following components: +* +* @field lightBarSirenInUse: it indicates whether light-bar or a siren is in use by the vehicle originating the CAM. +* +* @field incidentIndication: the optional incident related to the roadworks to provide additional information of the roadworks zone. +* +* @field emergencyPriority: the optional component represent right of way indicator of the vehicle ITS-S that originates the CAM PDU. +*/ +EmergencyContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCodeV2 OPTIONAL, + emergencyPriority EmergencyPriority OPTIONAL +} + +/** +* This type contains detaild information of the Safety Car Container. +* +* It shall include the following components: +* +* @field lightBarSirenInUse: it indicates whether light-bar or a siren is in use by the vehicle originating the CAM. +* +* @field incidentIndication: the optional incident related to the roadworks to provide additional information of the roadworks zone. +* +* @field trafficRule: an optional rule indicates whether vehicles are allowed to overtake a safety car that is originating this CAM. +* +* @field speedLimit: an optional speed indicates whether a speed limit is applied to vehicles following the safety car. +*/ +SafetyCarContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCodeV2 OPTIONAL, + trafficRule TrafficRule OPTIONAL, + speedLimit SpeedLimit OPTIONAL +} + +/** +* This type contains detaild information of the RSU Container High Frequency. +* +* It shall include the following components: +* +* @field protectedCommunicationZonesRSU: an optional Information about position of a CEN DSRC Tolling Station operating in the 5,8 GHz frequency +* band. If this information is provided by RSUs a receiving vehicle ITS-S is prepared to adopt mitigation techniques when being in the vicinity of +* CEN DSRC tolling stations. + +*/ +RSUContainerHighFrequency ::= SEQUENCE { + protectedCommunicationZonesRSU ProtectedCommunicationZonesRSU OPTIONAL, + ... +} + +END diff --git a/epan/dissectors/asn1/its/CAM.asn b/epan/dissectors/asn1/its/CAM.asn new file mode 100644 index 00000000..500e97c3 --- /dev/null +++ b/epan/dissectors/asn1/its/CAM.asn @@ -0,0 +1,139 @@ +-- https://www.etsi.org/deliver/etsi_en/302600_302699/30263702/01.04.01_30/en_30263702v010401v.pdf +-- +CAM-PDU-Descriptions { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (302637) cam (2) version (2) +} + + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + ItsPduHeader, ReferencePosition, AccelerationControl, CauseCode, Curvature,CurvatureCalculationMode,DriveDirection, + Heading, LanePosition, EmergencyPriority, EmbarkationStatus, Speed, + LongitudinalAcceleration, LateralAcceleration, VerticalAcceleration, StationType, + ExteriorLights, DangerousGoodsBasic, SpecialTransportType, LightBarSirenInUse, VehicleRole, + VehicleLength, VehicleWidth, PathHistoryV2, RoadworksSubCauseCode, ClosedLanes, TrafficRule, + SpeedLimit, SteeringWheelAngle, PerformanceClass, YawRate, ProtectedCommunicationZone, PtActivation, + Latitude, Longitude, ProtectedCommunicationZonesRSU, CenDsrcTollingZone + -- Wireshark modification + FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + ; + -- The root data frame for cooperative awareness messages + CAM ::= SEQUENCE { + header ItsPduHeader, + cam CoopAwareness + } + + CoopAwareness ::= SEQUENCE { + generationDeltaTime GenerationDeltaTime, + camParameters CamParameters + } + + CamParameters ::= SEQUENCE { + basicContainer BasicContainer, + highFrequencyContainer HighFrequencyContainer, + lowFrequencyContainer LowFrequencyContainer OPTIONAL, + specialVehicleContainer SpecialVehicleContainer OPTIONAL, + ... + } + + HighFrequencyContainer ::= CHOICE { + basicVehicleContainerHighFrequency BasicVehicleContainerHighFrequency, + rsuContainerHighFrequency RSUContainerHighFrequency, + ... + } + + LowFrequencyContainer ::= CHOICE { + basicVehicleContainerLowFrequency BasicVehicleContainerLowFrequency, + ... + } + + SpecialVehicleContainer ::= CHOICE { + publicTransportContainer PublicTransportContainer, + specialTransportContainer SpecialTransportContainer, + dangerousGoodsContainer DangerousGoodsContainer, + roadWorksContainerBasic RoadWorksContainerBasic, + rescueContainer RescueContainer, + emergencyContainer EmergencyContainer, + safetyCarContainer SafetyCarContainer, + ... + } + + BasicContainer ::= SEQUENCE { + stationType StationType, + referencePosition ReferencePosition, + ... + } + + BasicVehicleContainerHighFrequency ::= SEQUENCE { + heading Heading, + speed Speed, + driveDirection DriveDirection, + vehicleLength VehicleLength, + vehicleWidth VehicleWidth, + longitudinalAcceleration LongitudinalAcceleration, + curvature Curvature, + curvatureCalculationMode CurvatureCalculationMode, + yawRate YawRate, + accelerationControl AccelerationControl OPTIONAL, + lanePosition LanePosition OPTIONAL, + steeringWheelAngle SteeringWheelAngle OPTIONAL, + lateralAcceleration LateralAcceleration OPTIONAL, + verticalAcceleration VerticalAcceleration OPTIONAL, + performanceClass PerformanceClass OPTIONAL, + cenDsrcTollingZone CenDsrcTollingZone OPTIONAL + } + + BasicVehicleContainerLowFrequency ::= SEQUENCE { + vehicleRole VehicleRole, + exteriorLights ExteriorLights, + pathHistory PathHistoryV2 + } + + PublicTransportContainer ::= SEQUENCE { + embarkationStatus EmbarkationStatus, + ptActivation PtActivation OPTIONAL + } + + SpecialTransportContainer ::= SEQUENCE { + specialTransportType SpecialTransportType, + lightBarSirenInUse LightBarSirenInUse + } + + DangerousGoodsContainer ::= SEQUENCE { + dangerousGoodsBasic DangerousGoodsBasic + } + + RoadWorksContainerBasic ::= SEQUENCE { + roadworksSubCauseCode RoadworksSubCauseCode OPTIONAL, + lightBarSirenInUse LightBarSirenInUse, + closedLanes ClosedLanes OPTIONAL + } + + RescueContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse + } + + EmergencyContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCode OPTIONAL, + emergencyPriority EmergencyPriority OPTIONAL + } + + SafetyCarContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCode OPTIONAL, + trafficRule TrafficRule OPTIONAL, + speedLimit SpeedLimit OPTIONAL + } + + RSUContainerHighFrequency ::= SEQUENCE { + protectedCommunicationZonesRSU ProtectedCommunicationZonesRSU OPTIONAL, + ... + } + + GenerationDeltaTime ::= INTEGER { oneMilliSec(1) } (0..65535) + +END diff --git a/epan/dissectors/asn1/its/CAMv1.asn b/epan/dissectors/asn1/its/CAMv1.asn new file mode 100644 index 00000000..ce274548 --- /dev/null +++ b/epan/dissectors/asn1/its/CAMv1.asn @@ -0,0 +1,138 @@ +CAMv1-PDU-Descriptions { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (302637) cam (2) version (1) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS +ItsPduHeader, CauseCode, ReferencePosition, AccelerationControl, Curvature, CurvatureCalculationMode, Heading, LanePosition, EmergencyPriority, +EmbarkationStatus, Speed, DriveDirection, LongitudinalAcceleration, LateralAcceleration, VerticalAcceleration, StationType, ExteriorLights, +DangerousGoodsBasic, SpecialTransportType, LightBarSirenInUse, VehicleRole, VehicleLength, VehicleWidth, PathHistory, RoadworksSubCauseCode, +ClosedLanes, TrafficRule, SpeedLimit, SteeringWheelAngle, PerformanceClass, YawRate, ProtectedCommunicationZone, PtActivation, Latitude, +Longitude, ProtectedCommunicationZonesRSU, CenDsrcTollingZone + +FROM ITS-ContainerV1 { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (1) +}; + + +-- The root data frame for cooperative awareness messages + +CAMv1 ::= SEQUENCE { + header ItsPduHeader, + camv1 CoopAwarenessV1 +} + +CoopAwarenessV1 ::= SEQUENCE { + generationDeltaTime GenerationDeltaTime, + camParameters CamParameters +} + +CamParameters ::= SEQUENCE { + basicContainer BasicContainer, + highFrequencyContainer HighFrequencyContainer, + lowFrequencyContainer LowFrequencyContainer OPTIONAL, + specialVehicleContainer SpecialVehicleContainer OPTIONAL, + ... +} + +HighFrequencyContainer ::= CHOICE { + basicVehicleContainerHighFrequency BasicVehicleContainerHighFrequency, + rsuContainerHighFrequency RSUContainerHighFrequency, + ... +} + + LowFrequencyContainer ::= CHOICE { + basicVehicleContainerLowFrequency BasicVehicleContainerLowFrequency, + ... +} + +SpecialVehicleContainer ::= CHOICE { + publicTransportContainer PublicTransportContainer, + specialTransportContainer SpecialTransportContainer, + dangerousGoodsContainer DangerousGoodsContainer, + roadWorksContainerBasic RoadWorksContainerBasic, + rescueContainer RescueContainer, + emergencyContainer EmergencyContainer, + safetyCarContainer SafetyCarContainer, + ... +} + +BasicContainer ::= SEQUENCE { + stationType StationType, + referencePosition ReferencePosition, + ... +} + +BasicVehicleContainerHighFrequency ::= SEQUENCE { + heading Heading, + speed Speed, + driveDirection DriveDirection, + vehicleLength VehicleLength, + vehicleWidth VehicleWidth, + longitudinalAcceleration LongitudinalAcceleration, + curvature Curvature, + curvatureCalculationMode CurvatureCalculationMode, + yawRate YawRate, + accelerationControl AccelerationControl OPTIONAL, + lanePosition LanePosition OPTIONAL, + steeringWheelAngle SteeringWheelAngle OPTIONAL, + lateralAcceleration LateralAcceleration OPTIONAL, + verticalAcceleration VerticalAcceleration OPTIONAL, + performanceClass PerformanceClass OPTIONAL, + cenDsrcTollingZone CenDsrcTollingZone OPTIONAL +} + +BasicVehicleContainerLowFrequency ::= SEQUENCE { + vehicleRole VehicleRole, + exteriorLights ExteriorLights, + pathHistory PathHistory +} + +PublicTransportContainer ::= SEQUENCE { + embarkationStatus EmbarkationStatus, + ptActivation PtActivation OPTIONAL +} + +SpecialTransportContainer ::= SEQUENCE { + specialTransportType SpecialTransportType, + lightBarSirenInUse LightBarSirenInUse +} + + DangerousGoodsContainer ::= SEQUENCE { + dangerousGoodsBasic DangerousGoodsBasic + } + + RoadWorksContainerBasic ::= SEQUENCE { + roadworksSubCauseCode RoadworksSubCauseCode OPTIONAL, + lightBarSirenInUse LightBarSirenInUse, + closedLanes ClosedLanes OPTIONAL + } + +RescueContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse +} + +EmergencyContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCode OPTIONAL, + emergencyPriority EmergencyPriority OPTIONAL +} + +SafetyCarContainer ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse, + incidentIndication CauseCode OPTIONAL, + trafficRule TrafficRule OPTIONAL, + speedLimit SpeedLimit OPTIONAL +} + +RSUContainerHighFrequency ::= SEQUENCE { + protectedCommunicationZonesRSU ProtectedCommunicationZonesRSU OPTIONAL, + ... +} + +GenerationDeltaTime ::= INTEGER { oneMilliSec(1) } (0..65535) + +END diff --git a/epan/dissectors/asn1/its/CMakeLists.txt b/epan/dissectors/asn1/its/CMakeLists.txt new file mode 100644 index 00000000..2b616f69 --- /dev/null +++ b/epan/dissectors/asn1/its/CMakeLists.txt @@ -0,0 +1,61 @@ +# CMakeLists.txt +# +# Wireshark - Network traffic analyzer +# By Gerald Combs <gerald@wireshark.org> +# Copyright 1998 Gerald Combs +# +# SPDX-License-Identifier: GPL-2.0-or-later +# + +set( PROTOCOL_NAME its ) + +set( PROTO_OPT -o its ) + +set( EXT_ASN_FILE_LIST +) + +set( ASN_FILE_LIST + ETSI-ITS-CDD.asn +# ITS-Container.asn + ITS-ContainerV1.asn + ISO_TS_14816.asn +# ISO_TS_24534-3.asn +# ISO_TS_17419.asn + ISO_TS_14906_Application.asn + ISO_TS_19091.asn + GDD.asn + ISO19321IVIv2.asn + ETSI_TS_103301.asn + CAMv1.asn +# CAM.asn + CAM-PDU-Descriptions.asn + DENMv1.asn +# DENM.asn + DENM-PDU-Descriptions.asn + TIS_TPG_Transactions_Descriptions.asn + EVCSN-PDU-Descriptions.asn + EV-RSR-PDU-Descriptions.asn + CPM-OriginatingStationContainers.asn + CPM-PDU-Descriptions.asn + CPM-PerceivedObjectContainer.asn + CPM-PerceptionRegionContainer.asn + CPM-SensorInformationContainer.asn + VAM-PDU-Descriptions.asn +# VAM-Temp-Imports.asn + IMZM-PDU-Descriptions.asn +) + +set( EXTRA_DIST + ${ASN_FILE_LIST} + packet-${PROTOCOL_NAME}-template.c + ${PROTOCOL_NAME}.cnf +) + +set( SRC_FILES + ${EXTRA_DIST} + ${EXT_ASN_FILE_LIST} +) + +set( A2W_FLAGS ) + +ASN2WRS() diff --git a/epan/dissectors/asn1/its/CPM-OriginatingStationContainers.asn b/epan/dissectors/asn1/its/CPM-OriginatingStationContainers.asn new file mode 100644 index 00000000..995cf9e2 --- /dev/null +++ b/epan/dissectors/asn1/its/CPM-OriginatingStationContainers.asn @@ -0,0 +1,28 @@ +CPM-OriginatingStationContainers {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) originatingStationContainers (2) major-version-1 (1) minor-version-1(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +CartesianAngle, MapReference, Speed, StationType, TrailerData, Wgs84Angle +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1)} +; + +OriginatingVehicleContainer ::= SEQUENCE { + orientationAngle Wgs84Angle, + pitchAngle CartesianAngle OPTIONAL, + rollAngle CartesianAngle OPTIONAL, + trailerDataSet TrailerDataSet OPTIONAL, + ... +} + +OriginatingRsuContainer ::= SEQUENCE{ + mapReference MapReference OPTIONAL, + ... +} + +TrailerDataSet::= SEQUENCE SIZE(1..8,...) OF TrailerData (WITH COMPONENTS {... ,frontOverhang ABSENT, rearOverhang ABSENT, trailerWidth ABSENT}) + +END diff --git a/epan/dissectors/asn1/its/CPM-PDU-Descriptions.asn b/epan/dissectors/asn1/its/CPM-PDU-Descriptions.asn new file mode 100644 index 00000000..afb669b6 --- /dev/null +++ b/epan/dissectors/asn1/its/CPM-PDU-Descriptions.asn @@ -0,0 +1,108 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ETSI TR 103 562 V2.1.1 (2019-12) +-- +-- Intelligent Transport Systems (ITS); +-- Vehicular Communications; +-- Basic Set of Applications; +-- Analysis of the Collective Perception Service (CPS); +-- Release 2 +-- +-- https://www.etsi.org/deliver/etsi_tr/103500_103599/103562/02.01.01_60/tr_103562v020101p.pdf +-- +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +CPM-PDU-Descriptions { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) cpm (1) major-version-1 (1) minor-version-1(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +ItsPduHeader, MessageRateHz, MessageSegmentationInfo, OrdinalNumber1B, ReferencePosition, StationType, TimestampIts +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1)} +--WITH SUCCESSORS + +OriginatingRsuContainer, OriginatingVehicleContainer +FROM CPM-OriginatingStationContainers {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) originatingStationContainers (2) major-version-1 (1) minor-version-1(1)} +--WITH SUCCESSORS + +SensorInformationContainer +FROM CPM-SensorInformationContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) sensorInformationContainer (3) major-version-1 (1) minor-version-1(1)} +--WITH SUCCESSORS + +PerceptionRegionContainer +FROM CPM-PerceptionRegionContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) perceptionRegionContainer (5) major-version-1 (1) minor-version-1(1)} +--WITH SUCCESSORS + +PerceivedObjectContainer +FROM CPM-PerceivedObjectContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) perceivedObjectContainer (4) major-version-1 (1) minor-version-1(1)} +--WITH SUCCESSORS + +; + +CollectivePerceptionMessage ::= SEQUENCE { + header ItsPduHeader (WITH COMPONENTS {... , protocolVersion (2), messageId(cpm)}), + payload CpmPayload +} + +CpmPayload ::= SEQUENCE { + managementContainer ManagementContainer, + cpmContainers ConstraintWrappedCpmContainers, + ... +} + +ManagementContainer ::= SEQUENCE { + referenceTime TimestampIts, + referencePosition ReferencePosition, + segmentationInfo MessageSegmentationInfo OPTIONAL, + messageRateRange MessageRateRange OPTIONAL, + ... +} + + +CPM-CONTAINER-ID-AND-TYPE ::= CLASS { + &id CpmContainerId UNIQUE, + &Type +} WITH SYNTAX {&Type IDENTIFIED BY &id} + +CpmContainerId ::= INTEGER (1..16) + +originatingVehicleContainer CpmContainerId ::= 1 +originatingRsuContainer CpmContainerId ::= 2 +sensorInformationContainer CpmContainerId ::= 3 +perceptionRegionContainer CpmContainerId ::= 4 +perceivedObjectContainer CpmContainerId ::= 5 + + +CpmContainers CPM-CONTAINER-ID-AND-TYPE ::= { + {OriginatingVehicleContainer IDENTIFIED BY originatingVehicleContainer} | + {OriginatingRsuContainer IDENTIFIED BY originatingRsuContainer} | + {SensorInformationContainer IDENTIFIED BY sensorInformationContainer} | + {PerceptionRegionContainer IDENTIFIED BY perceptionRegionContainer} | + {PerceivedObjectContainer IDENTIFIED BY perceivedObjectContainer}, + ... +} + +WrappedCpmContainer ::= SEQUENCE { + containerId CPM-CONTAINER-ID-AND-TYPE.&id( {CpmContainers} ), + containerData CPM-CONTAINER-ID-AND-TYPE.&Type( {CpmContainers}{@containerId} ) +} + + +WrappedCpmContainers::= SEQUENCE SIZE(1..8,...) OF WrappedCpmContainer + +ConstraintWrappedCpmContainers ::= WrappedCpmContainers +-- ((WITH COMPONENT (WITH COMPONENTS {..., containerId (ALL EXCEPT 1)})) | +-- (WITH COMPONENT (WITH COMPONENTS {..., containerId (ALL EXCEPT 2)}))) +-- ALL did not work... + ((WITH COMPONENT (WITH COMPONENTS {..., containerId })) | + (WITH COMPONENT (WITH COMPONENTS {..., containerId }))) + +MessageRateRange::= SEQUENCE{ + messageRateMin MessageRateHz, + messageRateMax MessageRateHz +} + +END + diff --git a/epan/dissectors/asn1/its/CPM-PerceivedObjectContainer.asn b/epan/dissectors/asn1/its/CPM-PerceivedObjectContainer.asn new file mode 100644 index 00000000..652ac551 --- /dev/null +++ b/epan/dissectors/asn1/its/CPM-PerceivedObjectContainer.asn @@ -0,0 +1,21 @@ +CPM-PerceivedObjectContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) perceivedObjectContainer (4) major-version-1 (1) minor-version-1(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +CardinalNumber1B, PerceivedObject +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1)} +; + +PerceivedObjectContainer ::= SEQUENCE { + numberOfPerceivedObjects CardinalNumber1B, + perceivedObjects PerceivedObjects, + ... +} + +PerceivedObjects::= SEQUENCE SIZE(0..255, ...) OF PerceivedObject (WITH COMPONENTS {... ,objectId PRESENT}) + +END diff --git a/epan/dissectors/asn1/its/CPM-PerceptionRegionContainer.asn b/epan/dissectors/asn1/its/CPM-PerceptionRegionContainer.asn new file mode 100644 index 00000000..06a96fed --- /dev/null +++ b/epan/dissectors/asn1/its/CPM-PerceptionRegionContainer.asn @@ -0,0 +1,29 @@ +CPM-PerceptionRegionContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) perceptionRegionContainer (5) major-version-1 (1) minor-version-1(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +CardinalNumber1B, DeltaTimeMilliSecondSigned, Identifier2B, Shape, ConfidenceLevel, SensorType, SequenceOfIdentifier1B +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1)} +; + + +PerceptionRegionContainer ::= SEQUENCE SIZE(1..256, ...) OF PerceptionRegion + +PerceptionRegion ::= SEQUENCE { + measurementDeltaTime DeltaTimeMilliSecondSigned, + perceptionRegionConfidence ConfidenceLevel, + perceptionRegionShape Shape, + shadowingApplies BOOLEAN, + sensorIdList SequenceOfIdentifier1B OPTIONAL, + numberOfPerceivedObjects CardinalNumber1B OPTIONAL, + perceivedObjectIds PerceivedObjectIds OPTIONAL, + ... +} + +PerceivedObjectIds::= SEQUENCE SIZE(0..255, ...) OF Identifier2B + +END diff --git a/epan/dissectors/asn1/its/CPM-SensorInformationContainer.asn b/epan/dissectors/asn1/its/CPM-SensorInformationContainer.asn new file mode 100644 index 00000000..b41bfff8 --- /dev/null +++ b/epan/dissectors/asn1/its/CPM-SensorInformationContainer.asn @@ -0,0 +1,26 @@ +CPM-SensorInformationContainer {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (103324) sensorInformationContainer (3) major-version-1 (1) minor-version-1(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +Shape, ConfidenceLevel, Identifier1B, SensorType +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1) } +; + +SensorInformationContainer ::= SEQUENCE SIZE(1..128, ...) OF SensorInformation + + +SensorInformation ::= SEQUENCE { + sensorId Identifier1B, + sensorType SensorType, + perceptionRegionShape Shape OPTIONAL, + perceptionRegionConfidence ConfidenceLevel OPTIONAL, + shadowingApplies BOOLEAN, + ... +} + + +END diff --git a/epan/dissectors/asn1/its/DENM-PDU-Descriptions.asn b/epan/dissectors/asn1/its/DENM-PDU-Descriptions.asn new file mode 100644 index 00000000..98994902 --- /dev/null +++ b/epan/dissectors/asn1/its/DENM-PDU-Descriptions.asn @@ -0,0 +1,113 @@ +-- https://forge.etsi.org/rep/ITS/asn1/denm_ts103831/-/blob/release2/DENM-PDU-Descriptions.asn +-- +DENM-PDU-Description {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) denmPduRelease2 (103831) major-version-2 (2) minor-version-1 (1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +ActionId, ActionIdList, CauseCodeV2, ClosedLanes, DangerousGoodsExtended, DeltaReferencePosition, DeltaTimeMilliSecondPositive, DeltaTimeSecond, +EnergyStorageType, EventZone, HeightLonCarr, InformationQuality, ItsPduHeader, LanePosition, LightBarSirenInUse, ItineraryPath, NumberOfOccupants, +PosLonCarr, PosCentMass, PositionOfPillars, PositioningSolutionType, PosFrontAx, PositionOfOccupants, RequestResponseIndication, ReferencePosition, +RestrictedTypes, RoadType, StandardLength3b, StationType, Speed, SpeedLimit, StationarySince, TimestampIts, Traces, +TrafficDirection, TrafficRule, TurningRadius, Temperature, VehicleMass, VehicleIdentification, Wgs84Angle, WheelBaseVehicle + +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) major-version-3 (3) minor-version-1 (1)} +; + + +DENM ::= SEQUENCE { + header ItsPduHeader (WITH COMPONENTS {... , protocolVersion (2), messageId(denm)}), + denm DenmPayload +} + +DenmPayload ::= SEQUENCE { + management ManagementContainer, + situation SituationContainer OPTIONAL, + location LocationContainer OPTIONAL, + alacarte AlacarteContainer OPTIONAL +} + +ManagementContainer ::= SEQUENCE { + actionId ActionId, + detectionTime TimestampIts, + referenceTime TimestampIts, + termination Termination OPTIONAL, + eventPosition ReferencePosition, + awarenessDistance StandardLength3b OPTIONAL, + awarenessTrafficDirection TrafficDirection OPTIONAL, + validityDuration DeltaTimeSecond DEFAULT defaultValidity, + transmissionInterval DeltaTimeMilliSecondPositive OPTIONAL, + stationType StationType, + ... +} + +SituationContainer ::= SEQUENCE { + informationQuality InformationQuality, + eventType CauseCodeV2, + linkedCause CauseCodeV2 OPTIONAL, + eventZone EventZone OPTIONAL, + ... +} + +LocationContainer ::= SEQUENCE { + eventSpeed Speed OPTIONAL, + eventPositionHeading Wgs84Angle OPTIONAL, + traces Traces, + roadType RoadType OPTIONAL, + ... +} + +ImpactReductionContainer ::= SEQUENCE { + heightLonCarrLeft HeightLonCarr, + heightLonCarrRight HeightLonCarr, + posLonCarrLeft PosLonCarr, + posLonCarrRight PosLonCarr, + positionOfPillars PositionOfPillars, + posCentMass PosCentMass, + wheelBaseVehicle WheelBaseVehicle, + turningRadius TurningRadius, + posFrontAx PosFrontAx, + positionOfOccupants PositionOfOccupants, + vehicleMass VehicleMass, + requestResponseIndication RequestResponseIndication +} + +RoadWorksContainerExtended ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse OPTIONAL, + closedLanes ClosedLanes OPTIONAL, + restriction RestrictedTypes OPTIONAL, + speedLimit SpeedLimit OPTIONAL, + incidentIndication CauseCodeV2 OPTIONAL, + recommendedPath ItineraryPath OPTIONAL, + startingPointSpeedLimit DeltaReferencePosition OPTIONAL, + trafficFlowRule TrafficRule OPTIONAL, + referenceDenms ActionIdList OPTIONAL + } + +StationaryVehicleContainer ::= SEQUENCE { + stationarySince StationarySince OPTIONAL, + stationaryCause CauseCodeV2 OPTIONAL, + carryingDangerousGoods DangerousGoodsExtended OPTIONAL, + numberOfOccupants NumberOfOccupants OPTIONAL, + vehicleIdentification VehicleIdentification OPTIONAL, + energyStorageType EnergyStorageType OPTIONAL +} + +AlacarteContainer ::= SEQUENCE { + lanePosition LanePosition OPTIONAL, + impactReduction ImpactReductionContainer OPTIONAL, + externalTemperature Temperature OPTIONAL, + roadWorks RoadWorksContainerExtended OPTIONAL, + positioningSolution PositioningSolutionType OPTIONAL, + stationaryVehicle StationaryVehicleContainer OPTIONAL, + ... +} + +defaultValidity INTEGER ::= 600 + +Termination ::= ENUMERATED {isCancellation(0), isNegation (1)} + +END diff --git a/epan/dissectors/asn1/its/DENM.asn b/epan/dissectors/asn1/its/DENM.asn new file mode 100644 index 00000000..4c00ae09 --- /dev/null +++ b/epan/dissectors/asn1/its/DENM.asn @@ -0,0 +1,104 @@ +-- +-- https://www.etsi.org/deliver/etsi_en/302600_302699/30263703/01.03.00_20/en_30263703v010300a.pdf +DENMv1-PDU-Descriptions {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en +(302637) denm (1) version (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + BEGIN + IMPORTS + -- Wireshark modification + CauseCode, + ItsPduHeader, Speed, InformationQuality, ReferencePosition, ClosedLanes, + DangerousGoodsExtended, Heading, LanePosition, LightBarSirenInUse, RoadType, HeightLonCarr, + PosLonCarr, PosCentMass, PositioningSolutionType, RequestResponseIndication, StationType, + SpeedLimit, StationarySince, TimestampIts, WheelBaseVehicle, TurningRadius, PosFrontAx, + PositionOfOccupants, Temperature, VehicleMass, VehicleIdentification, EnergyStorageType, ActionID, + ItineraryPath, NumberOfOccupants, PositionOfPillars, RelevanceTrafficDirection, RestrictedTypes, + Traces, TransmissionInterval, ValidityDuration, RelevanceDistance, EventHistory, TrafficRule, + DeltaReferencePosition + FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + ; + + DENM ::= SEQUENCE { + header ItsPduHeader, + denm DecentralizedEnvironmentalNotificationMessage + } + DecentralizedEnvironmentalNotificationMessage ::= SEQUENCE { + management ManagementContainer, + situation SituationContainer OPTIONAL, + location LocationContainer OPTIONAL, + alacarte AlacarteContainer OPTIONAL + } + ManagementContainer ::= SEQUENCE { + actionID ActionID, + detectionTime TimestampIts, + referenceTime TimestampIts, + termination Termination OPTIONAL, + eventPosition ReferencePosition, + relevanceDistance RelevanceDistance OPTIONAL, + relevanceTrafficDirection RelevanceTrafficDirection OPTIONAL, + validityDuration ValidityDuration DEFAULT defaultValidity, + transmissionInterval TransmissionInterval OPTIONAL, + stationType StationType, + ... + } + SituationContainer ::= SEQUENCE { + informationQuality InformationQuality, + eventType CauseCode, + linkedCause CauseCode OPTIONAL, + eventHistory EventHistory OPTIONAL, + ... + } + LocationContainer ::= SEQUENCE { + eventSpeed Speed OPTIONAL, + eventPositionHeading Heading OPTIONAL, + traces Traces, + roadType RoadType OPTIONAL, + ... + } + ImpactReductionContainer ::= SEQUENCE { + heightLonCarrLeft HeightLonCarr, + heightLonCarrRight HeightLonCarr, + posLonCarrLeft PosLonCarr, + posLonCarrRight PosLonCarr, + positionOfPillars PositionOfPillars, + posCentMass PosCentMass, + wheelBaseVehicle WheelBaseVehicle, + turningRadius TurningRadius, + posFrontAx PosFrontAx, + positionOfOccupants PositionOfOccupants, + vehicleMass VehicleMass, + requestResponseIndication RequestResponseIndication + } + RoadWorksContainerExtended ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse OPTIONAL, + closedLanes ClosedLanes OPTIONAL, + restriction RestrictedTypes OPTIONAL, + speedLimit SpeedLimit OPTIONAL, + incidentIndication CauseCode OPTIONAL, + recommendedPath ItineraryPath OPTIONAL, + startingPointSpeedLimit DeltaReferencePosition OPTIONAL, + trafficFlowRule TrafficRule OPTIONAL, + referenceDenms ReferenceDenms OPTIONAL + } + StationaryVehicleContainer ::= SEQUENCE { + stationarySince StationarySince OPTIONAL, + stationaryCause CauseCode OPTIONAL, + carryingDangerousGoods DangerousGoodsExtended OPTIONAL, + numberOfOccupants NumberOfOccupants OPTIONAL, + vehicleIdentification VehicleIdentification OPTIONAL, + energyStorageType EnergyStorageType OPTIONAL + } + AlacarteContainer ::= SEQUENCE { + lanePosition LanePosition OPTIONAL, + impactReduction ImpactReductionContainer OPTIONAL, + externalTemperature Temperature OPTIONAL, + roadWorks RoadWorksContainerExtended OPTIONAL, + positioningSolution PositioningSolutionType OPTIONAL, + stationaryVehicle StationaryVehicleContainer OPTIONAL, + ... + } + defaultValidity INTEGER ::= 600 + Termination ::= ENUMERATED {isCancellation(0), isNegation (1)} + ReferenceDenms ::= SEQUENCE (SIZE(1..8, ...)) OF ActionID +END diff --git a/epan/dissectors/asn1/its/DENMv1.asn b/epan/dissectors/asn1/its/DENMv1.asn new file mode 100644 index 00000000..b329c1e8 --- /dev/null +++ b/epan/dissectors/asn1/its/DENMv1.asn @@ -0,0 +1,113 @@ +DENMv1-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (302637) denm (1) version (1) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS +ItsPduHeader, CauseCode, Speed, InformationQuality, ReferencePosition, ClosedLanes, DangerousGoodsExtended, Heading, LanePosition, LightBarSirenInUse, RoadType, HeightLonCarr, +PosLonCarr, PosCentMass, PositioningSolutionType, RequestResponseIndication, StationType, SpeedLimit, StationarySince, TimestampIts, WheelBaseVehicle, TurningRadius, PosFrontAx, +PositionOfOccupants, Temperature, VehicleMass, VehicleIdentification, EnergyStorageType, ActionID, ItineraryPath, NumberOfOccupants, PositionOfPillars, RelevanceTrafficDirection, +RestrictedTypes, Traces, TransmissionInterval, ValidityDuration, RelevanceDistance, EventHistory, TrafficRule, DeltaReferencePosition +FROM ITS-ContainerV1 { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (1) +}; + + +DENMv1 ::= SEQUENCE { + header ItsPduHeader, + denm DecentralizedEnvironmentalNotificationMessageV1 +} + +DecentralizedEnvironmentalNotificationMessageV1 ::= SEQUENCE { + management ManagementContainer, + situation SituationContainer OPTIONAL, + location LocationContainer OPTIONAL, + alacarte AlacarteContainer OPTIONAL +} + +ManagementContainer ::= SEQUENCE { + actionID ActionID, + detectionTime TimestampIts, + referenceTime TimestampIts, + termination Termination OPTIONAL, + eventPosition ReferencePosition, + relevanceDistance RelevanceDistance OPTIONAL, + relevanceTrafficDirection RelevanceTrafficDirection OPTIONAL, + validityDuration ValidityDuration DEFAULT defaultValidity, + transmissionInterval TransmissionInterval OPTIONAL, + stationType StationType, + ... +} + +SituationContainer ::= SEQUENCE { + informationQuality InformationQuality, + eventType CauseCode, + linkedCause CauseCode OPTIONAL, + eventHistory EventHistory OPTIONAL, + ... +} + +LocationContainer ::= SEQUENCE { + eventSpeed Speed OPTIONAL, + eventPositionHeading Heading OPTIONAL, + traces Traces, + roadType RoadType OPTIONAL, + ... +} + +ImpactReductionContainer ::= SEQUENCE { + heightLonCarrLeft HeightLonCarr, + heightLonCarrRight HeightLonCarr, + posLonCarrLeft PosLonCarr, + posLonCarrRight PosLonCarr, + positionOfPillars PositionOfPillars, + posCentMass PosCentMass, + wheelBaseVehicle WheelBaseVehicle, + turningRadius TurningRadius, + posFrontAx PosFrontAx, + positionOfOccupants PositionOfOccupants, + vehicleMass VehicleMass, + requestResponseIndication RequestResponseIndication +} + +RoadWorksContainerExtended ::= SEQUENCE { + lightBarSirenInUse LightBarSirenInUse OPTIONAL, + closedLanes ClosedLanes OPTIONAL, + restriction RestrictedTypes OPTIONAL, + speedLimit SpeedLimit OPTIONAL, + incidentIndication CauseCode OPTIONAL, + recommendedPath ItineraryPath OPTIONAL, + startingPointSpeedLimit DeltaReferencePosition OPTIONAL, + trafficFlowRule TrafficRule OPTIONAL, + referenceDenms ReferenceDenms OPTIONAL + } + +StationaryVehicleContainer ::= SEQUENCE { + stationarySince StationarySince OPTIONAL, + stationaryCause CauseCode OPTIONAL, + carryingDangerousGoods DangerousGoodsExtended OPTIONAL, + numberOfOccupants NumberOfOccupants OPTIONAL, + vehicleIdentification VehicleIdentification OPTIONAL, + energyStorageType EnergyStorageType OPTIONAL +} + +AlacarteContainer ::= SEQUENCE { + lanePosition LanePosition OPTIONAL, + impactReduction ImpactReductionContainer OPTIONAL, + externalTemperature Temperature OPTIONAL, + roadWorks RoadWorksContainerExtended OPTIONAL, + positioningSolution PositioningSolutionType OPTIONAL, + stationaryVehicle StationaryVehicleContainer OPTIONAL, + ... +} + +defaultValidity INTEGER ::= 600 + +Termination ::= ENUMERATED {isCancellation(0), isNegation (1)} + +ReferenceDenms ::= SEQUENCE (SIZE(1..8, ...)) OF ActionID + +END diff --git a/epan/dissectors/asn1/its/ETSI-ITS-CDD.asn b/epan/dissectors/asn1/its/ETSI-ITS-CDD.asn new file mode 100644 index 00000000..63050676 --- /dev/null +++ b/epan/dissectors/asn1/its/ETSI-ITS-CDD.asn @@ -0,0 +1,2133 @@ +--! @options: no-fields-header + +ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +------------------------------------------ +-- Specification of CDD Data Elements: +------------------------------------------ + +AccelerationChange::= ENUMERATED { + accelerate (0), + decelerate (1) +} + +AccelerationConfidence ::= INTEGER { + outOfRange (101), + unavailable (102) +} (0..102) + +AccelerationControl ::= BIT STRING { + brakePedalEngaged (0), + gasPedalEngaged (1), + emergencyBrakeEngaged (2), + collisionWarningEngaged (3), + accEngaged (4), + cruiseControlEngaged (5), + speedLimiterEngaged (6) +} (SIZE(7)) + +AccelerationMagnitudeValue ::= INTEGER { + positiveOutOfRange (160), + unavailable (161) +} (0.. 161) + + +AccelerationValue ::= INTEGER { + negativeOutOfRange (-160), + positiveOutOfRange (160), + unavailable (161) +} (-160 .. 161) + + +AccessTechnologyClass ::= ENUMERATED { + any (0), + itsg5Class (1), + ltev2xClass (2), + nrv2xClass (3), + ... +} + +AccidentSubCauseCode ::= INTEGER { + unavailable (0), + multiVehicleAccident (1), + heavyAccident (2), + accidentInvolvingLorry (3), + accidentInvolvingBus (4), + accidentInvolvingHazardousMaterials (5), + accidentOnOppositeLane (6), + unsecuredAccident (7), + assistanceRequested (8) +} (0..255) + +AdverseWeatherCondition-AdhesionSubCauseCode ::= INTEGER { + unavailable (0), + heavyFrostOnRoad (1), + fuelOnRoad (2), + mudOnRoad (3), + snowOnRoad (4), + iceOnRoad (5), + blackIceOnRoad (6), + oilOnRoad (7), + looseChippings (8), + instantBlackIce (9), + roadsSalted (10) +} (0..255) + +AdverseWeatherCondition-ExtremeWeatherConditionSubCauseCode ::= INTEGER { + unavailable (0), + strongWinds (1), + damagingHail (2), + hurricane (3), + thunderstorm (4), + tornado (5), + blizzard (6) +} (0..255) + +AdverseWeatherCondition-PrecipitationSubCauseCode ::= INTEGER { + unavailable (0), + heavyRain (1), + heavySnowfall (2), + softHail (3) +} (0..255) + +AdverseWeatherCondition-VisibilitySubCauseCode ::= INTEGER { + unavailable (0), + fog (1), + smoke (2), + heavySnowfall (3), + heavyRain (4), + heavyHail (5), + lowSunGlare (6), + sandstorms (7), + swarmsOfInsects (8) +} (0..255) + +AirHumidity ::= INTEGER { + oneHundredPercent (1000), + unavailable (1001) +} (1..1001) + + +AltitudeConfidence ::= ENUMERATED { + alt-000-01 (0), + alt-000-02 (1), + alt-000-05 (2), + alt-000-10 (3), + alt-000-20 (4), + alt-000-50 (5), + alt-001-00 (6), + alt-002-00 (7), + alt-005-00 (8), + alt-010-00 (9), + alt-020-00 (10), + alt-050-00 (11), + alt-100-00 (12), + alt-200-00 (13), + outOfRange (14), + unavailable (15) +} + +AltitudeValue ::= INTEGER { + negativeOutOfRange (-100000), + postiveOutOfRange (800000), + unavailable (800001) +} (-100000..800001) + +AngleConfidence ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +AngularSpeedConfidence ::= ENUMERATED { + degSec-01 (0), + degSec-02 (1), + degSec-05 (2), + degSec-10 (3), + degSec-20 (4), + degSec-50 (5), + outOfRange (6), + unavailable (7) +} + +AngularAccelerationConfidence ::= ENUMERATED { + degSecSquared-01 (0), + degSecSquared-02 (1), + degSecSquared-05 (2), + degSecSquared-10 (3), + degSecSquared-20 (4), + degSecSquared-50 (5), + outOfRange (6), + unavailable (7) +} + +AxlesCount ::= INTEGER{ + outOfRange (1001), + unavailable (1002) +} (2..1002) + +BarometricPressure ::= INTEGER{ + outOfRangelower (2999), + outOfRangeUpper (12001), + unavailable (12002) +} (2999..12002) + +BogiesCount ::= INTEGER{ + outOfRange (100), + unavailable (101) +} (2..101) + + +CardinalNumber1B ::= INTEGER(0..255) + +CardinalNumber3b ::= INTEGER(1..8) + +CartesianAngleValue ::= INTEGER { + valueNotUsed (3600), + unavailable (3601) +} (0..3601) + +CartesianAngularAccelerationComponentValue ::= INTEGER { + negativeOutOfRange (-255), + positiveOutOfRange (255), + unavailable (256) +} (-255..256) + +CartesianAngularVelocityComponentValue ::= INTEGER { + negativeOutofRange (-255), + positiveOutOfRange (255), + unavailable (256) +} (-255..256) + + +CauseCodeType ::= INTEGER { + reserved (0), + trafficCondition (1), + accident (2), + roadworks (3), + impassability (5), + adverseWeatherCondition-Adhesion (6), + aquaplaning (7), + hazardousLocation-SurfaceCondition (9), + hazardousLocation-ObstacleOnTheRoad (10), + hazardousLocation-AnimalOnTheRoad (11), + humanPresenceOnTheRoad (12), + wrongWayDriving (14), + rescueAndRecoveryWorkInProgress (15), + adverseWeatherCondition-ExtremeWeatherCondition (17), + adverseWeatherCondition-Visibility (18), + adverseWeatherCondition-Precipitation (19), + violence (20), + slowVehicle (26), + dangerousEndOfQueue (27), + vehicleBreakdown (91), + postCrash (92), + humanProblem (93), + stationaryVehicle (94), + emergencyVehicleApproaching (95), + hazardousLocation-DangerousCurve (96), + collisionRisk (97), + signalViolation (98), + dangerousSituation (99), + railwayLevelCrossing (100) +} (0..255) + +CartesianCoordinateSmall::= INTEGER { + negativeOutOfRange (-3094), + positiveOutOfRange (1001) +} (-3094..1001) + +CartesianCoordinate::= INTEGER{ + negativeOutOfRange (-32768), + positiveOutOfRange (32767) +} (-32768..32767) + +CartesianCoordinateLarge::= INTEGER{ + negativeOutOfRange (-131072), + positiveOutOfRange (131071) +} (-131072..131071) + +--CenDsrcTollingZoneID::= ProtectedZoneId + +ClusterBreakupReason ::= ENUMERATED { + notProvided (0), + clusteringPurposeCompleted (1), + leaderMovedOutOfClusterBoundingBox (2), + joiningAnotherCluster (3), + enteringLowRiskAreaBasedOnMaps (4), + receptionOfCpmContainingCluster (5), + max(15) +} + +ClusterLeaveReason ::= ENUMERATED { + notProvided (0), + clusterLeaderLost (1), + clusterDisbandedByLeader (2), + outOfClusterBoundingBox (3), + outOfClusterSpeedRange (4), + joiningAnotherCluster (5), + cancelledJoin (6), + failedJoin (7), + safetyCondition (8), + max(15) +} + +CollisionRiskSubCauseCode ::= INTEGER { + unavailable (0), + longitudinalCollisionRisk (1), + crossingCollisionRisk (2), + lateralCollisionRisk (3), + vulnerableRoadUser (4) +}(0..255) + +ConfidenceLevel ::= INTEGER { + unavailable (101) +} (1..101) + +CoordinateConfidence ::= INTEGER { + outOfRange (4095), + unavailable (4096) +} (1..4096) + + +CorrelationCellValue ::= INTEGER { + full-negative-correlation (-100), + no-correlation (0), + full-positive-correlation (100), + unavailable (101) +} (-100..101) + +CurvatureCalculationMode ::= ENUMERATED { + yawRateUsed (0), + yawRateNotUsed (1), + unavailable (2), + ... +} + +CurvatureConfidence ::= ENUMERATED { + onePerMeter-0-00002 (0), + onePerMeter-0-0001 (1), + onePerMeter-0-0005 (2), + onePerMeter-0-002 (3), + onePerMeter-0-01 (4), + onePerMeter-0-1 (5), + outOfRange (6), + unavailable (7) +} + +CurvatureValue ::= INTEGER { + outOfRangeNegative (-1023), + straight (0), + outOfRangePositive (1022), + unavailable (1023) +} (-1023..1023) + +DangerousEndOfQueueSubCauseCode ::= INTEGER { + unavailable (0), + suddenEndOfQueue (1), + queueOverHill (2), + queueAroundBend (3), + queueInTunnel (4) +} (0..255) + +DangerousGoodsBasic::= ENUMERATED { + explosives1 (0), + explosives2 (1), + explosives3 (2), + explosives4 (3), + explosives5 (4), + explosives6 (5), + flammableGases (6), + nonFlammableGases (7), + toxicGases (8), + flammableLiquids (9), + flammableSolids (10), + substancesLiableToSpontaneousCombustion (11), + substancesEmittingFlammableGasesUponContactWithWater (12), + oxidizingSubstances (13), + organicPeroxides (14), + toxicSubstances (15), + infectiousSubstances (16), + radioactiveMaterial (17), + corrosiveSubstances (18), + miscellaneousDangerousSubstances (19) +} + +DangerousSituationSubCauseCode ::= INTEGER { + unavailable (0), + emergencyElectronicBrakeEngaged (1), + preCrashSystemEngaged (2), + espEngaged (3), + absEngaged (4), + ebEngaged (5), + brakeWarningEngaged (6), + collisionRiskWarningEngaged (7) +} (0..255) + +DeltaAltitude ::= INTEGER { + negativeOutOfRange (-12700), + positiveOutOfRange (12799), + unavailable (12800) +} (-12700..12800) + +DeltaLatitude ::= INTEGER { + unavailable (131072) +} (-131071..131072) + +DeltaLongitude ::= INTEGER { + unavailable (131072) +} (-131071..131072) + +DeltaTimeMilliSecondPositive ::= INTEGER (1..10000) + +DeltaTimeMilliSecondSigned ::= INTEGER (-2048..2047) + +DeltaTimeQuarterSecond::= INTEGER { + unavailable (255) +} (1..255) + +DeltaTimeTenthOfSecond::= INTEGER { + unavailable (127) +} (0..127) + +DeltaTimeSecond ::= INTEGER (0..86400) + +-- Exists in IVI {iso (1) standard (0) ivi (19321) version2 (2) +--Direction::= INTEGER{ +-- sameDirection (0), +-- oppositeDirection (1), +-- bothDirections (2), +-- unavailable (3) +-- } (0..3) + +DriveDirection ::= ENUMERATED { + forward (0), + backward (1), + unavailable (2) +} + +DrivingLaneStatus ::= BIT STRING (SIZE (1..13)) + +EmbarkationStatus ::= BOOLEAN + +EmergencyPriority ::= BIT STRING { + requestForRightOfWay (0), + requestForFreeCrossingAtATrafficLight (1) +} (SIZE(2)) + +EmergencyVehicleApproachingSubCauseCode ::= INTEGER { + unavailable (0), + emergencyVehicleApproaching (1), + prioritizedVehicleApproaching (2) +} (0..255) + +EnergyStorageType ::= BIT STRING { + hydrogenStorage (0), + electricEnergyStorage (1), + liquidPropaneGas (2), + compressedNaturalGas (3), + diesel (4), + gasoline (5), + ammonia (6) +}(SIZE(7)) + +EuVehicleCategoryL ::= ENUMERATED { l1, l2, l3, l4, l5, l6, l7 } + +EuVehicleCategoryM ::= ENUMERATED {m1, m2, m3} + +EuVehicleCategoryN ::= ENUMERATED {n1, n2, n3} + +EuVehicleCategoryO ::= ENUMERATED {o1, o2, o3, o4} + +ExteriorLights ::= BIT STRING { + lowBeamHeadlightsOn (0), + highBeamHeadlightsOn (1), + leftTurnSignalOn (2), + rightTurnSignalOn (3), + daytimeRunningLightsOn (4), + reverseLightOn (5), + fogLightOn (6), + parkingLightsOn (7) +} (SIZE(8)) + +GenerationDeltaTime ::= INTEGER { oneMilliSec(1) } (0..65535) + +HardShoulderStatus ::= ENUMERATED { + availableForStopping (0), + closed (1), + availableForDriving (2) +} + +HazardousLocation-AnimalOnTheRoadSubCauseCode ::= INTEGER { + unavailable (0), + wildAnimals (1), + herdOfAnimals (2), + smallAnimals (3), + largeAnimals (4) +} (0..255) + +HazardousLocation-DangerousCurveSubCauseCode ::= INTEGER { + unavailable (0), + dangerousLeftTurnCurve (1), + dangerousRightTurnCurve (2), + multipleCurvesStartingWithUnknownTurningDirection (3), + multipleCurvesStartingWithLeftTurn (4), + multipleCurvesStartingWithRightTurn (5) +} (0..255) + +HazardousLocation-ObstacleOnTheRoadSubCauseCode ::= INTEGER { + unavailable (0), + shedLoad (1), + partsOfVehicles (2), + partsOfTyres (3), + bigObjects (4), + fallenTrees (5), + hubCaps (6), + waitingVehicles (7) +} (0..255) + +HazardousLocation-SurfaceConditionSubCauseCode ::= INTEGER { + unavailable (0), + rockfalls (1), + earthquakeDamage (2), + sewerCollapse (3), + subsidence (4), + snowDrifts (5), + stormDamage (6), + burstPipe (7), + volcanoEruption (8), + fallingIce (9), + fire (10) +} (0..255) + +HeadingConfidence ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +HeadingValue ::= INTEGER { + wgs84North (0), + wgs84East (900), + wgs84South (1800), + wgs84West (2700), + doNotUse (3600), + unavailable (3601) +} (0..3601) + +HeightLonCarr ::= INTEGER { + outOfRange(99), + unavailable(100) +} (1..100) + +HumanPresenceOnTheRoadSubCauseCode ::= INTEGER { + unavailable (0), + childrenOnRoadway (1), + cyclistOnRoadway (2), + motorcyclistOnRoadway (3) +} (0..255) + +HumanProblemSubCauseCode ::= INTEGER { + unavailable (0), + glycemiaProblem (1), + heartProblem (2) +} (0..255) + +Identifier1B ::= INTEGER (0..255) + +Identifier2B ::= INTEGER (0..65535) + +InformationQuality ::= INTEGER (0..7) + +InterferenceManagementZoneType ::= ENUMERATED { + permanentCenDsrcTolling (0), + temporaryCenDsrcTolling (1), + unavailable (2), + urbanRail (3), + satelliteStation (4), + fixedLinks (5), + ... +} + +Iso3833VehicleType ::= INTEGER { + passengerCar (0), + saloon (1), + convertibleSaloon (2), + pullmanSaloon (3), + stationWagon (4), + truckStationWagon (5), + coupe (6), + convertible (7), + multipurposePassengerCar (8), + forwardControlPassengerCar (9), + specialPassengerCar (10), + bus (11), + minibus (12), + urbanBus (13), + interurbanCoach (14), + longDistanceCoach (15), + articulatedBus (16), + trolleyBus (17), + specialBus (18), + commercialVehicle (19), + specialCommercialVehicle (20), + specialVehicle (21), + trailingTowingVehicle (22), + semiTrailerTowingVehicle (23), + trailer (24), + busTrailer (25), + generalPurposeTrailer (26), + caravan (27), + specialTrailer (28), + semiTrailer (29), + busSemiTrailer (30), + generalPurposeSemiTrailer (31), + specialSemiTrailer (32), + roadTrain (33), + passengerRoadTrain (34), + articulatedRoadTrain (35), + doubleRoadTrain (36), + compositeRoadTrain (37), + specialRoadTrain (38), + moped (39), + motorCycle (40) + } (0..255) + +LanePosition ::= INTEGER { + offTheRoad (-1), + innerHardShoulder (0), + outerHardShoulder (14) +} (-1..14) + +LaneType::= INTEGER{ + traffic (0), + through (1), + reversible (2), + acceleration (3), + deceleration (4), + leftHandTurning (5), + rightHandTurning (6), + dedicatedVehicle (7), + bus (8), + taxi (9), + hov (10), + hot (11), + pedestrian (12), + cycleLane (13), + median (14), + striping (15), + trackedVehicle (16), + parking (17), + emergency (18), + verge (19), + minimumRiskManoeuvre (20), + unknown (31) +}(0..31) + +--LaneWidth::= INTEGER (0..1023) + +Latitude ::= INTEGER { + unavailable(900000001) +} (-900000000..900000001) + +LateralAccelerationValue ::= INTEGER { + negativeOutOfRange (-160), + positiveOutOfRange (160), + unavailable (161) +} (-160 .. 161) + +LightBarSirenInUse ::= BIT STRING { + lightBarActivated (0), + sirenActivated (1) +} (SIZE(2)) + +Longitude ::= INTEGER { + valueNotUsed (-1800000000), + unavailable (1800000001) +} (-1800000000..1800000001) + +LongitudinalAccelerationValue::= INTEGER { + negativeOutOfRange (-160), + positiveOutOfRange (160), + unavailable (161) +} (-160 .. 161) + +LongitudinalLanePositionValue ::= INTEGER { + outOfRange(32766), + unavailable(32767) +}(0..32767) + +LongitudinalLanePositionConfidence ::= INTEGER { + outOfRange (1022), + unavailable (1023) +} (0..1023) + +MatrixIncludedComponents::= BIT STRING{ + xPosition (0), + yPosition (1), + zPosition (2), + xVelocityOrVelocityMagnitude (3), + yVelocityOrVelocityDirection (4), + zSpeed (5), + xAccelOrAccelMagnitude (6), + yAccelOrAccelDirection (7), + zAcceleration (8), + zAngle (9), + yAngle (10), + xAngle (11), + zAngularVelocity (12) +} (SIZE(13,...)) + +MessageId::= INTEGER { + denm (1), + cam (2), + poi (3), + spatem (4), + mapem (5), + ivim (6), + ev-rsr (7), + tistpgtransaction (8), + srem (9), + ssem (10), + evcsn (11), + saem (12), + rtcmem (13), + cpm (14), + imzm (15), + vam (16), + dsm (17), + pcim (18), + pcvm (19), + mcm (20), + pam (21) +} (0..255) + +NumberOfOccupants ::= INTEGER { + outOfRange (126), + unavailable (127) +} (0 .. 127) + +ObjectPerceptionQuality ::= INTEGER { + noConfidence (0), + fullConfidence (15) +} (0..15) + +ObjectDimensionValue ::= INTEGER { + outOfRange (255), + unavailable (256) +}(1..256) + +ObjectDimensionConfidence ::= INTEGER { + outOfRange (31), + unavailable (32) +} (1..32) + +ObjectFace ::= ENUMERATED { + front (0), + sideLeftFront (1), + sideLeftBack (2), + sideRightFront (3), + sideRightBack (4), + back (5) +} + +OpeningDaysHours ::= UTF8String + +--OrdinalNumber1B ::= INTEGER(0..255) + + +OrdinalNumber3b ::= INTEGER(1..8) + +OtherSubClass ::= INTEGER { + unknown (0), + singleObject (1), + multipleObjects (2), + bulkMaterial (3) +} (0..255) + +PathDeltaTime ::= INTEGER (1..65535, ...) + +PerformanceClass ::= INTEGER { + unavailable (0), + performanceClassA (1), + performanceClassB (2) +} (0..7) + +PhoneNumber ::= NumericString (SIZE(1..16)) + +PosCentMass ::= INTEGER { + tenCentimetres (1), + outOfRange (62), + unavailable (63) +} (1..63) + +PositioningSolutionType ::= ENUMERATED { + noPositioningSolution (0), + sGNSS (1), + dGNSS (2), + sGNSSplusDR (3), + dGNSSplusDR (4), + dR (5), + ... +} + +PositionOfOccupants ::= BIT STRING { + row1LeftOccupied (0), + row1RightOccupied (1), + row1MidOccupied (2), + row1NotDetectable (3), + row1NotPresent (4), + row2LeftOccupied (5), + row2RightOccupied (6), + row2MidOccupied (7), + row2NotDetectable (8), + row2NotPresent (9), + row3LeftOccupied (10), + row3RightOccupied (11), + row3MidOccupied (12), + row3NotDetectable (13), + row3NotPresent (14), + row4LeftOccupied (15), + row4RightOccupied (16), + row4MidOccupied (17), + row4NotDetectable (18), + row4NotPresent (19) +} (SIZE(20)) + +PosFrontAx ::= INTEGER { + outOfRange (19), + unavailable(20) +} (1..20) + +PosLonCarr ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +PosPillar ::= INTEGER { + outOfRange (29), + unavailable (30) +} (1..30) + +PostCrashSubCauseCode ::= INTEGER { + unavailable (0), + accidentWithoutECallTriggered (1), + accidentWithECallManuallyTriggered (2), + accidentWithECallAutomaticallyTriggered (3), + accidentWithECallTriggeredWithoutAccessToCellularNetwork (4) +} (0..255) + +PrecipitationIntensity ::= INTEGER { + outOfRange (2000), + unavailable (2001) +} (1..2001) + +ProtectedZoneId ::= INTEGER (0.. 134217727) + +ProtectedZoneRadius ::= INTEGER (1..255,...) + +ProtectedZoneType::= ENUMERATED { + permanentCenDsrcTolling (0), + ..., + temporaryCenDsrcTolling (1) +} + +PtActivationData ::= OCTET STRING (SIZE(1..20)) + +PtActivationType ::= INTEGER { + undefinedCodingType (0), + r09-16CodingType (1), + vdv-50149CodingType (2) +} (0..255) + +RailwayLevelCrossingSubCauseCode ::= INTEGER { + unavailable (0), + doNotCrossAbnormalSituation (1), + closed (2), + unguarded (3), + nominal (4) +} (0..255) + +--RelevanceDistance ::= ENUMERATED { +-- lessThan50m(0), +-- lessThan100m(1), +-- lessThan200m(2), +-- lessThan500m(3), +-- lessThan1000m(4), +-- lessThan5km(5), +-- lessThan10km(6), +-- over10km(7) +--} + +--RelevanceTrafficDirection ::= ENUMERATED { +-- allTrafficDirections(0), +-- upstreamTraffic(1), +-- downstreamTraffic(2), +-- oppositeTraffic(3) +--} + +RequestResponseIndication ::= ENUMERATED { + request (0), + response (1) +} + +RescueAndRecoveryWorkInProgressSubCauseCode ::= INTEGER { + unavailable (0), + emergencyVehicles (1), + rescueHelicopterLanding (2), + policeActivityOngoing (3), + medicalEmergencyOngoing (4), + childAbductionInProgress (5) +} (0..255) + + +RoadType ::= ENUMERATED { + urban-NoStructuralSeparationToOppositeLanes (0), + urban-WithStructuralSeparationToOppositeLanes (1), + nonUrban-NoStructuralSeparationToOppositeLanes (2), + nonUrban-WithStructuralSeparationToOppositeLanes (3) +} + +RoadworksSubCauseCode ::= INTEGER { + unavailable (0), + majorRoadworks (1), + roadMarkingWork (2), + slowMovingRoadMaintenance (3), + shortTermStationaryRoadworks (4), + streetCleaning (5), + winterService (6) +} (0..255) + +SafeDistanceIndicator::= BOOLEAN + +SemiAxisLength ::= INTEGER{ + doNotUse (0), + outOfRange (4094), + unavailable (4095) +} (0..4095) + +SensorType ::= INTEGER { + undefined (0), + radar (1), + lidar (2), + monovideo (3), + stereovision (4), + nightvision (5), + ultrasonic (6), + pmd (7), + inductionLoop (8), + sphericalCamera (9), + uwb (10), + acoustic (11), + localAggregation (12), + itsAggregation (13) +} (0..31) + +SequenceNumber ::= INTEGER (0..65535) + +SignalViolationSubCauseCode ::= INTEGER { + unavailable (0), + stopSignViolation (1), + trafficLightViolation (2), + turningRegulationViolation (3) +} (0..255) + +SlowVehicleSubCauseCode ::= INTEGER { + unavailable (0), + maintenanceVehicle (1), + vehiclesSlowingToLookAtAccident (2), + abnormalLoad (3), + abnormalWideLoad (4), + convoy (5), + snowplough (6), + deicing (7), + saltingVehicles (8) +} (0..255) + +SpecialTransportType ::= BIT STRING { + heavyLoad (0), + excessWidth (1), + excessLength (2), + excessHeight (3) +} (SIZE(4)) + +SpeedConfidence ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +SpeedLimit ::= INTEGER (1..255) + +SpeedValue ::= INTEGER { + standstill (0), + outOfRange (16382), + unavailable (16383) +} (0..16383) + +VelocityComponentValue ::= INTEGER { + negativeOutOfRange (-16383), + positiveOutOfRange (16382), + unavailable (16383) +} (-16383..16383) + + +StabilityLossProbability ::= INTEGER { + stable (0), + totalLossOfStability (50), + unavailable (63) +} (0..63) + +StandardLength12b::= INTEGER (0..4095) + +StandardLength3b ::= ENUMERATED { + lessThan50m (0), + lessThan100m (1), + lessThan200m (2), + lessThan500m (3), + lessThan1000m (4), + lessThan5km (5), + lessThan10km (6), + over10km (7) +} + +StandardLength9b::= INTEGER (0..511) + +StandardLength1B::= INTEGER (0..255) + +StandardLength2B::= INTEGER (0..65535) + +StationarySince ::= ENUMERATED { + lessThan1Minute (0), + lessThan2Minutes (1), + lessThan15Minutes (2), + equalOrGreater15Minutes (3) +} + +StationaryVehicleSubCauseCode ::= INTEGER { + unavailable (0), + humanProblem (1), + vehicleBreakdown (2), + postCrash (3), + publicTransportStop (4), + carryingDangerousGoods (5), + vehicleOnFire (6) +} (0..255) + +StationId ::= INTEGER(0..4294967295) + +StationID ::= INTEGER(0..4294967295) + +StationType ::= INTEGER { + unknown (0), + pedestrian (1), + cyclist (2), + moped (3), + motorcycle (4), + passengerCar (5), + bus (6), + lightTruck (7), + heavyTruck (8), + trailer (9), + specialVehicle (10), + tram (11), + lightVruVehicle (12), + animal (13), + roadSideUnit (15) +} (0..255) + +SteeringWheelAngleConfidence ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +SteeringWheelAngleValue ::= INTEGER { + negativeOutOfRange (-511), + positiveOutOfRange (511), + unavailable (512) +} (-511..512) + +SubCauseCodeType ::= INTEGER (0..255) + +Temperature ::= INTEGER { + equalOrSmallerThanMinus60Deg (-60), + equalOrGreaterThan67Deg(67)} (-60..67) + +TimestampIts ::= INTEGER (0..4398046511103) + +TrafficConditionSubCauseCode ::= INTEGER { + unavailable (0), + increasedVolumeOfTraffic (1), + trafficJamSlowlyIncreasing (2), + trafficJamIncreasing (3), + trafficJamStronglyIncreasing (4), + trafficStationary (5), + trafficJamSlightlyDecreasing (6), + trafficJamDecreasing (7), + trafficJamStronglyDecreasing (8) +} (0..255) + +TrafficDirection ::= ENUMERATED { + allTrafficDirections (0), + upstreamTraffic (1), + downstreamTraffic (2), + oppositeTraffic (3) +} + +TrafficParticipantType ::= INTEGER { + unknown (0), + pedestrian (1), + cyclist (2), + moped (3), + motorcycle (4), + passengerCar (5), + bus (6), + lightTruck (7), + heavyTruck (8), + trailer (9), + specialVehicle (10), + tram (11), + lightVruVehicle (12), + animal (13), + agricultural (14), + roadSideUnit (15) +} (0..255) + +TrafficRule ::= ENUMERATED { + noPassing (0), + noPassingForTrucks (1), + passToRight (2), + passToLeft (3), + ...} + +TrailerPresenceInformation ::= ENUMERATED { + noTrailerPresent (0), + trailerPresentWithKnownLength (1), + trailerPresentWithUnknownLength (2), + trailerPresenceIsUnknown (3), + unavailable (4) +} + +TrajectoryInterceptionProbability ::= INTEGER { + unavailable (63) +} (0..63) + +TrajectoryInterceptionConfidence ::= INTEGER { + lessthan50percent (0), + between50and70Percent (1), + between70and90Percent (2), + above90Percent (3) +} (0..3) + +--TransmissionInterval::= INTEGER (1..10000) + +TurningDirection::= ENUMERATED { + left, + right +} + +TurningRadius ::= INTEGER { + outOfRange (254), + unavailable (255) +} (1..255) + +--ValidityDuration::= INTEGER { +-- timeOfDetection(0), +-- oneSecondAfterDetection(1) +--} (0..86400) + +VDS ::= IA5String (SIZE(6)) + +VehicleBreakdownSubCauseCode ::= INTEGER { + unavailable (0), + lackOfFuel (1), + lackOfBatteryPower (2), + engineProblem (3), + transmissionProblem (4), + engineCoolingProblem (5), + brakingSystemProblem (6), + steeringProblem (7), + tyrePuncture (8), + tyrePressureProblem (9), + vehicleOnFire (10) +} (0..255) + +VehicleHeight ::= INTEGER { + outOfRange (126), + unavailable (127) +}(1..128) + +VehicleLengthConfidenceIndication ::= ENUMERATED { + noTrailerPresent (0), + trailerPresentWithKnownLength (1), + trailerPresentWithUnknownLength (2), + trailerPresenceIsUnknown (3), + unavailable (4) +} + +VehicleLengthValue ::= INTEGER { + outOfRange(1022), + unavailable(1023) +} (1..1023) + +VehicleMass ::= INTEGER { + outOfRange (1023), + unavailable(1024) +} (1..1024) + +VehicleRole ::= ENUMERATED { + default (0), + publicTransport (1), + specialTransport(2), + dangerousGoods (3), + roadWork (4), + rescue (5), + emergency (6), + safetyCar (7), + agriculture (8), + commercial (9), + military (10), + roadOperator (11), + taxi (12), + reserved1 (13), + reserved2 (14), + reserved3 (15) +} + +VehicleWidth ::= INTEGER { + outOfRange (61), + unavailable (62) +} (1..62) + +VerticalAccelerationValue ::= INTEGER { + negativeOutOfRange (-160), + positiveOutOfRange (160), + unavailable (161) +} (-160 .. 161) + +VruClusterProfiles ::= BIT STRING { + pedestrian (0), + bicyclist (1), + motorcyclist (2), + animal (3) +} (SIZE(4)) + +VruDeviceUsage ::= ENUMERATED { + unavailable (0), + other (1), + idle (2), + listeningToAudio (3), + typing (4), + calling (5), + playingGames (6), + reading (7), + viewing (8), + max (255) +} + +VruEnvironment ::= ENUMERATED { + unavailable (0), + intersectionCrossing (1), + zebraCrossing (2), + sidewalk (3), + onVehicleRoad (4), + protectedGeographicArea (5), + max (255) +} + +VruMovementControl ::= ENUMERATED { + unavailable (0), + braking (1), + hardBraking (2), + stopPedaling (3), + brakingAndStopPedaling (4), + hardBrakingAndStopPedaling (5), + noReaction (6), + max (255) +} + +VruSubProfilePedestrian ::= ENUMERATED { + unavailable (0), + ordinary-pedestrian (1), + road-worker (2), + first-responder (3), + max (15) +} + +VruSubProfileBicyclist ::= ENUMERATED { + unavailable (0), + bicyclist (1), + wheelchair-user (2), + horse-and-rider (3), + rollerskater (4), + e-scooter (5), + personal-transporter (6), + pedelec (7), + speed-pedelec (8), + max (15) +} + +VruSubProfileMotorcyclist ::= ENUMERATED { + unavailable (0), + moped (1), + motorcycle (2), + motorcycle-and-sidecar-right (3), + motorcycle-and-sidecar-left (4), + max (15) +} + +VruSubProfileAnimal ::= ENUMERATED { + unavailable (0), + wild-animal (1), + farm-animal (2), + service-animal (3), + max (15) +} + +VruSizeClass ::= ENUMERATED { + unavailable (0), + low (1), + medium (2), + high (3), + max (15) +} + +VruSpecificExteriorLights ::= BIT STRING { + unavailable (0), + backFlashLight (1), + helmetLight (2), + armLight (3), + legLight (4), + wheelLight (5) +} (SIZE(8)) + +WheelBaseVehicle ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + +Wgs84AngleConfidence ::= INTEGER { + outOfRange (126), + unavailable (127) +} (1..127) + + +Wgs84AngleValue ::= INTEGER { + wgs84North (0), + wgs84East (900), + wgs84South (1800), + wgs84West (2700), + doNotUse (3600), + unavailable (3601) +} (0..3601) + +WMInumber ::= IA5String (SIZE(1..3)) + +WrongWayDrivingSubCauseCode ::= INTEGER { + unavailable (0), + wrongLane (1), + wrongDirection (2) +} (0..255) + +YawRateConfidence ::= ENUMERATED { + degSec-000-01 (0), + degSec-000-05 (1), + degSec-000-10 (2), + degSec-001-00 (3), + degSec-005-00 (4), + degSec-010-00 (5), + degSec-100-00 (6), + outOfRange (7), + unavailable (8) +} + +YawRateValue ::= INTEGER { + negativeOutOfRange (-32766), + positiveOutOfRange (32766), + unavailable (32767) +} (-32766..32767) + +---------------------------------------- +-- Specification of CDD Data Frames: +---------------------------------------- + +Acceleration3dWithConfidence::= CHOICE { + polarAcceleration AccelerationPolarWithZ, + cartesianAcceleration AccelerationCartesian +} + +AccelerationPolarWithZ::= SEQUENCE{ + accelerationMagnitude AccelerationMagnitude, + accelerationDirection CartesianAngle, + zAcceleration AccelerationComponent OPTIONAL +} + +AccelerationCartesian::= SEQUENCE{ + xAcceleration AccelerationComponent, + yAcceleration AccelerationComponent, + zAcceleration AccelerationComponent OPTIONAL +} + +AccelerationComponent ::= SEQUENCE { + value AccelerationValue, + confidence AccelerationConfidence +} + +AccelerationChangeIndication ::= SEQUENCE { + accelOrDecel AccelerationChange, + actionDeltaTime DeltaTimeTenthOfSecond, + ... +} + +AccelerationMagnitude::= SEQUENCE { + accelerationMagnitudeValue AccelerationMagnitudeValue, + accelerationConfidence AccelerationConfidence +} + +ActionId ::= SEQUENCE { + originatingStationId StationId, + sequenceNumber SequenceNumber +} + +ActionID ::= SEQUENCE { + originatingStationId StationID, + sequenceNumber SequenceNumber +} + +ActionIdList::= SEQUENCE (SIZE(1..8, ...)) OF ActionId + +Altitude ::= SEQUENCE { + altitudeValue AltitudeValue, + altitudeConfidence AltitudeConfidence +} + +BasicContainer ::= SEQUENCE { + stationType TrafficParticipantType, + referencePosition ReferencePositionWithConfidence, + ... +} + +CartesianAngle ::= SEQUENCE { + value CartesianAngleValue, + confidence AngleConfidence +} + +CartesianAngularVelocityComponent ::= SEQUENCE { + value CartesianAngularVelocityComponentValue, + confidence AngularSpeedConfidence +} + +CartesianAngularAccelerationComponent ::= SEQUENCE { + value CartesianAngularAccelerationComponentValue, + confidence AngularAccelerationConfidence +} + +CartesianCoordinateWithConfidence ::= SEQUENCE { + value CartesianCoordinateLarge, + confidence CoordinateConfidence +} + +CartesianPosition3d::=SEQUENCE{ + xCoordinate CartesianCoordinate, + yCoordinate CartesianCoordinate, + zCoordinate CartesianCoordinate OPTIONAL +} + +CartesianPosition3dWithConfidence::= SEQUENCE{ + xCoordinate CartesianCoordinateWithConfidence, + yCoordinate CartesianCoordinateWithConfidence, + zCoordinate CartesianCoordinateWithConfidence OPTIONAL +} + +CauseCode ::= SEQUENCE { + causeCode CauseCodeType, + subCauseCode SubCauseCodeType, + ... +} + +CauseCodeChoice::= CHOICE { + reserved0 SubCauseCodeType, + trafficCondition1 TrafficConditionSubCauseCode, + accident2 AccidentSubCauseCode, + roadworks3 RoadworksSubCauseCode, + reserved4 SubCauseCodeType, + impassability5 SubCauseCodeType, + adverseWeatherCondition-Adhesion6 AdverseWeatherCondition-AdhesionSubCauseCode, + aquaplaning7 SubCauseCodeType, + reserved8 SubCauseCodeType, + hazardousLocation-SurfaceCondition9 HazardousLocation-SurfaceConditionSubCauseCode, + hazardousLocation-ObstacleOnTheRoad10 HazardousLocation-ObstacleOnTheRoadSubCauseCode, + hazardousLocation-AnimalOnTheRoad11 HazardousLocation-AnimalOnTheRoadSubCauseCode, + humanPresenceOnTheRoad12 HumanPresenceOnTheRoadSubCauseCode, + reserved13 SubCauseCodeType, + wrongWayDriving14 WrongWayDrivingSubCauseCode, + rescueAndRecoveryWorkInProgress15 RescueAndRecoveryWorkInProgressSubCauseCode, + reserved16 SubCauseCodeType, + adverseWeatherCondition-ExtremeWeatherCondition17 AdverseWeatherCondition-ExtremeWeatherConditionSubCauseCode, + adverseWeatherCondition-Visibility18 AdverseWeatherCondition-VisibilitySubCauseCode, + adverseWeatherCondition-Precipitation19 AdverseWeatherCondition-PrecipitationSubCauseCode, + violence20 SubCauseCodeType, + reserved21 SubCauseCodeType, + reserved22 SubCauseCodeType, + reserved23 SubCauseCodeType, + reserved24 SubCauseCodeType, + reserved25 SubCauseCodeType, + slowVehicle26 SlowVehicleSubCauseCode, + dangerousEndOfQueue27 DangerousEndOfQueueSubCauseCode, + reserved28 SubCauseCodeType, + reserved29 SubCauseCodeType, + reserved30 SubCauseCodeType, + reserved31 SubCauseCodeType, + reserved32 SubCauseCodeType, + reserved33 SubCauseCodeType, + reserved34 SubCauseCodeType, + reserved35 SubCauseCodeType, + reserved36 SubCauseCodeType, + reserved37 SubCauseCodeType, + reserved38 SubCauseCodeType, + reserved39 SubCauseCodeType, + reserved40 SubCauseCodeType, + reserved41 SubCauseCodeType, + reserved42 SubCauseCodeType, + reserved43 SubCauseCodeType, + reserved44 SubCauseCodeType, + reserved45 SubCauseCodeType, + reserved46 SubCauseCodeType, + reserved47 SubCauseCodeType, + reserved48 SubCauseCodeType, + reserved49 SubCauseCodeType, + reserved50 SubCauseCodeType, + reserved51 SubCauseCodeType, + reserved52 SubCauseCodeType, + reserved53 SubCauseCodeType, + reserved54 SubCauseCodeType, + reserved55 SubCauseCodeType, + reserved56 SubCauseCodeType, + reserved57 SubCauseCodeType, + reserved58 SubCauseCodeType, + reserved59 SubCauseCodeType, + reserved60 SubCauseCodeType, + reserved61 SubCauseCodeType, + reserved62 SubCauseCodeType, + reserved63 SubCauseCodeType, + reserved64 SubCauseCodeType, + reserved65 SubCauseCodeType, + reserved66 SubCauseCodeType, + reserved67 SubCauseCodeType, + reserved68 SubCauseCodeType, + reserved69 SubCauseCodeType, + reserved70 SubCauseCodeType, + reserved71 SubCauseCodeType, + reserved72 SubCauseCodeType, + reserved73 SubCauseCodeType, + reserved74 SubCauseCodeType, + reserved75 SubCauseCodeType, + reserved76 SubCauseCodeType, + reserved77 SubCauseCodeType, + reserved78 SubCauseCodeType, + reserved79 SubCauseCodeType, + reserved80 SubCauseCodeType, + reserved81 SubCauseCodeType, + reserved82 SubCauseCodeType, + reserved83 SubCauseCodeType, + reserved84 SubCauseCodeType, + reserved85 SubCauseCodeType, + reserved86 SubCauseCodeType, + reserved87 SubCauseCodeType, + reserved88 SubCauseCodeType, + reserved89 SubCauseCodeType, + reserved90 SubCauseCodeType, + vehicleBreakdown91 VehicleBreakdownSubCauseCode, + postCrash92 PostCrashSubCauseCode, + humanProblem93 HumanProblemSubCauseCode, + stationaryVehicle94 StationaryVehicleSubCauseCode, + emergencyVehicleApproaching95 EmergencyVehicleApproachingSubCauseCode, + hazardousLocation-DangerousCurve96 HazardousLocation-DangerousCurveSubCauseCode, + collisionRisk97 CollisionRiskSubCauseCode, + signalViolation98 SignalViolationSubCauseCode, + dangerousSituation99 DangerousSituationSubCauseCode, + railwayLevelCrossing100 RailwayLevelCrossingSubCauseCode, + reserved101 SubCauseCodeType, + reserved102 SubCauseCodeType, + reserved103 SubCauseCodeType, + reserved104 SubCauseCodeType, + reserved105 SubCauseCodeType, + reserved106 SubCauseCodeType, + reserved107 SubCauseCodeType, + reserved108 SubCauseCodeType, + reserved109 SubCauseCodeType, + reserved110 SubCauseCodeType, + reserved111 SubCauseCodeType, + reserved112 SubCauseCodeType, + reserved113 SubCauseCodeType, + reserved114 SubCauseCodeType, + reserved115 SubCauseCodeType, + reserved116 SubCauseCodeType, + reserved117 SubCauseCodeType, + reserved118 SubCauseCodeType, + reserved119 SubCauseCodeType, + reserved120 SubCauseCodeType, + reserved121 SubCauseCodeType, + reserved122 SubCauseCodeType, + reserved123 SubCauseCodeType, + reserved124 SubCauseCodeType, + reserved125 SubCauseCodeType, + reserved126 SubCauseCodeType, + reserved127 SubCauseCodeType, + reserved128 SubCauseCodeType + } + +CauseCodeV2 ::= SEQUENCE { + ccAndScc CauseCodeChoice, + ... +} + +CenDsrcTollingZone ::= SEQUENCE { + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + cenDsrcTollingZoneId ProtectedZoneId OPTIONAL, + ... +} + +CircularShape ::= SEQUENCE { + shapeReferencePoint CartesianPosition3d OPTIONAL, + radius StandardLength12b, + height StandardLength12b OPTIONAL +} + +ClosedLanes ::= SEQUENCE { + innerhardShoulderStatus HardShoulderStatus OPTIONAL, + outerhardShoulderStatus HardShoulderStatus OPTIONAL, + drivingLaneStatus DrivingLaneStatus OPTIONAL, + ... +} + +ClusterBreakupInfo ::= SEQUENCE { + clusterBreakupReason ClusterBreakupReason, + breakupTime DeltaTimeQuarterSecond, + ... +} + +ClusterJoinInfo ::= SEQUENCE { + clusterId Identifier1B, + joinTime DeltaTimeQuarterSecond, + ... +} + +ClusterLeaveInfo ::= SEQUENCE { + clusterId Identifier1B, + clusterLeaveReason ClusterLeaveReason, + ... +} + +CorrelationColumn ::= SEQUENCE SIZE (1..13,...) OF CorrelationCellValue + +Curvature ::= SEQUENCE { + curvatureValue CurvatureValue, + curvatureConfidence CurvatureConfidence +} + +DangerousGoodsExtended ::= SEQUENCE { + dangerousGoodsType DangerousGoodsBasic, + unNumber INTEGER (0..9999), + elevatedTemperature BOOLEAN, + tunnelsRestricted BOOLEAN, + limitedQuantity BOOLEAN, + emergencyActionCode IA5String (SIZE (1..24)) OPTIONAL, + phoneNumber PhoneNumber OPTIONAL, + companyName UTF8String (SIZE (1..24)) OPTIONAL, + ... +} + +DeltaReferencePosition ::= SEQUENCE { + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude, + deltaAltitude DeltaAltitude +} + +DigitalMap ::= SEQUENCE (SIZE(1..256)) OF ReferencePosition + +EllipticalShape ::= SEQUENCE { + shapeReferencePoint CartesianPosition3d OPTIONAL, + semiMajorAxisLength StandardLength12b, + semiMinorAxisLength StandardLength12b, + orientation Wgs84AngleValue OPTIONAL, + height StandardLength12b OPTIONAL +} + +EulerAnglesWithConfidence ::= SEQUENCE { + zAngle CartesianAngle, + yAngle CartesianAngle OPTIONAL, + xAngle CartesianAngle OPTIONAL +} + +EuVehicleCategoryCode ::= CHOICE { + euVehicleCategoryL EuVehicleCategoryL, + euVehicleCategoryM EuVehicleCategoryM, + euVehicleCategoryN EuVehicleCategoryN, + euVehicleCategoryO EuVehicleCategoryO, + euVehicleCategoryT NULL, + euVehicleCategoryG NULL + } + +EventHistory::= SEQUENCE (SIZE(1..23)) OF EventPoint + +EventPoint ::= SEQUENCE { + eventPosition DeltaReferencePosition, + eventDeltaTime PathDeltaTime OPTIONAL, + informationQuality InformationQuality +} + +EventZone::= EventHistory + ((WITH COMPONENT (WITH COMPONENTS {..., eventDeltaTime PRESENT})) | + (WITH COMPONENT (WITH COMPONENTS {..., eventDeltaTime ABSENT}))) + +GeneralizedLanePosition::= CHOICE { + trafficLanePosition LanePosition, + nonTrafficLanePosition LanePositionAndType, + trafficIslandPosition TrafficIslandPosition, + mapPosition MapPosition, + ... +} + +Heading ::= SEQUENCE { + headingValue HeadingValue, + headingConfidence HeadingConfidence +} + + +HeadingChangeIndication ::= SEQUENCE { + direction TurningDirection, + actionDeltaTime DeltaTimeTenthOfSecond, + ... +} + +InterferenceManagementChannel ::= SEQUENCE { + centreFrequency INTEGER (1 .. 99999), + channelWidth INTEGER (0 .. 9999), + exponent INTEGER (0 .. 15) +} + +InterferenceManagementZone ::= SEQUENCE { + zoneDefinition InterferenceManagementZoneDefinition, + managementInfo InterferenceManagementInfo +} + +InterferenceManagementZoneDefinition::= SEQUENCE{ + interferenceManagementZoneLatitude Latitude, + interferenceManagementZoneLongitude Longitude, + interferenceManagementZoneId ProtectedZoneId OPTIONAL, + interferenceManagementZoneShape Shape (WITH COMPONENTS{..., radial ABSENT, radialShapes ABSENT}) OPTIONAL, + ... +} + +InterferenceManagementInfo::= SEQUENCE (SIZE(1..16,...)) OF InterferenceManagementInfoPerChannel + + +InterferenceManagementInfoPerChannel ::= SEQUENCE { + interferenceManagementChannel InterferenceManagementChannel, + interferenceManagementZoneType InterferenceManagementZoneType, + interferenceManagementMitigationType MitigationForTechnologies OPTIONAL, + expiryTime TimestampIts OPTIONAL, + ... +} + +InterferenceManagementZones ::= SEQUENCE (SIZE(1..16), ...) OF InterferenceManagementZone + +IntersectionReferenceId ::= SEQUENCE { + region Identifier2B OPTIONAL, + id Identifier2B +} + +ItineraryPath ::= SEQUENCE SIZE(1..40) OF ReferencePosition + +ProtocolVersion ::= INTEGER(0..255) + +ItsPduHeader ::= SEQUENCE { +-- protocolVersion OrdinalNumber1B, + protocolVersion ProtocolVersion, + messageId MessageId, + stationId StationId +} + +LanePositionAndType::= SEQUENCE { + transversalPosition LanePosition, + laneType LaneType, + ... +} + +LateralAcceleration ::= SEQUENCE { + lateralAccelerationValue LateralAccelerationValue, + lateralAccelerationConfidence AccelerationConfidence +} + +LongitudinalAcceleration ::= SEQUENCE { + longitudinalAccelerationValue LongitudinalAccelerationValue, + longitudinalAccelerationConfidence AccelerationConfidence +} + +LongitudinalLanePosition ::= SEQUENCE { + longitudinalLanePositionValue LongitudinalLanePositionValue, + longitudinalLanePositionConfidence LongitudinalLanePositionConfidence +} + +LowerTriangularPositiveSemidefiniteMatrices::= SEQUENCE SIZE (1..4) OF LowerTriangularPositiveSemidefiniteMatrix + +LowerTriangularPositiveSemidefiniteMatrix ::= SEQUENCE{ + componentsIncludedIntheMatrix MatrixIncludedComponents, + matrix LowerTriangularPositiveSemidefiniteMatrixColumns +} + +LowerTriangularPositiveSemidefiniteMatrixColumns ::= SEQUENCE SIZE (1..13) OF CorrelationColumn + +MapPosition ::= SEQUENCE { + mapReference MapReference OPTIONAL, + laneId Identifier1B OPTIONAL, + connectionId Identifier1B OPTIONAL, + longitudinalLanePosition LongitudinalLanePosition OPTIONAL, + ... +} + ((WITH COMPONENTS {..., laneId PRESENT, connectionId ABSENT }) | + (WITH COMPONENTS {..., laneId ABSENT, connectionId PRESENT })) + +MapReference::= CHOICE { + roadsegment RoadSegmentReferenceId, + intersection IntersectionReferenceId + } + +MessageRateHz::= SEQUENCE { + mantissa INTEGER (1..100), + exponent INTEGER (-5..2) + } + +MessageSegmentationInfo ::= SEQUENCE { + totalMsgNo CardinalNumber3b, + thisMsgNo OrdinalNumber3b + } + +MitigationForTechnologies ::= SEQUENCE (SIZE(1..8)) OF MitigationPerTechnologyClass + +MitigationPerTechnologyClass ::= SEQUENCE { + accessTechnologyClass AccessTechnologyClass, + lowDutyCycle INTEGER (0 .. 10000) OPTIONAL, + powerReduction INTEGER (0 .. 30) OPTIONAL, + dmcToffLimit INTEGER (0 .. 1200) OPTIONAL, + dmcTonLimit INTEGER (0 .. 20) OPTIONAL, + ... +} + +ObjectClass ::= CHOICE { + vehicleSubClass TrafficParticipantType (unknown|passengerCar..tram|agricultural), + vruSubClass VruProfileAndSubprofile, + groupSubClass VruClusterInformation (WITH COMPONENTS{..., clusterBoundingBoxShape ABSENT}), + otherSubClass OtherSubClass, + ... +} + +ObjectClassDescription ::= SEQUENCE (SIZE(1..8)) OF ObjectClassWithConfidence + +ObjectClassWithConfidence ::= SEQUENCE { + objectClass ObjectClass, + confidence ConfidenceLevel +} + +ObjectDimension ::= SEQUENCE { + value ObjectDimensionValue, + confidence ObjectDimensionConfidence +} + +Path::= SEQUENCE (SIZE(0..40)) OF PathPoint + +PathHistory::= SEQUENCE (SIZE(40)) OF PathPoint + +PathPredicted::= SEQUENCE (SIZE(0..15,...)) OF PathPointPredicted + +PathPoint ::= SEQUENCE { + pathPosition DeltaReferencePosition, + pathDeltaTime PathDeltaTime OPTIONAL +} + +PathPointPredicted::= SEQUENCE { + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude, + horizontalPositionConfidence PosConfidenceEllipse OPTIONAL, + deltaAltitude DeltaAltitude DEFAULT unavailable, + altitudeConfidence AltitudeConfidence DEFAULT unavailable, + pathDeltaTime DeltaTimeTenthOfSecond, + ... +} + +PerceivedObject ::= SEQUENCE { + objectId Identifier2B OPTIONAL, + measurementDeltaTime DeltaTimeMilliSecondSigned, + position CartesianPosition3dWithConfidence, + velocity Velocity3dWithConfidence OPTIONAL, + acceleration Acceleration3dWithConfidence OPTIONAL, + angles EulerAnglesWithConfidence OPTIONAL, + zAngularVelocity CartesianAngularVelocityComponent OPTIONAL, + lowerTriangularCorrelationMatrices LowerTriangularPositiveSemidefiniteMatrices OPTIONAL, + objectDimensionZ ObjectDimension OPTIONAL, + objectDimensionY ObjectDimension OPTIONAL, + objectDimensionX ObjectDimension OPTIONAL, + objectAge DeltaTimeMilliSecondSigned (0..2047) OPTIONAL, + objectPerceptionQuality ObjectPerceptionQuality OPTIONAL, + sensorIdList SequenceOfIdentifier1B OPTIONAL, + classification ObjectClassDescription OPTIONAL, + mapPosition MapPosition OPTIONAL, + ... +} + +PolygonalShape ::= SEQUENCE { + shapeReferencePoint CartesianPosition3d OPTIONAL, + polygon SequenceOfCartesianPosition3d (SIZE(3..16,...)), + height StandardLength12b OPTIONAL +} + +PosConfidenceEllipse ::= SEQUENCE { + semiMajorConfidence SemiAxisLength, + semiMinorConfidence SemiAxisLength, + semiMajorOrientation HeadingValue +} + +PositionConfidenceEllipse ::= SEQUENCE { + semiMajorAxisLength SemiAxisLength, + semiMinorAxisLength SemiAxisLength, + semiMajorAxisOrientation Wgs84AngleValue +} + +PositionOfPillars ::= SEQUENCE (SIZE(1..3, ...)) OF PosPillar + +ProtectedCommunicationZone ::= SEQUENCE { + protectedZoneType ProtectedZoneType, + expiryTime TimestampIts OPTIONAL, + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + protectedZoneRadius ProtectedZoneRadius OPTIONAL, + protectedZoneId ProtectedZoneId OPTIONAL, + ... +} + +ProtectedCommunicationZonesRSU ::= SEQUENCE (SIZE(1..16)) OF ProtectedCommunicationZone + +PtActivation ::= SEQUENCE { + ptActivationType PtActivationType, + ptActivationData PtActivationData +} + +RadialShape ::= SEQUENCE { + shapeReferencePoint CartesianPosition3d OPTIONAL, + range StandardLength12b, + stationaryHorizontalOpeningAngleStart Wgs84AngleValue, + stationaryHorizontalOpeningAngleEnd Wgs84AngleValue, + verticalOpeningAngleStart CartesianAngleValue OPTIONAL, + verticalOpeningAngleEnd CartesianAngleValue OPTIONAL +} + + +RadialShapes ::= SEQUENCE { + refPointId Identifier1B, + xCoordinate CartesianCoordinateSmall, + yCoordinate CartesianCoordinateSmall, + zCoordinate CartesianCoordinateSmall OPTIONAL, + radialShapesList RadialShapesList +} + +RadialShapesList ::= SEQUENCE SIZE(1..16,...) OF RadialShapeDetails + +RadialShapeDetails ::= SEQUENCE { + range StandardLength12b, + horizontalOpeningAngleStart CartesianAngleValue, + horizontalOpeningAngleEnd CartesianAngleValue, + verticalOpeningAngleStart CartesianAngleValue OPTIONAL, + verticalOpeningAngleEnd CartesianAngleValue OPTIONAL +} + +RectangularShape ::= SEQUENCE { + centerPoint CartesianPosition3d OPTIONAL, + semiLength StandardLength12b, + semiBreadth StandardLength12b, + orientation Wgs84AngleValue OPTIONAL, + height StandardLength12b OPTIONAL +} + +ReferencePosition ::= SEQUENCE { + latitude Latitude, + longitude Longitude, + positionConfidenceEllipse PosConfidenceEllipse, + altitude Altitude +} + +ReferencePositionWithConfidence ::= SEQUENCE { + latitude Latitude, + longitude Longitude, + positionConfidenceEllipse PositionConfidenceEllipse, + altitude Altitude +} + +RestrictedTypes ::= SEQUENCE (SIZE(1..3, ...)) OF StationType + +RoadSegmentReferenceId ::= SEQUENCE { + region Identifier2B OPTIONAL, + id Identifier2B +} + +SafeDistanceIndication ::= SEQUENCE { + subjectStation StationId OPTIONAL, + safeDistanceIndicator SafeDistanceIndicator, + timeToCollision DeltaTimeTenthOfSecond OPTIONAL, + ... +} + +SequenceOfCartesianPosition3d ::= SEQUENCE (SIZE(1..16, ...)) OF CartesianPosition3d + +SequenceOfIdentifier1B ::= SEQUENCE SIZE(1..128, ...) OF Identifier1B + +SequenceOfSafeDistanceIndication ::= SEQUENCE(SIZE(1..8,...)) OF SafeDistanceIndication + +SequenceOfTrajectoryInterceptionIndication ::= SEQUENCE (SIZE(1..8,...)) OF TrajectoryInterceptionIndication + +Shape::= CHOICE { + rectangular RectangularShape, + circular CircularShape, + polygonal PolygonalShape, + elliptical EllipticalShape, + radial RadialShape, + radialShapes RadialShapes, + ... +} + +Speed ::= SEQUENCE { + speedValue SpeedValue, + speedConfidence SpeedConfidence +} + +StabilityChangeIndication ::= SEQUENCE { + lossProbability StabilityLossProbability, + actionDeltaTime DeltaTimeTenthOfSecond, + ... +} + +SteeringWheelAngle ::= SEQUENCE { + steeringWheelAngleValue SteeringWheelAngleValue, + steeringWheelAngleConfidence SteeringWheelAngleConfidence +} + +Traces ::= SEQUENCE SIZE(1..7) OF Path + +TrafficIslandPosition ::= SEQUENCE { + oneSide LanePositionAndType, + otherSide LanePositionAndType, + ... +} + +TrailerData ::= SEQUENCE { + refPointId Identifier1B, + hitchPointOffset StandardLength1B, + frontOverhang StandardLength1B OPTIONAL, + rearOverhang StandardLength1B OPTIONAL, + trailerWidth VehicleWidth OPTIONAL, + hitchAngle CartesianAngle, + ... +} + +TrajectoryInterceptionIndication ::= SEQUENCE { + subjectStation StationId OPTIONAL, + trajectoryInterceptionProbability TrajectoryInterceptionProbability, + trajectoryInterceptionConfidence TrajectoryInterceptionConfidence OPTIONAL, + ... +} + +VarLengthNumber::=CHOICE{ + content [0] INTEGER(0..127), -- one octet length + extension [1] Ext1 + } +Ext1::=CHOICE{ + content [0] INTEGER(128..16511), -- two octets length + extension [1] Ext2 +} +Ext2::=CHOICE{ + content [0] INTEGER(16512..2113663), -- three octets length + extension [1] Ext3 + } +Ext3::= INTEGER(2113664..270549119,...) -- four and more octets length + +VerticalAcceleration ::= SEQUENCE { + verticalAccelerationValue VerticalAccelerationValue, + verticalAccelerationConfidence AccelerationConfidence +} + +VehicleIdentification ::= SEQUENCE { + wMInumber WMInumber OPTIONAL, + vDS VDS OPTIONAL, + ... +} + +VehicleLength ::= SEQUENCE { + vehicleLengthValue VehicleLengthValue, + vehicleLengthConfidenceIndication VehicleLengthConfidenceIndication +} + +VehicleLengthV2 ::= SEQUENCE { + vehicleLengthValue VehicleLengthValue, + trailerPresenceInformation TrailerPresenceInformation +} + +Velocity3dWithConfidence::= CHOICE{ + polarVelocity VelocityPolarWithZ, + cartesianVelocity VelocityCartesian +} + +VelocityCartesian::= SEQUENCE { + xVelocity VelocityComponent, + yVelocity VelocityComponent, + zVelocity VelocityComponent OPTIONAL +} + +VelocityComponent ::= SEQUENCE { + value VelocityComponentValue, + confidence SpeedConfidence +} + +VelocityPolarWithZ::= SEQUENCE { + velocityMagnitude Speed, + velocityDirection CartesianAngle, + zVelocity VelocityComponent OPTIONAL +} + +VruClusterInformation ::= SEQUENCE { + clusterId Identifier1B OPTIONAL, + clusterBoundingBoxShape Shape (WITH COMPONENTS{..., elliptical ABSENT, radial ABSENT, radialShapes ABSENT}) OPTIONAL, + clusterCardinalitySize CardinalNumber1B, + clusterProfiles VruClusterProfiles OPTIONAL, + ... +} + +VruExteriorLights ::= SEQUENCE { + vehicular ExteriorLights, + vruSpecific VruSpecificExteriorLights, + ... +} + +VruProfileAndSubprofile ::= CHOICE { + pedestrian VruSubProfilePedestrian, + bicyclistAndLightVruVehicle VruSubProfileBicyclist, + motorcyclist VruSubProfileMotorcyclist, + animal VruSubProfileAnimal, + ... +} + +Wgs84Angle ::= SEQUENCE { + value Wgs84AngleValue, + confidence Wgs84AngleConfidence +} + + +YawRate::= SEQUENCE { + yawRateValue YawRateValue, + yawRateConfidence YawRateConfidence +} + +------------------------------------------ +END + diff --git a/epan/dissectors/asn1/its/ETSI_TS_103301.asn b/epan/dissectors/asn1/its/ETSI_TS_103301.asn new file mode 100644 index 00000000..3e4bba06 --- /dev/null +++ b/epan/dissectors/asn1/its/ETSI_TS_103301.asn @@ -0,0 +1,179 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ETSI TS 103 301 +-- +-- This ASN.1 was generated: 30.08.2016 +-- +-- This document contains the data element needed for the encoding the SPATEM, MAPEM, IVIM, SSEM and SREM message +-- as defined in ETSI TS 103 301 +-- +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: SPAT-MESSAGE-PDU-Descriptions +-- +-- This ASN.1 was created: 30.08.2016 +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +SPATEM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) spatem (0) version2 (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + SPAT FROM DSRC { iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 + (2) } + + ItsPduHeader FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 + (1) ts (102894) cdd (2) version (2) }; + + SPATEM ::= SEQUENCE { + header ItsPduHeader, + spat SPAT + } +END + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: MAP-MESSAGE-PDU-Descriptions +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +MAPEM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) mapem (1) version2 (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + MapData + FROM DSRC { iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 (2) } + + ItsPduHeader + FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (2)}; + + MAPEM ::= SEQUENCE { + header ItsPduHeader, + map MapData + } + +END + + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: IVI-MESSAGE-PDU-Descriptions +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +IVIM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) ivim (2) +version2 (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + IviStructure FROM IVI {iso (1) standard (0) ivi (19321) version1 (1)} + + ItsPduHeader FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 + (1) ts (102894) cdd (2) version (2)}; + + IVIM ::= SEQUENCE { + header ItsPduHeader, + ivi IviStructure + } + +END + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: SRM-MESSAGE-PDU-Descriptions +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +SREM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) srem (3) +version2 (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + SignalRequestMessage FROM DSRC { iso (1) standard (0) signalizedIntersection (19091) profilec(2) + dsrc (2) version2 (2) } + + ItsPduHeader FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 + (1) ts (102894) cdd (2) version (2)}; + + SREM ::= SEQUENCE { + header ItsPduHeader, + srm SignalRequestMessage + } +END + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: SSM-MESSAGE-PDU-Descriptions +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +SSEM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) ssem (4) +version2 (2) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + SignalStatusMessage FROM DSRC { iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc + (2) version2 (2) } + + ItsPduHeader FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 + (1) ts (102894) cdd (2) version (2)}; + + SSEM ::= SEQUENCE { + header ItsPduHeader, + ssm SignalStatusMessage + } + +END + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: RTCM corrections extended message +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +RTCMEM-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (103301) rtcmem (5) +version1 (1) +} + DEFINITIONS AUTOMATIC TAGS ::= + + BEGIN + + IMPORTS + + RTCMcorrections FROM DSRC { iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) + version2 (2) } + + ItsPduHeader FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 + (1) ts (102894) cdd (2) version (2)}; + + RTCMEM ::= SEQUENCE { + header ItsPduHeader, + rtcmc RTCMcorrections + } + +END diff --git a/epan/dissectors/asn1/its/EV-RSR-PDU-Descriptions.asn b/epan/dissectors/asn1/its/EV-RSR-PDU-Descriptions.asn new file mode 100644 index 00000000..8a61a6e4 --- /dev/null +++ b/epan/dissectors/asn1/its/EV-RSR-PDU-Descriptions.asn @@ -0,0 +1,157 @@ +EV-RechargingSpotReservation-PDU-Descriptions { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (101556) ev-rsr (4) version (1) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + ItsPduHeader FROM ITS-Container { + itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (2) +}; + +EV-RSR ::= SEQUENCE { + header ItsPduHeader, + messageBody EV-RSR-MessageBody +} + +EV-RSR-MessageBody ::= CHOICE { + preReservationRequestMessage PreReservationRequestMessage, + preReservationResponseMessage PreReservationResponseMessage, + reservationRequestMessage ReservationRequestMessage, + reservationResponseMessage ReservationResponseMessage, + cancellationRequestMessage CancellationRequestMessage, + cancellationResponseMessage CancellationResponseMessage, + updateRequestMessage UpdateRequestMessage, + updateResponseMessage UpdateResponseMessage, +... +} + +PreReservationRequestMessage ::= SEQUENCE { + evse-ID EVSE-ID, + arrivalTime TimestampUTC, + departureTime TimestampUTC OPTIONAL, + rechargingType RechargingType, + batteryType BatteryType OPTIONAL, + ... +} + +PreReservationResponseMessage ::= SEQUENCE { + preReservation-ID PreReservation-ID, + availabilityStatus AvailabilityStatus, + preReservationExpirationTime TimestampUTC, + supportedPaymentTypes SupportedPaymentTypes, + ... +} + +ReservationRequestMessage ::= SEQUENCE { + currentTime TimestampUTC, + preReservation-ID PreReservation-ID, + arrivalTime TimestampUTC, + departureTime TimestampUTC OPTIONAL, + eAmount EAmount, + eAmountMin EAmount, + paymentType PaymentType, + payment-ID Payment-ID, + secondPayment-ID Payment-ID OPTIONAL, + pairing-ID Pairing-ID OPTIONAL, + ... +} + +ReservationResponseMessage ::= SEQUENCE { + reservationResponseCode ReservationResponseCode, + reservation-ID Reservation-ID OPTIONAL, + reservation-Password Reservation-Password OPTIONAL, + stationDetails StationDetails OPTIONAL, + chargingSpotLabel ChargingSpotLabel OPTIONAL, + expirationTime TimestampUTC, + freeCancelTimeLimit TimestampUTC OPTIONAL, + ... +} + +CancellationRequestMessage ::= SEQUENCE { + reservation-ID Reservation-ID, + reservation-Password Reservation-Password, + currentTime TimestampUTC, + ... +} + +CancellationResponseMessage ::= SEQUENCE { + reservation-ID Reservation-ID, + cancellationResponseCode CancellationResponseCode, + ... +} + +UpdateRequestMessage ::= SEQUENCE { + reservation-ID Reservation-ID, + reservation-Password Reservation-Password, + updatedArrivalTime TimestampUTC, + updatedDepartureTime TimestampUTC, + ... +} + +UpdateResponseMessage ::= SEQUENCE { + reservation-ID Reservation-ID, + updateResponseCode UpdateResponseCode, + chargingSpotLabel ChargingSpotLabel OPTIONAL, + ... +} + + + +AvailabilityStatus ::= ENUMERATED { available, no-free-capacity } + +BatteryType ::= UTF8String (SIZE(1..16)) + +CancellationResponseCode ::= ENUMERATED { ok, unknown-Reservation-ID, mismatching-Reservation-Password } + +ChargingSpotLabel ::= UTF8String (SIZE(1..4)) + +ContractID ::= UTF8String (SIZE(1..24)) + +EAmount ::= INTEGER { oneWh(1) } (1..500000) + +ChargingPower ::= INTEGER { oneW(1) } (1..200000) + +EVSE-ID ::= OCTET STRING (SIZE(1..32)) + +ExternalIdentificationMeans ::= UTF8String (SIZE(1..24)) + +Pairing-ID ::= VisibleString (SIZE(1..64)) + +PaymentType ::= ENUMERATED {contract, externalIdentification} + +Payment-ID ::= CHOICE { + contractID ContractID, + externalIdentificationMeans ExternalIdentificationMeans +} + +RechargingType ::= SEQUENCE { + rechargingMode RechargingMode, + powerSource PowerSource +} + +RechargingMode ::= INTEGER { mode1(0), mode2(1), mode3(2), mode4(3), quickDrop(8), inductiveChargingWhileStationary(12), inductiveChargingWhileDriving(14) } (0..15) + +PowerSource::= INTEGER { notApplicable(0), ac1Phase(1), ac2Phase(2), ac3Phase(3), dcc(4), chaDeMo(5) } (0..7) +ReservationResponseCode ::= ENUMERATED {ok, invalid-EVSE-ID, payment-type-not-supported, payment-error, authentication-error, insufficient-power-availability } + +Reservation-ID ::= VisibleString (SIZE(8)) + +PreReservation-ID ::= Reservation-ID + +Reservation-Password ::= VisibleString (SIZE(8)) + + +StationDetails ::= UTF8String (SIZE(1..32)) + +SupportedPaymentTypes ::= BIT STRING { contract(0), externalIdentification (1) } (SIZE(2)) + +TimestampUTC ::= INTEGER { utcStartOf2013(0), oneSecondAfterUTCStartOf2013(1) } + +UpdateResponseCode ::= ENUMERATED { ok, unknown-Reservation-ID, mismatching-Reservation-Password, invalid-Arrival-Time, invalid-Departure-Time } + +StatusResponseCode ::= ENUMERATED { charging-Spot-Occupied, charging-Spot-Unoccupied, charging-Ongoing, reservation-Limit-Exceeded, reservation-Cancelled, unknown-Reservation-ID, expired-Reservation-ID } + +END diff --git a/epan/dissectors/asn1/its/EVCSN-PDU-Descriptions.asn b/epan/dissectors/asn1/its/EVCSN-PDU-Descriptions.asn new file mode 100644 index 00000000..b95dfd08 --- /dev/null +++ b/epan/dissectors/asn1/its/EVCSN-PDU-Descriptions.asn @@ -0,0 +1,102 @@ +-- Point of Interest (POI) notification for charging spot +-- for electric vehicle +-- EVCSN Message definition +-- ASN.1 Start Definition + +EVCSN-PDU-Descriptions { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) +wg1 (1) ts (101556) evcsn (1) version (1) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + ItsPduHeader, + StationID, + TimestampIts, -- CORRECTION + DigitalMap, -- PATCH + ReferencePosition +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} +; + +-- Root Message PDU: EvcsnPdu + +EvcsnPdu ::= SEQUENCE { + header ItsPduHeader, + evcsn EVChargingSpotNotificationPOIMessage +} + +EVChargingSpotNotificationPOIMessage ::= SEQUENCE { + poiHeader ItsPOIHeader, -- Specific POI Message Header + evcsnData ItsEVCSNData -- Electric Vehicle Charging Spot Data Elements +} + +ItsPOIHeader ::= SEQUENCE { + poiType POIType, -- set to "EV charging station POI ID = 1" + timeStamp TimestampIts, -- CORRECTION + relayCapable BOOLEAN +} + + +ItsEVCSNData ::= SEQUENCE { + totalNumberOfStations NumberStations, + chargingStationsData SEQUENCE (SIZE(1..256)) OF ItsChargingStationData +} + +ItsChargingStationData ::= SEQUENCE { + chargingStationID StationID, + utilityDistributorId UTF8String (SIZE(1..32)) OPTIONAL, + providerID UTF8String (SIZE(1..32)) OPTIONAL, + chargingStationLocation ReferencePosition, + address UTF8String OPTIONAL, + phoneNumber NumericString (SIZE(1..16)) OPTIONAL, + accessibility UTF8String (SIZE(1..32)), + digitalMap DigitalMap OPTIONAL, + openingDaysHours UTF8String, + pricing UTF8String, + bookingContactInfo UTF8String OPTIONAL, + payment UTF8String OPTIONAL, + chargingSpotsAvailable ItsChargingSpots, + ... +} + + +ItsChargingSpots ::= SEQUENCE (SIZE(1..16)) OF ItsChargingSpotDataElements + + +ItsChargingSpotDataElements ::= SEQUENCE { + type ChargingSpotType, + evEquipmentID UTF8String OPTIONAL, + typeOfReceptacle TypeOfReceptacle, + energyAvailability UTF8String, + parkingPlacesData ParkingPlacesData OPTIONAL +} + +-- DigitalMap ::= SEQUENCE (SIZE(1..256)) OF ReferencePosition PATCH + +ChargingSpotType ::= BIT STRING { + standardChargeMode1(0), + standardChargeMode2(1), + standardOrFastChargeMode3(2), + fastChargeWithExternalCharger(3), + quickDrop(8), + inductiveChargeWhileStationary(12), + inductiveChargeWhileDriving(14) +} + +TypeOfReceptacle ::= BIT STRING + +ParkingPlacesData ::= SEQUENCE (SIZE(1..4)) OF SpotAvailability + +SpotAvailability ::= SEQUENCE { + maxWaitingTimeMinutes INTEGER (0..1400), -- 0 if available or max waiting + -- time (minutes) + blocking BOOLEAN -- true if the spot can be blocked +} + +POIType ::= INTEGER(0..65535) +NumberStations ::= INTEGER(1..256) + +END diff --git a/epan/dissectors/asn1/its/GDD.asn b/epan/dissectors/asn1/its/GDD.asn new file mode 100644 index 00000000..0680e3e5 --- /dev/null +++ b/epan/dissectors/asn1/its/GDD.asn @@ -0,0 +1,302 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TR 14823-2 +-- +-- Taken from ISO/TR 14823-2:2019(E) preview +-- https://www.sis.se/api/document/preview/80015457/ +-- +-- Changes to original version: +-- - add this header +-- - reformat +-- - rename InternationalSign-distinationInformation -> InternationalSign-destinationInformation +-- - rename DistinationInformationIO -> DestinationInformationIO +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +GDD {iso (1) standard (0) gdd(14823) version1 (0)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN +GddStructure ::= SEQUENCE { + pictogramCode Pictogram, + attributes GddAttributes OPTIONAL +} + +Pictogram ::= SEQUENCE { + countryCode Pictogram-countryCode OPTIONAL, + serviceCategoryCode Pictogram-serviceCategory, + pictogramCategoryCode Pictogram-category +} + +Pictogram-countryCode ::= OCTET STRING (SIZE (2)) + +Pictogram-serviceCategory ::= CHOICE { + trafficSignPictogram Pictogram-trafficSign, + publicFacilitiesPictogram Pictogram-publicFacilitySign, + ambientOrRoadConditionPictogram Pictogram-conditionsSign +} + +Pictogram-category ::= SEQUENCE { + nature Pictogram-nature, + serialNumber Pictogram-serialNumber +} + +Pictogram-trafficSign ::= ENUMERATED { + dangerWarning (11), + regulatory (12), + informative (13), + ... +} + +Pictogram-publicFacilitySign ::= ENUMERATED { + publicFacilities (21), + ... +} + +Pictogram-conditionsSign ::= ENUMERATED { + ambientCondition (31), + roadCondition (32), + ... +} + +Pictogram-nature ::= INTEGER (1..9) + +Pictogram-serialNumber ::= INTEGER (0..99) + +GddAttributes ::= SEQUENCE (SIZE (1..8), ...) OF CHOICE { + dtm InternationalSign-applicablePeriod, + edt InternationalSign-exemptedApplicablePeriod, + dfl InternationalSign-directionalFlowOfLane, + ved InternationalSign-applicableVehicleDimensions, + spe InternationalSign-speedLimits, + roi InternationalSign-rateOfIncline, + dbv InternationalSign-distanceBetweenVehicles, + ddd InternationalSign-destinationInformation, + set InternationalSign-section, + nol InternationalSign-numberOfLane +} + +InternationalSign-applicablePeriod ::= SEQUENCE { + year SEQUENCE { + yearRangeStartYear Year, + yearRangeEndYear Year + } OPTIONAL, + month-day SEQUENCE { + dateRangeStartMonthDate MonthDay, + dateRangeEndMonthDate MonthDay + } OPTIONAL, + repeatingPeriodDayTypes RPDT OPTIONAL, + hourMinutes SEQUENCE { + timeRangeStartTime HoursMinutes, + timeRangeEndTime HoursMinutes + } OPTIONAL, + dateRangeOfWeek DayOfWeek OPTIONAL, + durationHourminute HoursMinutes OPTIONAL +} + +MonthDay ::= SEQUENCE { + month MonthDay-month, + day MonthDay-day +} + +HoursMinutes ::= SEQUENCE { + hours HoursMinutes-hours, + mins HoursMinutes-mins +} + +Year ::= INTEGER (2000..2127,...) + +MonthDay-month ::= INTEGER (1..12) + +MonthDay-day ::= INTEGER (1..31) + +HoursMinutes-hours ::= INTEGER (0..23) + +HoursMinutes-mins ::= INTEGER (0..59) + +RPDT ::= BIT STRING { + national-holiday (0), + even-days (1), + odd-days (2), + market-day (3) +} (SIZE (4)) + +DayOfWeek ::= BIT STRING { + unused (0), + monday (1), + tuesday (2), + wednesday (3), + thursday (4), + friday (5), + saturday (6), + sunday (7) +} (SIZE (8)) + +InternationalSign-exemptedApplicablePeriod ::= InternationalSign-applicablePeriod + +InternationalSign-section ::= SEQUENCE { + startingPointLength Distance OPTIONAL, + continuityLength Distance OPTIONAL +} + +InternationalSign-numberOfLane ::= INTEGER (0..99) + +InternationalSign-directionalFlowOfLane ::= INTEGER { + sLT(2), + sDL(1), + sRT(3), + lTO(4), + rTO(5), + cLL(6), + cRI(7), + oVL(8) +} (1..8) + +InternationalSign-applicableVehicleDimensions ::= SEQUENCE { + vehicleHeight Distance OPTIONAL, + vehicleWidth Distance OPTIONAL, + vehicleLength Distance OPTIONAL, + vehicleWeight Weight OPTIONAL +} + +Distance ::= SEQUENCE { + value INTEGER (1..16384), + unit Code-Units (2..4|6..8) +} + +Weight ::= SEQUENCE { + value INTEGER (1..16384), + unit Code-Units (10..12) +} + +Code-Units ::= INTEGER { + kmperh (0), + milesperh (1), + kilometre (2), + metre (3), + decimetre (4), + centimetre (5), + mile (6), + yard (7), + foot (8), + minutesOfTime (9), + tonnes (10), + hundredkg (11), + pound (12), + rateOfIncline (13), + durationinminutes (14) +} (0..15) + +InternationalSign-speedLimits ::= SEQUENCE { + speedLimitMax INTEGER(0..250) OPTIONAL, + speedLimitMin INTEGER(0..250) OPTIONAL, + unit Code-Units (0..1) +} + +InternationalSign-rateOfIncline ::= INTEGER (1..32) + +InternationalSign-distanceBetweenVehicles ::= Distance + +InternationalSign-destinationInformation ::= SEQUENCE { + junctionDirection DistinInfo-junctionDirection OPTIONAL, + roundaboutCwDirection DistinInfo-roundaboutCwDirection OPTIONAL, + roundaboutCcwDirection DistinInfo-roundaboutCcwDirection OPTIONAL, + ioList SEQUENCE (SIZE (1..8,...)) OF DestinationInformationIO +} + +DestinationInformationIO ::= SEQUENCE { + arrowDirection IO-arrowDirection, + destPlace SEQUENCE (SIZE (1..4,...)) OF DestinationPlace OPTIONAL, + destRoad SEQUENCE (SIZE (1..4,...)) OF DestinationRoad OPTIONAL, + roadNumberIdentifier IO-roadNumberIdentifier OPTIONAL, + streetName IO-streetName OPTIONAL, + streetNameText IO-streetNameText OPTIONAL, + distanceToDivergingPoint DistanceOrDuration OPTIONAL, + distanceToDestinationPlace DistanceOrDuration OPTIONAL +} + +DestinationPlace ::= SEQUENCE { + destType DestinationType, + destRSCode GddStructure (WITH COMPONENTS {..., attributes ABSENT}) OPTIONAL, + destBlob DestPlace-destBlob OPTIONAL, + placeNameIdentification DestPlace-placeNameIdentification OPTIONAL, + placeNameText DestPlace-placeNameText OPTIONAL +} + +DestinationRoad ::= SEQUENCE { + derType DestinationRoadType, + roadNumberIdentifier DestRoad-roadNumberIdentifier OPTIONAL, + roadNumberText DestRoad-roadNumberText OPTIONAL +} + +DistanceOrDuration ::= SEQUENCE { + value DistOrDuration-value, + unit DistOrDuration-Units +} + +DistinInfo-junctionDirection ::= INTEGER (1..128) + +DistinInfo-roundaboutCwDirection ::= INTEGER (1..128) + +DistinInfo-roundaboutCcwDirection ::= INTEGER (1..128) + +IO-arrowDirection ::= INTEGER (0..7) + +IO-roadNumberIdentifier ::= INTEGER (1..999) + +IO-streetName ::= INTEGER (1..999) + +IO-streetNameText ::= UTF8String + +DestPlace-destBlob ::= OCTET STRING + +DestPlace-placeNameIdentification ::= INTEGER (1..999) + +DestPlace-placeNameText ::= UTF8String + +DestRoad-roadNumberIdentifier ::= INTEGER (1..999) + +DestRoad-roadNumberText ::= UTF8String + +DistOrDuration-value::= INTEGER (1..16384) + +DistOrDuration-Units ::= Code-Units (2..9) + +DestinationRoadType ::= INTEGER { + none (0), + nationalHighway (1), + localHighway (2), + tollExpresswayMotorway (3), + internationalHighway (4), + highway (5), + expressway (6), + nationalRoad (7), + regionalProvincialRoad (8), + localRoad (9), + motorwayJunction (10), + diversion (11), + rfu1 (12), + rfu2 (13), + rfu3 (14), + rfu4 (15) +} (0..15, ...) + +DestinationType ::= INTEGER { + none (0), + importantArea (1), + principalArea (2), + generalArea (3), + wellKnownPoint (4), + country (5), + city (6), + street (7), + industrialArea (8), + historicArea (9), + touristicArea (10), + culturalArea (11), + touristicRoute (12), + recommendedRoute (13), + touristicAttraction (14), + geographicArea (15) +} (0..15, ...) + +END diff --git a/epan/dissectors/asn1/its/IMZM-PDU-Descriptions.asn b/epan/dissectors/asn1/its/IMZM-PDU-Descriptions.asn new file mode 100644 index 00000000..72a4092f --- /dev/null +++ b/epan/dissectors/asn1/its/IMZM-PDU-Descriptions.asn @@ -0,0 +1,264 @@ +--! @brief Specification of the Interference Management Zone Message ETSI TS 103 724 +--! Latest version available at @url https: +--https ://forge.etsi.org/rep/ITS/asn1/imzm_ts103724/-/blob/release2/IMZM-PDU-Descriptions.asn + +IMZM-PDU-Descriptions { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts103724 (103724) imzm (1) version1 (1) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS +--! @brief Include ETSI TS 102 894-2 +--! Include references from @url https: +ItsPduHeader, Latitude, Longitude, TimestampIts, ProtectedZoneRadius, ProtectedZoneId, InterferenceManagementZones, BasicContainer, GenerationDeltaTime +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1) } + + +--! @brief Include ETSI EN 302 637-2 +--! Include references from @url https: +--BasicContainer, +--GenerationDeltaTime +--FROM CAM-PDU-Descriptions { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) en (302637) cam (2) version (2)} + +--! @brief Include ETSI TS 103 300-3 +--! All data types, imported from `VAM-Temp-Imports` will be imported from the CDD ETSI TS 102 894-2 Release 2 when available +AreaCircular, AreaRectangle, AreaPolygon, OffsetPoint, SemiRangeLength, WGS84AngleValue +FROM VAM-Temp-Imports { itu-t(0) identified-organization(4) etsi(0) itsDomain(5) wg1(1) ts(103300) temp-imports(255) version1(1)} +; + +--! @brief DF: Interference Management Zone Message Root +--! This DF includes DEs for the IMZM `protocolVersion`, the IMZ message type identifier `messageID` +--! and the station identifier `stationID` of the originating ITS-S. +IMZM ::= SEQUENCE { + --! @details header + --! - The DE `protocolVersion` is used to select the appropriate protocol decoder at the receiving + --! ITS-S. For TS 103 724 V2.1.1, the value of the DE `protocolVersion` shall be set to 1. + --! - The DE `messageID` shall be harmonized with other V2X message identifier definitions. + --! For IMZM, the DE messageID shall be set to `imzm(15)`. + header ItsPduHeader, + imzm InterferenceManagementZoneMessage +} + +--! @brief DF: Interference Management Zone Message +--! This is the actual IMZM Payload. It shall include the time stamp of the IMZM and the applicable +--! containers of type `BasicContainer` and `ImzmContainer`. +InterferenceManagementZoneMessage ::= SEQUENCE { + generationDeltaTime GenerationDeltaTime, -- from CAM-PDU-Descriptions + imzmParameters ImzmParameters +} + +--! @brief DF: IMZM Parameters +--! The sequence of containers in the IMZM. Other containers may be added in the future. +ImzmParameters ::= SEQUENCE { + --! @details basicContainer + --! imported from CAM-PDU-Descriptions + basicContainer BasicContainer, + --! @details imzmContainer + --! container specific to the IMZM + imzmContainer ImzmContainer, + ... +} + +--! @brief DF: IMZM Container +--! The IMZM container includes a sequence of up to 16 interference management zones. +--! For each interference management zones, it contains a sequence of interference +--! management zones per channel together with their characteristics. +ImzmContainer ::= SEQUENCE { + --! @details interferenceManagementZones + --! mapped to the DF_ProtectedCommunicationZone in ETSI TS 102 894-2 + interferenceManagementZones InterferenceManagementZones, + ... +} + +--! @brief DF: List of Interference Management Zones +--! A list of up to 16 interference management zones. +--! +--! **EXAMPLE**: An interference management communication zone may be defined around a +--! CEN DSRC road side equipment or an urban rail operational area. +--! @category: Infrastructure information, Communication information +--InterferenceManagementZones ::= SEQUENCE (SIZE(1..16), ...) OF InterferenceManagementZone + +--! @brief DF: Interference Management Zone +--! Describes a zone of interferenceManagement inside which the ITS communication should +--! be restricted. +--! @category: Infrastructure information, Communication information +--InterferenceManagementZone ::= SEQUENCE { +-- zoneDefinition ZoneDefinition, +-- interferenceManagementInfo InterferenceManagementInfo +--} + +--! @brief DF: Zone Definition +--! Describes the zone where band sharing occurs. When reusing CDD Rel.1 types, names are unchanged. +--! @category: Infrastructure information, Communication information +--ZoneDefinition::= SEQUENCE{ + --! @details interferenceManagementZoneLatitude + --! Latitude of the centre point of the interference management zone. +-- interferenceManagementZoneLatitude Latitude, - - from ITS-Container + --! @details interferenceManagementZoneLongitude + --! Longitude of the centre point of the interference management zone. +-- interferenceManagementZoneLongitude Longitude, - - from ITS-Container + --! @details interferenceManagementZoneRadius + --! Radius of the interference management zone in metres. + --! This DE is present if the data is available +-- interferenceManagementZoneRadius ProtectedZoneRadius OPTIONAL, - - from ITS-Container + --! @details interferenceManagementZoneID + --! Identification of the interference management zone. + --! This DE is present if the data is available. +-- interferenceManagementZoneID ProtectedZoneId OPTIONAL, - - from ITS-Container + --! @details interferenceManagementZoneShape + --! Shape of the interference management zone. + --! This DF is present if the data is available. +-- interferenceManagementZoneShape InterferenceManagementZoneShape OPTIONAL, +-- ... +--} + +--! @brief DF: Interference Management Information +--! A list of up to 16 definitions containing which interference management may be applied in the zone, +--! per affected frequency channels. +--! +--! **Note**: in the case where no mitigation should be applied by the ITS-S, this is indicated +--! by the value of interferenceManagementMitigationType set to unavailable. +--! @category: Infrastructure information, Communication information +-- InterferenceManagementInfo::= SEQUENCE (SIZE(1..16,...)) OF InterferenceManagementInfoPerChannel + +--! @brief DF: Interference Management Information Per Channel +--! A break up of the interference management information per affected frequency channels. +--! @category: Infrastructure information, Communication information +--InterferenceManagementInfoPerChannel ::= SEQUENCE { + --! @details interferenceManagementChannel + --! Characteritics of the frequency channel for which the zone + --! should be applied interference management +-- interferenceManagementChannel InterferenceManagementChannel, + --! @details interferenceManagementZoneType + --! Type of the interference management zone. +-- interferenceManagementZoneType InterferenceManagementZoneType, + --! @details interferenceManagementMitigationType + --! Type of the mitigation to be used in the interference management zone. +-- interferenceManagementMitigationType InterferenceManagementMitigationType OPTIONAL, + --! @details expiryTime + --! Time at which the validity of the interference management communication zone will expire. + --! This DE is present when the interference management is temporarily valid +-- expiryTime TimestampIts OPTIONAL, - - from ITS-Container +-- ... +--} + +--! @brief DF: InterferenceManagementChannel +--! Indicates which shared frequency channel should be applied interference management in the zone. +--! @category: Communication information +--InterferenceManagementChannel ::= SEQUENCE { + --! @details centre frequency of the channel + --! @unit: 10exp+2 Hz (where exp is exponent) +-- centreFrequency INTEGER (1 .. 99999), + --! @details width of the channel + --! @unit: 10exp Hz (where exp is exponent) +-- channelWidth INTEGER (0 .. 9999), + --! @details exponent of the power of 10 + --! @unit: N/A +-- exponent INTEGER (0 .. 15) +--} + +--! @brief DE: InterferenceManagementZoneType +--! defines the type of an interference management zone, so that an ITS-S can +--! assert the actions to do while passing by such zone (e.g. reduce the transmit +--! power in case of a DSRC tolling station). +--! @unit: N/A +--! @category: Communication information +--InterferenceManagementZoneType ::= ENUMERATED { +-- permanentCenDsrcTolling(0), - -!< as specified in ETSI TS 102 792 +-- temporaryCenDsrcTolling(1), - -!< as specified in ETSI TS 102 792 +-- unavailable(2), - -!< default value. Set to 2 for backwards compatibility with DSRC tolling +-- urbanRail(3), - -!< as specified in ETSI TS 103 724, clause 7 +-- satelliteStation(4), - -!< as specified in ETSI TS 103 724, clause 7 +-- fixedLinks(5), - -!< as specified in ETSI TS 103 724, clause 7 +-- ... +--} + +--! @brief DF: Mitigation type in the interference management zone +--! Information and commands defining the required mitigation type the +--! receiving ITS-S has to use in the defined interference management zone. +--! It indicates the type of mitigation and the parameters to be used to protect the +--! potential victim in the interference management zone per channel access technology class. +--! @category: Communication information +--InterferenceManagementMitigationType ::= CHOICE { + --! @details unavailable is the default value to be used when data is not available. +-- unavailable NULL, +-- mitigationForTechnologies MitigationForTechnologies +--} + +--! @brief DF: Mitigation type container for the different channel access technology classes +--! Class of parameters for the relevant channel access technology classes, +--! as specified in ETSI TS 103 724, clause 7. +--! @category: Communication information +--MitigationForTechnologies ::= SEQUENCE (SIZE(1..8)) OF MitigationPerTechnologyClass + +--! @brief DF: Mitigation type container per channel access technology class +--! Class of parameters for the specific technology indicated in the container. +--! All parameters are optional, as they may not apply to some of the technologies or +--! interference management zone types. Specification details are in ETSI TS 103 724, clause 7. +--! @category: Communication information +--MitigationPerTechnologyClass ::= SEQUENCE { + --! @details channel access technology in which this mitigation is applied. + --! @unit: N/A +-- accessTechnologyClass AccessTechnologyClass, + --! @details duty cycle limit. + --! @unit: 0.01% steps +-- lowDutyCycle INTEGER (0 .. 10000) OPTIONAL, + --! @details power reduction. + --! @unit: dB +-- powerReduction INTEGER (0 .. 30) OPTIONAL, + --! @details Idle time limit as defined in ETSI TS 103 175. + --! @unit: ms +-- dmcToffLimit INTEGER (0 .. 1200) OPTIONAL, + --! @details Transmission duration limit, as defined in ETSI EN 302 571. + --! @unit: ms +-- dmcTonLimit INTEGER (0 .. 20) OPTIONAL, +-- ... +--} + +--! @brief DE: channel access technology class +--! Access technology to which the mitigation type applies. +--! @category: Communication information +--AccessTechnologyClass ::= ENUMERATED { +-- any(0), - -!< any access technology class (see clause 7 of TS 103 724). +-- itsg5Class(1), - -!< ITS-G5 access technology class. +-- ltev2xClass(2), - -!< LTE-V2X access technology class. +-- nrv2xClass(3), - -!< NR-V2X access technology class. +-- ... +--} + +--! @brief DF: Shape of the interference management zone +--! Bounding box of an interference management zone +--! @category: GeoReference information +--InterferenceManagementZoneShape::= CHOICE { +-- rectangle AreaRectangle, - - imported from VAM-Temp-Imports +-- circle AreaCircular, - - imported from VAM-Temp-Imports +-- polygon AreaPolygon, - - imported from VAM-Temp-Imports +-- ellipse AreaEllipse, - - could not be imported from another specification yet +-- ... +--} + +--! @brief DF: Area Ellipse +--! Area Ellipse copied from CPM TR 103 562. Will be removed when CDD Release 2 is available. +--! Describes an elliptical area. The ellipse is centred about the reference point +--! of the ITS-S or about the nodeCenterPoint (if provided). +--! @category: GeoReference information +--AreaEllipse ::= SEQUENCE { + --! @details nodeCenterPoint + --! Optional offset point about which the ellipse is centred with respect to the reference + --! position of the ITS-S. +-- nodeCenterPoint OffsetPoint OPTIONAL, + --! @details semiMajorRangeLength + --! Minor radius of the ellipse. +-- semiMajorRangeLength SemiRangeLength, + --! @details semiMinorRangeLength + --! Major radius of the ellipse. +-- semiMinorRangeLength SemiRangeLength, + --! @details semiMajorRangeOrientation + --! Orientation of the semiMajorRangeLength of the ellipse in the WGS84 coordinate system. +-- semiMajorRangeOrientation WGS84AngleValue +--} + +END diff --git a/epan/dissectors/asn1/its/ISO19321IVIv2.asn b/epan/dissectors/asn1/its/ISO19321IVIv2.asn new file mode 100644 index 00000000..2340b301 --- /dev/null +++ b/epan/dissectors/asn1/its/ISO19321IVIv2.asn @@ -0,0 +1,722 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 19321 +-- +-- Published version location: +-- https://standards.iso.org/iso/ts/19321/ed-2/en/ISO19321IVIv2.asn +-- +-- Changes to original version: +-- - add this header +-- - rename imported module CITSdataDictionary1 -> CITSapplMgmtIDs +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +IVI {iso (1) standard (0) ivi (19321) version2 (2)} + +DEFINITIONS AUTOMATIC TAGS ::= +BEGIN +IMPORTS + +ActionID, Altitude, DangerousGoodsBasic , DeltaLatitude, DeltaLongitude, DeltaReferencePosition, Heading, HeadingValue, Latitude, LanePosition, Longitude, +ReferencePosition, RoadType, SpecialTransportType, Speed, SpeedValue, StationType, TimestampIts, VehicleRole, VarLengthNumber, EuVehicleCategoryCode, Iso3833VehicleType +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + +AxleWeightLimits, DieselEmissionValues, ExhaustEmissionValues, EngineCharacteristics, EnvironmentalCharacteristics, PassengerCapacity , Provider, SoundLevel, VehicleDimensions, VehicleWeightLimits +FROM EfcDsrcApplication {iso(1) standard(0) 14906 application(0) version6(6)} + +--EuVehicleCategoryCode, +--Iso3833VehicleType +--FROM ElectronicRegistrationIdentificationVehicleDataModule {iso(1) standard(0) iso24534 (24534) vehicleData (1) version1 (1)} + +--VarLengthNumber use ETSI-ITS-CDD instead +--FROM CITSapplMgmtIDs {iso(1) standard(0) cits-applMgmt (17419) dataDictionary (1) version1 (1)} + +RoadSegmentReferenceID, IntersectionReferenceID, LaneID +FROM DSRC {iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 (2)} + +InternationalSign-applicablePeriod, InternationalSign-exemptedApplicablePeriod, InternationalSign-directionalFlowOfLane, InternationalSign-applicableVehicleDimensions, InternationalSign-speedLimits, InternationalSign-rateOfIncline, InternationalSign-distanceBetweenVehicles, InternationalSign-destinationInformation +FROM GDD {iso (1) standard (0) gdd(14823) version1 (0)}; + +-- Definition of IVI structure + +IviStructure::= SEQUENCE{ + mandatory IviManagementContainer, + optional IviContainers OPTIONAL + } + +IviContainers ::= SEQUENCE (SIZE (1..8,...)) OF IviContainer + +--Definition of Containers + +IviContainer::= CHOICE { + glc GeographicLocationContainer, + giv GeneralIviContainer, + rcc RoadConfigurationContainer, + tc TextContainer, + lac LayoutContainer, + ..., -- original extension indicator of V1 +[[ -- Extension in V2 + avc AutomatedVehicleContainer, + mlc MapLocationContainer, + rsc RoadSurfaceContainer ]] + } + +IviManagementContainer::= SEQUENCE { + serviceProviderId Provider, + iviIdentificationNumber IviIdentificationNumber, + timeStamp TimestampIts OPTIONAL, + validFrom TimestampIts OPTIONAL, + validTo TimestampIts OPTIONAL, + connectedIviStructures IviIdentificationNumbers OPTIONAL, + iviStatus IviStatus, + ..., -- original extension indicator of V1 + connectedDenms ConnectedDenms OPTIONAL -- Extension in V2 + } + +GeographicLocationContainer::= SEQUENCE { + referencePosition ReferencePosition, + referencePositionTime TimestampIts OPTIONAL, + referencePositionHeading Heading OPTIONAL, + referencePositionSpeed Speed OPTIONAL, + parts GlcParts, + ... + } +GlcParts ::= SEQUENCE (SIZE (1..16,...)) OF GlcPart + +GlcPart::= SEQUENCE { + zoneId Zid, + laneNumber LanePosition OPTIONAL, + zoneExtension INTEGER (0..255) OPTIONAL, + zoneHeading HeadingValue OPTIONAL, + zone Zone OPTIONAL, + ... + } + +GeneralIviContainer::= SEQUENCE (SIZE (1..16,...)) OF GicPart + +GicPart::= SEQUENCE { + detectionZoneIds ZoneIds OPTIONAL, + its-Rrid VarLengthNumber OPTIONAL, + relevanceZoneIds ZoneIds OPTIONAL, + direction Direction OPTIONAL, + driverAwarenessZoneIds ZoneIds OPTIONAL, + minimumAwarenessTime INTEGER (0..255) OPTIONAL, + applicableLanes LanePositions OPTIONAL, + iviType IviType, + iviPurpose IviPurpose OPTIONAL, + laneStatus LaneStatus OPTIONAL, + vehicleCharacteristics VehicleCharacteristicsList OPTIONAL, + driverCharacteristics DriverCharacteristics OPTIONAL, + layoutId INTEGER(1..4,...) OPTIONAL, + preStoredlayoutId INTEGER(1..64,...) OPTIONAL, + roadSignCodes RoadSignCodes, + extraText ConstraintTextLines1 OPTIONAL, + ... + } + +RoadConfigurationContainer::= SEQUENCE (SIZE (1..16,...)) OF RccPart + +RccPart::= SEQUENCE{ + relevanceZoneIds ZoneIds, + roadType RoadType, + laneConfiguration LaneConfiguration, + ... + } + +RoadSurfaceContainer::= SEQUENCE (SIZE (1..16,...)) OF RscPart + +RscPart::= SEQUENCE{ + detectionZoneIds ZoneIds OPTIONAL, + relevanceZoneIds ZoneIds, + direction Direction OPTIONAL, + roadSurfaceStaticCharacteristics RoadSurfaceStaticCharacteristics OPTIONAL, + roadSurfaceDynamicCharacteristics RoadSurfaceDynamicCharacteristics OPTIONAL + } (WITH COMPONENTS {..., roadSurfaceStaticCharacteristics PRESENT} | + WITH COMPONENTS {..., roadSurfaceDynamicCharacteristics PRESENT}) + +TextContainer::= SEQUENCE (SIZE (1..16,...)) OF TcPart + +TcPart::= SEQUENCE { + detectionZoneIds ZoneIds OPTIONAL, + relevanceZoneIds ZoneIds, + direction Direction OPTIONAL, + driverAwarenessZoneIds ZoneIds OPTIONAL, + minimumAwarenessTime INTEGER (0..255) OPTIONAL, + applicableLanes LanePositions OPTIONAL, + layoutId INTEGER(1..4,...) OPTIONAL, + preStoredlayoutId INTEGER(1..64,...) OPTIONAL, + text TextLines OPTIONAL, + data OCTET STRING, + ..., +[[ --extension in V2 + iviType IviType, + laneStatus LaneStatus OPTIONAL, + vehicleCharacteristics VehicleCharacteristicsList OPTIONAL ]] + } + +LayoutContainer::=SEQUENCE{ + layoutId INTEGER(1..4,...), + height INTEGER(10..73) OPTIONAL, + width INTEGER(10..265) OPTIONAL, + layoutComponents LayoutComponents, + ... + } + +AutomatedVehicleContainer::= SEQUENCE (SIZE (1..16,...)) OF AvcPart -- new container in V2 + +AvcPart::= SEQUENCE { -- new container part in V2 + detectionZoneIds ZoneIds OPTIONAL, + relevanceZoneIds ZoneIds, + direction Direction OPTIONAL, + applicableLanes LanePositions OPTIONAL, + vehicleCharacteristics VehicleCharacteristicsList OPTIONAL, + automatedVehicleRules AutomatedVehicleRules OPTIONAL, + platooningRules PlatooningRules OPTIONAL, + ... + } (WITH COMPONENTS {..., automatedVehicleRules PRESENT} | + WITH COMPONENTS {..., platooningRules PRESENT}) + + +MapLocationContainer::=SEQUENCE{ -- new container in V2 + reference MapReference, + parts MlcParts + } + +MlcParts::= SEQUENCE (SIZE (1..16,...)) OF MlcPart -- new container part in V2 + +MlcPart::= SEQUENCE{ -- new container part in V2 + zoneId Zid, + laneIds LaneIds OPTIONAL + } + +-- Definition of data frames which are lists of data frames +-- note: those definitions are to avoid "implicit type definitions" but are bit compatible with V1 + +AbsolutePositions ::= SEQUENCE (SIZE (1..8,...)) OF AbsolutePosition + +AbsolutePositionsWAltitude ::= SEQUENCE (SIZE (1..8,...)) OF AbsolutePositionWAltitude + +AutomatedVehicleRules::= SEQUENCE (SIZE (1..5)) OF AutomatedVehicleRule -- new DF in V2 + +ConnectedDenms::= SEQUENCE (SIZE(1..8, ...)) OF ActionID -- new DF in V2 + +DeltaPositions ::= SEQUENCE (SIZE (1..32,...,100)) OF DeltaPosition --size extension in V2 + +DeltaReferencePositions ::= SEQUENCE (SIZE (1..32,..., 100)) OF DeltaReferencePosition --size extension in V2 + +ConstraintTextLines1 ::= SEQUENCE (SIZE (1..4),...) OF Text (WITH COMPONENTS {layoutComponentId, language, textContent (SIZE(1..32))}) + +ConstraintTextLines2::= SEQUENCE (SIZE (1..4),...) OF Text (WITH COMPONENTS {..., textContent (SIZE(1..32))}) + +IviIdentificationNumbers ::= SEQUENCE (SIZE(1..8)) OF IviIdentificationNumber + +ISO14823Attributes::= SEQUENCE (SIZE(1..8),...) OF ISO14823Attribute + +LaneConfiguration ::= SEQUENCE (SIZE (1..16,...)) OF LaneInformation + +LaneIds::= SEQUENCE (SIZE (1..16,...)) OF LaneID + +LanePositions ::= SEQUENCE (SIZE (1..8,...)) OF LanePosition + +LayoutComponents ::= SEQUENCE SIZE (1..4,...) OF LayoutComponent + +PlatooningRules::= SEQUENCE (SIZE (1..5)) OF PlatooningRule -- new DF in V2 + +RoadSignCodes ::= SEQUENCE (SIZE (1..4),...) OF RSCode + +TextLines::= SEQUENCE (SIZE (1..4),...) OF Text + +TrailerCharacteristicsList ::= SEQUENCE (SIZE (1..3)) OF TrailerCharacteristics + +TrailerCharacteristicsFixValuesList ::= SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues (WITH COMPONENTS {..., euroAndCo2value ABSENT, engineCharacteristics ABSENT}) + +TrailerCharacteristicsRangesList ::= SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsRanges (WITH COMPONENTS {comparisonOperator, limits (WITH COMPONENTS {..., exhaustEmissionValues ABSENT, dieselEmissionValues ABSENT, soundLevel ABSENT})}) + +SaeAutomationLevels::= SEQUENCE (SIZE (1..5)) OF SaeAutomationLevel -- new DF in V2 + +VehicleCharacteristicsFixValuesList ::= SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues + +VehicleCharacteristicsList ::= SEQUENCE (SIZE (1..8, ...)) OF CompleteVehicleCharacteristics + +VehicleCharacteristicsRangesList ::= SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsRanges + +ValidityPeriods ::= SEQUENCE (SIZE (1..8),...) OF InternationalSign-applicablePeriod + +ZoneIds ::= SEQUENCE (SIZE (1..8,...)) OF Zid + +-- Definition of Data Frames + +AbsolutePosition::= SEQUENCE{ + latitude Latitude, + longitude Longitude + } + +AbsolutePositionWAltitude::= SEQUENCE{ + latitude Latitude, + longitude Longitude, + altitude Altitude + } + +AnyCatalogue::=SEQUENCE{ + owner Provider, + version INTEGER(0..255), + pictogramCode INTEGER(0..65535), + value INTEGER (0..65535) OPTIONAL, + unit RSCUnit OPTIONAL, + attributes ISO14823Attributes OPTIONAL + } + +AutomatedVehicleRule::= SEQUENCE { -- new DF in V2 + priority PriorityLevel, + allowedSaeAutomationLevels SaeAutomationLevels, + minGapBetweenVehicles GapBetweenVehicles OPTIONAL, + recGapBetweenVehicles GapBetweenVehicles OPTIONAL, + automatedVehicleMaxSpeedLimit SpeedValue OPTIONAL, + automatedVehicleMinSpeedLimit SpeedValue OPTIONAL, + automatedVehicleSpeedRecommendation SpeedValue OPTIONAL, + roadSignCodes RoadSignCodes OPTIONAL, + extraText ConstraintTextLines2 OPTIONAL, + ... + } + +CompleteVehicleCharacteristics::= SEQUENCE{ + tractor TractorCharacteristics OPTIONAL, + trailer TrailerCharacteristicsList OPTIONAL, + train TrainCharacteristics OPTIONAL + } + +ComputedSegment::= SEQUENCE { + zoneId Zid, + laneNumber LanePosition, + laneWidth IviLaneWidth, + offsetDistance INTEGER (-32768..32767) OPTIONAL, + offsetPosition DeltaReferencePosition OPTIONAL + } + +DeltaPosition::=SEQUENCE{ + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude + } + +ISO14823Attribute::= CHOICE{ + dtm InternationalSign-applicablePeriod, -- Date/Time/Period + edt InternationalSign-exemptedApplicablePeriod,-- Exemption status of Date/Time/Period + dfl InternationalSign-directionalFlowOfLane,-- Directional Flow of Lane + ved InternationalSign-applicableVehicleDimensions,-- Vehicle Dimensions + spe InternationalSign-speedLimits,-- Speed + roi InternationalSign-rateOfIncline,-- Rate of Incline + dbv InternationalSign-distanceBetweenVehicles,-- Distance Between Vehicles + ddd InternationalSign-destinationInformation-- Destination/Direction/Distance + } + +ISO14823Code ::= SEQUENCE{ + pictogramCode SEQUENCE { + countryCode OCTET STRING (SIZE (2)) OPTIONAL, + serviceCategoryCode CHOICE { + trafficSignPictogram ENUMERATED {dangerWarning, regulatory, informative,...}, + publicFacilitiesPictogram ENUMERATED {publicFacilities, ...}, + ambientOrRoadConditionPictogram ENUMERATED {ambientCondition, roadCondition,...}, + ...}, + pictogramCategoryCode SEQUENCE { + nature INTEGER (1..9), + serialNumber INTEGER (0..99) + }}, + attributes ISO14823Attributes OPTIONAL + } + +LaneInformation::= SEQUENCE{ + laneNumber LanePosition, + direction Direction, + validity InternationalSign-applicablePeriod OPTIONAL, + laneType LaneType, + laneTypeQualifier CompleteVehicleCharacteristics OPTIONAL, + laneStatus LaneStatus, + laneWidth IviLaneWidth OPTIONAL, + ..., +[[ --extension in V2 + detectionZoneIds ZoneIds OPTIONAL, + relevanceZoneIds ZoneIds OPTIONAL, + laneCharacteristics LaneCharacteristics OPTIONAL, + laneSurfaceStaticCharacteristics RoadSurfaceStaticCharacteristics OPTIONAL, + laneSurfaceDynamicCharacteristics RoadSurfaceDynamicCharacteristics OPTIONAL ]] + } + +LaneCharacteristics::= SEQUENCE{ + zoneDefinitionAccuracy DefinitionAccuracy, + existinglaneMarkingStatus LaneMarkingStatus, + newlaneMarkingColour MarkingColour, + laneDelimitationLeft LaneDelimitation, + laneDelimitationRight LaneDelimitation, + mergingWith Zid + } + +LayoutComponent::=SEQUENCE{ + layoutComponentId INTEGER(1..8,...), + height INTEGER(10..73), + width INTEGER(10..265), + x INTEGER(10..265), + y INTEGER(10..73), + textScripting INTEGER {horizontal (0), vertical (1)}(0..1) + } + +LoadType::= SEQUENCE{ + goodsType GoodsType, + dangerousGoodsType DangerousGoodsBasic, + specialTransportType SpecialTransportType + } + +MapReference::= CHOICE { -- new DF in V2 + roadsegment RoadSegmentReferenceID, + intersection IntersectionReferenceID + } + +PlatooningRule::= SEQUENCE { -- new DF in V2 + priority PriorityLevel, + allowedSaeAutomationLevels SaeAutomationLevels, + maxNoOfVehicles MaxNoOfVehicles OPTIONAL, + maxLenghtOfPlatoon MaxLenghtOfPlatoon OPTIONAL, + minGapBetweenVehicles GapBetweenVehicles OPTIONAL, + platoonMaxSpeedLimit SpeedValue OPTIONAL, + platoonMinSpeedLimit SpeedValue OPTIONAL, + platoonSpeedRecommendation SpeedValue OPTIONAL, + roadSignCodes RoadSignCodes OPTIONAL, + extraText ConstraintTextLines2 OPTIONAL, + ... + } + +PolygonalLine::= CHOICE { + deltaPositions DeltaPositions, + deltaPositionsWithAltitude DeltaReferencePositions, + absolutePositions AbsolutePositions, + absolutePositionsWithAltitude AbsolutePositionsWAltitude, + ... + } + +RoadSurfaceDynamicCharacteristics::= SEQUENCE{ + condition Condition, + temperature Temperature, + iceOrWaterDepth Depth, + treatment TreatmentType + } + +RoadSurfaceStaticCharacteristics::= SEQUENCE{ + frictionCoefficient FrictionCoefficient, + material MaterialType, + wear WearLevel, + avBankingAngle BankingAngle + } + +RSCode::= SEQUENCE{ + layoutComponentId INTEGER(1..4,...) OPTIONAL, + code CHOICE { + viennaConvention VcCode, -- see Vienna Convention Annex A + iso14823 ISO14823Code, + itisCodes INTEGER (0..65535), -- see SAE J2540 + anyCatalogue AnyCatalogue, + ... + }} + +Segment::= SEQUENCE { + line PolygonalLine, + laneWidth IviLaneWidth OPTIONAL + } + +Text::= SEQUENCE { + layoutComponentId INTEGER(1..4,...) OPTIONAL, + language BIT STRING (SIZE(10)), + textContent UTF8String + } + +TractorCharacteristics::=SEQUENCE{ + equalTo VehicleCharacteristicsFixValuesList OPTIONAL, + notEqualTo VehicleCharacteristicsFixValuesList OPTIONAL, + ranges VehicleCharacteristicsRangesList OPTIONAL + } + +TrailerCharacteristics::=SEQUENCE{ + equalTo TrailerCharacteristicsFixValuesList OPTIONAL, + notEqualTo TrailerCharacteristicsFixValuesList OPTIONAL, + ranges TrailerCharacteristicsRangesList OPTIONAL + } + +TrainCharacteristics::= TractorCharacteristics + +VcCode::= SEQUENCE { + roadSignClass VcClass, -- see Vienna Convention + roadSignCode INTEGER (1..64), + vcOption VcOption, -- e.g. the "a" in H, 3a + validity ValidityPeriods OPTIONAL, + value INTEGER (0..65535) OPTIONAL, + unit RSCUnit OPTIONAL + } + +VehicleCharacteristicsFixValues::= CHOICE{ + simpleVehicleType StationType, + euVehicleCategoryCode EuVehicleCategoryCode, + iso3833VehicleType Iso3833VehicleType, + euroAndCo2value EnvironmentalCharacteristics, + engineCharacteristics EngineCharacteristics, + loadType LoadType, + usage VehicleRole, + ... + } + +VehicleCharacteristicsRanges::= SEQUENCE{ + comparisonOperator ComparisonOperator, + limits CHOICE{ + numberOfAxles INTEGER(0..7), + vehicleDimensions VehicleDimensions, + vehicleWeightLimits VehicleWeightLimits, + axleWeightLimits AxleWeightLimits, + passengerCapacity PassengerCapacity, + exhaustEmissionValues ExhaustEmissionValues, + dieselEmissionValues DieselEmissionValues, + soundLevel SoundLevel, + ... + } + } + +Zone::= CHOICE { + segment Segment, + area PolygonalLine, + computedSegment ComputedSegment, + ... + } + +-- Defition of IVI specific data elements + +BankingAngle::=INTEGER (-20..21) + +ComparisonOperator ::= INTEGER { + greaterThan (0), + greaterThanOrEqualTo (1), + lessThan (2), + lessThanOrEqualTo (3) + } (0..3) + +Condition::=INTEGER{ + dry (0), + moist (1), + wet (2), + standingWater (3), + frost (4), + ice (5), + snow (6), + slush (7), + unvailable (8) +-- values 9 to 15 reserved for future use +} (0..15, ...) + +DefinitionAccuracy::= INTEGER{ + oneCm (0), + twoCm (1), + fiveCm (2), + tenCm (3), + twentyCm (4), + fiftyCm (5), + oneMeter (6), + unavailable (7) +} (0..7, ...) + +Depth::= INTEGER (0..255) + +Direction::= INTEGER{ + sameDirection (0), + oppositeDirection (1), + bothDirections (2), + valueNotUsed (3) + } (0..3) + +DriverCharacteristics::= INTEGER{ + unexperiencedDrivers (0), + experiencedDrivers (1), + rfu1 (2), + rfu2 (3) + } (0..3) + +FrictionCoefficient::= INTEGER (0..101) + +GapBetweenVehicles::= INTEGER (0..255) -- new DE in V2 + +GoodsType::= INTEGER { + ammunition (0), + chemicals (1), + empty (2), + fuel (3), + glass (4), + dangerous (5), + liquid (6), + liveStock (7), + dangerousForPeople (8), + dangerousForTheEnvironment (9), + dangerousForWater (10), + perishableProducts (11), + pharmaceutical (12), + vehicles (13) + -- other values reserved for future use + } (0..15,...) + +IviIdentificationNumber::= INTEGER(1..32767,...) + +IviLaneWidth::= INTEGER (0..1023) -- only renamed from V1, no change + +IviPurpose::= INTEGER { + safety (0), + environmental (1), + trafficOptimisation (2) + } (0..3) + +IviStatus::= INTEGER { + new (0), + update (1), + cancellation (2), + negation (3) + -- other values reserved for future use + }(0..7) + +IviType::= INTEGER { + immediateDangerWarningMessages (0), + regulatoryMessages (1), + trafficRelatedInformationMessages (2), + pollutionMessages (3), + notTrafficRelatedInformationMessages (4) + -- other values reserved for future use + } (0..7) + +LaneDelimitation::=INTEGER { + noDelimitation (0), + lowLaneSeparator (1), + highLaneSeparator (2), + wall (3), + curb (4), + unpaved (5), + guardrail (6) + -- value 7 reserved for future use +} (0..7, ...) + +LaneMarkingStatus::= BOOLEAN + +LaneStatus::= INTEGER { + open (0), + closed (1), + mergeR (2), + mergeL (3), + mergeLR (4), + provisionallyOpen (5), + diverging (6) + -- value 7 reserved for future use +} (0..7, ...) + +LaneType::= INTEGER{ + traffic (0), + through (1), + reversible (2), + acceleration (3), + deceleration (4), + leftHandTurning (5), + rightHandTurning (6), + dedicatedVehicle (7), + bus (8), + taxi (9), + hov (10), + hot (11), + pedestrian (12), + bikeLane (13), + median (14), + striping (15), + trackedVehicle (16), + parking (17), + emergency (18), + verge (19), + minimumRiskManoeuvre(20) +-- values 21 to 31 reserved for future use + }(0..31) + +MarkingColour::=INTEGER { + white (0), + yellow (1), + orange (2), + red (3), + blue (4), + unavailable (7) + -- value 5,6 reserved for future use +} (0..7, ...) + +MaterialType::=INTEGER { + asphalt (0), + concrete (1), + cobblestone (2), + gravel (3), + unavailable (7) +-- value 4, 5,6 reserved for future use +} (0..7, ...) + +MaxLenghtOfPlatoon::= INTEGER (1..64) -- new DE in V2 + +MaxNoOfVehicles::= INTEGER (2..64) -- new DE in V2 + +PriorityLevel::=INTEGER (0..2) -- new DE in V2 + +RSCUnit::= INTEGER { + kmperh (0), + milesperh (1), + kilometer (2), + meter (3), + decimeter (4), + centimeter (5), + mile (6), + yard (7), + foot (8), + minutesOfTime (9), + tonnes (10), --1000 kg, not Ton! + hundredkg (11), + pound (12), --lbs + rateOfIncline (13) + -- other value reserved for future use + } (0..15) + +SaeAutomationLevel::= INTEGER (0..5) -- new DE in V2 + +Temperature::=INTEGER (-100..151) + +TreatmentType ::= INTEGER { + no (0), + antiskid (1), + anti-icing (2), + de-icing (3), + unavailable (7) +-- value 4 to 6 reserved for future use + } (0..7) + +VcClass::= INTEGER { + classA (0), + classB (1), + classC (2), + classD (3), + classE (4), + classF (5), + classG (6), + classH (7) + } (0..7) + +VcOption::= INTEGER { + none (0), + a (1), + b (2), + c (3), + d (4), + e (5), + f (6), + g (7) + } (0..7) + +WearLevel::=INTEGER { + new (0), + good (1), + bad (2), + hasPotholes (3), + unavailable (7) +-- value 4, 5,6 reserved for future use +} (0..7, ...) + +Zid::= INTEGER (1..32,...) + +END diff --git a/epan/dissectors/asn1/its/ISO_TS_14816.asn b/epan/dissectors/asn1/its/ISO_TS_14816.asn new file mode 100644 index 00000000..9f7298f9 --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_14816.asn @@ -0,0 +1,29 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 14816 +-- +-- This ASN.1 was generateds: 30.08.2016 +-- +-- This document contains only the data element needed for the encoding of an IVI message +-- as defined in ISO TS 19321(2015) +-- +-- Published version location: +-- http://standards.iso.org/iso/14816/ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +AVIAEINumberingAndDataStructures {iso(1) standard(0) iso14816(14816) asnm1(1) version1(1)} + +DEFINITIONS AUTOMATIC TAGS::= BEGIN +IMPORTS; + +CS5::= SEQUENCE { + vin VisibleString, -- 17 characters VIN + fill BIT STRING (SIZE(9)) -- set to '000000000' +} + + + +CountryCode::= BIT STRING(SIZE(10)) + +AVIAEIIssuerIdentifier::= INTEGER(0 .. 16383) + +END diff --git a/epan/dissectors/asn1/its/ISO_TS_14906_Application.asn b/epan/dissectors/asn1/its/ISO_TS_14906_Application.asn new file mode 100644 index 00000000..98db4809 --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_14906_Application.asn @@ -0,0 +1,143 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 14906 Application +-- +-- This ASN.1 was generateds: 30.08.2016 +-- +-- This document contains only the data element needed for the encoding of an IVI message +-- as defined in ISO TS 19321(2015) +-- +-- Published version location: +-- http://standards.iso.org/iso/14906 +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +EfcDsrcApplication { iso(1) standard(0) 14906 application(0) version5(5) } + +DEFINITIONS AUTOMATIC TAGS ::= BEGIN +EXPORTS ALL; +IMPORTS +CountryCode, CS5, AVIAEIIssuerIdentifier +FROM AVIAEINumberingAndDataStructures {iso(1) standard(0) iso14816(14816) asnm1(1) version1(1)} +-- defined in ISO 14816 -- +AttributeIdList +FROM EfcDsrcGeneric {iso(1) standard(0) 14906 generic(1) version5(5)} +-- NOTE: The following are the definitions of the action and response +-- parameters + +; +-- End of IMPORTS + +AxleWeightLimits ::= SEQUENCE { + maxLadenweightOnAxle1 Int2, + maxLadenweightOnAxle2 Int2, + maxLadenweightOnAxle3 Int2, + maxLadenweightOnAxle4 Int2, + maxLadenweightOnAxle5 Int2 +} + +DieselEmissionValues::= SEQUENCE { + particulate SEQUENCE { + unitType UnitType, + value INTEGER (0..32767) + }, + absorptionCoeff Int2 +} + +EnvironmentalCharacteristics::= SEQUENCE { + euroValue EuroValue, + copValue CopValue +} + +EuroValue::= ENUMERATED { + noEntry (0), + euro-1 (1), + euro-2 (2), + euro-3 (3), + euro-4 (4), + euro-5 (5), + euro-6 (6), + reservedForUse1 (7), + reservedForUse2 (8), + reservedForUse3 (9), + reservedForUse4 (10), + reservedForUse5 (11), + reservedForUse6 (12), + reservedForUse7 (13), + reservedForUse8 (14), + eev (15) +} -- 4 bits, EURO-Clases as defined in EC directive 88/77/EEC, annex 1 +-- and in 91/542/EEC, 96/1/EC, 1999/96/EC, 2001/27/EC, regulation No 595/2009 +-- and for EEV in Section 6.2.1 of Annex I in EC directive 2005/55/EC + +CopValue::= ENUMERATED { + noEntry (0), + co2class1 (1), -- below 101 g/km + co2class2 (2), -- 101 to 120 g/km + co2class3 (3), -- 121 to 140 g/km + co2class4 (4), -- 141 to 160 g/km + co2class5 (5), -- 161 to 200 g/km + co2class6 (6), -- 201 to 250 g/km + co2class7 (7), -- above 250 g/km + reservedforUse (8) -- reserved for future CEN and ISO use +} -- 4 bits, reserved for carbon dioxide pollution values as defined in +-- EC directive 2003/127/EC' + +EngineCharacteristics::= INTEGER { + noEntry (0), + noEngine (1), + petrolUnleaded (2), + petrolLeaded (3), + diesel (4), + lPG (5), + battery (6), + solar (7), + hybrid (8), + hydrogen (9) + -- (10-255) are reserved for future CEN use +} (0..255) + +ExhaustEmissionValues ::= SEQUENCE { + unitType UnitType, + emissionCO INTEGER (0..32767), + emissionHC Int2, + emissionNOX Int2, + emissionHCNOX Int2 +} + + +Int1 ::= INTEGER(0..255) + +Int2 ::= INTEGER(0..65535) + +PassengerCapacity ::= SEQUENCE{ + numberOfSeats Int1, + numberOfStandingPlaces Int1 +} + +Provider ::= SEQUENCE { + countryCode CountryCode, + providerIdentifier AVIAEIIssuerIdentifier +} + +SoundLevel ::= SEQUENCE{ + soundstationary Int1, + sounddriveby Int1 +} + +UnitType::= ENUMERATED { + mg-km (0), + mg-kWh (1) +} + +VehicleDimensions ::= SEQUENCE { + vehicleLengthOverall Int1, + vehicleHeigthOverall Int1, + vehicleWidthOverall Int1 +} + +VehicleWeightLimits ::= SEQUENCE { + vehicleMaxLadenWeight Int2, + vehicleTrainMaximumWeight Int2, + vehicleWeightUnladen Int2 +} + +END diff --git a/epan/dissectors/asn1/its/ISO_TS_17419.asn b/epan/dissectors/asn1/its/ISO_TS_17419.asn new file mode 100644 index 00000000..e705e21e --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_17419.asn @@ -0,0 +1,44 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 17419 +-- +-- This ASN.1 was generateds: 30.08.2016 +-- +-- This document contains only the data element needed for the encoding of an IVI message +-- as defined in ISO TS 19321(2015) +-- +-- Published version location: +-- http://standards.iso.org/iso/ts/17419/ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +CITSapplMgmtIDs {iso(1) standard(0) cits-applMgmt (17419) ids (1) version1 (1)} + +DEFINITIONS AUTOMATIC TAGS::=BEGIN + +IMPORTS + +; + +-- End of IMPORTS + +-- Types + +-- Variable length data types + +VarLengthNumber::=CHOICE{ + content [0] INTEGER(0..127), -- one octet length + extension [1] Ext1 + } + +Ext1::=CHOICE{ + content [0] INTEGER(128..16511), -- two octets length + extension [1] Ext2 +} + +Ext2::=CHOICE{ + content [0] INTEGER(16512..2113663), -- three octets length + extension [1] Ext3 + } + +Ext3::=INTEGER(2113664..270549119,...) -- four and more octets length + +END diff --git a/epan/dissectors/asn1/its/ISO_TS_19091.asn b/epan/dissectors/asn1/its/ISO_TS_19091.asn new file mode 100644 index 00000000..f9adef05 --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_19091.asn @@ -0,0 +1,1583 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 19091 +-- +-- This ASN.1 was generated: 30.08.2016 +-- +-- This document contains the data element needed for the encoding the SPAT, MapData, SignalRequestMessage, SignalStatusMessage message +-- as defined in ISO TS 19091 and SAEJ2735 +-- +-- It includes the addendunm extensions for Addgrp-C (e.g. Europe) +-- +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: DSRC +-- Some Types renamed (added xxxDSRC) to avoid name-clashes with CDD +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- + +DSRC { + iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 (2) +} + +DEFINITIONS AUTOMATIC TAGS::= BEGIN + +IMPORTS + +Longitude, Latitude, StationID, VehicleHeight, Iso3833VehicleType +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + +Reg-AdvisorySpeed, Reg-ComputedLane, Reg-ConnectionManeuverAssist, Reg-GenericLane, +Reg-IntersectionGeometry, Reg-IntersectionState, Reg-LaneAttributes, Reg-MapData, +Reg-LaneDataAttribute, Reg-MovementEvent, Reg-MovementState, +Reg-NodeAttributeSetXY, Reg-NodeOffsetPointXY, Reg-Position3D, Reg-RequestorDescription, Reg-RequestorType, Reg-RestrictionUserType, Reg-RoadSegment, +Reg-RTCMcorrections, Reg-SignalControlZone, Reg-SignalRequestPackage, Reg-SignalRequest, Reg-SignalStatus, Reg-SignalStatusPackage, Reg-SignalRequestMessage, +Reg-SignalStatusMessage, Reg-SPAT +FROM REGION {iso (1) standard (0) signalizedIntersection (19091) profilec(2) region (1) version2 (2)} + + +--Iso3833VehicleType +--FROM ElectronicRegistrationIdentificationVehicleDataModule { iso(1) standard(0) iso24534 (24534) vehicleData (1) version1 (1) } +; + +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ +-- Messages +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ + +REG-EXT-ID-AND-TYPE ::= CLASS { + &id RegionId UNIQUE, + &Type +} WITH SYNTAX {&Type IDENTIFIED BY &id} + +RegionalExtension {REG-EXT-ID-AND-TYPE : Set} ::= SEQUENCE { + regionId REG-EXT-ID-AND-TYPE.&id( {Set} ), + regExtValue REG-EXT-ID-AND-TYPE.&Type( {Set}{@regionId} ) +} + +MapData ::= SEQUENCE { + timeStamp MinuteOfTheYear OPTIONAL, + msgIssueRevision MsgCount, + layerType LayerType OPTIONAL, + layerID LayerID OPTIONAL, + intersections IntersectionGeometryList OPTIONAL, + roadSegments RoadSegmentList OPTIONAL, + dataParameters DataParameters OPTIONAL, + restrictionList RestrictionClassList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-MapData}} OPTIONAL, + ... +} + +RTCMcorrections ::= SEQUENCE { + msgCnt MsgCount, + rev RTCM-Revision, + timeStamp MinuteOfTheYear OPTIONAL, + anchorPoint FullPositionVector OPTIONAL, + rtcmHeader RTCMheader OPTIONAL, + msgs RTCMmessageList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-RTCMcorrections}} OPTIONAL, + ... +} + +SPAT ::= SEQUENCE { + timeStamp MinuteOfTheYear OPTIONAL, + name DescriptiveName OPTIONAL, + intersections IntersectionStateList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SPAT}} OPTIONAL, + ... +} + +SignalRequestMessage ::= SEQUENCE { + timeStamp MinuteOfTheYear OPTIONAL, + second DSecond, + sequenceNumber MsgCount OPTIONAL, + requests SignalRequestList OPTIONAL, + requestor RequestorDescription, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalRequestMessage}} OPTIONAL, + ... +} + +SignalStatusMessage ::= SEQUENCE { + timeStamp MinuteOfTheYear OPTIONAL, + second DSecond, + sequenceNumber MsgCount OPTIONAL, + status SignalStatusList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalStatusMessage}} OPTIONAL, + ... +} + + + + +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ +-- Start of entries from table Data_Frames... +-- Data frames +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ + +AdvisorySpeed ::= SEQUENCE { + type AdvisorySpeedType, + speed SpeedAdvice OPTIONAL, + confidence SpeedConfidenceDSRC OPTIONAL, + distance ZoneLength OPTIONAL, + class RestrictionClassID OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-AdvisorySpeed}} OPTIONAL, + ... +} + +AdvisorySpeedList ::= SEQUENCE (SIZE(1..16)) OF AdvisorySpeed + +AntennaOffsetSet ::= SEQUENCE { + antOffsetX Offset-B12, + antOffsetY Offset-B09, + antOffsetZ Offset-B10 + } + +ComputedLane ::= SEQUENCE { + referenceLaneId LaneID, + offsetXaxis CHOICE { + small DrivenLineOffsetSm, + large DrivenLineOffsetLg + }, + offsetYaxis CHOICE { + small DrivenLineOffsetSm, + large DrivenLineOffsetLg + }, + rotateXY Angle OPTIONAL, + scaleXaxis Scale-B12 OPTIONAL, + scaleYaxis Scale-B12 OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-ComputedLane}} OPTIONAL, + ... +} + +ConnectsToList ::= SEQUENCE (SIZE(1..16)) OF Connection + +ConnectingLane ::= SEQUENCE { + lane LaneID, + maneuver AllowedManeuvers OPTIONAL +} + +Connection ::= SEQUENCE { + connectingLane ConnectingLane, + remoteIntersection IntersectionReferenceID OPTIONAL, + signalGroup SignalGroupID OPTIONAL, + userClass RestrictionClassID OPTIONAL, + connectionID LaneConnectionID OPTIONAL +} + +ConnectionManeuverAssist ::= SEQUENCE { + connectionID LaneConnectionID, + queueLength ZoneLength OPTIONAL, + availableStorageLength ZoneLength OPTIONAL, + waitOnStop WaitOnStopline OPTIONAL, + pedBicycleDetect PedestrianBicycleDetect OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-ConnectionManeuverAssist}} OPTIONAL, + ... +} + +DataParameters ::= SEQUENCE { + processMethod IA5String(SIZE(1..255)) OPTIONAL, + processAgency IA5String(SIZE(1..255)) OPTIONAL, + lastCheckedDate IA5String(SIZE(1..255)) OPTIONAL, + geoidUsed IA5String(SIZE(1..255)) OPTIONAL, + ... +} + + +DDateTime ::= SEQUENCE { + year DYear OPTIONAL, + month DMonth OPTIONAL, + day DDay OPTIONAL, + hour DHour OPTIONAL, + minute DMinute OPTIONAL, + second DSecond OPTIONAL, + offset DOffset OPTIONAL + } + +EnabledLaneList ::= SEQUENCE (SIZE(1..16)) OF LaneID + +FullPositionVector ::= SEQUENCE { + utcTime DDateTime OPTIONAL, -- time with mSec precision + long Longitude, + lat Latitude, + elevation Elevation OPTIONAL, + heading HeadingDSRC OPTIONAL, + speed TransmissionAndSpeed OPTIONAL, + posAccuracy PositionalAccuracy OPTIONAL, + timeConfidence TimeConfidence OPTIONAL, + posConfidence PositionConfidenceSet OPTIONAL, + speedConfidence SpeedandHeadingandThrottleConfidence OPTIONAL, + ... + } + + +GenericLane ::= SEQUENCE { + laneID LaneID, + name DescriptiveName OPTIONAL, + ingressApproach ApproachID OPTIONAL, + egressApproach ApproachID OPTIONAL, + laneAttributes LaneAttributes, + maneuvers AllowedManeuvers OPTIONAL, + nodeList NodeListXY, + connectsTo ConnectsToList OPTIONAL, + overlays OverlayLaneList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-GenericLane}} OPTIONAL, + ... +} + +IntersectionAccessPoint ::= CHOICE { + lane LaneID, + approach ApproachID, + connection LaneConnectionID, + ... +} + +IntersectionGeometry ::= SEQUENCE { + name DescriptiveName OPTIONAL, + id IntersectionReferenceID, + revision MsgCount, + refPoint Position3D, + laneWidth LaneWidth OPTIONAL, + speedLimits SpeedLimitList OPTIONAL, + laneSet LaneList, + preemptPriorityData PreemptPriorityList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-IntersectionGeometry}} OPTIONAL, + ... +} + +IntersectionGeometryList ::= SEQUENCE (SIZE(1..32)) OF IntersectionGeometry + +IntersectionReferenceID ::= SEQUENCE { + region RoadRegulatorID OPTIONAL, + id IntersectionID +} + +IntersectionState ::= SEQUENCE { + name DescriptiveName OPTIONAL, + id IntersectionReferenceID, + revision MsgCount, + status IntersectionStatusObject, + moy MinuteOfTheYear OPTIONAL, + timeStamp DSecond OPTIONAL, + enabledLanes EnabledLaneList OPTIONAL, + states MovementList, + maneuverAssistList ManeuverAssistList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-IntersectionState}} OPTIONAL, + ... +} + +IntersectionStateList ::= SEQUENCE (SIZE(1..32)) OF IntersectionState + +LaneAttributes ::= SEQUENCE { + directionalUse LaneDirection, + sharedWith LaneSharing, + laneType LaneTypeAttributes, + regional RegionalExtension {{Reg-LaneAttributes}} OPTIONAL +} + +LaneDataAttribute ::= CHOICE { + pathEndPointAngle DeltaAngle, + laneCrownPointCenter RoadwayCrownAngle, + laneCrownPointLeft RoadwayCrownAngle, + laneCrownPointRight RoadwayCrownAngle, + laneAngle MergeDivergeNodeAngle, + speedLimits SpeedLimitList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-LaneDataAttribute}}, + ... +} + +LaneDataAttributeList ::= SEQUENCE (SIZE(1..8)) OF LaneDataAttribute + +LaneList ::= SEQUENCE (SIZE(1..255)) OF GenericLane + +LaneSharing ::= BIT STRING { + overlappingLaneDescriptionProvided (0), + multipleLanesTreatedAsOneLane (1), + otherNonMotorizedTrafficTypes (2), + individualMotorizedVehicleTraffic (3), + busVehicleTraffic (4), + taxiVehicleTraffic (5), + pedestriansTraffic (6), + cyclistVehicleTraffic (7), + trackedVehicleTraffic (8), + pedestrianTraffic (9) +} (SIZE (10)) + +LaneTypeAttributes ::= CHOICE { + vehicle LaneAttributes-Vehicle, + crosswalk LaneAttributes-Crosswalk, + bikeLane LaneAttributes-Bike, + sidewalk LaneAttributes-Sidewalk, + median LaneAttributes-Barrier, + striping LaneAttributes-Striping, + trackedVehicle LaneAttributes-TrackedVehicle, + parking LaneAttributes-Parking, + ... +} + +ManeuverAssistList ::= SEQUENCE (SIZE(1..16)) OF ConnectionManeuverAssist + +MovementEvent ::= SEQUENCE { + eventState MovementPhaseState, + timing TimeChangeDetails OPTIONAL, + speeds AdvisorySpeedList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-MovementEvent}} OPTIONAL, + ... +} + +MovementEventList ::= SEQUENCE (SIZE(1..16)) OF MovementEvent + +MovementList ::= SEQUENCE (SIZE(1..255)) OF MovementState + +MovementState ::= SEQUENCE { + movementName DescriptiveName OPTIONAL, + signalGroup SignalGroupID, + state-time-speed MovementEventList, + maneuverAssistList ManeuverAssistList OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-MovementState}} OPTIONAL, + ... +} + +NodeAttributeSetXY ::= SEQUENCE { + localNode NodeAttributeXYList OPTIONAL, + disabled SegmentAttributeXYList OPTIONAL, + enabled SegmentAttributeXYList OPTIONAL, + data LaneDataAttributeList OPTIONAL, + dWidth Offset-B10 OPTIONAL, + dElevation Offset-B10 OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-NodeAttributeSetXY}} OPTIONAL, + ... +} + +NodeAttributeXY ::= ENUMERATED { + reserved, + stopLine, + roundedCapStyleA, + roundedCapStyleB, + mergePoint, + divergePoint, + downstreamStopLine, + downstreamStartNode, + closedToTraffic, + safeIsland, + curbPresentAtStepOff, + hydrantPresent, + ... +} + +NodeAttributeXYList ::= SEQUENCE (SIZE(1..8)) OF NodeAttributeXY + +Node-LLmD-64b ::= SEQUENCE { + lon Longitude, + lat Latitude +} + +Node-XY-20b ::= SEQUENCE { + x Offset-B10, + y Offset-B10 +} + +Node-XY-22b ::= SEQUENCE { + x Offset-B11, + y Offset-B11 +} + +Node-XY-24b ::= SEQUENCE { + x Offset-B12, + y Offset-B12 +} + +Node-XY-26b ::= SEQUENCE { + x Offset-B13, + y Offset-B13 +} + +Node-XY-28b ::= SEQUENCE { + x Offset-B14, + y Offset-B14 +} + +Node-XY-32b ::= SEQUENCE { + x Offset-B16, + y Offset-B16 +} + +NodeListXY ::= CHOICE { + nodes NodeSetXY, + computed ComputedLane, + ... +} + +NodeOffsetPointXY ::= CHOICE { + node-XY1 Node-XY-20b, + node-XY2 Node-XY-22b, + node-XY3 Node-XY-24b, + node-XY4 Node-XY-26b, + node-XY5 Node-XY-28b, + node-XY6 Node-XY-32b, + node-LatLon Node-LLmD-64b, + regional RegionalExtension {{Reg-NodeOffsetPointXY}} +} + +NodeXY ::= SEQUENCE { + delta NodeOffsetPointXY, + attributes NodeAttributeSetXY OPTIONAL, + ... +} + +NodeSetXY ::= SEQUENCE (SIZE(2..63)) OF NodeXY + +OverlayLaneList ::= SEQUENCE (SIZE(1..5)) OF LaneID + +PositionalAccuracy ::= SEQUENCE { + semiMajor SemiMajorAxisAccuracy, + semiMinor SemiMinorAxisAccuracy, + orientation SemiMajorAxisOrientation +} + +PositionConfidenceSet ::= SEQUENCE { + pos PositionConfidence, -- for both horizontal directions + elevation ElevationConfidence + } + + +Position3D ::= SEQUENCE { + lat Latitude, + long Longitude, + elevation Elevation OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-Position3D}} OPTIONAL, + ... +} + +PreemptPriorityList ::= SEQUENCE (SIZE(1..32)) OF SignalControlZone + +RegulatorySpeedLimit ::= SEQUENCE { + type SpeedLimitType, + speed Velocity +} + +RequestorDescription ::= SEQUENCE { + id VehicleID, + type RequestorType OPTIONAL, + position RequestorPositionVector OPTIONAL, + name DescriptiveName OPTIONAL, + routeName DescriptiveName OPTIONAL, + transitStatus TransitVehicleStatus OPTIONAL, + transitOccupancy TransitVehicleOccupancy OPTIONAL, + transitSchedule DeltaTime OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-RequestorDescription}} OPTIONAL, + ... +} + +RequestorPositionVector ::= SEQUENCE { + position Position3D, + heading Angle OPTIONAL, + speed TransmissionAndSpeed OPTIONAL, + ... +} + +RequestorType ::= SEQUENCE { + role BasicVehicleRole, + subrole RequestSubRole OPTIONAL, + request RequestImportanceLevel OPTIONAL, + iso3883 Iso3833VehicleType OPTIONAL, + hpmsType VehicleType OPTIONAL, + regional RegionalExtension {{Reg-RequestorType}} OPTIONAL, + ... +} + +RestrictionClassAssignment ::= SEQUENCE { + id RestrictionClassID, + users RestrictionUserTypeList +} + +RestrictionClassList ::= SEQUENCE (SIZE(1..254)) OF RestrictionClassAssignment + +RestrictionUserType ::= CHOICE { + basicType RestrictionAppliesTo, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-RestrictionUserType}}, + ... +} + +RestrictionUserTypeList ::= SEQUENCE (SIZE(1..16)) OF RestrictionUserType + +RoadLaneSetList ::= SEQUENCE (SIZE(1..255)) OF GenericLane + +RoadSegmentReferenceID ::= SEQUENCE { + region RoadRegulatorID OPTIONAL, + id RoadSegmentID +} + +RoadSegment ::= SEQUENCE { + name DescriptiveName OPTIONAL, + id RoadSegmentReferenceID, + revision MsgCount, + refPoint Position3D, + laneWidth LaneWidth OPTIONAL, + speedLimits SpeedLimitList OPTIONAL, + roadLaneSet RoadLaneSetList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-RoadSegment}} OPTIONAL, + ... +} + +RoadSegmentList ::= SEQUENCE (SIZE(1..32)) OF RoadSegment + +RTCMheader ::= SEQUENCE { + status GNSSstatus, + offsetSet AntennaOffsetSet + } + +RTCMmessageList ::= SEQUENCE (SIZE(1..5)) OF RTCMmessage + +SegmentAttributeXYList ::= SEQUENCE (SIZE(1..8)) OF SegmentAttributeXY + +SignalControlZone ::= SEQUENCE { + zone RegionalExtension {{Reg-SignalControlZone}}, + ... +} + +SignalRequesterInfo ::= SEQUENCE { + id VehicleID, + request RequestID, + sequenceNumber MsgCount, + role BasicVehicleRole OPTIONAL, + typeData RequestorType OPTIONAL, + ... +} + +SignalRequest ::= SEQUENCE { + id IntersectionReferenceID, + requestID RequestID, + requestType PriorityRequestType, + inBoundLane IntersectionAccessPoint, + outBoundLane IntersectionAccessPoint OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalRequest}} OPTIONAL, + ... +} + +SignalRequestList ::= SEQUENCE (SIZE(1..32)) OF SignalRequestPackage + +SignalRequestPackage ::= SEQUENCE { + request SignalRequest, + minute MinuteOfTheYear OPTIONAL, + second DSecond OPTIONAL, + duration DSecond OPTIONAL, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalRequestPackage}} OPTIONAL, + ... +} + +SignalStatus ::= SEQUENCE { + sequenceNumber MsgCount, + id IntersectionReferenceID, + sigStatus SignalStatusPackageList, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalStatus}} OPTIONAL, + ... +} + +SignalStatusList ::= SEQUENCE (SIZE(1..32)) OF SignalStatus + +SignalStatusPackageList ::= SEQUENCE (SIZE(1..32)) OF SignalStatusPackage + +SignalStatusPackage ::= SEQUENCE { + requester SignalRequesterInfo OPTIONAL, + inboundOn IntersectionAccessPoint, + outboundOn IntersectionAccessPoint OPTIONAL, + + minute MinuteOfTheYear OPTIONAL, + second DSecond OPTIONAL, + duration DSecond OPTIONAL, + status PrioritizationResponseStatus, + regional SEQUENCE (SIZE(1..4)) OF + RegionalExtension {{Reg-SignalStatusPackage}} OPTIONAL, + ... +} + +SpeedandHeadingandThrottleConfidence ::= SEQUENCE { + heading HeadingConfidenceDSRC, + speed SpeedConfidenceDSRC, + throttle ThrottleConfidence + } + + +SpeedLimitList ::= SEQUENCE (SIZE(1..9)) OF RegulatorySpeedLimit + +SpeedLimitType ::= ENUMERATED { + unknown, + maxSpeedInSchoolZone, + maxSpeedInSchoolZoneWhenChildrenArePresent, + maxSpeedInConstructionZone, + vehicleMinSpeed, + vehicleMaxSpeed, + vehicleNightMaxSpeed, + truckMinSpeed, + truckMaxSpeed, + truckNightMaxSpeed, + vehiclesWithTrailersMinSpeed, + vehiclesWithTrailersMaxSpeed, + vehiclesWithTrailersNightMaxSpeed, + ... +} + +TimeChangeDetails ::= SEQUENCE { + startTime TimeMark OPTIONAL, + minEndTime TimeMark, + maxEndTime TimeMark OPTIONAL, + likelyTime TimeMark OPTIONAL, + confidence TimeIntervalConfidence OPTIONAL, + nextTime TimeMark OPTIONAL +} + +TimeMark ::= INTEGER (0..36001) + +TransmissionAndSpeed ::= SEQUENCE { + transmisson TransmissionState, + speed Velocity +} + +VehicleID ::= CHOICE { + entityID TemporaryID, + stationID StationID +} + + +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ +-- data elements +-- -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ + +AdvisorySpeedType ::= ENUMERATED { + none (0), + greenwave (1), + ecoDrive (2), + transit (3), + ... +} + +AllowedManeuvers ::= BIT STRING { + maneuverStraightAllowed (0), + maneuverLeftAllowed (1), + maneuverRightAllowed (2), + maneuverUTurnAllowed (3), + maneuverLeftTurnOnRedAllowed (4), + maneuverRightTurnOnRedAllowed (5), + maneuverLaneChangeAllowed (6), + maneuverNoStoppingAllowed (7), + yieldAllwaysRequired (8), + goWithHalt (9), + caution (10), + reserved1 (11) +} (SIZE(12)) + +Angle ::= INTEGER (0..28800) + +ApproachID ::= INTEGER (0..15) + +BasicVehicleRole ::= ENUMERATED { + basicVehicle (0), + publicTransport (1), + specialTransport (2), + dangerousGoods (3), + roadWork (4), + roadRescue (5), + emergency (6), + safetyCar (7), + none-unknown (8), + truck (9), + motorcycle (10), + roadSideSource (11), + police (12), + fire (13), + ambulance (14), + dot (15), + transit (16), + slowMoving (17), + stopNgo (18), + cyclist (19), + pedestrian (20), + nonMotorized (21), + military (22), + ... +} + +DDay ::= INTEGER (0..31) + +DeltaAngle ::= INTEGER (-150..150) + +DeltaTime ::= INTEGER (-122 .. 121) + +DescriptiveName ::= IA5String (SIZE(1..63)) + +DHour ::= INTEGER (0..31) + +DMinute ::= INTEGER (0..60) + +DMonth ::= INTEGER (0..12) + +DOffset ::= INTEGER (-840..840) + +DrivenLineOffsetLg ::= INTEGER (-32767..32767) + +DrivenLineOffsetSm ::= INTEGER (-2047..2047) + +DSecond ::= INTEGER (0..65535) + +DSRCmsgID ::= INTEGER (0..32767) + mapData DSRCmsgID ::= 18 + rtcmCorrections DSRCmsgID ::= 28 + signalPhaseAndTimingMessage DSRCmsgID ::= 19 + signalRequestMessage DSRCmsgID ::= 29 + signalStatusMessage DSRCmsgID ::= 30 + +DYear ::= INTEGER (0..4095) + +Elevation ::= INTEGER (-4096..61439) + +ElevationConfidence ::= ENUMERATED { + unavailable (0), + elev-500-00 (1), + elev-200-00 (2), + elev-100-00 (3), + elev-050-00 (4), + elev-020-00 (5), + elev-010-00 (6), + elev-005-00 (7), + elev-002-00 (8), + elev-001-00 (9), + elev-000-50 (10), + elev-000-20 (11), + elev-000-10 (12), + elev-000-05 (13), + elev-000-02 (14), + elev-000-01 (15) + } + + +FuelType ::= INTEGER (0..15) + unknownFuel FuelType ::= 0 + gasoline FuelType ::= 1 + ethanol FuelType ::= 2 + diesel FuelType ::= 3 + electric FuelType ::= 4 + hybrid FuelType ::= 5 + hydrogen FuelType ::= 6 + natGasLiquid FuelType ::= 7 + natGasComp FuelType ::= 8 + propane FuelType ::= 9 + +GNSSstatus ::= BIT STRING { + unavailable (0), + isHealthy (1), + isMonitored (2), + baseStationType (3), + aPDOPofUnder5 (4), + inViewOfUnder5 (5), + localCorrectionsPresent (6), + networkCorrectionsPresent (7) + } (SIZE(8)) + +HeadingConfidenceDSRC ::= ENUMERATED { + unavailable (0), + prec10deg (1), + prec05deg (2), + prec01deg (3), + prec0-1deg (4), + prec0-05deg (5), + prec0-01deg (6), + prec0-0125deg (7) + } + +HeadingDSRC ::= INTEGER (0..28800) + +IntersectionID ::= INTEGER (0..65535) + +IntersectionStatusObject ::= BIT STRING { + manualControlIsEnabled (0), + stopTimeIsActivated (1), + failureFlash (2), + preemptIsActive (3), + signalPriorityIsActive (4), + fixedTimeOperation (5), + trafficDependentOperation (6), + standbyOperation (7), + failureMode (8), + off (9), + recentMAPmessageUpdate (10), + recentChangeInMAPassignedLanesIDsUsed (11), + noValidMAPisAvailableAtThisTime (12), + noValidSPATisAvailableAtThisTime (13) +} (SIZE(16)) + +LaneAttributes-Barrier ::= BIT STRING { + median-RevocableLane (0), + median (1), + whiteLineHashing (2), + stripedLines (3), + doubleStripedLines (4), + trafficCones (5), + constructionBarrier (6), + trafficChannels (7), + lowCurbs (8), + highCurbs (9) +} (SIZE (16)) + +LaneAttributes-Bike ::= BIT STRING { + bikeRevocableLane (0), + pedestrianUseAllowed (1), + isBikeFlyOverLane (2), + fixedCycleTime (3), + biDirectionalCycleTimes (4), + isolatedByBarrier (5), + unsignalizedSegmentsPresent (6) +} (SIZE (16)) + +LaneAttributes-Crosswalk ::= BIT STRING { + crosswalkRevocableLane (0), + bicyleUseAllowed (1), + isXwalkFlyOverLane (2), + fixedCycleTime (3), + biDirectionalCycleTimes (4), + hasPushToWalkButton (5), + audioSupport (6), + rfSignalRequestPresent (7), + unsignalizedSegmentsPresent (8) +} (SIZE (16)) + +LaneAttributes-Parking ::= BIT STRING { + parkingRevocableLane (0), + parallelParkingInUse (1), + headInParkingInUse (2), + doNotParkZone (3), + parkingForBusUse (4), + parkingForTaxiUse (5), + noPublicParkingUse (6) +} (SIZE (16)) + +LaneAttributes-Sidewalk ::= BIT STRING { + sidewalk-RevocableLane (0), + bicyleUseAllowed (1), + isSidewalkFlyOverLane (2), + walkBikes (3) +} (SIZE (16)) + +LaneAttributes-Striping ::= BIT STRING { + stripeToConnectingLanesRevocableLane (0), + stripeDrawOnLeft (1), + stripeDrawOnRight (2), + stripeToConnectingLanesLeft (3), + stripeToConnectingLanesRight (4), + stripeToConnectingLanesAhead (5) +} (SIZE (16)) + +LaneAttributes-TrackedVehicle ::= BIT STRING { + spec-RevocableLane (0), + spec-commuterRailRoadTrack (1), + spec-lightRailRoadTrack (2), + spec-heavyRailRoadTrack (3), + spec-otherRailType (4) +} (SIZE (16)) + + +LaneAttributes-Vehicle ::= BIT STRING { + isVehicleRevocableLane (0), + isVehicleFlyOverLane (1), + hovLaneUseOnly (2), + restrictedToBusUse (3), + restrictedToTaxiUse (4), + restrictedFromPublicUse (5), + hasIRbeaconCoverage (6), + permissionOnRequest (7) +} (SIZE (8,...)) + +LaneConnectionID ::= INTEGER (0..255) + +LaneDirection ::= BIT STRING { + ingressPath (0), + egressPath (1) +} (SIZE (2)) + +LaneID ::= INTEGER (0..255) + +LayerID ::= INTEGER (0..100) + +LayerType ::= ENUMERATED { + none, + mixedContent, + generalMapData, + intersectionData, + curveData, + roadwaySectionData, + parkingAreaData, + sharedLaneData, + ... +} + +LaneWidth ::= INTEGER (0..32767) + +MergeDivergeNodeAngle ::= INTEGER (-180..180) + +MinuteOfTheYear ::= INTEGER (0..527040) + +MovementPhaseState ::= ENUMERATED { + unavailable (0), + dark (1), + stop-Then-Proceed (2), + stop-And-Remain (3), + pre-Movement (4), + permissive-Movement-Allowed (5), + protected-Movement-Allowed (6), + permissive-clearance (7), + protected-clearance (8), + caution-Conflicting-Traffic (9) +} + +MsgCount ::= INTEGER (0..127) + +Offset-B09 ::= INTEGER (-256..255) + +Offset-B10 ::= INTEGER (-512..511) + +Offset-B11 ::= INTEGER (-1024..1023) + +Offset-B12 ::= INTEGER (-2048..2047) + +Offset-B13 ::= INTEGER (-4096..4095) + +Offset-B14 ::= INTEGER (-8192..8191) + +Offset-B16 ::= INTEGER (-32768..32767) + +PedestrianBicycleDetect ::= BOOLEAN + +PositionConfidence ::= ENUMERATED { + unavailable (0), + a500m (1), + a200m (2), + a100m (3), + a50m (4), + a20m (5), + a10m (6), + a5m (7), + a2m (8), + a1m (9), + a50cm (10), + a20cm (11), + a10cm (12), + a5cm (13), + a2cm (14), + a1cm (15) + } + +PrioritizationResponseStatus ::= ENUMERATED { + unknown (0), + requested (1), + processing (2), + watchOtherTraffic (3), + granted (4), + rejected (5), + maxPresence (6), + reserviceLocked (7), + ... +} + +PriorityRequestType ::= ENUMERATED { + priorityRequestTypeReserved (0), + priorityRequest (1), + priorityRequestUpdate (2), + priorityCancellation (3), + ... +} + +RegionId ::= INTEGER (0..255) + noRegion RegionId ::= 0 + addGrpA RegionId ::= 1 + addGrpB RegionId ::= 2 + addGrpC RegionId ::= 3 + +RequestID ::= INTEGER (0..255) + +RequestImportanceLevel ::= ENUMERATED { + requestImportanceLevelUnKnown (0), + requestImportanceLevel1 (1), + requestImportanceLevel2 (2), + requestImportanceLevel3 (3), + requestImportanceLevel4 (4), + requestImportanceLevel5 (5), + requestImportanceLevel6 (6), + requestImportanceLevel7 (7), + requestImportanceLevel8 (8), + requestImportanceLevel9 (9), + requestImportanceLevel10 (10), + requestImportanceLevel11 (11), + requestImportanceLevel12 (12), + requestImportanceLevel13 (13), + requestImportanceLevel14 (14), + requestImportanceReserved (15) +} + +RequestSubRole ::= ENUMERATED { + requestSubRoleUnKnown (0), + requestSubRole1 (1), + requestSubRole2 (2), + requestSubRole3 (3), + requestSubRole4 (4), + requestSubRole5 (5), + requestSubRole6 (6), + requestSubRole7 (7), + requestSubRole8 (8), + requestSubRole9 (9), + requestSubRole10 (10), + requestSubRole11 (11), + requestSubRole12 (12), + requestSubRole13 (13), + requestSubRole14 (14), + requestSubRoleReserved (15) +} + +RestrictionAppliesTo ::= ENUMERATED { + none, + equippedTransit, + equippedTaxis, + equippedOther, + emissionCompliant, + equippedBicycle, + weightCompliant, + heightCompliant, + pedestrians, + slowMovingPersons, + wheelchairUsers, + visualDisabilities, + audioDisabilities, + otherUnknownDisabilities, + ... +} + +RestrictionClassID ::= INTEGER (0..255) + +RoadRegulatorID ::= INTEGER (0..65535) + +RoadSegmentID ::= INTEGER (0..65535) + +RoadwayCrownAngle ::= INTEGER (-128..127) + +RTCMmessage ::= OCTET STRING (SIZE(1..1023)) + +RTCM-Revision ::= ENUMERATED { + unknown (0), + rtcmRev2 (1), -- Std 10402.x et al + rtcmRev3 (2), -- Std 10403.x et al + reserved (3), + ... +} + +Scale-B12 ::= INTEGER (-2048..2047) + +SignalGroupID ::= INTEGER (0..255) + +SegmentAttributeXY ::= ENUMERATED { + reserved , + doNotBlock , + whiteLine , + mergingLaneLeft , + mergingLaneRight , + curbOnLeft , + curbOnRight , + loadingzoneOnLeft , + loadingzoneOnRight , + turnOutPointOnLeft , + turnOutPointOnRight , + adjacentParkingOnLeft , + adjacentParkingOnRight , + adjacentBikeLaneOnLeft , + adjacentBikeLaneOnRight , + sharedBikeLane , + bikeBoxInFront , + transitStopOnLeft , + transitStopOnRight , + transitStopInLane , + sharedWithTrackedVehicle , + safeIsland , + lowCurbsPresent , + rumbleStripPresent , + audibleSignalingPresent , + adaptiveTimingPresent , + rfSignalRequestPresent , + partialCurbIntrusion , + taperToLeft , + taperToRight , + taperToCenterLine , + parallelParking , + headInParking , + freeParking , + timeRestrictionsOnParking , + costToPark , + midBlockCurbPresent , + unEvenPavementPresent , + ... +} + +SemiMajorAxisAccuracy ::= INTEGER (0..255) + +SemiMajorAxisOrientation ::= INTEGER (0..65535) + +SemiMinorAxisAccuracy ::= INTEGER (0..255) + +SpeedAdvice ::= INTEGER (0..500) + +SpeedConfidenceDSRC ::= ENUMERATED { + unavailable (0), -- Not Equipped or unavailable + prec100ms (1), -- 100 meters / sec + prec10ms (2), -- 10 meters / sec + prec5ms (3), -- 5 meters / sec + prec1ms (4), -- 1 meters / sec + prec0-1ms (5), -- 0.1 meters / sec + prec0-05ms (6), -- 0.05 meters / sec + prec0-01ms (7) -- 0.01 meters / sec + } + +TemporaryID ::= OCTET STRING (SIZE(4)) + +ThrottleConfidence ::= ENUMERATED { + unavailable (0), + prec10percent (1), + prec1percent (2), + prec0-5percent (3) + } + +TimeConfidence ::= ENUMERATED { + unavailable (0), + time-100-000 (1), + time-050-000 (2), + time-020-000 (3), + time-010-000 (4), + time-002-000 (5), + time-001-000 (6), + time-000-500 (7), + time-000-200 (8), + time-000-100 (9), + time-000-050 (10), + time-000-020 (11), + time-000-010 (12), + time-000-005 (13), + time-000-002 (14), + time-000-001 (15), + time-000-000-5 (16), + time-000-000-2 (17), + time-000-000-1 (18), + time-000-000-05 (19), + time-000-000-02 (20), + time-000-000-01 (21), + time-000-000-005 (22), + time-000-000-002 (23), + time-000-000-001 (24), + time-000-000-000-5 (25), + time-000-000-000-2 (26), + time-000-000-000-1 (27), + time-000-000-000-05 (28), + time-000-000-000-02 (29), + time-000-000-000-01 (30), + time-000-000-000-005 (31), + time-000-000-000-002 (32), + time-000-000-000-001 (33), + time-000-000-000-000-5 (34), + time-000-000-000-000-2 (35), + time-000-000-000-000-1 (36), + time-000-000-000-000-05 (37), + time-000-000-000-000-02 (38), + time-000-000-000-000-01 (39) +} + +TimeIntervalConfidence ::= INTEGER (0..15) + +TransitVehicleOccupancy ::= ENUMERATED { + occupancyUnknown (0), + occupancyEmpty (1), + occupancyVeryLow (2), + occupancyLow (3), + occupancyMed (4), + occupancyHigh (5), + occupancyNearlyFull (6), + occupancyFull (7) +} + +TransitVehicleStatus ::= BIT STRING { + loading (0), + anADAuse (1), + aBikeLoad (2), + doorOpen (3), + charging (4), + atStopLine (5) +} (SIZE(8)) + +TransmissionState ::= ENUMERATED { + neutral (0), + park (1), + forwardGears (2), + reverseGears (3), + reserved1 (4), + reserved2 (5), + reserved3 (6), + unavailable (7) +} + +--VehicleHeight ::= INTEGER (0..127) + +VehicleType ::= ENUMERATED { + none (0), + unknown (1), + special (2), + moto (3), + car (4), + carOther (5), + bus (6), + axleCnt2 (7), + axleCnt3 (8), + axleCnt4 (9), + axleCnt4Trailer (10), + axleCnt5Trailer (11), + axleCnt6Trailer (12), + axleCnt5MultiTrailer (13), + axleCnt6MultiTrailer (14), + axleCnt7MultiTrailer (15), + ... +} + +Velocity ::= INTEGER (0..8191) + +WaitOnStopline ::= BOOLEAN + +ZoneLength ::= INTEGER (0..10000) + +END + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: AddGrpC +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +AddGrpC { + iso (1) standard (0) signalizedIntersection (19091) profilec (2) addgrpc (0) + version2 (2) + } + +DEFINITIONS AUTOMATIC TAGS::= BEGIN + +IMPORTS + +DeltaTime, FuelType, IntersectionID, LaneConnectionID, LaneID, NodeOffsetPointXY, NodeSetXY, PrioritizationResponseStatus, SignalGroupID +FROM DSRC { + iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 (2) +} + + +Altitude, DeltaAltitude, StationID, VehicleMass, VehicleHeight +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)}; + +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- AddGrpC data dictionary extensions to SAEJ2735 +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +ConnectionManeuverAssist-addGrpC ::= SEQUENCE { + itsStationPosition ItsStationPositionList OPTIONAL, + ... +} + +ConnectionTrajectory-addGrpC ::= SEQUENCE { + nodes NodeSetXY, + connectionID LaneConnectionID, + ... +} + +IntersectionState-addGrpC ::= SEQUENCE { + activePrioritizations PrioritizationResponseList OPTIONAL, + ... +} + +LaneAttributes-addGrpC ::= SEQUENCE { + maxVehicleHeight VehicleHeight OPTIONAL, + maxVehicleWeight VehicleMass OPTIONAL, + ... +} + +MapData-addGrpC ::= SEQUENCE { + signalHeadLocations SignalHeadLocationList OPTIONAL, + ... +} + +MovementEvent-addGrpC ::= SEQUENCE { + stateChangeReason ExceptionalCondition OPTIONAL, + ... +} + +NodeAttributeSet-addGrpC ::= SEQUENCE { + ptvRequest PtvRequestType OPTIONAL, + nodeLink NodeLink OPTIONAL, + node Node OPTIONAL, + ... +} + +Position3D-addGrpC ::= SEQUENCE { + altitude Altitude, + ... +} + +RestrictionUserType-addGrpC ::= SEQUENCE { + emission EmissionType OPTIONAL, + fuel FuelType OPTIONAL, + ... +} + +RequestorDescription-addGrpC ::= SEQUENCE { + fuel FuelType OPTIONAL, + batteryStatus BatteryStatus OPTIONAL, + ... +} + +SignalStatusPackage-addGrpC ::= SEQUENCE { + synchToSchedule DeltaTime OPTIONAL, + rejectedReason RejectedReason OPTIONAL, + ... +} + + +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Data frames +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +ItsStationPosition ::= SEQUENCE { + stationID StationID, + laneID LaneID OPTIONAL, + nodeXY NodeOffsetPointXY OPTIONAL, + timeReference TimeReference OPTIONAL, + ... +} + +ItsStationPositionList ::= SEQUENCE SIZE(1..5) OF ItsStationPosition + +Node ::= SEQUENCE { + id INTEGER, + lane LaneID OPTIONAL, + connectionID LaneConnectionID OPTIONAL, + intersectionID IntersectionID OPTIONAL, + ... +} + +NodeLink ::= SEQUENCE SIZE (1..5) OF Node + +PrioritizationResponse ::= SEQUENCE { + stationID StationID, + priorState PrioritizationResponseStatus, + signalGroup SignalGroupID, + ... +} + +PrioritizationResponseList ::= SEQUENCE SIZE(1..10) OF PrioritizationResponse + +SignalHeadLocation ::= SEQUENCE { + nodeXY NodeOffsetPointXY, + nodeZ DeltaAltitude, + signalGroupID SignalGroupID, + ... +} + +SignalHeadLocationList ::= SEQUENCE (SIZE(1..64)) OF SignalHeadLocation + + +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Data elements +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +BatteryStatus ::= ENUMERATED { + unknown, + critical, + low, + good, + ... +} + +EmissionType ::= ENUMERATED { + euro1, + euro2, + euro3, + euro4, + euro5, + euro6, + ... +} + +ExceptionalCondition ::= ENUMERATED { + unknown, + publicTransportPriority, + emergencyVehiclePriority, + trainPriority, + bridgeOpen, + vehicleHeight, + weather, + trafficJam, + tunnelClosure, + meteringActive, + truckPriority, + bicyclePlatoonPriority, + vehiclePlatoonPriority, + ... +} + +PtvRequestType ::= ENUMERATED { + preRequest, + mainRequest, + doorCloseRequest, + cancelRequest, + emergencyRequest, + ... +} + +RejectedReason ::= ENUMERATED { + unknown, + exceptionalCondition, + maxWaitingTimeExceeded, + ptPriorityDisabled, + higherPTPriorityGranted, + vehicleTrackingUnknown, + ... +} + +TimeReference ::= INTEGER { oneMilliSec(1) } (0..60000) + +END + + +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- +-- +-- module: REGION +-- +-- ^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^- + +REGION { + iso (1) standard (0) signalizedIntersection (19091) profilec (2) region (1) + version2 (2) +} + +DEFINITIONS AUTOMATIC TAGS::= BEGIN + +IMPORTS + +addGrpC, REG-EXT-ID-AND-TYPE +FROM DSRC { + iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) version2 (2) +} + +ConnectionManeuverAssist-addGrpC, ConnectionTrajectory-addGrpC, +IntersectionState-addGrpC, LaneAttributes-addGrpC, MapData-addGrpC, +MovementEvent-addGrpC, NodeAttributeSet-addGrpC, Position3D-addGrpC, RequestorDescription-addGrpC, RestrictionUserType-addGrpC, SignalStatusPackage-addGrpC +FROM AddGrpC {iso (1) standard (0) signalizedIntersection (19091) profilec(2) addgrpc (0) version2 (2)}; + +Reg-AdvisorySpeed REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-ComputedLane REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-ConnectionManeuverAssist REG-EXT-ID-AND-TYPE ::= { + {ConnectionManeuverAssist-addGrpC IDENTIFIED BY addGrpC}, + ... +} + +Reg-GenericLane REG-EXT-ID-AND-TYPE ::= { + {ConnectionTrajectory-addGrpC IDENTIFIED BY addGrpC} , + ... +} + +Reg-IntersectionGeometry REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-IntersectionState REG-EXT-ID-AND-TYPE ::= { + {IntersectionState-addGrpC IDENTIFIED BY addGrpC}, + ... +} + +Reg-LaneAttributes REG-EXT-ID-AND-TYPE ::= { + {LaneAttributes-addGrpC IDENTIFIED BY addGrpC} , + ... +} +Reg-LaneDataAttribute REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-MapData REG-EXT-ID-AND-TYPE ::= { + {MapData-addGrpC IDENTIFIED BY addGrpC}, + ... +} + +Reg-MovementEvent REG-EXT-ID-AND-TYPE ::= { + {MovementEvent-addGrpC IDENTIFIED BY addGrpC} , + ... +} +Reg-MovementState REG-EXT-ID-AND-TYPE ::= { ... } + +-- Reg-NodeAttributeSetLL REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-NodeAttributeSetXY REG-EXT-ID-AND-TYPE ::= { + {NodeAttributeSet-addGrpC IDENTIFIED BY addGrpC}, + ... +} + +-- Reg-NodeOffsetPointLL REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-NodeOffsetPointXY REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-Position3D REG-EXT-ID-AND-TYPE ::= { + {Position3D-addGrpC IDENTIFIED BY addGrpC} , + ... +} + +Reg-RequestorDescription REG-EXT-ID-AND-TYPE ::= { + { RequestorDescription-addGrpC IDENTIFIED BY addGrpC} , + ... +} + +Reg-RequestorType REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-RestrictionUserType REG-EXT-ID-AND-TYPE ::= { + {RestrictionUserType-addGrpC IDENTIFIED BY addGrpC} , + ... +} + +Reg-RoadSegment REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-RTCMcorrections REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalControlZone REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalRequest REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalRequestMessage REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalRequestPackage REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalStatus REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalStatusMessage REG-EXT-ID-AND-TYPE ::= { ... } + +Reg-SignalStatusPackage REG-EXT-ID-AND-TYPE ::= { + { SignalStatusPackage-addGrpC IDENTIFIED BY addGrpC }, + ... +} + +Reg-SPAT REG-EXT-ID-AND-TYPE ::= { ... } + +END diff --git a/epan/dissectors/asn1/its/ISO_TS_19321.asn b/epan/dissectors/asn1/its/ISO_TS_19321.asn new file mode 100644 index 00000000..0299d718 --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_19321.asn @@ -0,0 +1,626 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 19321 +-- +-- This ASN.1 was generateds: 30.08.2016 +-- +-- Due to typos in the published version, +-- small ASN.1 syntax adaptations have been executed +-- +-- Published version location: +-- http://standards.iso.org/iso/ts/19321 +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +IVI {iso (1) standard (0) ivi (19321) version1 (1)} + +DEFINITIONS AUTOMATIC TAGS ::= +BEGIN +IMPORTS +ItsPduHeader, Altitude, DangerousGoodsBasic , DeltaLatitude, DeltaLongitude, DeltaReferencePosition, Heading, HeadingValue, Latitude, LanePosition, Longitude, ReferencePosition, RoadType, SpecialTransportType, Speed, StationType, TimestampIts, VehicleRole +FROM ITS-Container { itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (2) } + +AxleWeightLimits, DieselEmissionValues, ExhaustEmissionValues, EngineCharacteristics, EnvironmentalCharacteristics, PassengerCapacity , Provider, SoundLevel, VehicleDimensions, VehicleWeightLimits +FROM EfcDsrcApplication {iso(1) standard(0) 14906 application(0) version5(5)} + +EuVehicleCategoryCode, Iso3833VehicleType +FROM ElectronicRegistrationIdentificationVehicleDataModule {iso(1) standard(0) iso24534 (24534) vehicleData (1) version1 (1)} + + +VarLengthNumber +FROM CITSapplMgmtIDs {iso(1) standard(0) cits-applMgmt (17419) ids (1) version1 (1)} + +; +-- End of IMPORTS + + +--Definition of IVI message to be send over the air is outside of the scope and given for information only: + +IVI::= SEQUENCE { + header ItsPduHeader, + ivi IviStructure +} + +--Definition of IVI Structure + + + +IviStructure::= SEQUENCE{ + mandatory IVIManagementContainer, + optional SEQUENCE (SIZE (1..8,...)) OF IviContainer OPTIONAL + } + +--Definition of Containers + +IviContainer::= CHOICE { + glc GeographicLocationContainer, + giv GeneralIviContainer, + rcc RoadConfigurationContainer, + tc TextContainer, + lac LayoutContainer, + ... -- extension for future containers + } + +-- Prefix IVI added due to naming collision with data element ManagementContainer of Module DENM-PDU-Descriptions +IVIManagementContainer::= SEQUENCE { + serviceProviderId Provider, + iviIdentificationNumber IviIdentificationNumber, + timeStamp TimestampIts OPTIONAL, + validFrom TimestampIts OPTIONAL, + validTo TimestampIts OPTIONAL, + connectedIviStructures SEQUENCE (SIZE(1..8)) OF IviIdentificationNumber OPTIONAL, + iviStatus IviStatus, + ... + } + +GeographicLocationContainer::= SEQUENCE { + referencePosition ReferencePosition, + referencePositionTime TimestampIts OPTIONAL, + referencePositionHeading Heading OPTIONAL, + referencePositionSpeed Speed OPTIONAL, + parts SEQUENCE (SIZE (1..16,...)) OF GlcPart, + ... + } + +GlcPart::= SEQUENCE { + zoneId Zid, + laneNumber LanePosition OPTIONAL, + zoneExtension INTEGER (0..255) OPTIONAL, + zoneHeading HeadingValue OPTIONAL, + zone Zone OPTIONAL, + ... + } + +GeneralIviContainer::= SEQUENCE (SIZE (1..16,...)) OF GicPart + +GicPart::= SEQUENCE { + detectionZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid OPTIONAL, + its-Rrid VarLengthNumber OPTIONAL, + relevanceZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid OPTIONAL, + direction Direction OPTIONAL, + driverAwarenessZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid OPTIONAL, + minimumAwarenessTime INTEGER (0..255) OPTIONAL, + applicableLanes SEQUENCE (SIZE (1..8,...)) OF LanePosition OPTIONAL, + iviType IviType, + iviPurpose IviPurpose OPTIONAL, + laneStatus LaneStatus OPTIONAL, + vehicleCharacteristics SEQUENCE (SIZE (1..8, ...)) OF CompleteVehicleCharacteristics OPTIONAL, + driverCharacteristics DriverCharacteristics OPTIONAL, + layoutId INTEGER(1..4,...) OPTIONAL, + preStoredlayoutId INTEGER(1..64,...) OPTIONAL, + roadSignCodes SEQUENCE (SIZE (1..4,...)) OF RSCode, + extraText SEQUENCE (SIZE (1..4,...)) OF Text (WITH COMPONENTS {layoutComponentId, language, textContent (SIZE(1..32))}) OPTIONAL, + ... + } + +RoadConfigurationContainer::= SEQUENCE (SIZE (1..16,...)) OF RccPart + +RccPart::= SEQUENCE{ + zoneIds SEQUENCE (SIZE (1..8,...)) OF Zid, + roadType RoadType, + laneConfiguration SEQUENCE (SIZE (1..16,...)) OF LaneInformation, + ... + } + +TextContainer::= SEQUENCE (SIZE (1..16,...)) OF TcPart + +TcPart::= SEQUENCE { + detectionZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid OPTIONAL, + relevanceZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid, + direction Direction OPTIONAL, + driverAwarenessZoneIds SEQUENCE (SIZE (1..8,...)) OF Zid OPTIONAL, + minimumAwarenessTime INTEGER (0..255) OPTIONAL, + applicableLanes SEQUENCE (SIZE (1..8,...)) OF LanePosition OPTIONAL, + layoutId INTEGER(1..4,...) OPTIONAL, + preStoredlayoutId INTEGER(1..64,...) OPTIONAL, + text SEQUENCE (SIZE (1..4,...)) OF Text OPTIONAL, + data OCTET STRING, + ... + } + +LayoutContainer::=SEQUENCE{ + layoutId INTEGER(1..4,...), + height INTEGER(10..73) OPTIONAL, + width INTEGER(10..265) OPTIONAL, + layoutComponents SEQUENCE SIZE (1..4,...) OF LayoutComponent, + ... + } + +-- Definition of Data Frames & Elements + +AbsolutePosition::= SEQUENCE{ + latitude Latitude, + longitude Longitude + } + +AbsolutePositionWAltitude::= SEQUENCE{ + latitude Latitude, + longitude Longitude, + altitude Altitude + } + +AnyCatalogue::=SEQUENCE{ + owner Provider, + version INTEGER(0..255), + pictogramCode INTEGER(0..65535), + value INTEGER (0..65535) OPTIONAL, + unit RSCUnit OPTIONAL, + attributes ISO14823Attributes OPTIONAL + } + +ComparisonOperator ::= INTEGER { + greaterThan (0), + greaterThanOrEqualTo (1), + lessThan (2), + lessThanOrEqualTo (3) +} (0..3) + +CompleteVehicleCharacteristics::= SEQUENCE{ + tractor TractorCharacteristics OPTIONAL, + trailer SEQUENCE (SIZE (1..3)) OF TrailerCharacteristics OPTIONAL, + train TrainCharacteristics OPTIONAL + } + +ComputedSegment::= SEQUENCE { + zoneId Zid, + laneNumber LanePosition, + laneWidth IVILaneWidth, + offsetDistance INTEGER (-32768..32767) OPTIONAL, + offsetPosition DeltaReferencePosition OPTIONAL + } + +DeltaPosition::=SEQUENCE{ + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude + } + +Direction::= INTEGER{ + sameDirection (0), + oppositeDirection (1), + bothDirections (2), + valueNotUsed (3) + } (0..3) + +Distance::= SEQUENCE { + value INTEGER(1..16384), + unit RSCUnit (2..4|6..8) + } + +DistanceOrDuration::= SEQUENCE { + value INTEGER(1..16384), + unit RSCUnit (2..9) + } + +DriverCharacteristics::= INTEGER{ + unexperiencedDrivers (0), + experiencedDrivers (1), + rfu1 (2), + rfu2 (3) + } (0..3) + +GoodsType::= INTEGER { + ammunition (0), + chemicals (1), + empty (2), + fuel (3), + glass (4), + dangerous (5), + liquid (6), + liveStock (7), + dangerousForPeople (8), + dangerousForTheEnvironment (9), + dangerousForWater (10), + perishableProducts (11), + pharmaceutical (12), + vehicles (13) + -- other values reserved for future use + } (0..15,...) + + +ISO14823Attributes::= SEQUENCE (SIZE(1..8,...)) OF CHOICE{ + dtm DTM, -- Date/Time/Period + edt EDT, -- Exemption status of Date/Time/Period + dfl DFL, -- Directional Flow of Lane + ved VED, -- Vehicle Dimensions + spe SPE, -- Speed + roi ROI, -- Rate of Incline + dbv DBV, -- Distance Between Vehicles + ddd DDD -- Destination/Direction/Distance + } + +ISO14823Code ::= SEQUENCE{ + pictogramCode SEQUENCE { + countryCode OCTET STRING (SIZE (2)) OPTIONAL, + serviceCategoryCode CHOICE { + trafficSignPictogram ENUMERATED {dangerWarning, regulatory, informative,...}, + publicFacilitiesPictogram ENUMERATED {publicFacilities, ...}, + ambientOrRoadConditionPictogram ENUMERATED {ambientCondition, roadCondition,...}, + ...}, + pictogramCategoryCode SEQUENCE { + nature INTEGER (1..9), + serialNumber INTEGER (0..99) + }}, + attributes ISO14823Attributes OPTIONAL + } + +IviIdentificationNumber::= INTEGER(1..32767,...) + +IviPurpose::= INTEGER { + safety (0), + environmental (1), + trafficOptimisation (2) + } (0..3) + +IviStatus::= INTEGER { + new (0), + update (1), + cancellation (2), + negation (3) + -- other values reserved for future use + }(0..7) + +IviType::= INTEGER { + immediateDangerWarningMessages (0), + regulatoryMessages (1), + trafficRelatedInformationMessages (2), + pollutionMessages (3), + notTrafficRelatedInformationMessages (4) + -- other values reserved for future use + } (0..7) + +LaneInformation::= SEQUENCE{ + laneNumber LanePosition, + direction Direction, + validity DTM OPTIONAL, + laneType LaneType, + laneTypeQualifier CompleteVehicleCharacteristics OPTIONAL, + laneStatus LaneStatus, + laneWidth IVILaneWidth OPTIONAL, + ... + } + +LaneStatus::= INTEGER { + open (0), + closed (1), + mergeR (2), + mergeL (3), + mergeLR (4), + provisionallyOpen (5), + diverging (6) + -- value 7 reserved for future use +} (0..7, ...) + +LaneType::= INTEGER{ + traffic (0), + through (1), + reversible (2), + acceleration (3), + deceleration (4), + leftHandTurning (5), + rightHandTurning (6), + dedicatedVehicle (7), + bus (8), + taxi (9), + hov (10), + hot (11), + pedestrian (12), + bikeLane (13), + median (14), + striping (15), + trackedVehicle (16), + parking (17), + emergency (18), + verge (19) +-- values 20 to 31 reserved for future use + }(0..31) + +-- Prefix IVI added due to naming collision with data element LaneWidth of Module DSRC +IVILaneWidth::= INTEGER (0..1023) + +LayoutComponent::=SEQUENCE{ + layoutComponentId INTEGER(1..8,...), + height INTEGER(10..73), + width INTEGER(10..265), + x INTEGER(10..265), + y INTEGER(10..73), + textScripting INTEGER {horizontal (0), vertical (1)}(0..1) + } + +LoadType::= SEQUENCE{ + goodsType GoodsType, + dangerousGoodsType DangerousGoodsBasic, + specialTransportType SpecialTransportType + } + +PolygonalLine::= CHOICE { + deltaPositions SEQUENCE (SIZE (1..32,...)) OF DeltaPosition, + deltaPositionsWithAltitude SEQUENCE (SIZE (1..32,...)) OF DeltaReferencePosition, + absolutePositions SEQUENCE (SIZE (1..8,...)) OF AbsolutePosition, + absolutePositionsWithAltitude SEQUENCE (SIZE (1..8,...)) OF AbsolutePositionWAltitude, + ... + } + +RSCode::= SEQUENCE{ + layoutComponentId INTEGER(1..4,...) OPTIONAL, + code CHOICE { + viennaConvention VcCode, -- see Vienna Convention Annex A + iso14823 ISO14823Code, + itisCodes INTEGER (0..65535), -- see SAE J2540 + anyCatalogue AnyCatalogue, + ... + }} + +RSCUnit::= INTEGER { + kmperh (0), + milesperh (1), + kilometer (2), + meter (3), + decimeter (4), + centimeter (5), + mile (6), + yard (7), + foot (8), + minutesOfTime (9), + tonnes (10), --1000 kg, not Ton! + hundredkg (11), + pound (12), --lbs + rateOfIncline (13) + -- other value reserved for future use + } (0..15) + + +Segment::= SEQUENCE { + line PolygonalLine, + laneWidth IVILaneWidth OPTIONAL + } + +Text::= SEQUENCE { + layoutComponentId INTEGER(1..4,...) OPTIONAL, + language BIT STRING (SIZE(10)), + textContent UTF8String + } + +TractorCharacteristics::=SEQUENCE{ + equalTo SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues OPTIONAL, + notEqualTo SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues OPTIONAL, + ranges SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsRanges OPTIONAL +} + +TrailerCharacteristics::=SEQUENCE{ + equalTo SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues (WITH COMPONENTS {..., euroAndCo2value ABSENT, engineCharacteristics ABSENT}) OPTIONAL, + notEqualTo SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsFixValues (WITH COMPONENTS {..., euroAndCo2value ABSENT, engineCharacteristics ABSENT}) OPTIONAL, + ranges SEQUENCE (SIZE (1..4,...)) OF VehicleCharacteristicsRanges (WITH COMPONENTS {comparisonOperator, limits (WITH COMPONENTS {..., exhaustEmissionValues ABSENT, dieselEmissionValues ABSENT, soundLevel ABSENT})}) OPTIONAL + } + +TrainCharacteristics::= TractorCharacteristics + +VcClass::= INTEGER { + classA (0), + classB (1), + classC (2), + classD (3), + classE (4), + classF (5), + classG (6), + classH (7) + } (0..7) + +VcCode::= SEQUENCE { + roadSignClass VcClass, -- see Vienna Convention + roadSignCode INTEGER (1..64), + vcOption VcOption, -- e.g. the "a" in H, 3a + validity SEQUENCE (SIZE (1..8,...)) OF DTM OPTIONAL, + value INTEGER (0..65535) OPTIONAL, + unit RSCUnit OPTIONAL + } + +VcOption::= INTEGER { + none (0), + a (1), + b (2), + c (3), + d (4), + e (5), + f (6), + g (7) + } (0..7) + +VehicleCharacteristicsFixValues::= CHOICE{ + simpleVehicleType StationType, + euVehicleCategoryCode EuVehicleCategoryCode, + iso3833VehicleType Iso3833VehicleType, + euroAndCo2value EnvironmentalCharacteristics, + engineCharacteristics EngineCharacteristics, + loadType LoadType, + usage VehicleRole, + ...} + +VehicleCharacteristicsRanges::= SEQUENCE{ + comparisonOperator ComparisonOperator, + limits CHOICE{ + numberOfAxles INTEGER(0..7), + vehicleDimensions VehicleDimensions, + vehicleWeightLimits VehicleWeightLimits, + axleWeightLimits AxleWeightLimits, + passengerCapacity PassengerCapacity, + exhaustEmissionValues ExhaustEmissionValues, + dieselEmissionValues DieselEmissionValues, + soundLevel SoundLevel, + ...}} + +Weight::= SEQUENCE { + value INTEGER(1..16384), + unit RSCUnit (10..12) + } + +Zid::= INTEGER (1..32,...) + +Zone::= CHOICE { + segment Segment, + area PolygonalLine, + computedSegment ComputedSegment, + ... + } + +-- Definition of the single ISO 14823 Attributes + + +DTM ::= SEQUENCE { + year SEQUENCE { -- contains SYR and EYR + syr INTEGER(2000..2127,...), + eyr INTEGER(2000..2127,...) + } OPTIONAL, + month-day SEQUENCE { -- contains SMD and EMD + smd MonthDay, + emd MonthDay + } OPTIONAL, + pmd PMD OPTIONAL, + hourMinutes SEQUENCE { -- contains SHM and EHM + shm HoursMinutes, + ehm HoursMinutes + } OPTIONAL, + dayOfWeek DayOfWeek OPTIONAL, -- corresponds to SDY and EDY + period HoursMinutes OPTIONAL -- corresponds to LDM +} + +MonthDay ::= SEQUENCE { + month INTEGER (1..12), + day INTEGER (1..31) +} + +PMD::= BIT STRING {national-holiday (0), even-days(1), odd-days(2), market-day(3) } (SIZE (4)) + +HoursMinutes ::= SEQUENCE { + hours INTEGER (0..23), -- number of hours after midnight + mins INTEGER (0..59) -- number of minutes after the hour + } + +-- Prefix IVI added due to naming collision with data element DayOfWeek of Module DSRC +DayOfWeek ::= BIT STRING {unused(0), monday(1), tuesday(2), wednesday(3), thursday(4), friday(5), saturday(6), sunday(7)} (SIZE (8)) + +EDT ::= DTM + + + +DFL::= INTEGER { + sDL (1) , -- Straight Direction Only + sLT (2) , -- Straight and Left Turn Only + sRT (3) , -- Straight and Right Turn Only + lTO (4) , -- Left Turn Only + rTO (5) , -- Right Turn Only + cLL (6) , -- Convergence from the Left Lane + cRI (7) , -- Convergence from the Right Lane + oVL (8) -- Oncoming Vehicles Lane + } (1..8) + +VED::=SEQUENCE{ + hei Distance OPTIONAL, + wid Distance OPTIONAL, + vln Distance OPTIONAL, + wei Weight OPTIONAL + } + +SPE::=SEQUENCE{ + spm INTEGER(0..250) OPTIONAL, + mns INTEGER(0..250) OPTIONAL, + unit RSCUnit(0..1) + } + +ROI::= INTEGER(1..32) + +DBV::= Distance +-- changes: from DDD_IO to DDD-IO +DDD::= SEQUENCE{ + dcj INTEGER(1..128) OPTIONAL, + dcr INTEGER(1..128)OPTIONAL, + tpl INTEGER(1..128)OPTIONAL, + ioList SEQUENCE (SIZE (1..8,...)) OF DDD-IO + } +-- changes: from DDD_IO to DDD-IO +DDD-IO::= SEQUENCE{ + drn INTEGER(0..7), + dp SEQUENCE (SIZE (1..4,...)) OF DestinationPlace OPTIONAL, + dr SEQUENCE (SIZE (1..4,...)) OF DestinationRoad OPTIONAL, + rne INTEGER(1..999) OPTIONAL, + stnId INTEGER(1..999) OPTIONAL, + stnText UTF8String OPTIONAL, + dcp DistanceOrDuration OPTIONAL, + ddp DistanceOrDuration OPTIONAL + } +-- changes: from DDD_DEP to DDD-DEP +DestinationPlace::= SEQUENCE{ + depType DDD-DEP, + -- Encoding problem: to be checked if the statement is ASN.1 compatible + -- depRSCode ISO14823Code (WITH COMPONENTS {..., attributes ABSENT}) OPTIONAL, + depRSCode ISO14823Code OPTIONAL, + depBlob OCTET STRING OPTIONAL, + plnId INTEGER(1..999) OPTIONAL, + plnText UTF8String OPTIONAL + } +-- changes: from DDD_DER to DDD-DER +DestinationRoad::=SEQUENCE{ + derType DDD-DER, + ronId INTEGER(1..999) OPTIONAL, + ronText UTF8String OPTIONAL + } +-- changes: from DDD_DER to DDD-DER +DDD-DER::= INTEGER { + none (0), + nationalHighway (1), + localHighway (2), + tollExpresswayMotorway (3), + internationalHighway (4), + highway (5), + expressway (6), + nationalRoad (7), + regionalProvincialRoad (8), + localRoad (9), + motorwayJunction (10), + diversion (11), + rfu1 (12), + rfu2 (13), + rfu3 (14), + rfu4 (15) + } (0..15, ...) +-- changes: from DDD_DEP to DDD-DEP +DDD-DEP::= INTEGER { + none (0), + importantArea (1), + principalArea (2), + generalArea (3), + wellKnownPoint (4), + country (5), + city (6), + street (7), + industrialArea (8), + historicArea (9), + touristicArea (10), + culturalArea (11), + touristicRoute (12), + recommendedRoute (13), + touristicAttraction (14), + geographicArea (15) + } (0..15, ...) + + + +END + diff --git a/epan/dissectors/asn1/its/ISO_TS_24534-3.asn b/epan/dissectors/asn1/its/ISO_TS_24534-3.asn new file mode 100644 index 00000000..f106babc --- /dev/null +++ b/epan/dissectors/asn1/its/ISO_TS_24534-3.asn @@ -0,0 +1,86 @@ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- ISO TS 24534-3:2015 +-- +-- This ASN.1 was generateds: 30.08.2016 +-- +-- This document contains only the data element needed for the encoding of an IVI message +-- as defined in ISO TS 19321(2015) +-- +-- Published version location: +-- http://standards.iso.org/iso/24534/-3/ +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +-- ISO 24534-3:2015 +-- Version 29.4.2015 + + +ElectronicRegistrationIdentificationVehicleDataModule {iso(1) standard(0) iso24534 (24534) vehicleData (1) version1 (1)} + + +DEFINITIONS AUTOMATIC TAGS ::= BEGIN +IMPORTS; + +-- Electronic Registration Identification (ERI)- Vehicle Data + +EuVehicleCategoryCode ::= CHOICE { + euVehicleCategoryL EuVehicleCategoryL, -- conforms to EU 2002/24 and UNECE 1999 + euVehicleCategoryM EuVehicleCategoryM, -- conforms to EU 2001/116 and UNECE 1999 + euVehicleCategoryN EuVehicleCategoryN, -- conforms to EU 2001/116 and UNECE 1999 + euVehicleCategoryO EuVehicleCategoryO, -- conforms to EU 2001/116 and UNECE 1999 + euVehilcleCategoryT NULL, -- conforms to UNECE 1999 + euVehilcleCategoryG NULL -- conforms to EU 2001/116 and UNECE 1999 + } + +EuVehicleCategoryL ::= ENUMERATED { l1, l2, l3, l4, l5, l6, l7 } + +EuVehicleCategoryM ::= ENUMERATED {m1, m2, m3} + +EuVehicleCategoryN ::= ENUMERATED {n1, n2, n3} + +EuVehicleCategoryO ::= ENUMERATED {o1, o2, o3, o4} + +Iso3833VehicleType ::= INTEGER { + passengerCar (0), -- term No 3.1.1 + saloon (1), -- term No 3.1.1.1 (sedan) + convertibleSaloon (2), -- term No 3.1.1.2 + pullmanSaloon (3), -- term No 3.1.1.3 + stationWagon (4), -- term No 3.1.1.4 + truckStationWagon (5), -- term No 3.1.1.4.1 + coupe (6), -- term No 3.1.1.5 (coupé) + convertible (7), -- term No 3.1.1.6 (open tourer, roadstar, spider) + multipurposePassengerCar (8), -- term No 3.1.1.7 + forwardControlPassengerCar (9), -- term No 3.1.1.8 + specialPassengerCar (10), -- term No 3.1.1.9 + bus (11), -- term No 3.1.2 + minibus (12), -- term No 3.1.2.1 + urbanBus (13), -- term No 3.1.2.2 + interurbanCoach (14), -- term No 3.1.2.3 + longDistanceCoach (15), -- term No 3.1.2.4 + articulatedBus (16), -- term No 3.1.2.5 + trolleyBus (17), -- term No 3.1.2.6 + specialBus (18), -- term No 3.1.2.7 + commercialVehicle (19), -- term No 3.1.3 + specialCommercialVehicle (20), -- term No 3.1.3.1 + specialVehicle (21), -- term No 3.1.4 + trailingTowingVehicle (22), -- term No 3.1.5 (draw-bar tractor) + semiTrailerTowingVehicle (23), -- term No 3.1.6 (fifth wheel tractor) + trailer (24), -- term No 3.2.1 + busTrailer (25), -- term No 3.2.1.1 + generalPurposeTrailer (26), -- term No 3.2.1.2 + caravan (27), -- term No 3.2.1.3 + specialTrailer (28), -- term No 3.2.1.4 + semiTrailer (29), -- term No 3.2.2 + busSemiTrailer (30), -- term No 3.2.2.1 + generalPurposeSemiTrailer (31), -- term No 3.2.2.2 + specialSemiTrailer (32), -- term No 3.2.2.3 + roadTrain (33), -- term No 3.3.1 + passengerRoadTrain (34), -- term No 3.3.2 + articulatedRoadTrain (35), -- term No 3.3.3 + doubleRoadTrain (36), -- term No 3.3.4 + compositeRoadTrain (37), -- term No 3.3.5 + specialRoadTrain (38), -- term No 3.3.6 + moped (39), -- term No 3.4 + motorCycle (40) -- term No 3.5 + } (0..255) + +END diff --git a/epan/dissectors/asn1/its/ITS-Container.asn b/epan/dissectors/asn1/its/ITS-Container.asn new file mode 100644 index 00000000..a66af201 --- /dev/null +++ b/epan/dissectors/asn1/its/ITS-Container.asn @@ -0,0 +1,515 @@ +ITS-Container { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (2) +} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + -- Wireshark modification + CauseCode + FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + +; + +ItsPduHeader ::= SEQUENCE { + protocolVersion INTEGER (0..255), + messageID INTEGER{ denm(1), cam(2), poi(3), spatem(4), mapem(5), ivim(6), ev-rsr(7), tistpgtransaction(8), srem(9), ssem(10), evcsn(11), saem(12), rtcmem(13), cpm(14), + imzm(15), vam(16),dsm(17), pcim(18), pcvm(19), mcm(20), pam(21) } (0..255), -- Mantis #7209, #7005 + stationID StationID +} + +StationID ::= INTEGER(0..4294967295) + +ReferencePosition ::= SEQUENCE { + latitude Latitude, + longitude Longitude, + positionConfidenceEllipse PosConfidenceEllipse , + altitude Altitude +} + +DeltaReferencePosition ::= SEQUENCE { + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude, + deltaAltitude DeltaAltitude +} + +Longitude ::= INTEGER {oneMicrodegreeEast (10), oneMicrodegreeWest (-10), unavailable(1800000001)} (-1800000000..1800000001) + +Latitude ::= INTEGER {oneMicrodegreeNorth (10), oneMicrodegreeSouth (-10), unavailable(900000001)} (-900000000..900000001) + +Altitude ::= SEQUENCE { + altitudeValue AltitudeValue, + altitudeConfidence AltitudeConfidence +} + +AltitudeValue ::= INTEGER {referenceEllipsoidSurface(0), oneCentimeter(1), unavailable(800001)} (-100000..800001) + +AltitudeConfidence ::= ENUMERATED { + alt-000-01 (0), + alt-000-02 (1), + alt-000-05 (2), + alt-000-10 (3), + alt-000-20 (4), + alt-000-50 (5), + alt-001-00 (6), + alt-002-00 (7), + alt-005-00 (8), + alt-010-00 (9), + alt-020-00 (10), + alt-050-00 (11), + alt-100-00 (12), + alt-200-00 (13), + outOfRange (14), + unavailable (15) +} + +DeltaLongitude ::= INTEGER {oneMicrodegreeEast (10), oneMicrodegreeWest (-10), unavailable(131072)} (-131071..131072) + +DeltaLatitude ::= INTEGER {oneMicrodegreeNorth (10), oneMicrodegreeSouth (-10) , unavailable(131072)} (-131071..131072) + +DeltaAltitude ::= INTEGER {oneCentimeterUp (1), oneCentimeterDown (-1), unavailable(12800)} (-12700..12800) + +PosConfidenceEllipse ::= SEQUENCE { + semiMajorConfidence SemiAxisLength, + semiMinorConfidence SemiAxisLength, + semiMajorOrientation HeadingValue +} + +PathPoint ::= SEQUENCE { + pathPosition DeltaReferencePosition, + pathDeltaTime PathDeltaTime OPTIONAL +} + +PathDeltaTime ::= INTEGER {tenMilliSecondsInPast(1)} (1..65535, ...) + +PtActivation ::= SEQUENCE { + ptActivationType PtActivationType, + ptActivationData PtActivationData +} + +PtActivationType ::= INTEGER {undefinedCodingType(0), r09-16CodingType(1), vdv-50149CodingType(2)} (0..255) + +PtActivationData ::= OCTET STRING (SIZE(1..20)) + +--AccelerationControl ::= BIT STRING { +-- brakePedalEngaged (0), +-- gasPedalEngaged (1), +-- emergencyBrakeEngaged (2), +-- collisionWarningEngaged (3), +-- accEngaged (4), +-- cruiseControlEngaged (5), +-- speedLimiterEngaged (6) +--} (SIZE(7)) + +SemiAxisLength ::= INTEGER{oneCentimeter(1), outOfRange(4094), unavailable(4095)} (0..4095) + +-- WS Modification +--CauseCode ::= SEQUENCE { +-- causeCode CauseCodeType, +-- subCauseCode SubCauseCodeType, +-- ... +-- } + +-- WS Modification +--CauseCodeType ::= INTEGER { +-- reserved (0), +-- trafficCondition (1), +-- accident (2), +-- roadworks (3), +-- impassability (5), +-- adverseWeatherCondition-Adhesion (6), +-- aquaplaning (7), +-- hazardousLocation-SurfaceCondition (9), +-- hazardousLocation-ObstacleOnTheRoad (10), +-- hazardousLocation-AnimalOnTheRoad (11), +-- humanPresenceOnTheRoad (12), +-- wrongWayDriving (14), +-- rescueAndRecoveryWorkInProgress (15), +-- adverseWeatherCondition-ExtremeWeatherCondition (17), +-- adverseWeatherCondition-Visibility (18), +-- adverseWeatherCondition-Precipitation (19), +-- violence (20), +-- slowVehicle (26), +-- dangerousEndOfQueue (27), +-- vehicleBreakdown (91), +-- postCrash (92), +-- humanProblem (93), +-- stationaryVehicle (94), +-- emergencyVehicleApproaching (95), +-- hazardousLocation-DangerousCurve (96), +-- collisionRisk (97), +-- signalViolation (98), +-- dangerousSituation (99), +-- railwayLevelCrossing (100) +--} (0..255) + +-- SubCauseCodeType ::= INTEGER (0..255) + + TrafficConditionSubCauseCode ::= INTEGER {unavailable(0), increasedVolumeOfTraffic(1), trafficJamSlowlyIncreasing(2), trafficJamIncreasing(3), trafficJamStronglyIncreasing(4), trafficStationary(5), trafficJamSlightlyDecreasing(6), trafficJamDecreasing(7), trafficJamStronglyDecreasing(8)} (0..255) + + AccidentSubCauseCode ::= INTEGER {unavailable(0), multiVehicleAccident(1), heavyAccident(2), accidentInvolvingLorry(3), accidentInvolvingBus(4), accidentInvolvingHazardousMaterials(5), accidentOnOppositeLane(6), unsecuredAccident(7), assistanceRequested(8)} (0..255) + + RoadworksSubCauseCode ::= INTEGER {unavailable(0), majorRoadworks(1), roadMarkingWork(2), slowMovingRoadMaintenance(3), shortTermStationaryRoadworks(4), streetCleaning(5), winterService(6)} (0..255) + + HumanPresenceOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), childrenOnRoadway(1), cyclistOnRoadway(2), motorcyclistOnRoadway(3)} (0..255) + + WrongWayDrivingSubCauseCode ::= INTEGER {unavailable(0), wrongLane(1), wrongDirection(2)} (0..255) + + AdverseWeatherCondition-ExtremeWeatherConditionSubCauseCode ::= INTEGER {unavailable(0), strongWinds(1), damagingHail(2), hurricane(3), thunderstorm(4), tornado(5), blizzard(6)} (0..255) + + AdverseWeatherCondition-AdhesionSubCauseCode ::= INTEGER {unavailable(0), heavyFrostOnRoad(1), fuelOnRoad(2), mudOnRoad(3), snowOnRoad(4), iceOnRoad(5), blackIceOnRoad(6), oilOnRoad(7), looseChippings(8), instantBlackIce(9), roadsSalted(10)} (0..255) + + AdverseWeatherCondition-VisibilitySubCauseCode ::= INTEGER {unavailable(0), fog(1), smoke(2), heavySnowfall(3), heavyRain(4), heavyHail(5), lowSunGlare(6), sandstorms(7), swarmsOfInsects(8)} (0..255) + + AdverseWeatherCondition-PrecipitationSubCauseCode ::= INTEGER {unavailable(0), heavyRain(1), heavySnowfall(2), softHail(3)} (0..255) + + SlowVehicleSubCauseCode ::= INTEGER {unavailable(0), maintenanceVehicle(1), vehiclesSlowingToLookAtAccident(2), abnormalLoad(3), abnormalWideLoad(4), convoy(5), snowplough(6), deicing(7), saltingVehicles(8)} (0..255) + + StationaryVehicleSubCauseCode ::= INTEGER {unavailable(0), humanProblem(1), vehicleBreakdown(2), postCrash(3), publicTransportStop(4), carryingDangerousGoods(5)} (0..255) + + HumanProblemSubCauseCode ::= INTEGER {unavailable(0), glycemiaProblem(1), heartProblem(2)} (0..255) + + EmergencyVehicleApproachingSubCauseCode ::= INTEGER {unavailable(0), emergencyVehicleApproaching(1), prioritizedVehicleApproaching(2)} (0..255) + + HazardousLocation-DangerousCurveSubCauseCode ::= INTEGER {unavailable(0), dangerousLeftTurnCurve(1), dangerousRightTurnCurve(2), multipleCurvesStartingWithUnknownTurningDirection(3), multipleCurvesStartingWithLeftTurn(4), multipleCurvesStartingWithRightTurn(5)} (0..255) + + HazardousLocation-SurfaceConditionSubCauseCode ::= INTEGER {unavailable(0), rockfalls(1), earthquakeDamage(2), sewerCollapse(3), subsidence(4), snowDrifts(5), stormDamage(6), burstPipe(7), volcanoEruption(8), fallingIce(9)} (0..255) + + HazardousLocation-ObstacleOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), shedLoad(1), partsOfVehicles(2), partsOfTyres(3), bigObjects(4), fallenTrees(5), hubCaps(6), waitingVehicles(7)} (0..255) + + HazardousLocation-AnimalOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), wildAnimals(1), herdOfAnimals(2), smallAnimals(3), largeAnimals(4)} (0..255) + + CollisionRiskSubCauseCode ::= INTEGER {unavailable(0), longitudinalCollisionRisk(1), crossingCollisionRisk(2), lateralCollisionRisk(3), vulnerableRoadUser(4)} (0..255) + + SignalViolationSubCauseCode ::= INTEGER {unavailable(0), stopSignViolation(1), trafficLightViolation(2), turningRegulationViolation(3)} (0..255) + + RescueAndRecoveryWorkInProgressSubCauseCode ::= INTEGER {unavailable(0), emergencyVehicles(1), rescueHelicopterLanding(2), policeActivityOngoing(3), medicalEmergencyOngoing(4), childAbductionInProgress(5)} (0..255) + + DangerousEndOfQueueSubCauseCode ::= INTEGER {unavailable(0), suddenEndOfQueue(1), queueOverHill(2), queueAroundBend(3), queueInTunnel(4)} (0..255) + + DangerousSituationSubCauseCode ::= INTEGER {unavailable(0), emergencyElectronicBrakeEngaged(1), preCrashSystemEngaged(2), espEngaged(3), absEngaged(4), aebEngaged(5), brakeWarningEngaged(6), collisionRiskWarningEngaged(7)} (0..255) + + VehicleBreakdownSubCauseCode ::= INTEGER {unavailable(0), lackOfFuel (1), lackOfBatteryPower (2), engineProblem(3), transmissionProblem(4), engineCoolingProblem(5), brakingSystemProblem(6), steeringProblem(7), tyrePuncture(8), tyrePressureProblem(9)} (0..255) + + PostCrashSubCauseCode ::= INTEGER {unavailable(0), accidentWithoutECallTriggered (1), accidentWithECallManuallyTriggered (2), accidentWithECallAutomaticallyTriggered (3), accidentWithECallTriggeredWithoutAccessToCellularNetwork(4)} (0..255) +-- Curvature ::= SEQUENCE { +-- curvatureValue CurvatureValue, +-- curvatureConfidence CurvatureConfidence +--} + +-- CurvatureValue ::= INTEGER {straight(0), unavailable(1023)} (-1023..1023) + +--CurvatureConfidence ::= ENUMERATED { +-- onePerMeter-0-00002 (0), +-- onePerMeter-0-0001 (1), +-- onePerMeter-0-0005 (2), +-- onePerMeter-0-002 (3), +-- onePerMeter-0-01 (4), +-- onePerMeter-0-1 (5), +-- outOfRange (6), +-- unavailable (7) +--} + +-- CurvatureCalculationMode ::= ENUMERATED {yawRateUsed(0), yawRateNotUsed(1), unavailable(2), ...} + +Heading ::= SEQUENCE { + headingValue HeadingValue, + headingConfidence HeadingConfidence +} + +HeadingValue ::= INTEGER {wgs84North(0), wgs84East(900), wgs84South(1800), wgs84West(2700), unavailable(3601)} (0..3601) + +HeadingConfidence ::= INTEGER {equalOrWithinZeroPointOneDegree (1), equalOrWithinOneDegree (10), outOfRange(126), unavailable(127)} (1..127) +LanePosition::= INTEGER {offTheRoad(-1), innerHardShoulder(0), innermostDrivingLane(1), secondLaneFromInside(2), outerHardShoulder(14)} (-1..14) + +ClosedLanes ::= SEQUENCE { + innerhardShoulderStatus HardShoulderStatus OPTIONAL, + outerhardShoulderStatus HardShoulderStatus OPTIONAL, + drivingLaneStatus DrivingLaneStatus OPTIONAL, + ... +} + +HardShoulderStatus ::= ENUMERATED {availableForStopping(0), closed(1), availableForDriving(2)} + +DrivingLaneStatus ::= BIT STRING (SIZE (1..13)) + +PerformanceClass ::= INTEGER {unavailable(0), performanceClassA(1), performanceClassB(2)} (0..7) + +SpeedValue ::= INTEGER {standstill(0), oneCentimeterPerSec(1), unavailable(16383)} (0..16383) + +SpeedConfidence ::= INTEGER {equalOrWithinOneCentimeterPerSec(1), equalOrWithinOneMeterPerSec(100), outOfRange(126), unavailable(127)} (1..127) + +VehicleMass ::= INTEGER {hundredKg(1), unavailable(1024)} (1..1024) + +Speed ::= SEQUENCE { + speedValue SpeedValue, + speedConfidence SpeedConfidence +} + +-- DriveDirection ::= ENUMERATED {forward (0), backward (1), unavailable (2)} + +EmbarkationStatus ::= BOOLEAN + +--LongitudinalAcceleration ::= SEQUENCE { +-- longitudinalAccelerationValue LongitudinalAccelerationValue, +-- longitudinalAccelerationConfidence AccelerationConfidence +--} + +--LongitudinalAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredForward(1), pointOneMeterPerSecSquaredBackward(-1), unavailable(161)} (-160 .. 161) + +--AccelerationConfidence ::= INTEGER {pointOneMeterPerSecSquared(1), outOfRange(101), unavailable(102)} (0 .. 102) + +--LateralAcceleration ::= SEQUENCE { +-- lateralAccelerationValue LateralAccelerationValue, +-- lateralAccelerationConfidence AccelerationConfidence +--} + +--LateralAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredToRight(-1), pointOneMeterPerSecSquaredToLeft(1), unavailable(161)} (-160 .. 161) + +--VerticalAcceleration ::= SEQUENCE { +-- verticalAccelerationValue VerticalAccelerationValue, +-- verticalAccelerationConfidence AccelerationConfidence +--} + +--VerticalAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredUp(1), pointOneMeterPerSecSquaredDown(-1), unavailable(161)} (-160 .. 161) + +StationType ::= INTEGER {unknown(0), pedestrian(1), cyclist(2), moped(3), motorcycle(4), passengerCar(5), bus(6), lightTruck(7), heavyTruck(8), trailer(9), specialVehicles(10), tram(11), roadSideUnit(15)} (0..255) + +ExteriorLights ::= BIT STRING { + lowBeamHeadlightsOn (0), + highBeamHeadlightsOn (1), + leftTurnSignalOn (2), + rightTurnSignalOn (3), + daytimeRunningLightsOn (4), + reverseLightOn (5), + fogLightOn (6), + parkingLightsOn (7) +} (SIZE(8)) + +DangerousGoodsBasic::= ENUMERATED { + explosives1(0), + explosives2(1), + explosives3(2), + explosives4(3), + explosives5(4), + explosives6(5), + flammableGases(6), + nonFlammableGases(7), + toxicGases(8), + flammableLiquids(9), + flammableSolids(10), + substancesLiableToSpontaneousCombustion(11), + substancesEmittingFlammableGasesUponContactWithWater(12), + oxidizingSubstances(13), + organicPeroxides(14), + toxicSubstances(15), + infectiousSubstances(16), + radioactiveMaterial(17), + corrosiveSubstances(18), + miscellaneousDangerousSubstances(19) +} + +--DangerousGoodsExtended ::= SEQUENCE { +-- dangerousGoodsType DangerousGoodsBasic, +-- unNumber INTEGER (0..9999), +-- elevatedTemperature BOOLEAN, +-- tunnelsRestricted BOOLEAN, +-- limitedQuantity BOOLEAN, +-- emergencyActionCode IA5String (SIZE (1..24)) OPTIONAL, +-- phoneNumber PhoneNumber OPTIONAL, +-- companyName UTF8String (SIZE (1..24)) OPTIONAL, +-- ... +--} + +SpecialTransportType ::= BIT STRING {heavyLoad(0), excessWidth(1), excessLength(2), excessHeight(3)} (SIZE(4)) + +LightBarSirenInUse ::= BIT STRING { + lightBarActivated (0), + sirenActivated (1) +} (SIZE(2)) + +--HeightLonCarr ::= INTEGER {oneCentimeter(1), unavailable(100)} (1..100) + +--PosLonCarr ::= INTEGER {oneCentimeter(1), unavailable(127)} (1..127) + +--PosPillar ::= INTEGER {tenCentimeters(1), unavailable(30)} (1..30) + +-- PosCentMass ::= INTEGER {tenCentimeters(1), unavailable(63)} (1..63) + +-- RequestResponseIndication ::= ENUMERATED {request(0), response(1)} + +SpeedLimit ::= INTEGER {oneKmPerHour(1)} (1..255) + +-- StationarySince ::= ENUMERATED {lessThan1Minute(0), lessThan2Minutes(1), lessThan15Minutes(2), equalOrGreater15Minutes(3)} + +--Temperature ::= INTEGER {equalOrSmallerThanMinus60Deg (-60), oneDegreeCelsius(1), equalOrGreaterThan67Deg(67)} (-60..67) + +TrafficRule ::= ENUMERATED {noPassing(0), noPassingForTrucks(1), passToRight(2), passToLeft(3), ... } + +-- WheelBaseVehicle ::= INTEGER {tenCentimeters(1), unavailable(127)} (1..127) + +--TurningRadius ::= INTEGER {point4Meters(1), unavailable(255)} (1..255) + +-- PosFrontAx ::= INTEGER {tenCentimeters(1), unavailable(20)} (1..20) + +--PositionOfOccupants ::= BIT STRING { +-- row1LeftOccupied (0), +-- row1RightOccupied (1), +-- row1MidOccupied (2), +-- row1NotDetectable (3), +-- row1NotPresent (4), +-- row2LeftOccupied (5), +-- row2RightOccupied (6), +-- row2MidOccupied (7), +-- row2NotDetectable (8), +-- row2NotPresent (9), +-- row3LeftOccupied (10), +-- row3RightOccupied (11), +-- row3MidOccupied (12), +-- row3NotDetectable (13), +-- row3NotPresent (14), +-- row4LeftOccupied (15), +-- row4RightOccupied (16), +-- row4MidOccupied (17), +-- row4NotDetectable (18), +-- row4NotPresent (19) +--} (SIZE(20)) + +-- PositioningSolutionType ::= ENUMERATED {noPositioningSolution(0), sGNSS(1), dGNSS(2), sGNSSplusDR(3), dGNSSplusDR(4), dR(5), ...} + +--VehicleIdentification ::= SEQUENCE { +-- wMInumber WMInumber OPTIONAL, +-- vDS VDS OPTIONAL, +-- ... +--} + +--WMInumber ::= IA5String (SIZE(1..3)) + +--VDS ::= IA5String (SIZE(6)) + +-- EnergyStorageType ::= BIT STRING {hydrogenStorage(0), electricEnergyStorage(1), liquidPropaneGas(2), compressedNaturalGas(3), diesel(4), gasoline(5), ammonia(6)} (SIZE(7)) + +--VehicleLength ::= SEQUENCE { +-- vehicleLengthValue VehicleLengthValue, +-- vehicleLengthConfidenceIndication VehicleLengthConfidenceIndication +--} + +--VehicleLengthValue ::= INTEGER {tenCentimeters(1), outOfRange(1022), unavailable(1023)} (1..1023) + +--VehicleLengthConfidenceIndication ::= ENUMERATED {noTrailerPresent(0), trailerPresentWithKnownLength(1), trailerPresentWithUnknownLength(2), trailerPresenceIsUnknown(3), unavailable(4)} + +--VehicleWidth ::= INTEGER {tenCentimeters(1), outOfRange(61), unavailable(62)} (1..62) + +PathHistory::= SEQUENCE (SIZE(0..40)) OF PathPoint + +EmergencyPriority ::= BIT STRING {requestForRightOfWay(0), requestForFreeCrossingAtATrafficLight(1)} (SIZE(2)) + +InformationQuality ::= INTEGER {unavailable(0), lowest(1), highest(7)} (0..7) + +RoadType ::= ENUMERATED { + urban-NoStructuralSeparationToOppositeLanes(0), + urban-WithStructuralSeparationToOppositeLanes(1), + nonUrban-NoStructuralSeparationToOppositeLanes(2), + nonUrban-WithStructuralSeparationToOppositeLanes(3) +} + +SteeringWheelAngle ::= SEQUENCE { + steeringWheelAngleValue SteeringWheelAngleValue, + steeringWheelAngleConfidence SteeringWheelAngleConfidence +} + +SteeringWheelAngleValue ::= INTEGER {straight(0), onePointFiveDegreesToRight(-1), onePointFiveDegreesToLeft(1), unavailable(512)} (-511..512) + +SteeringWheelAngleConfidence ::= INTEGER {equalOrWithinOnePointFiveDegree (1), outOfRange(126), unavailable(127)} (1..127) + +TimestampIts ::= INTEGER {utcStartOf2004(0), oneMillisecAfterUTCStartOf2004(1)} (0..4398046511103) + +VehicleRole ::= ENUMERATED {default(0), publicTransport(1), specialTransport(2), dangerousGoods(3), roadWork(4), rescue(5), emergency(6), safetyCar(7), agriculture(8), commercial(9), military(10), roadOperator(11), taxi(12), reserved1(13), reserved2(14), reserved3(15)} + +YawRate::= SEQUENCE { + yawRateValue YawRateValue, + yawRateConfidence YawRateConfidence +} + +YawRateValue ::= INTEGER {straight(0), degSec-000-01ToRight(-1), degSec-000-01ToLeft(1), unavailable(32767)} (-32766..32767) + +YawRateConfidence ::= ENUMERATED { + degSec-000-01 (0), + degSec-000-05 (1), + degSec-000-10 (2), + degSec-001-00 (3), + degSec-005-00 (4), + degSec-010-00 (5), + degSec-100-00 (6), + outOfRange (7), + unavailable (8) +} + +ProtectedZoneType::= ENUMERATED { permanentCenDsrcTolling (0), ..., temporaryCenDsrcTolling (1) } + +-- RelevanceDistance ::= ENUMERATED {lessThan50m(0), lessThan100m(1), lessThan200m(2), lessThan500m(3), lessThan1000m(4), lessThan5km(5), lessThan10km(6), over10km(7)} + +-- RelevanceTrafficDirection ::= ENUMERATED {allTrafficDirections(0), upstreamTraffic(1), downstreamTraffic(2), oppositeTraffic(3)} + +-- TransmissionInterval ::= INTEGER {oneMilliSecond(1), tenSeconds(10000)} (1..10000) + +-- ValidityDuration ::= INTEGER {timeOfDetection(0), oneSecondAfterDetection(1)} (0..86400) + +ActionID ::= SEQUENCE { + originatingStationID StationID, + sequenceNumber SequenceNumber +} + +-- ItineraryPath ::= SEQUENCE SIZE(1..40) OF ReferencePosition + +ProtectedCommunicationZone ::= SEQUENCE { + protectedZoneType ProtectedZoneType, + expiryTime TimestampIts OPTIONAL, + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + protectedZoneRadius ProtectedZoneRadius OPTIONAL, + protectedZoneID ProtectedZoneID OPTIONAL, + ... +} + +-- Traces ::= SEQUENCE SIZE(1..7) OF PathHistory + +-- NumberOfOccupants ::= INTEGER {oneOccupant (1), unavailable(127)} (0 .. 127) + +SequenceNumber ::= INTEGER (0..65535) + +-- PositionOfPillars ::= SEQUENCE (SIZE(1..3, ...)) OF PosPillar + +-- RestrictedTypes ::= SEQUENCE (SIZE(1..3, ...)) OF StationType + +--EventHistory::= SEQUENCE (SIZE(1..23)) OF EventPoint + +--EventPoint ::= SEQUENCE { +-- eventPosition DeltaReferencePosition, +-- eventDeltaTime PathDeltaTime OPTIONAL, +-- informationQuality InformationQuality +--} + +ProtectedCommunicationZonesRSU ::= SEQUENCE (SIZE(1..16)) OF ProtectedCommunicationZone + +CenDsrcTollingZone ::= SEQUENCE { + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + cenDsrcTollingZoneID CenDsrcTollingZoneID OPTIONAL, + ... +} + +ProtectedZoneRadius ::= INTEGER {oneMeter(1)} (1..255,...) + +ProtectedZoneID ::= INTEGER (0.. 134217727) + +CenDsrcTollingZoneID ::= ProtectedZoneID + +DigitalMap ::= SEQUENCE (SIZE(1..256)) OF ReferencePosition + +OpeningDaysHours ::= UTF8String + +PhoneNumber ::= NumericString (SIZE(1..16)) +END diff --git a/epan/dissectors/asn1/its/ITS-ContainerV1.asn b/epan/dissectors/asn1/its/ITS-ContainerV1.asn new file mode 100644 index 00000000..779a9648 --- /dev/null +++ b/epan/dissectors/asn1/its/ITS-ContainerV1.asn @@ -0,0 +1,464 @@ +-- https://www.etsi.org/deliver/etsi_ts/102800_102899/10289402/01.02.01_60/ts_10289402v010201p.pdf +-- +ITS-ContainerV1 { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) ts (102894) cdd (2) version (1) +} + DEFINITIONS AUTOMATIC TAGS ::= + BEGIN +-- Use the def from V2 +-- ItsPduHeaderV1 ::= SEQUENCE { +-- protocolVersion INTEGER{currentVersion(1)} (0..255), +-- messageID INTEGER{denm(1),cam(2), poi(3), spat(4), map(5), ivi(6), ev-rsr(7)} (0..255), +-- stationID StationID +-- } + StationID ::= INTEGER(0..4294967295) + ReferencePosition ::= SEQUENCE { + latitude Latitude, + longitude Longitude, + positionConfidenceEllipse PosConfidenceEllipse , + altitude Altitude + } + DeltaReferencePosition ::= SEQUENCE { + deltaLatitude DeltaLatitude, + deltaLongitude DeltaLongitude, + deltaAltitude DeltaAltitude + } + Longitude ::= INTEGER {oneMicrodegreeEast (10), oneMicrodegreeWest (-10), unavailable(1800000001)} + (-1800000000..1800000001) + Latitude ::= INTEGER {oneMicrodegreeNorth (10), oneMicrodegreeSouth (-10), unavailable(900000001)} + (-900000000..900000001) + Altitude ::= SEQUENCE { + altitudeValue AltitudeValue, + altitudeConfidence AltitudeConfidence + } + AltitudeValue ::= INTEGER {referenceEllipsoidSurface(0), oneCentimeter(1), unavailable(800001)} (- + 100000..800001) + AltitudeConfidence ::= ENUMERATED { + alt-000-01 (0), + alt-000-02 (1), + alt-000-05 (2), + alt-000-10 (3), + alt-000-20 (4), + alt-000-50 (5), + alt-001-00 (6), + alt-002-00 (7), + alt-005-00 (8), + alt-010-00 (9), + alt-020-00 (10), + alt-050-00 (11), + alt-100-00 (12), + alt-200-00 (13), + outOfRange (14), + unavailable (15) + } + DeltaLongitude ::= INTEGER {oneMicrodegreeEast (10), oneMicrodegreeWest (-10), unavailable(131072)} + (-131071..131072) + DeltaLatitude ::= INTEGER {oneMicrodegreeNorth (10), oneMicrodegreeSouth (-10) , + unavailable(131072)} (-131071..131072) + DeltaAltitude ::= INTEGER {oneCentimeterUp (1), oneCentimeterDown (-1), unavailable(12800)} (- + 12700..12800) + + PosConfidenceEllipse ::= SEQUENCE { + semiMajorConfidence SemiAxisLength, + semiMinorConfidence SemiAxisLength, + semiMajorOrientation HeadingValue + } + PathPoint ::= SEQUENCE { + pathPosition DeltaReferencePosition, + pathDeltaTime PathDeltaTime OPTIONAL + } + PathDeltaTime ::= INTEGER {tenMilliSecondsInPast(1)} (1..65535, ...) + PtActivation ::= SEQUENCE { + ptActivationType PtActivationType, + ptActivationData PtActivationData + } + PtActivationType ::= INTEGER {undefinedCodingType(0), r09-16CodingType(1), vdv-50149CodingType(2)} + (0..255) + PtActivationData ::= OCTET STRING (SIZE(1..20)) + AccelerationControl ::= BIT STRING { + brakePedalEngaged (0), + gasPedalEngaged (1), + emergencyBrakeEngaged (2), + collisionWarningEngaged (3), + accEngaged (4), + cruiseControlEngaged (5), + speedLimiterEngaged (6) + } (SIZE(7)) + + SemiAxisLength ::= INTEGER{oneCentimeter(1), outOfRange(4094), unavailable(4095)} (0..4095) + + CauseCode ::= SEQUENCE { + causeCode CauseCodeTypeV1, + subCauseCode SubCauseCodeTypeV1 + } + + CauseCodeTypeV1 ::= INTEGER { + reserved (0), + trafficCondition (1), + accident (2), + roadworks (3), + adverseWeatherCondition-Adhesion (6), + hazardousLocation-SurfaceCondition (9), + hazardousLocation-ObstacleOnTheRoad (10), + hazardousLocation-AnimalOnTheRoad (11), + humanPresenceOnTheRoad (12), + wrongWayDriving (14), + rescueAndRecoveryWorkInProgress (15), + adverseWeatherCondition-ExtremeWeatherCondition (17), + adverseWeatherCondition-Visibility (18), + adverseWeatherCondition-Precipitation (19), + slowVehicle (26), + dangerousEndOfQueue (27), + vehicleBreakdown (91), + postCrash (92), + humanProblem (93), + stationaryVehicle (94), + emergencyVehicleApproaching (95), + hazardousLocation-DangerousCurve (96), + collisionRisk (97), + signalViolation (98), + dangerousSituation (99) + } (0..255) + + SubCauseCodeTypeV1 ::= INTEGER (0..255) +-- Wireshark modification comment out the subCauses the ones from V2 will be used. +-- TrafficConditionSubCauseCode ::= INTEGER { +-- unavailable(0), +-- increasedVolumeOfTraffic(1), +-- trafficJamSlowlyIncreasing(2), +-- trafficJamIncreasing(3), +-- trafficJamStronglyIncreasing(4), +-- trafficStationary(5), +-- trafficJamSlightlyDecreasing(6), +-- trafficJamDecreasing(7), +-- trafficJamStronglyDecreasing(8) +-- } (0..255) + +-- AccidentSubCauseCode ::= INTEGER {unavailable(0), multiVehicleAccident(1), heavyAccident(2), +-- accidentInvolvingLorry(3), accidentInvolvingBus(4), accidentInvolvingHazardousMaterials(5), +-- accidentOnOppositeLane(6), unsecuredAccident(7), assistanceRequested(8)} (0..255) + RoadworksSubCauseCode ::= INTEGER {unavailable(0), majorRoadworks(1), roadMarkingWork(2), + slowMovingRoadMaintenance(3), shortTermStationaryRoadworks(4), streetCleaning(5), winterService(6)} + (0..255) + +-- HumanPresenceOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), childrenOnRoadway(1), +-- cyclistOnRoadway(2), motorcyclistOnRoadway(3)} (0..255) + +-- WrongWayDrivingSubCauseCode ::= INTEGER {unavailable(0), wrongLane(1), wrongDirection(2)} (0..255) + +-- AdverseWeatherCondition-ExtremeWeatherConditionSubCauseCode ::= INTEGER {unavailable(0), +-- strongWinds(1), damagingHail(2), hurricane(3), thunderstorm(4), tornado(5), blizzard(6)} (0..255) + +-- AdverseWeatherCondition-AdhesionSubCauseCode ::= INTEGER {unavailable(0), heavyFrostOnRoad(1), +-- fuelOnRoad(2), mudOnRoad(3), snowOnRoad(4), iceOnRoad(5), blackIceOnRoad(6), oilOnRoad(7), +-- looseChippings(8), instantBlackIce(9), roadsSalted(10)} (0..255) +-- AdverseWeatherCondition-VisibilitySubCauseCode ::= INTEGER {unavailable(0), fog(1), smoke(2), +-- heavySnowfall(3), heavyRain(4), heavyHail(5), lowSunGlare(6), sandstorms(7), swarmsOfInsects(8)} +-- (0..255) +-- AdverseWeatherCondition-PrecipitationSubCauseCode ::= INTEGER {unavailable(0), heavyRain(1), +-- heavySnowfall(2), softHail(3)} (0..255) +-- SlowVehicleSubCauseCode ::= INTEGER {unavailable(0), maintenanceVehicle(1), +-- vehiclesSlowingToLookAtAccident(2), abnormalLoad(3), abnormalWideLoad(4), convoy(5), snowplough(6), +-- deicing(7), saltingVehicles(8)} (0..255) + +-- StationaryVehicleSubCauseCode ::= INTEGER {unavailable(0), humanProblem(1), vehicleBreakdown(2), +-- postCrash(3), publicTransportStop(4), carryingDangerousGoods(5)} (0..255) +-- HumanProblemSubCauseCode ::= INTEGER {unavailable(0), glycemiaProblem(1), heartProblem(2)} (0..255) +-- EmergencyVehicleApproachingSubCauseCode ::= INTEGER {unavailable(0), emergencyVehicleApproaching(1), +-- prioritizedVehicleApproaching(2)} (0..255) +-- HazardousLocation-DangerousCurveSubCauseCode ::= INTEGER {unavailable(0), dangerousLeftTurnCurve(1), +-- dangerousRightTurnCurve(2), multipleCurvesStartingWithUnknownTurningDirection(3), +-- multipleCurvesStartingWithLeftTurn(4), multipleCurvesStartingWithRightTurn(5)} (0..255) +-- HazardousLocation-SurfaceConditionSubCauseCode ::= INTEGER {unavailable(0), rockfalls(1), +-- earthquakeDamage(2), sewerCollapse(3), subsidence(4), snowDrifts(5), stormDamage(6), burstPipe(7), +-- volcanoEruption(8), fallingIce(9)} (0..255) +-- HazardousLocation-ObstacleOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), shedLoad(1), +-- partsOfVehicles(2), partsOfTyres(3), bigObjects(4), fallenTrees(5), hubCaps(6), waitingVehicles(7)} +-- (0..255) +-- HazardousLocation-AnimalOnTheRoadSubCauseCode ::= INTEGER {unavailable(0), wildAnimals(1), +-- herdOfAnimals(2), smallAnimals(3), largeAnimals(4)} (0..255) +-- CollisionRiskSubCauseCode ::= INTEGER {unavailable(0), longitudinalCollisionRisk(1), +-- crossingCollisionRisk(2), lateralCollisionRisk(3), vulnerableRoadUser(4)} (0..255) + +-- SignalViolationSubCauseCode ::= INTEGER {unavailable(0), stopSignViolation(1), +-- trafficLightViolation(2), turningRegulationViolation(3)} (0..255) +-- RescueAndRecoveryWorkInProgressSubCauseCode ::= INTEGER {unavailable(0), emergencyVehicles(1), +-- rescueHelicopterLanding(2), policeActivityOngoing(3), medicalEmergencyOngoing(4), +-- childAbductionInProgress(5)} (0..255) +-- DangerousEndOfQueueSubCauseCode ::= INTEGER {unavailable(0), suddenEndOfQueue(1), queueOverHill(2), +-- queueAroundBend(3), queueInTunnel(4)} (0..255) +-- DangerousSituationSubCauseCode ::= INTEGER {unavailable(0), emergencyElectronicBrakeEngaged(1), +-- preCrashSystemEngaged(2), espEngaged(3), absEngaged(4), aebEngaged(5), brakeWarningEngaged(6), +-- collisionRiskWarningEngaged(7)} (0..255) +-- VehicleBreakdownSubCauseCode ::= INTEGER {unavailable(0), lackOfFuel (1), lackOfBatteryPower (2), +-- engineProblem(3), transmissionProblem(4), engineCoolingProblem(5), brakingSystemProblem(6), +-- steeringProblem(7), tyrePuncture(8)} (0..255) + +-- PostCrashSubCauseCode ::= INTEGER {unavailable(0), accidentWithoutECallTriggered (1), +-- accidentWithECallManuallyTriggered (2), accidentWithECallAutomaticallyTriggered (3), +-- accidentWithECallTriggeredWithoutAccessToCellularNetwork(4)} (0..255) + + Curvature ::= SEQUENCE { + curvatureValue CurvatureValue, + curvatureConfidence CurvatureConfidence + } + CurvatureValue ::= INTEGER {straight(0), reciprocalOf1MeterRadiusToRight(-30000), + reciprocalOf1MeterRadiusToLeft(30000), unavailable(30001)} (-30000..30001) + CurvatureConfidence ::= ENUMERATED { + onePerMeter-0-00002 (0), + onePerMeter-0-0001 (1), + onePerMeter-0-0005 (2), + onePerMeter-0-002 (3), + onePerMeter-0-01 (4), + onePerMeter-0-1 (5), + outOfRange (6), + unavailable (7) + } + CurvatureCalculationMode ::= ENUMERATED {yawRateUsed(0), yawRateNotUsed(1), unavailable(2), ...} + Heading ::= SEQUENCE { + headingValue HeadingValue, + headingConfidence HeadingConfidence + } + HeadingValue ::= INTEGER {wgs84North(0), wgs84East(900), wgs84South(1800), wgs84West(2700), + unavailable(3601)} (0..3601) + HeadingConfidence ::= INTEGER {equalOrWithinZeroPointOneDegree (1), equalOrWithinOneDegree (10), + outOfRange(126), unavailable(127)} (1..127) + LanePosition::= INTEGER {offTheRoad(-1), hardShoulder(0), + outermostDrivingLane(1), secondLaneFromOutside(2)} (-1..14) + ClosedLanes ::= SEQUENCE { + hardShoulderStatus HardShoulderStatus OPTIONAL, + drivingLaneStatus DrivingLaneStatus, + ... + } + HardShoulderStatus ::= ENUMERATED {availableForStopping(0), closed(1), availableForDriving(2)} + DrivingLaneStatus ::= BIT STRING {outermostLaneClosed(1), secondLaneFromOutsideClosed(2)} (SIZE + (1..14)) + PerformanceClass ::= INTEGER {unavailable(0), performanceClassA(1), performanceClassB(2)} (0..7) + SpeedValue ::= INTEGER {standstill(0), oneCentimeterPerSec(1), unavailable(16383)} (0..16383) + SpeedConfidence ::= INTEGER {equalOrWithinOneCentimeterPerSec(1), equalOrWithinOneMeterPerSec(100), + outOfRange(126), unavailable(127)} (1..127) + VehicleMass ::= INTEGER {hundredKg(1), unavailable(1024)} (1..1024) + Speed ::= SEQUENCE { + speedValue SpeedValue, + speedConfidence SpeedConfidence + } + DriveDirection ::= ENUMERATED {forward (0), backward (1), unavailable (2)} + EmbarkationStatus ::= BOOLEAN + LongitudinalAcceleration ::= SEQUENCE { + longitudinalAccelerationValue LongitudinalAccelerationValue, + longitudinalAccelerationConfidence AccelerationConfidence + } + LongitudinalAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredForward(1), + pointOneMeterPerSecSquaredBackward(-1), unavailable(161)} (-160 .. 161) + AccelerationConfidence ::= INTEGER {pointOneMeterPerSecSquared(1), outOfRange(101), + unavailable(102)} (0 .. 102) + + LateralAcceleration ::= SEQUENCE { + lateralAccelerationValue LateralAccelerationValue, + lateralAccelerationConfidence AccelerationConfidence + } + LateralAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredToRight(-1), + pointOneMeterPerSecSquaredToLeft(1), unavailable(161)} (-160 .. 161) + VerticalAcceleration ::= SEQUENCE { + verticalAccelerationValue VerticalAccelerationValue, + verticalAccelerationConfidence AccelerationConfidence + } + + VerticalAccelerationValue ::= INTEGER {pointOneMeterPerSecSquaredUp(1), + pointOneMeterPerSecSquaredDown(-1), unavailable(161)} (-160 .. 161) + StationType ::= INTEGER {unknown(0), pedestrian(1), cyclist(2), moped(3), motorcycle(4), + passengerCar(5), bus(6), + lightTruck(7), heavyTruck(8), trailer(9), specialVehicles(10), tram(11), roadSideUnit(15)} (0..255) + ExteriorLights ::= BIT STRING { + lowBeamHeadlightsOn (0), + highBeamHeadlightsOn (1), + leftTurnSignalOn (2), + rightTurnSignalOn (3), + daytimeRunningLightsOn (4), + reverseLightOn (5), + fogLightOn (6), + parkingLightsOn (7) + } (SIZE(8)) + + DangerousGoodsBasic::= ENUMERATED { + explosives1(0), + explosives2(1), + explosives3(2), + explosives4(3), + explosives5(4), + explosives6(5), + flammableGases(6), + nonFlammableGases(7), + toxicGases(8), + flammableLiquids(9), + flammableSolids(10), + substancesLiableToSpontaneousCombustion(11), + substancesEmittingFlammableGasesUponContactWithWater(12), + oxidizingSubstances(13), + organicPeroxides(14), + toxicSubstances(15), + infectiousSubstances(16), + radioactiveMaterial(17), + corrosiveSubstances(18), + miscellaneousDangerousSubstances(19) + } + + DangerousGoodsExtended ::= SEQUENCE { + dangerousGoodsType DangerousGoodsBasic, + unNumber INTEGER (0..9999), + elevatedTemperature BOOLEAN, + tunnelsRestricted BOOLEAN, + limitedQuantity BOOLEAN, + emergencyActionCode IA5String (SIZE (1..24)) OPTIONAL, + phoneNumber IA5String (SIZE (1..24)) OPTIONAL, + companyName UTF8String (SIZE (1..24)) OPTIONAL + } + + SpecialTransportType ::= BIT STRING {heavyLoad(0), excessWidth(1), excessLength(2), excessHeight(3)} + (SIZE(4)) + LightBarSirenInUse ::= BIT STRING { + lightBarActivated (0), + sirenActivated (1) + } (SIZE(2)) + HeightLonCarr ::= INTEGER {oneCentimeter(1), unavailable(100)} (1..100) + PosLonCarr ::= INTEGER {oneCentimeter(1), unavailable(127)} (1..127) + PosPillar ::= INTEGER {tenCentimeters(1), unavailable(30)} (1..30) + PosCentMass ::= INTEGER {tenCentimeters(1), unavailable(63)} (1..63) + RequestResponseIndication ::= ENUMERATED {request(0), response(1)} + SpeedLimit ::= INTEGER {oneKmPerHour(1)} (1..255) + StationarySince ::= ENUMERATED {lessThan1Minute(0), lessThan2Minutes(1), lessThan15Minutes(2), + equalOrGreater15Minutes(3)} + Temperature ::= INTEGER {equalOrSmallerThanMinus60Deg (-60), oneDegreeCelsius(1), + equalOrGreaterThan67Deg(67)} (-60..67) + TrafficRule ::= ENUMERATED {noPassing(0), noPassingForTrucks(1), passToRight(2), passToLeft(3), ... + } + WheelBaseVehicle ::= INTEGER {tenCentimeters(1), unavailable(127)} (1..127) + TurningRadius ::= INTEGER {point4Meters(1), unavailable(255)} (1..255) + PosFrontAx ::= INTEGER {tenCentimeters(1), unavailable(20)} (1..20) + PositionOfOccupants ::= BIT STRING { + row1LeftOccupied (0), + row1RightOccupied (1), + row1MidOccupied (2), + row1NotDetectable (3), + row1NotPresent (4), + row2LeftOccupied (5), + row2RightOccupied (6), + row2MidOccupied (7), + row2NotDetectable (8), + row2NotPresent (9), + row3LeftOccupied (10), + row3RightOccupied (11), + row3MidOccupied (12), + row3NotDetectable (13), + row3NotPresent (14), + row4LeftOccupied (15), + row4RightOccupied (16), + row4MidOccupied (17), + row4NotDetectable (18), + row4NotPresent (19)} (SIZE(20)) + PositioningSolutionType ::= ENUMERATED {noPositioningSolution(0), sGNSS(1), dGNSS(2), + sGNSSplusDR(3), dGNSSplusDR(4), dR(5), ...} + VehicleIdentification ::= SEQUENCE { + wMInumber WMInumber OPTIONAL, + vDS VDS OPTIONAL, + ... + } + WMInumber ::= IA5String (SIZE(1..3)) + VDS ::= IA5String (SIZE(6)) + EnergyStorageType ::= BIT STRING {hydrogenStorage(0), electricEnergyStorage(1), liquidPropaneGas(2), + compressedNaturalGas(3), diesel(4), gasoline(5), ammonia(6)} (SIZE(7)) + VehicleLength ::= SEQUENCE { + vehicleLengthValue VehicleLengthValue, + vehicleLengthConfidenceIndication VehicleLengthConfidenceIndication + } + VehicleLengthValue ::= INTEGER {tenCentimeters(1), outOfRange(1022), unavailable(1023)} (1..1023) + VehicleLengthConfidenceIndication ::= ENUMERATED {noTrailerPresent(0), + trailerPresentWithKnownLength(1), trailerPresentWithUnknownLength(2), trailerPresenceIsUnknown(3), + unavailable(4)} + VehicleWidth ::= INTEGER {tenCentimeters(1), outOfRange(61), unavailable(62)} (1..62) + PathHistory::= SEQUENCE (SIZE(0..40)) OF PathPoint + + EmergencyPriority ::= BIT STRING {requestForRightOfWay(0), requestForFreeCrossingAtATrafficLight(1)} + (SIZE(2)) + InformationQuality ::= INTEGER {unavailable(0), lowest(1), highest(7)} (0..7) + RoadType ::= ENUMERATED { + urban-NoStructuralSeparationToOppositeLanes(0), + urban-WithStructuralSeparationToOppositeLanes(1), + nonUrban-NoStructuralSeparationToOppositeLanes(2), + nonUrban-WithStructuralSeparationToOppositeLanes(3)} + SteeringWheelAngle ::= SEQUENCE { + steeringWheelAngleValue SteeringWheelAngleValue, + steeringWheelAngleConfidence SteeringWheelAngleConfidence + } + SteeringWheelAngleValue ::= INTEGER {straight(0), onePointFiveDegreesToRight(-1), + onePointFiveDegreesToLeft(1), unavailable(512)} (-511..512) + SteeringWheelAngleConfidence ::= INTEGER {equalOrWithinOnePointFiveDegree (1), outOfRange(126), + unavailable(127)} (1..127) + TimestampIts ::= INTEGER {utcStartOf2004(0), oneMillisecAfterUTCStartOf2004(1)} (0..4398046511103) + VehicleRole ::= ENUMERATED {default(0), publicTransport(1), specialTransport(2), dangerousGoods(3), + roadWork(4), rescue(5), emergency(6), safetyCar(7), + agriculture(8),commercial(9),military(10),roadOperator(11),taxi(12), reserved1(13), reserved2(14), + reserved3(15)} + YawRate::= SEQUENCE { + yawRateValue YawRateValue, + yawRateConfidence YawRateConfidence + } + YawRateValue ::= INTEGER {straight(0), degSec-000-01ToRight(-1), degSec-000-01ToLeft(1), + unavailable(32767)} (-32766..32767) + YawRateConfidence ::= ENUMERATED { + degSec-000-01 (0), + degSec-000-05 (1), + degSec-000-10 (2), + degSec-001-00 (3), + degSec-005-00 (4), + degSec-010-00 (5), + degSec-100-00 (6), + outOfRange (7), + unavailable (8) + } + ProtectedZoneType::= ENUMERATED { + cenDsrcTolling (0), + ... + } + RelevanceDistance ::= ENUMERATED {lessThan50m(0), lessThan100m(1), lessThan200m(2), lessThan500m(3), + lessThan1000m(4), lessThan5km(5), lessThan10km(6), over10km(7)} + RelevanceTrafficDirection ::= ENUMERATED {allTrafficDirections(0), upstreamTraffic(1), + downstreamTraffic(2), oppositeTraffic(3)} + TransmissionInterval ::= INTEGER {oneMilliSecond(1), tenSeconds(10000)} (1..10000) + ValidityDuration ::= INTEGER {timeOfDetection(0), oneSecondAfterDetection(1)} (0..86400) + ActionID ::= SEQUENCE { + originatingStationID StationID, + sequenceNumber SequenceNumber + } + ItineraryPath ::= SEQUENCE SIZE(1..40) OF ReferencePosition + + ProtectedCommunicationZone ::= SEQUENCE { + protectedZoneType ProtectedZoneType, + expiryTime TimestampIts OPTIONAL, + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + protectedZoneRadius ProtectedZoneRadius OPTIONAL, + protectedZoneID ProtectedZoneID OPTIONAL + } + Traces ::= SEQUENCE SIZE(1..7) OF PathHistory + NumberOfOccupants ::= INTEGER {oneOccupant (1), unavailable(127)} (0 .. 127) + SequenceNumber ::= INTEGER (0..65535) + PositionOfPillars ::= SEQUENCE (SIZE(1..3, ...)) OF PosPillar + RestrictedTypes ::= SEQUENCE (SIZE(1..3, ...)) OF StationType + EventHistory::= SEQUENCE (SIZE(1..23)) OF EventPoint + EventPoint ::= SEQUENCE { + eventPosition DeltaReferencePosition, + eventDeltaTime PathDeltaTime OPTIONAL, + informationQuality InformationQuality + } + ProtectedCommunicationZonesRSU ::= SEQUENCE (SIZE(1..16)) OF ProtectedCommunicationZone + CenDsrcTollingZone ::= SEQUENCE { + protectedZoneLatitude Latitude, + protectedZoneLongitude Longitude, + cenDsrcTollingZoneID CenDsrcTollingZoneID OPTIONAL + } + ProtectedZoneRadius ::= INTEGER {oneMeter(1)} (1..255,...) + ProtectedZoneID ::= INTEGER (0.. 134217727) + CenDsrcTollingZoneID ::= ProtectedZoneID + +END diff --git a/epan/dissectors/asn1/its/TIS_TPG_Transactions_Descriptions.asn b/epan/dissectors/asn1/its/TIS_TPG_Transactions_Descriptions.asn new file mode 100644 index 00000000..b4df4800 --- /dev/null +++ b/epan/dissectors/asn1/its/TIS_TPG_Transactions_Descriptions.asn @@ -0,0 +1,347 @@ +-- TIS-TPG Transactions message definitions +-- ASN.1 Start Definition + +TIS-TPG-Transactions-Descriptions { +itu-t (0) identified-organization (4) etsi (0) itsDomain (5) +wg1 (1) i2vApplications (101556) tpms (2) transactions (1) version (1)} +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS +CauseCode, ItsPduHeader, ReferencePosition, Speed, Heading, TimestampIts, StationID, PhoneNumber, OpeningDaysHours, DigitalMap -- PATCH +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} +; + + + +-- Root Message PDU: TisTpgTransactionsPdu + +TisTpgTransactionsPdu ::= SEQUENCE { + header ItsPduHeader, + tisTpgTransaction TisTpgTransaction +} + +TisTpgTransaction ::= CHOICE { + drm TisTpgDRM, + snm TisTpgSNM, + trm TisTpgTRM, + tcm TisTpgTCM, + vdrm TisTpgVDRM, + vdpm TisTpgVDPM, + eofm TisTpgEOFM +} + +-- TisTpgDRM + +TisTpgDRM ::= SEQUENCE { + management TisTpgDRM-Management, + situation TisTpgDRM-Situation, + location TisTpgDRM-Location, + ... +} + +TisTpgDRM-Management ::= SEQUENCE { + generationTime TimestampIts, + vehicleType UNVehicleClassifcation, + costumerContract CustomerContract OPTIONAL, + tisProfile TisProfile, + ... +} + +TisTpgDRM-Situation ::= SEQUENCE { + causeCode CauseCode, + ... +} + +TisTpgDRM-Location ::= SEQUENCE { + vehiclePosition ReferencePosition, + vehicleSpeed Speed, + vehicleHeading Heading, + requestedPosition ReferencePosition OPTIONAL, + searchRange SearchRange OPTIONAL, + searchCondition SearchCondition OPTIONAL, + ... +} + +-- TisTpgSNM + +TisTpgSNM ::= SEQUENCE { + management TisTpgSNM-Management, + tpgContainer TpgNotifContainer +} + +TisTpgSNM-Management ::= SEQUENCE { + generationTime TimestampIts, + totalTpgStations TotalTpgStations, + ... +} + +-- TisTpgTRM + +TisTpgTRM ::= SEQUENCE { + management TisTpgTRM-Management, + situation TisTpgTRM-Situation OPTIONAL, + location TisTpgTRM-Location OPTIONAL, + ... +} + +TisTpgTRM-Management ::= SEQUENCE { + generationTime TimestampIts, + vehicleType UNVehicleClassifcation, + tpgStationID StationID, + reservationStatus ReservationStatus, + costumercontract CustomerContract OPTIONAL, + reservationID ReservationID OPTIONAL, + ... +} + +TisTpgTRM-Situation ::= SEQUENCE { + estArrivalTime TimestampIts, + proposedPairingID PairingID OPTIONAL +} + +TisTpgTRM-Location ::= SEQUENCE { + vehiclePosition ReferencePosition, + vehicleSpeed Speed, + vehicleHeading Heading, + ... +} + +-- TisTpgTCM + +TisTpgTCM ::= SEQUENCE { + management TisTpgTCM-Management, + situation TisTpgTCM-Situation OPTIONAL, + location TisTpgTCM-Location OPTIONAL, + ... +} + +TisTpgTCM-Management ::= SEQUENCE { + generationTime TimestampIts, + tpgStationID StationID, + reservationStatus ReservationStatus, + reservedTpg INTEGER(1..65535) OPTIONAL, + costumercontract CustomerContract OPTIONAL, + reservationID ReservationID OPTIONAL, + tpgAutomationLevel TpgAutomation OPTIONAL, + ... +} + +TisTpgTCM-Situation::= SEQUENCE { + pairingID PairingID OPTIONAL, + reservationTimeLimit TimestampIts, + cancellationCondition CancellationCondition OPTIONAL, + ... +} + +TisTpgTCM-Location::= SEQUENCE { + tpgLocation ReferencePosition OPTIONAL, + address UTF8String(SIZE(1..128)) OPTIONAL, + ... +} + +-- TisTpgVDRM + +TisTpgVDRM ::= SEQUENCE { + management TisTpgVDRM-Management, + ... +} + +TisTpgVDRM-Management ::= SEQUENCE { + generationTime TimestampIts, + fillingStatus FillingStatus, + automationLevel TpgAutomation, + pairingID PairingID OPTIONAL, + ... +} + +-- TisTpgVDPM + +TisTpgVDPM ::= SEQUENCE { + management TisTpgVDPM-Management, + placardTable PlacardTable, + vehicleSpecificData VehicleSpecificData OPTIONAL, + ... +} + +TisTpgVDPM-Management ::= SEQUENCE { + generationTime TimestampIts, + tisProfile TisProfile OPTIONAL, + language Language, + vehicleType UNVehicleClassifcation, + tyreTempCondition TyreTempCondition, + fillingStatus FillingStatus, + pairingID PairingID OPTIONAL, + ... +} + +VehicleSpecificData ::= SEQUENCE { + currentVehicleConfiguration PressureConfiguration, + frontLeftTyreData TyreData, + frontRightTyreData TyreData, + rearLeftTyreData TyreData, + rearRightTyreData TyreData, + spareTyreData TyreData, + ... +} + +-- TisTpgEOFM + +TisTpgEOFM ::= SEQUENCE { + management TisTpgEOFM-Management, + ... +} + +TisTpgEOFM-Management ::= SEQUENCE { + generationTime TimestampIts, + fillingStatus FillingStatus, + numberOfAppliedPressure NumberOfAppliedPressure, + appliedTyrePressures AppliedTyrePressures OPTIONAL, + pairingID PairingID OPTIONAL, + ... +} + +PlacardTable ::= SEQUENCE(SIZE(0..15)) OF TyreSetVariant + +TyreSetVariant ::= SEQUENCE +{ + variantID TyreSetVariantID, + frontAxleDimension TyreSidewallInformation OPTIONAL, + rearAxleDimension TyreSidewallInformation OPTIONAL, + pressureVariantsList PressureVariantsList +} + +PressureVariantsList ::= SEQUENCE(SIZE(1..15)) OF PressureVariant + +PressureVariant ::= SEQUENCE +{ + pressureConfiguration PressureConfiguration, + frontAxlePressure AxlePlacardPressure, + rearAxlePressure AxlePlacardPressure +} + +TyreData ::= SEQUENCE +{ + currentTyrePressure CHOICE { + tyrePressureValue TyrePressure, + unavailable NULL + } OPTIONAL, + tyreSidewallInformation CHOICE { + tyreSidewallInformationValue TyreSidewallInformation, + unavailable NULL + } OPTIONAL, + currentInsideAirTemperature CHOICE { + tyreAirTemperatureValue TyreAirTemperature, + unavailable NULL + } OPTIONAL, + recommendedTyrePressure CHOICE { + axlePlacardPressureValue AxlePlacardPressure, + unavailable NULL + } OPTIONAL, + tin CHOICE { + tinValue TIN, + unavailable NULL + } OPTIONAL, + sensorState CHOICE { + sensorStateValue SensorState, + unavailable NULL + } OPTIONAL, + ... +} + +AppliedTyrePressure ::= CHOICE { + tyrePressureValue TyrePressure, + unavailable NULL +} + +TpgStationData ::= SEQUENCE { + tpgStationID StationID, + tpgAutomationLevel TpgAutomation, + tpgNumber TpgNumber, + tpgProvider TpgProvider, + tpgLocation ReferencePosition, + accessibility Accessibility, + address UTF8String(SIZE(1..128)) OPTIONAL, + phoneNumber PhoneNumber OPTIONAL, + digitalMap DigitalMap OPTIONAL, + openingDaysHours OpeningDaysHours OPTIONAL, + bookingInfo BookingInfo OPTIONAL, + availableTpgNumber AvailableTpgNumber OPTIONAL, + cancellationCondition CancellationCondition OPTIONAL, + ... +} + +TyreSidewallInformation ::= BIT STRING (SIZE (60)) + +CurrentVehicleConfiguration ::= BIT STRING (SIZE (9)) + +AxlePlacardPressure ::= INTEGER { zero (0), fiveKPa (1) } (0..255) + +SensorState ::= INTEGER { malfunction(65534), unavailable(65535) } (0..65535) + +TyrePressure ::= INTEGER { invalid (0), lessThanOneBar (1), oneBar (2), oneBarPlusTwoAndHalfKPa (3), inflation (254), overflow(255) } (0..255) + +DriverLanguage ::= INTEGER {english (0), german (1), french (2), italian (3), spanish (4) } (0..15) + +TyreTempCondition ::= ENUMERATED {pressure-cold (0),pressure-warm (1), unavailable (2), ... } + +TyreAirTemperature ::= INTEGER { invalid (0), lessThanMinus50Celsius(1), minus50Celsius(2), minus49Celsius(3), zeroCelsius(52), overflowThreshold1(240), overflowThreshold2(241), overflowThreshold3(242), overflowThreshold4(243), overflowThreshold5(244), overflowThreshold6(245), overflowThreshold7(246), overflowThreshold8(247), overflowThreshold9(248), overflowThreshold10(249), overflowThreshold11(250), overflowThreshold12(251), overflowThreshold13(252), overflowThreshold14(253), overflowThreshold15(254), overflowThreshold16(255) } (0..255) + +TIN ::= BIT STRING (SIZE(64)) + +PressureConfiguration ::= BIT STRING (SIZE (9)) + +CustomerContract ::= IA5String(SIZE(1..32)) + +ReservationStatus ::= ENUMERATED { reservationOK (0), noReservationService (1), noTpmsAvailable (2), ...} + +PairingID ::= INTEGER(0..9999) + +AppliedTyrePressures ::= SEQUENCE (SIZE(1..5)) OF AppliedTyrePressure + +SearchRange ::= INTEGER(0..255) + +TotalTpgStations ::= INTEGER(0..65535) + +TpgNotifContainer ::= SEQUENCE (SIZE(1..8)) OF TpgStationData + +-- DigitalMap ::= SEQUENCE (SIZE(1..256)) OF ReferencePosition PATCH + +TpgNumber ::= INTEGER(1..65535) + +TpgProvider ::= UTF8String (SIZE(1..32)) + +TpgLocation ::= ReferencePosition + +Accessibility ::= UTF8String (SIZE(1..32)) + +-- PhoneNumber ::= NumericString (SIZE(1..16)) PATCH + +-- OpeningDaysHours ::= UTF8String PATCH + +BookingInfo ::= UTF8String + +AvailableTpgNumber ::= INTEGER(1..65535) + +CancellationCondition ::= UTF8String (SIZE(1..32)) + +TpgAutomation ::= BIT STRING {fullAutomated(0), semiAutomated(1), manual(2), reserved (3)} (SIZE(4)) + +FillingStatus ::= INTEGER {requestVehicleData(0), sendVehicleData(1), started(2), fillingProcessFailed (3), fillingProcessCompleted (4) } (0..7) + +NumberOfAppliedPressure ::= INTEGER {oneAppliedPressure(1), twoAppliedPressure (2)} (1..5) + +UNVehicleClassifcation ::= INTEGER {reserved(0), categoryL1(1), categoryL2(2), categoryL3(3), categoryL4(4), categoryL5(5), categoryL6(6), categoryL7(7), categoryL8(8)} (0..63) + +SearchCondition ::= INTEGER {nearest(0), quickest(1), paylessRoad(2)} (0..7) + +TisProfile ::= BIT STRING {reserved(0),profileOne(1), profileTwo(2), profileThree(3)} (SIZE(8)) + +ReservationID ::= UTF8String (SIZE(1..32)) + +Language ::= BIT STRING (SIZE (10)) + +TyreSetVariantID ::= INTEGER (0..15) + +END diff --git a/epan/dissectors/asn1/its/VAM-PDU-Descriptions.asn b/epan/dissectors/asn1/its/VAM-PDU-Descriptions.asn new file mode 100644 index 00000000..1cd6021b --- /dev/null +++ b/epan/dissectors/asn1/its/VAM-PDU-Descriptions.asn @@ -0,0 +1,98 @@ +-- Draft V0.0.4_2.2.1 - VAM TS 103 300-1 ASN.1 module +-- Based on the official version available at @url https: +-- Modified to import from the CDD module V2.1.1 + +VAM-PDU-Descriptions {itu-t(0) identified-organization(4) etsi(0) itsDomain(5) + wg1(1) 103300 vam(1) major-version-3(3) minor-version-1(1)} +DEFINITIONS AUTOMATIC TAGS ::= +BEGIN + + IMPORTS + AccelerationChangeIndication, BasicContainer, CartesianAngle, ClusterBreakupInfo, + ClusterJoinInfo, ClusterLeaveInfo, Curvature, CurvatureCalculationMode, + DeltaTimeQuarterSecond, GenerationDeltaTime, HeadingChangeIndication, ItsPduHeader, LanePosition, + LateralAcceleration, LongitudinalAcceleration, PathHistory, PathPredicted, + SequenceOfSafeDistanceIndication, SequenceOfTrajectoryInterceptionIndication, + SequenceOfTrajectoryInterceptionIndication, Speed, StabilityChangeIndication, StationId, + TrajectoryInterceptionIndication, VerticalAcceleration, VruClusterInformation, VruDeviceUsage, + VruEnvironment, VruExteriorLights, GeneralizedLanePosition, VruProfileAndSubprofile, VruMovementControl, + VruSizeClass, YawRate, Wgs84Angle + FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1) } + -- WITH SUCCESSORS + ; + + + VAM ::= SEQUENCE { + header ItsPduHeaderVam, + vam VruAwareness + } + + ItsPduHeaderVam ::= ItsPduHeader(WITH COMPONENTS {..., protocolVersion(3), messageId(vam)}) + + + VruAwareness ::= SEQUENCE { + generationDeltaTime GenerationDeltaTime, + vamParameters VamParameters + } + + VamParameters ::= SEQUENCE { + basicContainer BasicContainer, + vruHighFrequencyContainer VruHighFrequencyContainer, + vruLowFrequencyContainer VruLowFrequencyContainer OPTIONAL, + vruClusterInformationContainer VruClusterInformationContainer OPTIONAL, + vruClusterOperationContainer VruClusterOperationContainer OPTIONAL, + vruMotionPredictionContainer VruMotionPredictionContainer OPTIONAL, + ... + } + + VruHighFrequencyContainer ::= SEQUENCE { + heading Wgs84Angle, + speed Speed, + longitudinalAcceleration LongitudinalAcceleration, + curvature Curvature OPTIONAL, + curvatureCalculationMode CurvatureCalculationMode OPTIONAL, + yawRate YawRate OPTIONAL, + lateralAcceleration LateralAcceleration OPTIONAL, + verticalAcceleration VerticalAcceleration OPTIONAL, + vruLanePosition GeneralizedLanePosition OPTIONAL, + environment VruEnvironment OPTIONAL, + movementControl VruMovementControl OPTIONAL, + orientation Wgs84Angle OPTIONAL, + rollAngle CartesianAngle OPTIONAL, + deviceUsage VruDeviceUsage OPTIONAL, + ... + } + + VruLowFrequencyContainer ::= SEQUENCE { + profileAndSubprofile VruProfileAndSubprofile, + sizeClass VruSizeClass OPTIONAL, + exteriorLights VruExteriorLights OPTIONAL, + ... + } + + VruClusterInformationContainer::= SEQUENCE{ + vruClusterInformation VruClusterInformation (WITH COMPONENTS{..., clusterId, clusterBoundingBoxShape PRESENT}), + ... + } + + + VruClusterOperationContainer ::= SEQUENCE { + clusterJoinInfo ClusterJoinInfo OPTIONAL, + clusterLeaveInfo ClusterLeaveInfo OPTIONAL, + clusterBreakupInfo ClusterBreakupInfo OPTIONAL, + clusterIdChangeTimeInfo DeltaTimeQuarterSecond OPTIONAL, + ... + } + + VruMotionPredictionContainer ::= SEQUENCE { + pathHistory PathHistory OPTIONAL, + pathPrediction PathPredicted OPTIONAL, + safeDistance SequenceOfSafeDistanceIndication OPTIONAL, + trajectoryInterceptionIndication SequenceOfTrajectoryInterceptionIndication OPTIONAL, + accelerationChangeIndication AccelerationChangeIndication OPTIONAL, + headingChangeIndication HeadingChangeIndication OPTIONAL, + stabilityChangeIndication StabilityChangeIndication OPTIONAL, + ... + } + +END diff --git a/epan/dissectors/asn1/its/VAM-Temp-Imports.asn b/epan/dissectors/asn1/its/VAM-Temp-Imports.asn new file mode 100644 index 00000000..a9eb9624 --- /dev/null +++ b/epan/dissectors/asn1/its/VAM-Temp-Imports.asn @@ -0,0 +1,122 @@ +-- Note: This module defines types that are intended to be updated within +-- or added to the Common Data Dictionary. Defining the types in this +-- module allows them to be used by the VAM before the CDD has been +-- updated. Once the CDD has been updated, this module will also be +-- updated to import the new types directly from the CDD, and the +-- version number of this module will be incremented. + +VAM-Temp-Imports {itu-t(0) identified-organization(4) etsi(0) itsDomain(5) + wg1(1) ts(103300) part-3(3) temp-imports(255) version(1)} + +DEFINITIONS AUTOMATIC TAGS ::= + +BEGIN + +IMPORTS + +ReferencePosition, SpeedConfidence, StationID, VehicleWidth +FROM ETSI-ITS-CDD {itu-t (0) identified-organization (4) etsi (0) itsDomain (5) wg1 (1) 102894 cdd (2) major-version-3 (3) minor-version-1 (1)} + +NodeOffsetPointXY, Offset-B10, Offset-B11, Offset-B12, Offset-B13, +Offset-B14, Offset-B16 +FROM DSRC + {iso (1) standard (0) signalizedIntersection (19091) profilec(2) dsrc (2) + version (2)} + +; + +-- identical to BasicContainer as used in CAM +--BasicContainer ::= SEQUENCE { +-- stationType StationType, - - from VAM-Temp-Imports +-- referencePosition ReferencePosition, - - from ITS-Container +-- ... +--} + +--ItsPduHeader ::= SEQUENCE { +-- protocolVersion INTEGER (0..255), +-- messageID INTEGER{ denm(1), cam(2), poi(3), spatem(4), mapem(5), ivim(6), ev-rsr(7), tistpgtransaction(8), srem(9), ssem(10), evcsn(11), saem(12), rtcmem(13), vam(14) } (0..255), - - Mantis #7209, #7005 +-- stationID StationID +--} + + + + +--AreaCircular ::= SEQUENCE { +-- nodeCenterPoint OffsetPoint OPTIONAL, +-- radius Radius +--} + +--AreaPolygon ::= SEQUENCE { +-- polyPointList PolyPointList +--} + +--AreaRectangle ::= SEQUENCE { +-- nodeCenterPoint OffsetPoint OPTIONAL, +-- semiMajorRangeLength SemiRangeLength, +-- semiMinorRangeLength SemiRangeLength, +-- semiMajorRangeOrientation WGS84AngleValue, +-- semiHeight SemiRangeLength OPTIONAL +--} + +--OffsetPoint ::= SEQUENCE{ +-- nodeOffsetPointXY NodeOffsetPointXY (WITH COMPONENTS {..., node-LatLon ABSENT, regional ABSENT}), +-- nodeOffsetPointZ NodeOffsetPointZ OPTIONAL +--} + + +--NodeOffsetPointZ ::= CHOICE { +-- node-Z1 Offset-B10, - - node is within 5.11m of last node +-- node-Z2 Offset-B11, - - node is within 10.23m of last node +-- node-Z3 Offset-B12, - - node is within 20.47m of last node +-- node-Z4 Offset-B13, - - node is within 40.96m of last node +-- node-Z5 Offset-B14, - - node is within 81.91m of last node +-- node-Z6 Offset-B16 - - node is within 327.67m of last node +--} + + +--Radius ::= INTEGER { +-- zeroPointOneMeter (1), +-- oneMeter (10) +--} (0..10000) + + +-- PolyPointList ::= SEQUENCE (SIZE(3..16, ...)) OF OffsetPoint + +--SemiRangeLength ::= INTEGER { +-- zeroPointOneMeter (1), +-- oneMeter (10) +--} (0..10000) + +--WGS84Angle ::= SEQUENCE { +-- value WGS84AngleValue, +-- confidence AngleConfidence +--} + +--WGS84AngleValue ::= INTEGER { +-- wgs84North (0), +-- wgs84East (900), +-- wgs84South (1800), +-- wgs84West (2700), +-- unavailable (3601) +--} (0..3601) + +--AngleConfidence ::= INTEGER { +-- zeroPointOneDegree (1), - - if the heading accuracy is equal to or less than 0,1 degree +-- oneDegree (10), +-- outOfRange (126), - - if the heading accuracy is out of range, i.e. greater than + -- 12,5 degrees. A corresponding reported angle value shall be + -- considered invalid and cannot be trusted. +-- unavailable (127) - - if the heading accuracy information is not available +--} (1..127) + + + +--StationType ::= INTEGER { +-- unknown(0), pedestrian(1), cyclist(2), moped(3), motorcycle(4), +-- passengerCar(5), bus(6), lightTruck(7), heavyTruck(8), trailer(9), +-- specialVehicles(10), tram(11), lightVruVehicle(12), animals(13), +-- roadSideUnit(15) +--} +--(0..255) + +END diff --git a/epan/dissectors/asn1/its/its.cnf b/epan/dissectors/asn1/its/its.cnf new file mode 100644 index 00000000..b0205197 --- /dev/null +++ b/epan/dissectors/asn1/its/its.cnf @@ -0,0 +1,937 @@ +# its.cnf +# Intelligent Transport Systems (ITS) + +#.OPT +PER +UNALIGNED +#.END + +#.EXPORTS + +#.OMIT_ASSIGNMENT +# Get rid of unused code warnings +TisTpgTransactionsPdu +DENM +DENMv1 +CAM +CAMv1 +SSEM +SREM +IVIM +MAPEM +SPATEM +EV-RSR +RTCMEM +VAM +ItsPduHeaderVam +IMZM + +EvcsnPdu +DriverLanguage +ChargingPower +StatusResponseCode +CurrentVehicleConfiguration +TpgLocation +CS5 +DSRCmsgID +VehicleLengthV2 +TrailerPresenceInformation +CartesianAngularAccelerationComponent +CartesianAngularAccelerationComponentValue +AngularAccelerationConfidence +StandardLength2B +StandardLength9b +PrecipitationIntensity +ObjectFace +BogiesCount +BarometricPressure +AxlesCount +AirHumidity + +#.NO_EMIT +Code-Units WITHOUT_VALS + + +#.MODULE +CAMv1-PDU-Descriptions camv1 +CAM-PDU-Descriptions cam +DENMv1-PDU-Descriptions denmv1 +DENM-PDU-Description denm +EVCSN-PDU-Descriptions evcsn +EV-RechargingSpotReservation-PDU-Descriptions evrsr +IVIM-PDU-Descriptions ivim +TIS-TPG-Transactions-Descriptions tistpg +SPATEM-PDU-Descriptions spatem +MAPEM-PDU-Descriptions mapem +SREM-PDU-Descriptions srem +SSEM-PDU-Descriptions ssem +AVIAEINumberingAndDataStructures anads +ITS-Container itsv2 +ITS-ContainerV1 itsv1 +#ElectronicRegistrationIdentificationVehicleDataModule erivdm +#CITSapplMgmtIDs csmid +EfcDsrcApplication dsrc_app +IVI ivi +GDD gdd +DSRC dsrc +RTCMEM-PDU-Descriptions rtcmem +ETSI-ITS-CDD its +CPM-OriginatingStationContainers cpm +CPM-PDU-Descriptions cpm +CPM-PerceivedObjectContainer cpm +CPM-PerceptionRegionContainer cpm +CPM-SensorInformationContainer cpm +VAM-PDU-Descriptions vam +IMZM-PDU-Descriptions imzm +#VAM-Temp-Imports vam +#.END + +#.PDU +CamPayload +CoopAwarenessV1 +DenmPayload +DecentralizedEnvironmentalNotificationMessageV1 +EVChargingSpotNotificationPOIMessage +EV-RSR-MessageBody +TisTpgTransaction +IviStructure +SPAT +MapData +SignalRequestMessage +SignalStatusMessage +RTCMcorrections +CollectivePerceptionMessage +ItsPduHeader +VruAwareness +InterferenceManagementZoneMessage +# AddGrpC regional extension +ConnectionManeuverAssist-addGrpC +ConnectionTrajectory-addGrpC +NodeAttributeSet-addGrpC +IntersectionState-addGrpC +MapData-addGrpC +Position3D-addGrpC +RestrictionUserType-addGrpC +SignalStatusPackage-addGrpC +LaneAttributes-addGrpC +MovementEvent-addGrpC +RequestorDescription-addGrpC +#CpmContainers +OriginatingVehicleContainer +OriginatingRsuContainer +SensorInformationContainer +PerceptionRegionContainer +PerceivedObjectContainer + +#.TYPE_RENAME + +# GicPart +GicPart/relevanceZoneIds T_GicPartRelevanceZoneIds +GicPart/detectionZoneIds T_GicPartDetectionZoneIds +GicPart/driverAwarenessZoneIds T_GicPartDriverAwarenessZoneIds +GicPart/extraText T_GicPartExtraText + +TcPart/relevanceZoneIds T_TcPartRelevanceZoneIds +TcPart/detectionZoneIds T_TcPartDetectionZoneIds +TcPart/driverAwarenessZoneIds T_TcPartDriverAwarenessZoneIds +TcPart/text T_TcPartText + +TractorCharacteristics/equalTo T_TractorCharactEqualTo +TractorCharacteristics/notEqualTo T_TractorCharactNotEqualTo + +TrailerCharacteristics/equalTo T_TrailerCharactEqualTo +TrailerCharacteristics/notEqualTo T_TrailerCharactNotEqualTo + +SPAT/regional T_SPATRegional +SignalRequestMessage/regional T_SRMRegional +SignalStatusMessage/regional T_SSMRegional +MapData/regional T_MAPRegional +AdvisorySpeed/regional T_AdvisorySpeedRegional +ComputedLane/regional T_ComputedLaneRegional +ConnectionManeuverAssist/regional T_ConnectionManeuverAssistRegional +GenericLane/regional T_GenericLaneRegional +IntersectionGeometry/regional T_IntersectionGeometryRegional +IntersectionState/regional T_IntersectionStateRegional +LaneDataAttribute/regional T_LaneDataAttributeRegional +MovementEvent/regional T_MovementEventRegional +MovementState/regional T_MovementStateRegional +NodeAttributeSetXY/regional T_NodeAttributeSetXYRegional +Position3D/regional T_Position3DRegional +RequestorDescription/regional T_RequestorDescriptionRegional +RestrictionUserType/regional T_RestrictionUserTypeRegional +RoadSegment/regional T_RoadSegmentRegional +SignalRequestPackage/regional T_SignalRequestPackageRegional +SignalRequest/regional T_SignalRequestRegional +SignalStatusPackage/regional T_SignalStatusPackageRegional +SignalStatus/regional T_SignalStatusRegional +PerceptionRegion/numberOfPerceivedObjects T_PerceptionRegionNumberOfPerceivedObjects +PerceptionRegion/shadowingApplies T_PerceptionRegionShadowingApplies + + +#.END + +#.FIELD_RENAME +PerceptionRegion/perceptionRegionShape perceptionRegionPerceptionRegionShape +PerceptionRegion/shadowingApplies perceptionRegionShadowingApplies +PerceptionRegion/numberOfPerceivedObjects perceptionRegionNumberOfPerceivedObjects +PerceptionRegion/perceptionRegionConfidence perceptionRegionPerceptionRegionConfidence + +TisTpgDRM/location drmLocation +TisTpgTRM/location trmLocation +TisTpgTCM/location tcmLocation + +TisTpgVDRM/management vdrmManagement +TisTpgDRM/management drmManagement +TisTpgEOFM/management eofmManagement +TisTpgTCM/management tcmManagement +TisTpgVDPM/management vdpmManagement +TisTpgTRM/management trmManagement +TisTpgSNM/management snmManagement + +TisTpgDRM/situation drmSituation +TisTpgTRM/situation trmSituation +TisTpgTCM/situation tcmSituation + +Distance/value dValue +DistanceOrDuration/value dodValue +Weight/value wValue +AnyCatalogue/value acValue +VcCode/value vcValue + +Ext1/content e1Content +Ext2/content e2Content +VarLengthNumber/content vlnContent + +Ext2/extension e1Extension +Ext1/extension e2Extension +VarLengthNumber/extension vlnExtension + +RSCode/layoutComponentId rscLayoutComponentId +Text/layoutComponentId tLayoutComponentId +LayoutComponent/layoutComponentId lcLayoutComponentId + +ISO14823Code/pictogramCode icPictogramCode +AnyCatalogue/pictogramCode acPictogramCode + +VcCode/validity vcValidity +LaneInformation/validity liValidity + +RoadSegmentReferenceID/id rsrId +RoadSegment/id rsId +RequestorDescription/id rdId +SignalRequesterInfo/id sriId +IntersectionGeometry/id igId +IntersectionState/id isId +SignalRequest/id srId +SignalStatus/id ssId +IntersectionReferenceID/id irId +RestrictionClassAssignment/id scaId + +AdvisorySpeed/confidence asConfidence +TimeChangeDetails/confidence tcdConfidence + +SPAT/intersections spatIntersections +MapData/intersections mdIntersections + +RequestorPositionVector/position rpvPosition +RequestorDescription/position rdPosition + +SPAT/regional spatRegional +SignalRequestMessage/regional srmRegional +SignalStatusMessage/regional ssmRegional +MapData/regional mapRegional +AdvisorySpeed/regional asRegional +ComputedLane/regional clRegional +ConnectionManeuverAssist/regional cmaRegional +GenericLane/regional glRegional +IntersectionGeometry/regional igRegional +IntersectionState/regional isRegional +LaneDataAttribute/regional ldaRegional +MovementEvent/regional meRegional +MovementState/regional msRegional +NodeAttributeSetXY/regional nasxyRegional +Position3D/regional p3dRegional +RequestorDescription/regional rdRegional +RestrictionUserType/regional rutRegional +RoadSegment/regional rsRegional +SignalRequestPackage/regional srpRegional +SignalRequest/regional srRegional +SignalStatusPackage/regional sspRegional +SignalStatus/regional ssRegional + +LaneAttributes/regional laRegional +NodeOffsetPointXY/regional nopxyRegional +RequestorType/regional rtRegional + +SignalRequestPackage/request srpRequest +SignalRequesterInfo/request sriRequest +RequestorType/request rtRequest + +RegulatorySpeedLimit/speed rslSpeed +TransmissionAndSpeed/speed tasSpeed +RequestorPositionVector/speed rpvSpeed +AdvisorySpeed/speed asSpeed +FullPositionVector/speed fpvSpeed +SpeedandHeadingandThrottleConfidence/speed shtcSpeed + +SignalRequestPackage/minute srpMinute +SignalStatusPackage/minute sspMinute + +FullPositionVector/heading fpvHeading +RequestorPositionVector/heading rpvHeading +SpeedandHeadingandThrottleConfidence/heading shtcheading + +FullPositionVector/elevation fpvElevation +PositionConfidenceSet/elevation pcsElevation +Position3D/elevation p3dElevation + +IntersectionState/status isStatus +SignalStatusPackage/status sspStatus +SignalStatusMessage/status ssmStatus + +SPAT/timeStamp spatTimeStamp +SignalRequestMessage/timeStamp srmTimeStamp +SignalStatusMessage/timeStamp ssmTimeStamp +MapData/timeStamp mdTimeStamp +IntersectionState/timeStamp isTimeStamp + +AdvisorySpeed/type asType +RegulatorySpeedLimit/type rslType +RequestorDescription/type rdType + +TcPart/detectionZoneIds tpDetectionZoneIds +TcPart/driverAwarenessZoneIds tpDriverAwarenessZoneIds +TcPart/relevanceZoneIds tpRelevanceZoneIds + +GicPart/detectionZoneIds gpDetectionZoneIds +GicPart/driverAwarenessZoneIds gpDriverAwarenessZoneIds +GicPart/relevanceZoneIds gpRelevanceZoneIds + +TractorCharacteristics/equalTo toEqualTo +TractorCharacteristics/notEqualTo toNotEqualTo + +TrailerCharacteristics/equalTo teEqualTo +TrailerCharacteristics/notEqualTo teNotEqualTo + +Node-XY-20b/x n20bX +Node-XY-22b/x n22bX +Node-XY-24b/x n24bX +Node-XY-26b/x n26bX +Node-XY-28b/x n28bX +Node-XY-32b/x n32bX + +Node-XY-20b/y n20bY +Node-XY-22b/y n22bY +Node-XY-24b/y n24bY +Node-XY-26b/y n26bY +Node-XY-28b/y n28bY +Node-XY-32b/y n32bY + +#.TYPE_ATTR +Latitude DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_latitude_fmt) +Longitude DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_longitude_fmt) +AltitudeValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_altitude_fmt) +DeltaLatitude DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_delta_latitude_fmt) +DeltaLongitude DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_delta_longitude_fmt) +DeltaAltitude DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_delta_altitude_fmt) +PathDeltaTime DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_path_delta_time_fmt) +SemiAxisLength DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_sax_length_fmt) +HeadingValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_heading_value_fmt) +HeadingConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_heading_confidence_fmt) +SpeedValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_speed_value_fmt) +SpeedConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_speed_confidence_fmt) +SpeedLimit DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_speed_limit_fmt) +VehicleLengthValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_vehicle_length_value_fmt) +VehicleWidth DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_vehicle_width_fmt) +LongitudinalAccelerationValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_acceleration_value_fmt) +LateralAccelerationValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_acceleration_value_fmt) +VerticalAccelerationValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_acceleration_value_fmt) +AccelerationConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_acceleration_confidence_fmt) +CurvatureValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_curvature_value_fmt) +YawRateValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_yaw_rate_value_fmt) +SteeringWheelAngleValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_swa_value_fmt) +SteeringWheelAngleConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_swa_confidence_fmt) +TimestampIts DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_timestamp_fmt) +ValidityDuration DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(its_validity_duration_fmt) + +GenerationDeltaTime STRINGS=NULL + +MinuteOfTheYear DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_moi_fmt) +DSecond DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_dsecond_fmt) +TimeMark DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_time_mark_fmt) +TimeIntervalConfidence STRINGS=VALS(dsrc_TimeIntervalConfidence_vals) +Velocity DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_velocity_fmt) +Angle DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_angle_fmt) +HeadingDSRC DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_angle_fmt) +DeltaTime DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(dsrc_delta_time_fmt) + +TimeOfMeasurement STRINGS=NULL +ClassConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_general_confidence_fmt) +FreeSpaceConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_general_confidence_fmt) +ObjectConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_general_confidence_fmt) +DistanceValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_distance_value_fmt) +DistanceConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_distance_confidence_fmt) +SpeedValueExtended DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_speed_value_ext_fmt) +ObjectDimensionValue DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_object_dimension_value_fmt) +#ObjectDimensionConfidence DISPLAY=BASE_CUSTOM STRINGS=CF_FUNC(cpm_object_dimension_confidence_fmt) + +#.END + +#.FIELD_ATTR +IntersectionState/status ABBREV=intersectionState.status +SignalStatusPackage/status ABBREV=signalStatusPackage.status +SignalStatusMessage/status ABBREV=signalStatusMessage.status +FullPositionVector/elevation ABBREV=fullPositionVector.elevation +PositionConfidenceSet/elevation ABBREV=positionConfidenceSet.elevation +Position3D/elevation ABBREV=position3D.elevation + +#.END + +#.MAKE_DEFINES +MessageId +#.END + +#.MAKE_ENUM +RegionId +CauseCodeType + +#.FN_HDR CamPayload + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "CAM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "CAM"); +#.END + +#.FN_HDR CoopAwarenessV1 + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "CAMv1"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "CAMv1"); +#.END + +#.FN_HDR DenmPayload + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "DENM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "DENM"); +#.END + +#.FN_HDR DecentralizedEnvironmentalNotificationMessageV1 + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "DENMv1"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "DENMv1"); +#.END + +#.FN_HDR EVChargingSpotNotificationPOIMessage + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "EVCSN"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "EVCSN"); +#.END + +#.FN_HDR EV-RSR-MessageBody + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "EV-RSR"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "EV-RSR"); +#.END + +#.FN_HDR TisTpgTransaction + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "TISTPG"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "TISTPG"); +#.END + +#.FN_HDR IviStructure + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "IVIM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "IVIM"); +#.END + +#.FN_HDR SignalStatusMessage + its_private_data_t *regext = wmem_new0(actx->pinfo->pool, its_private_data_t); + actx->private_data = (void*)regext; + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "SSEM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "SSEM"); + regext->type = Reg_SignalStatusMessage; +#.END + +#.FN_HDR SignalRequestMessage + its_private_data_t *regext = wmem_new0(actx->pinfo->pool, its_private_data_t); + actx->private_data = (void*)regext; + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "SREM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "SREM"); + regext->type = Reg_SignalRequestMessage; +#.END + +#.FN_HDR MapData + its_private_data_t *regext = wmem_new0(actx->pinfo->pool, its_private_data_t); + actx->private_data = (void*)regext; + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "MAPEM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "MAPEM"); + regext->type = Reg_MapData; +#.END + +#.FN_HDR SPAT + its_private_data_t *regext = wmem_new0(actx->pinfo->pool, its_private_data_t); + actx->private_data = (void*)regext; + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "SPATEM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "SPATEM"); + regext->type = Reg_SPAT; +#.END + + +#.FN_HDR RTCMcorrections + its_private_data_t *regext = wmem_new0(actx->pinfo->pool, its_private_data_t); + actx->private_data = (void*)regext; + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "RTCMEM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "RTCMEM"); + regext->type = Reg_RTCMcorrections; +#.END + +#.FN_HDR CollectivePerceptionMessage + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "CPM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "CPM"); +#.END + +#.FN_HDR InterferenceManagementZoneMessage + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "IMZM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "IMZM"); +#.END + +#.FN_HDR VruAwareness + actx->private_data = (void*)wmem_new0(actx->pinfo->pool, its_private_data_t); + col_set_str(actx->pinfo->cinfo, COL_PROTOCOL, "VAM"); + col_set_str(actx->pinfo->cinfo, COL_INFO, "VAM"); +#.END + +#.FN_HDR ConnectionManeuverAssist-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR ConnectionTrajectory-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR NodeAttributeSet-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR IntersectionState-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR MapData-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR Position3D-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR RestrictionUserType-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR SignalStatusPackage-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR LaneAttributes-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR MovementEvent-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR RequestorDescription-addGrpC + actx->private_data = wmem_new0(actx->pinfo->pool, its_private_data_t); +#.END + + +#.FN_HDR AdvisorySpeed + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_AdvisorySpeed; +#.END +#.FN_FTR AdvisorySpeed + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR ComputedLane + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_ComputedLane; +#.END +#.FN_FTR ComputedLane + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR ConnectionManeuverAssist + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_ConnectionManeuverAssist; +#.END +#.FN_FTR ConnectionManeuverAssist + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR GenericLane + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_GenericLane; +#.END +#.FN_FTR GenericLane + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR IntersectionGeometry + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_IntersectionGeometry; +#.END +#.FN_FTR IntersectionGeometry + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR IntersectionState + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_IntersectionState; +#.END +#.FN_FTR IntersectionState + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR LaneAttributes + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_LaneAttributes; +#.END +#.FN_FTR LaneAttributes + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR LaneDataAttribute + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_LaneDataAttribute; +#.END +#.FN_FTR LaneDataAttribute + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR MovementEvent + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_MovementEvent; +#.END +#.FN_FTR MovementEvent + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR MovementState + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_MovementState; +#.END +#.FN_FTR MovementState + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR NodeAttributeSetXY + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_NodeAttributeSetXY; +#.END +#.FN_FTR NodeAttributeSetXY + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR NodeOffsetPointXY + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_NodeOffsetPointXY; +#.END +#.FN_FTR NodeOffsetPointXY + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR Position3D + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_Position3D; +#.END +#.FN_FTR Position3D + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR RequestorDescription + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_RequestorDescription; +#.END +#.FN_FTR RequestorDescription + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR RequestorType + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_RequestorType; +#.END +#.FN_FTR RequestorType + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR RestrictionUserType + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_RestrictionUserType; +#.END +#.FN_FTR RestrictionUserType + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR RoadSegment + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_RoadSegment; +#.END +#.FN_FTR RoadSegment + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR SignalRequestPackage + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_SignalRequestPackage; +#.END +#.FN_FTR SignalRequestPackage + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR SignalRequest + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_SignalRequest; +#.END +#.FN_FTR SignalRequest + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR SignalStatusPackage + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_SignalStatusPackage; +#.END +#.FN_FTR SignalStatusPackage + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR SignalStatus + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_SignalStatus; +#.END +#.FN_FTR SignalStatus + ((its_private_data_t*)actx->private_data)->type = save; +#.END + + +#.FN_HDR SignalControlZone + enum regext_type_enum save = ((its_private_data_t*)actx->private_data)->type; + ((its_private_data_t*)actx->private_data)->type = Reg_SignalControlZone; +#.END +#.FN_FTR SignalControlZone + ((its_private_data_t*)actx->private_data)->type = save; +#.END + +#.FN_PARS RegionId VAL_PTR = &((its_private_data_t*)actx->private_data)->region_id + +#.FN_PARS ProtocolVersion VAL_PTR = &((its_header_t*)actx->private_data)->version +#.FN_PARS MessageId VAL_PTR = &((its_header_t*)actx->private_data)->msgId +#.FN_PARS StationId VAL_PTR = actx->private_data?&((its_header_t*)actx->private_data)->stationId:NULL +#.FN_PARS CpmContainerId VAL_PTR = &((its_header_t*)actx->private_data)->CpmContainerId + +#.FN_BODY ItsPduHeader + guint8 version = tvb_get_guint8(tvb, 0); + int test_offset = offset; + if ((test_offset = dissector_try_uint(its_version_subdissector_table, version, tvb, actx->pinfo, tree))) { + return test_offset; + } + // Lets try it that way, regarless of version value... + its_header_t *hdr = wmem_new0(actx->pinfo->pool, its_header_t); + actx->private_data = (void*)hdr; +%(DEFAULT_BODY)s + tap_queue_packet(its_tap, actx->pinfo, actx->private_data); + tvbuff_t *next_tvb = tvb_new_subset_length(tvb, offset >> 3, -1); + int data_offset = dissector_try_uint(its_msgid_subdissector_table, (hdr->version << 16)+hdr->msgId, next_tvb, actx->pinfo, tree); + if (!data_offset) { + proto_tree_add_expert(tree, actx->pinfo, &ei_its_no_sub_dis, next_tvb, 0, - 1); + data_offset = call_data_dissector(next_tvb, actx->pinfo, tree); + } + offset += data_offset; +#.END + +#.ASSIGN_VALUE_TO_TYPE # ISO_TS_19091_DSRC ASN.1 does not have constants assigned to types + +#RegionId +noRegion RegionId +addGrpA RegionId +addGrpB RegionId +addGrpC RegionId + +#.END + +#.REGISTER +# Not used due to "protocol" detection issue: we shall register for its subdissector not dsrc +#.END + +#.FN_PARS RegionalExtension/regExtValue FN_VARIANT=_pdu_new TYPE_REF_FN=dissect_regextval_pdu + +#.FN_PARS WrappedCpmContainer/containerData FN_VARIANT=_pdu_new TYPE_REF_FN=dissect_cpmcontainers_pdu + + +#.FN_BODY TypeOfReceptacle VAL_PTR=¶meter_tvb LEN_PTR=&len + tvbuff_t *parameter_tvb = NULL; + int len; +%(DEFAULT_BODY)s + /* TODO Provide values? + * See ETSI TS 101 556-1 V1.1.1 Annex B Description for data elements + * Table B.2: Coding of the type of receptacle field + * + * Code Charging Standard plug / Type of Nb of Maximum Maximum + * spot type cable current phases Voltage Current + * ------------------------------------------------------------------------- + * 0000 Socket IEC 62196-2 type 1 AC Single 240V 16A + * 0001 Socket IEC 62196-2 type 1 AC Single 240V 32A + * 0010 Socket IEC 62196-2 type 1 AC Single 240V 80A + * 0011 Socket IEC 62196-2 type 1 AC Single 120V 12A + * 0100 Socket IEC 62196-2 type 1 AC Single 120V 16A + * 0101 Socket Standard Household AC Single 250V 16A + * 0110 Socket Standard Household AC Single 480V 16A + * 0111 Socket IEC 62196-2 type 2 AC Single 230V 16A + * 1000 Socket IEC 62196-2 type 2 AC Single 250V 32A + * 1001 Socket IEC 62196-2 type 2 AC Single 480V 32A + * 1010 Socket IEC 62196-2 type 2 AC Single 400V 32/250A + * 1011 Socket IEC 62196-2 type 3A AC Single 250V 32A + * 1100 Socket IEC 62196-2 type 3B AC Single 480V 32A + * 1101 Socket Reserved for Future AC Single 1000V 400A + IEC 62196-3 + * 1110 Cable for Reserved + DC charging + * 1111 Cable for Reserved + DC charging + */ +#.END + +#.FN_BODY CountryCode VAL_PTR=&val_tvb + tvbuff_t *val_tvb = NULL; +%(DEFAULT_BODY)s + append_country_code_fmt(actx->created_item, val_tvb); +#.END + +#.FN_BODY Text/language VAL_PTR=&val_tvb + tvbuff_t *val_tvb = NULL; +%(DEFAULT_BODY)s + append_country_code_fmt(actx->created_item, val_tvb); +#.END + + +#.NO_EMIT WITH_VALS +#.END + +#.NO_EMIT ONLY_VALS +Latitude +Longitude +AltitudeValue +DeltaLatitude +DeltaLongitude +DeltaAltitude +PathDeltaTime +SemiAxisLength +$ITS-ContainerV1$HeadingValue +HeadingConfidence +SpeedValue +SpeedConfidence +SpeedLimit +VehicleLengthValue +VehicleWidth +LongitudinalAccelerationValue +LateralAccelerationValue +VerticalAccelerationValue +AccelerationConfidence +CurvatureValue +YawRateValue +SteeringWheelAngleValue +ValidityDuration +ObjectDimensionValue +SteeringWheelAngleConfidence +TimestampIts +GenerationDeltaTime + +#.END + +#.NO_EMIT WITHOUT_VALS +# Just keep the vals. hf are made manually and used in cause/subcause decoding + +#.END + + +#.FN_PARS CauseCodeType VAL_PTR = &((its_private_data_t*)actx->private_data)->cause_code + +#.FN_BODY SubCauseCodeType + // Overwrite hf_index + hf_index = *find_subcause_from_cause((CauseCodeType_enum) ((its_private_data_t*)actx->private_data)->cause_code); +%(DEFAULT_BODY)s +#.END + +# +# RCUnit subtypes bodies implemented manually as asn2wrs is not able to handle subtype constraint +# + +#.FN_BODY InternationalSign-speedLimits/unit + offset = dissect_per_constrained_integer(%(TVB)s, %(OFFSET)s, %(ACTX)s, %(TREE)s, %(HF_INDEX)s, + 0U, 1U, %(VAL_PTR)s, FALSE); +#.END + +#.FN_BODY Weight/unit + offset = dissect_per_constrained_integer(%(TVB)s, %(OFFSET)s, %(ACTX)s, %(TREE)s, %(HF_INDEX)s, + 10U, 12U, %(VAL_PTR)s, FALSE); +#.END + +#.FN_BODY DistOrDuration-Units + offset = dissect_per_constrained_integer(%(TVB)s, %(OFFSET)s, %(ACTX)s, %(TREE)s, %(HF_INDEX)s, + 2U, 9U, %(VAL_PTR)s, FALSE); +#.END + +#.FN_BODY Distance/unit + offset = dissect_per_constrained_integer(%(TVB)s, %(OFFSET)s, %(ACTX)s, %(TREE)s, %(HF_INDEX)s, + 2U, 8U, %(VAL_PTR)s, FALSE); +#.END + +#=== PtActivation ======================================================= + +#.FN_HDR PtActivation + void *priv_data = actx->private_data; + its_pt_activation_data_t *pta; + + pta = wmem_new0(actx->pinfo->pool, its_pt_activation_data_t); + actx->private_data = pta; +#.FN_FTR + dissector_try_uint_new(cam_pt_activation_table, pta->type, pta->data, actx->pinfo, tree, TRUE, NULL); + actx->private_data = priv_data; +#.END + +#.FN_PARS +PtActivationType VAL_PTR = &((its_pt_activation_data_t*)actx->private_data)->type +PtActivationData VAL_PTR = &((its_pt_activation_data_t*)actx->private_data)->data +#.END diff --git a/epan/dissectors/asn1/its/packet-its-template.c b/epan/dissectors/asn1/its/packet-its-template.c new file mode 100644 index 00000000..13195380 --- /dev/null +++ b/epan/dissectors/asn1/its/packet-its-template.c @@ -0,0 +1,1060 @@ +/* packet-its-template.c + * + * Intelligent Transport Systems Applications dissectors + * Coyright 2018, C. Guerber <cguerber@yahoo.com> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + + +/* + * Implemented: + * CA (CAM) ETSI EN 302 637-2 V1.4.1 (2019-01) + * DEN (DENM) ETSI EN 302 637-3 V1.3.0 (2018-08) + * RLT (MAPEM) ETSI TS 103 301 V1.2.1 (2018-08) + * TLM (SPATEM) ETSI TS 103 301 V1.2.1 (2018-08) + * IVI (IVIM) ETSI TS 103 301 V1.2.1 (2018-08) + * TLC (SREM) ETSI TS 103 301 V1.2.1 (2018-08) + * TLC (SSEM) ETSI TS 103 301 V1.2.1 (2018-08) + * EVCSN POI (EVCSN POI message) ETSI TS 101 556-1 + * TPG (TRM, TCM, VDRM, VDPM, EOFM) ETSI TS 101 556-2 + * Charging (EV-RSR, SRM, SCM) ETSI TS 101 556-3 + * GPC (RTCMEM) ETSI TS 103 301 + * + * Not supported: + * SA (SAEM) ETSI TS 102 890-1 + * CTL (CTLM) ETSI TS 102 941 + * CRL (CRLM) ETSI TS 102 941 + * Certificate request ETSI TS 102 941 + */ +#include "config.h" + +#include <math.h> +#include <epan/packet.h> +#include <epan/expert.h> +#include <epan/decode_as.h> +#include <epan/proto_data.h> +#include <epan/exceptions.h> +#include <epan/conversation.h> +#include <epan/tap.h> +#include <wsutil/utf8_entities.h> +#include "packet-ber.h" +#include "packet-per.h" + +#include "packet-its.h" +#include "packet-ieee1609dot2.h" + +/* + * Well Known Ports definitions as per: + * + * ETSI TS 103 248 v1.2.1 (2018-08) + * Intelligent Transport Systems (ITS); + * GeoNetworking; + * Port Numbers for the Basic Transport Protocol (BTP) + * + * BTP port Facilities service Related standard + * number or Application + * values + * 2001 CA (CAM) ETSI EN 302 637-2 V1.4.1 (2019-01) + * 2002 DEN (DENM) ETSI EN 302 637-3 + * 2003 RLT (MAPEM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2004 TLM (SPATEM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2005 SA (SAEM) ETSI TS 102 890-1 + * 2006 IVI (IVIM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2007 TLC (SREM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2008 TLC (SSEM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2009 Allocated Allocated for "Intelligent Transport + * System (ITS); Vehicular Communications; + * Basic Set of Applications; Specification + * of the Collective Perception Service" + * 2010 EVCSN POI (EVCSN POI ETSI TS 101 556-1 + * message) + * 2011 TPG (TRM, TCM, VDRM, ETSI TS 101 556-2 + * VDPM, EOFM) + * 2012 Charging (EV-RSR, ETSI TS 101 556-3 + * SRM, SCM) + * 2013 GPC (RTCMEM) ETSI TS 103 301 V1.2.1 (2018-08) + * 2014 CTL (CTLM) ETSI TS 102 941 + * 2015 CRL (CRLM) ETSI TS 102 941 + * 2016 Certificate request ETSI TS 102 941 + */ + +// Applications Well Known Ports +#define ITS_WKP_CA 2001 +#define ITS_WKP_DEN 2002 +#define ITS_WKP_RLT 2003 +#define ITS_WKP_TLM 2004 +#define ITS_WKP_SA 2005 +#define ITS_WKP_IVI 2006 +#define ITS_WKP_TLC_SREM 2007 +#define ITS_WKP_TLC_SSEM 2008 +#define ITS_WKP_CPS 2009 +#define ITS_WKP_EVCSN 2010 +#define ITS_WKP_TPG 2011 +#define ITS_WKP_CHARGING 2012 +#define ITS_WKP_GPC 2013 +#define ITS_WKP_CTL 2014 +#define ITS_WKP_CRL 2015 +#define ITS_WKP_CERTIF_REQ 2016 + +/* + * Prototypes + */ +void proto_reg_handoff_its(void); +void proto_register_its(void); + +static dissector_handle_t its_handle; + +static expert_field ei_its_no_sub_dis = EI_INIT; + +// TAP +static int its_tap = -1; + +// Protocols +static int proto_its = -1; +static int proto_its_denm = -1; +static int proto_its_denmv1 = -1; +static int proto_its_cam = -1; +static int proto_its_camv1 = -1; +static int proto_its_evcsn = -1; +static int proto_its_evrsr = -1; +static int proto_its_ivimv1 = -1; +static int proto_its_ivim = -1; +static int proto_its_tistpg = -1; +static int proto_its_ssem = -1; +static int proto_its_srem = -1; +static int proto_its_rtcmemv1 = -1; +static int proto_its_rtcmem = -1; +static int proto_its_mapemv1 = -1; +static int proto_its_mapem = -1; +static int proto_its_spatemv1 = -1; +static int proto_its_spatem = -1; +static int proto_its_cpm = -1; +static int proto_its_imzm = -1; +static int proto_its_vam = -1; +static int proto_addgrpc = -1; + +/* + * DENM SSP + */ +static int hf_denmssp_version = -1; +static int hf_denmssp_flags = -1; +static int hf_denmssp_trafficCondition = -1; +static int hf_denmssp_accident = -1; +static int hf_denmssp_roadworks = -1; +static int hf_denmssp_adverseWeatherConditionAdhesion = -1; +static int hf_denmssp_hazardousLocationSurfaceCondition = -1; +static int hf_denmssp_hazardousLocationObstacleOnTheRoad = -1; +static int hf_denmssp_hazardousLocationAnimalOnTheRoad = -1; +static int hf_denmssp_humanPresenceOnTheRoad = -1; +static int hf_denmssp_wrongWayDriving = -1; +static int hf_denmssp_rescueAndRecoveryWorkInProgress = -1; +static int hf_denmssp_ExtremeWeatherCondition = -1; +static int hf_denmssp_adverseWeatherConditionVisibility = -1; +static int hf_denmssp_adverseWeatherConditionPrecipitation = -1; +static int hf_denmssp_slowVehicle = -1; +static int hf_denmssp_dangerousEndOfQueue = -1; +static int hf_denmssp_vehicleBreakdown = -1; +static int hf_denmssp_postCrash = -1; +static int hf_denmssp_humanProblem = -1; +static int hf_denmssp_stationaryVehicle = -1; +static int hf_denmssp_emergencyVehicleApproaching = -1; +static int hf_denmssp_hazardousLocationDangerousCurve = -1; +static int hf_denmssp_collisionRisk = -1; +static int hf_denmssp_signalViolation = -1; +static int hf_denmssp_dangerousSituation = -1; + +/* + * CAM SSP + */ +static int hf_camssp_version = -1; +static int hf_camssp_flags = -1; +static int hf_camssp_cenDsrcTollingZone = -1; +static int hf_camssp_publicTransport = -1; +static int hf_camssp_specialTransport = -1; +static int hf_camssp_dangerousGoods = -1; +static int hf_camssp_roadwork = -1; +static int hf_camssp_rescue = -1; +static int hf_camssp_emergency = -1; +static int hf_camssp_safetyCar = -1; +static int hf_camssp_closedLanes = -1; +static int hf_camssp_requestForRightOfWay = -1; +static int hf_camssp_requestForFreeCrossingAtATrafficLight = -1; +static int hf_camssp_noPassing = -1; +static int hf_camssp_noPassingForTrucks = -1; +static int hf_camssp_speedLimit = -1; +static int hf_camssp_reserved = -1; + +static gint ett_denmssp_flags = -1; +static gint ett_camssp_flags = -1; + +// Subdissectors +static dissector_table_t its_version_subdissector_table; +static dissector_table_t its_msgid_subdissector_table; +static dissector_table_t regionid_subdissector_table; +static dissector_table_t cpmcontainer_subdissector_table; +static dissector_table_t cam_pt_activation_table; + +typedef struct its_private_data { + enum regext_type_enum type; + guint32 region_id; + guint32 cause_code; +} its_private_data_t; + +typedef struct its_pt_activation_data { + guint32 type; + tvbuff_t *data; +} its_pt_activation_data_t; + +// Specific dissector for content of open type for regional extensions +static int dissect_regextval_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + its_private_data_t *re = (its_private_data_t*)data; + // XXX What to do when region_id = noRegion? Test length is zero? + if (!dissector_try_uint_new(regionid_subdissector_table, ((guint32) re->region_id<<16) + (guint32) re->type, tvb, pinfo, tree, FALSE, NULL)) + call_data_dissector(tvb, pinfo, tree); + return tvb_captured_length(tvb); +} + +// Specific dissector for content of open type for regional extensions +static int dissect_cpmcontainers_pdu(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_) +{ + its_header_t* hdr = (its_header_t*)data; + // XXX What to do when region_id = noRegion? Test length is zero? + if (!dissector_try_uint_new(cpmcontainer_subdissector_table, hdr->CpmContainerId, tvb, pinfo, tree, FALSE, NULL)) + call_data_dissector(tvb, pinfo, tree); + return tvb_captured_length(tvb); +} + +static int dissect_denmssp_pdu(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void *data _U_) +{ + static int * const denmssp_flags[] = { + &hf_denmssp_trafficCondition, + &hf_denmssp_accident, + &hf_denmssp_roadworks, + &hf_denmssp_adverseWeatherConditionAdhesion, + &hf_denmssp_hazardousLocationSurfaceCondition, + &hf_denmssp_hazardousLocationObstacleOnTheRoad, + &hf_denmssp_hazardousLocationAnimalOnTheRoad, + &hf_denmssp_humanPresenceOnTheRoad, + &hf_denmssp_wrongWayDriving, + &hf_denmssp_rescueAndRecoveryWorkInProgress, + &hf_denmssp_ExtremeWeatherCondition, + &hf_denmssp_adverseWeatherConditionVisibility, + &hf_denmssp_adverseWeatherConditionPrecipitation, + &hf_denmssp_slowVehicle, + &hf_denmssp_dangerousEndOfQueue, + &hf_denmssp_vehicleBreakdown, + &hf_denmssp_postCrash, + &hf_denmssp_humanProblem, + &hf_denmssp_stationaryVehicle, + &hf_denmssp_emergencyVehicleApproaching, + &hf_denmssp_hazardousLocationDangerousCurve, + &hf_denmssp_collisionRisk, + &hf_denmssp_signalViolation, + &hf_denmssp_dangerousSituation, + NULL + }; + + guint32 version; + + proto_tree_add_item_ret_uint(tree, hf_denmssp_version, tvb, 0, 1, ENC_BIG_ENDIAN, &version); + if (version == 1) { + proto_tree_add_bitmask(tree, tvb, 1, hf_denmssp_flags, ett_denmssp_flags, denmssp_flags, ENC_BIG_ENDIAN); + } + return tvb_reported_length(tvb); +} + +static int dissect_camssp_pdu(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void *data _U_) +{ + static int * const camssp_flags[] = { + &hf_camssp_cenDsrcTollingZone, + &hf_camssp_publicTransport, + &hf_camssp_specialTransport, + &hf_camssp_dangerousGoods, + &hf_camssp_roadwork, + &hf_camssp_rescue, + &hf_camssp_emergency, + &hf_camssp_safetyCar, + &hf_camssp_closedLanes, + &hf_camssp_requestForRightOfWay, + &hf_camssp_requestForFreeCrossingAtATrafficLight, + &hf_camssp_noPassing, + &hf_camssp_noPassingForTrucks, + &hf_camssp_speedLimit, + &hf_camssp_reserved, + NULL + }; + + guint32 version; + + proto_tree_add_item_ret_uint(tree, hf_camssp_version, tvb, 0, 1, ENC_BIG_ENDIAN, &version); + if (version == 1) { + proto_tree_add_bitmask(tree, tvb, 1, hf_camssp_flags, ett_camssp_flags, camssp_flags, ENC_BIG_ENDIAN); + } + return tvb_reported_length(tvb); +} + +// Generated by asn2wrs +#include "packet-its-hf.c" + +static gint ett_its = -1; + +#include "packet-its-ett.c" + +// Deal with cause/subcause code management +struct { CauseCodeType_enum cause; int* hf; } cause_to_subcause[] = { + { trafficCondition, &hf_its_trafficCondition1 }, + { accident, &hf_its_accident2 }, + { roadworks, &hf_its_roadworks3 }, + { adverseWeatherCondition_Precipitation, &hf_its_adverseWeatherCondition_Precipitation19 }, + { adverseWeatherCondition_Visibility, &hf_its_adverseWeatherCondition_Visibility18 }, + { adverseWeatherCondition_Adhesion, &hf_its_adverseWeatherCondition_Adhesion6 }, + { adverseWeatherCondition_ExtremeWeatherCondition, &hf_its_adverseWeatherCondition_ExtremeWeatherCondition17 }, + { hazardousLocation_AnimalOnTheRoad, &hf_its_hazardousLocation_AnimalOnTheRoad11 }, + { hazardousLocation_ObstacleOnTheRoad, &hf_its_hazardousLocation_ObstacleOnTheRoad10 }, + { hazardousLocation_SurfaceCondition, &hf_its_hazardousLocation_SurfaceCondition9 }, + { hazardousLocation_DangerousCurve, &hf_its_hazardousLocation_DangerousCurve96 }, + { humanPresenceOnTheRoad, &hf_its_humanPresenceOnTheRoad12 }, + { wrongWayDriving, &hf_its_wrongWayDriving14 }, + { rescueAndRecoveryWorkInProgress, &hf_its_rescueAndRecoveryWorkInProgress15 }, + { slowVehicle, &hf_its_slowVehicle26 }, + { dangerousEndOfQueue, &hf_its_dangerousEndOfQueue27 }, + { vehicleBreakdown, &hf_its_vehicleBreakdown91 }, + { postCrash, &hf_its_postCrash92 }, + { humanProblem, &hf_its_humanProblem93 }, + { stationaryVehicle, &hf_its_stationaryVehicle94 }, + { emergencyVehicleApproaching, &hf_its_emergencyVehicleApproaching95 }, + { collisionRisk, &hf_its_collisionRisk97 }, + { signalViolation, &hf_its_signalViolation98 }, + { dangerousSituation, &hf_its_dangerousSituation99 }, + { reserved, NULL }, +}; + +static int* +find_subcause_from_cause(CauseCodeType_enum cause) +{ + int idx = 0; + + while (cause_to_subcause[idx].hf && (cause_to_subcause[idx].cause != cause)) + idx++; + + return cause_to_subcause[idx].hf?cause_to_subcause[idx].hf:&hf_its_subCauseCode; +} + +static unsigned char ita2_ascii[32] = { + '\0', 'T', '\r', 'O', ' ', 'H', 'N', 'M', '\n', 'L', 'R', 'G', 'I', 'P', 'C', 'V', + 'E', 'Z', 'D', 'B', 'S', 'Y', 'F', 'X', 'A', 'W', 'J', '\0', 'U', 'Q', 'K' +}; + +static void +append_country_code_fmt(proto_item *item, tvbuff_t *val_tvb) +{ + guint16 v = tvb_get_guint16(val_tvb, 0, ENC_BIG_ENDIAN); + v >>= 6; /* 10 bits */ + guint16 v1 = (v >> 5) & 0x1F; + guint16 v2 = v & 0x1F; + proto_item_append_text(item, " - %c%c", ita2_ascii[v1], ita2_ascii[v2]); +} + +#include "packet-its-fn.c" + +static void +its_latitude_fmt(gchar *s, guint32 v) +{ + gint32 lat = (gint32)v; + if (lat == 900000001) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", lat); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%u°%u'%.3f\"%c (%d)", + abs(lat) / 10000000, + abs(lat) % 10000000 * 6 / 1000000, + abs(lat) % 10000000 * 6 % 1000000 * 6.0 / 100000.0, + (lat >= 0) ? 'N' : 'S', + lat); + } +} + +static void +its_longitude_fmt(gchar *s, guint32 v) +{ + gint32 lng = (gint32)v; + if (lng == 1800000001) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", lng); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%u°%u'%.3f\"%c (%d)", + abs(lng) / 10000000, + abs(lng) % 10000000 * 6 / 1000000, + abs(lng) % 10000000 * 6 % 1000000 * 6.0 / 100000.0, + (lng >= 0) ? 'E' : 'W', + lng); + } +} + +static void +its_altitude_fmt(gchar *s, guint32 v) +{ + gint32 alt = (gint32)v; + if (alt == 800001) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", alt); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm (%d)", alt * 0.01, alt); + } +} + +static void +its_delta_latitude_fmt(gchar *s, guint32 v) +{ + gint32 lat = (gint32)v; + if (lat == 131072) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", lat); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%u°%u'%.3f\"%c (%d)", + abs(lat) / 10000000, + abs(lat) % 10000000 * 6 / 1000000, + abs(lat) % 10000000 * 6 % 1000000 * 6.0 / 100000.0, + (lat >= 0) ? 'N' : 'S', + lat); + } +} + +static void +its_delta_longitude_fmt(gchar *s, guint32 v) +{ + gint32 lng = (gint32)v; + if (lng == 131072) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", lng); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%u°%u'%.3f\"%c (%d)", + abs(lng) / 10000000, + abs(lng) % 10000000 * 6 / 1000000, + abs(lng) % 10000000 * 6 % 1000000 * 6.0 / 100000.0, + (lng >= 0) ? 'E' : 'W', + lng); + } +} + +static void +its_delta_altitude_fmt(gchar *s, guint32 v) +{ + gint32 alt = (gint32)v; + if (alt == 12800) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", alt); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm (%d)", alt * 0.01, alt); + } +} + +static void +its_path_delta_time_fmt(gchar *s, guint32 v) +{ + gint32 dt = (gint32)v; + snprintf(s, ITEM_LABEL_LENGTH, "%.2fs (%d)", dt * 0.01, dt); +} + + +static void +its_sax_length_fmt(gchar *s, guint32 v) +{ + if (v == 4095) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 4094) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm (%d)", v * 0.01, v); + } +} + +static void +its_heading_value_fmt(gchar *s, guint32 v) +{ + const gchar *p = try_val_to_str(v, VALS(its_HeadingValue_vals)); + if (p) { + snprintf(s, ITEM_LABEL_LENGTH, "%s (%d)", p, v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1f° (%d)", v * 0.1, v); + } +} + +static void +its_heading_confidence_fmt(gchar *s, guint32 v) +{ + if (v == 127) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 126) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1f° (%d)", v * 0.1, v); + } +} + +static void +its_speed_value_fmt(gchar *s, guint32 v) +{ + if (v == 0) { + snprintf(s, ITEM_LABEL_LENGTH, "standstill (%d)", v); + } else if (v == 16383) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + double vms = v * 0.01; + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm/s = %.1fkm/h (%d)", + vms, vms * 3.6, v); + } +} + +static void +its_speed_confidence_fmt(gchar *s, guint32 v) +{ + if (v == 127) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 126) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm/s (%d)", v * 0.01, v); + } +} + +static void +its_speed_limit_fmt(gchar *s, guint32 v) +{ + snprintf(s, ITEM_LABEL_LENGTH, "%dkm/h (%d)", v, v); +} + +static void +its_vehicle_length_value_fmt(gchar *s, guint32 v) +{ + if (v == 1023) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 1022) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1fm (%d)", v * 0.1, v); + } +} + +static void +its_vehicle_width_fmt(gchar *s, guint32 v) +{ + if (v == 62) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 61) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1fm (%d)", v * 0.1, v); + } +} + +static void +its_acceleration_value_fmt(gchar *s, guint32 v) +{ + gint32 acc = (gint32)v; + if (acc == 161) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1fm/s² (%d)", acc * 0.1, acc); + } +} + +static void +its_acceleration_confidence_fmt(gchar *s, guint32 v) +{ + if (v == 102) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 101) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1fm/s² (%d)", v * 0.1, v); + } +} + +static void +its_curvature_value_fmt(gchar *s, guint32 v) +{ + gint32 curv = (gint32)v; + if (curv == 0) { + snprintf(s, ITEM_LABEL_LENGTH, "straight (%d)", v); + } else if (curv == 30001) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.3fm %s (%d)", + 30000.0 / curv, + (curv > 0) ? "left" : "right", + curv); + } +} + +static void +its_yaw_rate_value_fmt(gchar *s, guint32 v) +{ + gint32 yaw = (gint32)v; + if (yaw == 0) { + snprintf(s, ITEM_LABEL_LENGTH, "straight (%d)", v); + } else if (yaw == 32767) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.2f°/s %s (%d)", + yaw * 0.01, + (yaw > 0) ? "left" : "right", + yaw); + } +} + +static void +its_swa_value_fmt(gchar *s, guint32 v) +{ + gint32 swa = (gint32)v; + if (swa == 0) { + snprintf(s, ITEM_LABEL_LENGTH, "straight (%d)", v); + } else if (swa == 512) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1f° %s (%d)", + swa * 1.5, + (swa > 0) ? "left" : "right", + swa); + } +} + +static void +its_swa_confidence_fmt(gchar *s, guint32 v) +{ + if (v == 127) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if (v == 126) { + snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%.1f° (%d)", v * 1.5, v); + } +} + +static void +dsrc_moi_fmt(gchar *s, guint32 v) +{ + if (v == 527040) { + snprintf(s, ITEM_LABEL_LENGTH, "invalid (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%ud %02u:%02u (%d)", + v / 1440, v % 1440 / 60, v % 60, v); + } +} + +static void +dsrc_dsecond_fmt(gchar *s, guint32 v) +{ + if (v == 65535) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else if ((61000 <= v) && (v <= 65534)) { + snprintf(s, ITEM_LABEL_LENGTH, "reserved (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%02u.%03u (%d)", + v / 1000, v % 1000, v); + } +} + +static void +dsrc_time_mark_fmt(gchar *s, guint32 v) +{ + if (v == 36001) { + snprintf(s, ITEM_LABEL_LENGTH, "unknown (%d)", v); + } else if (v == 36000) { + snprintf(s, ITEM_LABEL_LENGTH, "moreThanHour (%d)", v); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%02u:%02u.%u (%d)", + v / 600, v % 600 / 10, v % 10, v); + } +} + +static void +its_timestamp_fmt(gchar *s, guint64 v) +{ + time_t secs = v / 1000 + 1072915200 - 5; + struct tm *tm = gmtime(&secs); + snprintf(s, ITEM_LABEL_LENGTH, "%u-%02u-%02u %02u:%02u:%02u.%03u (%" PRIu64 ")", + tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, (guint32)(v % 1000), v + ); +} + +static void +its_validity_duration_fmt(gchar *s, guint32 v) +{ + snprintf(s, ITEM_LABEL_LENGTH, "%02u:%02u:%02u (%d)", + v / 3600, v % 3600 / 60, v % 60, v); +} + +static const value_string dsrc_TimeIntervalConfidence_vals[] = { + { 0, "21% probability" }, + { 1, "36% probability" }, + { 2, "47% probability" }, + { 3, "56% probability" }, + { 4, "62% probability" }, + { 5, "68% probability" }, + { 6, "73% probability" }, + { 7, "77% probability" }, + { 8, "81% probability" }, + { 9, "85% probability" }, + { 10, "88% probability" }, + { 11, "91% probability" }, + { 12, "94% probability" }, + { 13, "96% probability" }, + { 14, "98% probability" }, + { 15, "10% probability" }, + { 0, NULL } +}; + +static void +dsrc_velocity_fmt(gchar *s, guint32 v) +{ + if (v == 8191) { + snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); + } else { + double vms = v * 0.02; + snprintf(s, ITEM_LABEL_LENGTH, "%.2fm/s = %ukm/h (%d)", + vms, (int)lround(vms * 3.6), v); + } +} + +static void +dsrc_angle_fmt(gchar *s, guint32 v) +{ + snprintf(s, ITEM_LABEL_LENGTH, "%.2f° (%d)", v * 0.0125, v); +} + +static void +dsrc_delta_time_fmt(gchar *s, guint32 v) +{ + gint32 dt = (gint32)v; + if (dt == -122) { + snprintf(s, ITEM_LABEL_LENGTH, "unknown (%d)", dt); + } else if (dt == -121) { + snprintf(s, ITEM_LABEL_LENGTH, "moreThanMinus20Minutes (%d)", dt); + } else if (dt == 121) { + snprintf(s, ITEM_LABEL_LENGTH, "moreThanPlus20Minutes (%d)", dt); + } else { + snprintf(s, ITEM_LABEL_LENGTH, "%s%d:%02u (%d)", + (dt < 0) ? "-" : "", abs(dt) / 6, abs(dt) % 6 * 10, dt); + } +} + + +static void +cpm_object_dimension_value_fmt(gchar *s, guint32 v) +{ + snprintf(s, ITEM_LABEL_LENGTH, "%.1fm (%d)", v * 0.1, v); +} + +//static void +//cpm_object_dimension_confidence_fmt(gchar *s, guint32 v) +//{ +// if (v == 102) { +// snprintf(s, ITEM_LABEL_LENGTH, "unavailable (%d)", v); +// } else if (v == 101) { +// snprintf(s, ITEM_LABEL_LENGTH, "outOfRange (%d)", v); +// } else { +// snprintf(s, ITEM_LABEL_LENGTH, "%.2fm (%d)", v * 0.01, v); +// } +//} + +static int +dissect_its_PDU(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + proto_item *its_item; + proto_tree *its_tree; + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "ITS"); + col_clear(pinfo->cinfo, COL_INFO); + + its_item = proto_tree_add_item(tree, proto_its, tvb, 0, -1, ENC_NA); + its_tree = proto_item_add_subtree(its_item, ett_its); + + return dissect_its_ItsPduHeader_PDU(tvb, pinfo, its_tree, data); +} + +// Decode As... +static void +its_msgid_prompt(packet_info *pinfo, gchar *result) +{ + guint32 msgid = GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, hf_its_messageId, pinfo->curr_layer_num)); + + snprintf(result, MAX_DECODE_AS_PROMPT_LEN, "MsgId (%s%u)", UTF8_RIGHTWARDS_ARROW, msgid); +} + +static gpointer +its_msgid_value(packet_info *pinfo) +{ + return p_get_proto_data(pinfo->pool, pinfo, hf_its_messageId, pinfo->curr_layer_num); +} + +// Registration of protocols +void proto_register_its(void) +{ + static hf_register_info hf_its[] = { + #include "packet-its-hfarr.c" + + + /* + * DENM SSP + */ + { &hf_denmssp_version, { "Version", "its.ssp.denm.version", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, + { &hf_denmssp_flags, { "Allowed to sign", "its.ssp.denm.flags", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL }}, + { &hf_denmssp_trafficCondition, + { "trafficCondition", "its.denm.ssp.trafficCondition", + FT_UINT24, BASE_DEC, NULL, 0x800000, NULL, HFILL }}, + { &hf_denmssp_accident, + { "accident", "its.denm.ssp.accident", + FT_UINT24, BASE_DEC, NULL, 0x400000, NULL, HFILL }}, + { &hf_denmssp_roadworks, + { "roadworks", "its.denm.ssp.roadworks", + FT_UINT24, BASE_DEC, NULL, 0x200000, NULL, HFILL }}, + { &hf_denmssp_adverseWeatherConditionAdhesion, + { "adverseWeatherConditionAdhesion", "its.denm.ssp.advWxConditionAdhesion", + FT_UINT24, BASE_DEC, NULL, 0x100000, NULL, HFILL }}, + { &hf_denmssp_hazardousLocationSurfaceCondition, + { "hazardousLocationSurfaceCondition", "its.denm.ssp.hazLocationSurfaceCondition", + FT_UINT24, BASE_DEC, NULL, 0x080000, NULL, HFILL }}, + { &hf_denmssp_hazardousLocationObstacleOnTheRoad, + { "hazardousLocationObstacleOnTheRoad", "its.denm.ssp.hazLocationObstacleOnTheRoad", + FT_UINT24, BASE_DEC, NULL, 0x040000, NULL, HFILL }}, + { &hf_denmssp_hazardousLocationAnimalOnTheRoad, + { "hazardousLocationAnimalOnTheRoad", "its.denm.ssp.hazLocationAnimalOnTheRoad", + FT_UINT24, BASE_DEC, NULL, 0x020000, NULL, HFILL }}, + { &hf_denmssp_humanPresenceOnTheRoad, + { "humanPresenceOnTheRoad", "its.denm.ssp.humanPresenceOnTheRoad", + FT_UINT24, BASE_DEC, NULL, 0x010000, NULL, HFILL }}, + { &hf_denmssp_wrongWayDriving, + { "wrongWayDriving", "its.denm.ssp.wrongWayDriving", + FT_UINT24, BASE_DEC, NULL, 0x008000, NULL, HFILL }}, + { &hf_denmssp_rescueAndRecoveryWorkInProgress, + { "rescueAndRecoveryWorkInProgress", "its.denm.ssp.rescueAndRecoveryWorkInProgress", + FT_UINT24, BASE_DEC, NULL, 0x004000, NULL, HFILL }}, + { &hf_denmssp_ExtremeWeatherCondition, + { "ExtremeWeatherCondition", "its.denm.ssp.ExtremeWxCondition", + FT_UINT24, BASE_DEC, NULL, 0x002000, NULL, HFILL }}, + { &hf_denmssp_adverseWeatherConditionVisibility, + { "adverseWeatherConditionVisibility", "its.denm.ssp.advWxConditionVisibility", + FT_UINT24, BASE_DEC, NULL, 0x001000, NULL, HFILL }}, + { &hf_denmssp_adverseWeatherConditionPrecipitation, + { "adverseWeatherConditionPrecipitation", "its.denm.ssp.advWxConditionPrecipitation", + FT_UINT24, BASE_DEC, NULL, 0x000800, NULL, HFILL }}, + { &hf_denmssp_slowVehicle, + { "slowVehicle", "its.denm.ssp.slowVehicle", + FT_UINT24, BASE_DEC, NULL, 0x000400, NULL, HFILL }}, + { &hf_denmssp_dangerousEndOfQueue, + { "dangerousEndOfQueue", "its.denm.ssp.dangerousEndOfQueue", + FT_UINT24, BASE_DEC, NULL, 0x000200, NULL, HFILL }}, + { &hf_denmssp_vehicleBreakdown, + { "vehicleBreakdown", "its.denm.ssp.vehicleBreakdown", + FT_UINT24, BASE_DEC, NULL, 0x000100, NULL, HFILL }}, + { &hf_denmssp_postCrash, + { "postCrash", "its.denm.ssp.postCrash", + FT_UINT24, BASE_DEC, NULL, 0x000080, NULL, HFILL }}, + { &hf_denmssp_humanProblem, + { "humanProblem", "its.denm.ssp.humanProblem", + FT_UINT24, BASE_DEC, NULL, 0x000040, NULL, HFILL }}, + { &hf_denmssp_stationaryVehicle, + { "stationaryVehicle", "its.denm.ssp.stationaryVehicle", + FT_UINT24, BASE_DEC, NULL, 0x000020, NULL, HFILL }}, + { &hf_denmssp_emergencyVehicleApproaching, + { "emergencyVehicleApproaching", "its.denm.ssp.emergencyVehicleApproaching", + FT_UINT24, BASE_DEC, NULL, 0x000010, NULL, HFILL }}, + { &hf_denmssp_hazardousLocationDangerousCurve, + { "hazardousLocationDangerousCurve", "its.denm.ssp.hazLocationDangerousCurve", + FT_UINT24, BASE_DEC, NULL, 0x000008, NULL, HFILL }}, + { &hf_denmssp_collisionRisk, + { "collisionRisk", "its.denm.ssp.collisionRisk", + FT_UINT24, BASE_DEC, NULL, 0x000004, NULL, HFILL }}, + { &hf_denmssp_signalViolation, + { "signalViolation", "its.denm.ssp.signalViolation", + FT_UINT24, BASE_DEC, NULL, 0x000002, NULL, HFILL }}, + { &hf_denmssp_dangerousSituation, + { "dangerousSituation", "its.denm.ssp.dangerousSituation", + FT_UINT24, BASE_DEC, NULL, 0x000001, NULL, HFILL }}, + + /* + * CAM SSP + */ + { &hf_camssp_version, { "Version", "its.ssp.cam.version", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, + { &hf_camssp_flags, { "Allowed to sign", "its.ssp.cam.flags", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, + { &hf_camssp_cenDsrcTollingZone, { "cenDsrcTollingZone", "its.ssp.cam.cenDsrcTollingZone", FT_UINT16, BASE_DEC, NULL, 0x8000, NULL, HFILL }}, + { &hf_camssp_publicTransport, { "publicTransport", "its.ssp.cam.publicTransport", FT_UINT16, BASE_DEC, NULL, 0x4000, NULL, HFILL }}, + { &hf_camssp_specialTransport, { "specialTransport", "its.ssp.cam.specialTransport", FT_UINT16, BASE_DEC, NULL, 0x2000, NULL, HFILL }}, + { &hf_camssp_dangerousGoods, { "dangerousGoods", "its.ssp.cam.dangerousGoods", FT_UINT16, BASE_DEC, NULL, 0x1000, NULL, HFILL }}, + { &hf_camssp_roadwork, { "roadwork", "its.ssp.cam.roadwork", FT_UINT16, BASE_DEC, NULL, 0x0800, NULL, HFILL }}, + { &hf_camssp_rescue, { "rescue", "its.ssp.cam.rescue", FT_UINT16, BASE_DEC, NULL, 0x0400, NULL, HFILL }}, + { &hf_camssp_emergency, { "emergency", "its.ssp.cam.emergency", FT_UINT16, BASE_DEC, NULL, 0x0200, NULL, HFILL }}, + { &hf_camssp_safetyCar, { "safetyCar", "its.ssp.cam.safetyCar", FT_UINT16, BASE_DEC, NULL, 0x0100, NULL, HFILL }}, + { &hf_camssp_closedLanes, { "closedLanes", "its.ssp.cam.closedLanes", FT_UINT16, BASE_DEC, NULL, 0x0080, NULL, HFILL }}, + { &hf_camssp_requestForRightOfWay, { "requestForRightOfWay", "its.ssp.cam.requestForRightOfWay", FT_UINT16, BASE_DEC, NULL, 0x0040, NULL, HFILL }}, + { &hf_camssp_requestForFreeCrossingAtATrafficLight, { "reqFreeCrossTrafLight", "its.ssp.cam.requestForFreeCrossingAtATrafficLight", FT_UINT16, BASE_DEC, NULL, 0x0020, NULL, HFILL }}, + { &hf_camssp_noPassing, { "noPassing", "its.ssp.cam.noPassing", FT_UINT16, BASE_DEC, NULL, 0x0010, NULL, HFILL }}, + { &hf_camssp_noPassingForTrucks, { "noPassingForTrucks", "its.ssp.cam.noPassingForTrucks", FT_UINT16, BASE_DEC, NULL, 0x0008, NULL, HFILL }}, + { &hf_camssp_speedLimit, { "speedLimit", "its.ssp.cam.speedLimit", FT_UINT16, BASE_DEC, NULL, 0x0004, NULL, HFILL }}, + { &hf_camssp_reserved, { "reserved", "its.ssp.cam.reserved", FT_UINT16, BASE_DEC, NULL, 0x0003, NULL, HFILL }}, + }; + + static gint *ett[] = { + &ett_its, + &ett_denmssp_flags, + &ett_camssp_flags, + #include "packet-its-ettarr.c" + }; + + static ei_register_info ei[] = { + { &ei_its_no_sub_dis, { "its.no_subdissector", PI_PROTOCOL, PI_NOTE, "No subdissector found for this Message id/protocol version combination", EXPFILL }}, + }; + + expert_module_t* expert_its; + + proto_its = proto_register_protocol("Intelligent Transport Systems", "ITS", "its"); + + proto_register_field_array(proto_its, hf_its, array_length(hf_its)); + + proto_register_subtree_array(ett, array_length(ett)); + + expert_its = expert_register_protocol(proto_its); + + expert_register_field_array(expert_its, ei, array_length(ei)); + + its_handle = register_dissector("its", dissect_its_PDU, proto_its); + + // Register subdissector table + its_version_subdissector_table = register_dissector_table("its.version", "ITS version", proto_its, FT_UINT8, BASE_DEC); + its_msgid_subdissector_table = register_dissector_table("its.msg_id", "ITS message id", proto_its, FT_UINT32, BASE_DEC); + regionid_subdissector_table = register_dissector_table("dsrc.regionid", "DSRC RegionId", proto_its, FT_UINT32, BASE_DEC); + cpmcontainer_subdissector_table = register_dissector_table("cpm.container", "CPM Containers id", proto_its, FT_UINT32, BASE_DEC); + cam_pt_activation_table = register_dissector_table("cam.ptat", "CAM PtActivationType", proto_its, FT_UINT32, BASE_DEC); + + proto_its_denm = proto_register_protocol_in_name_only("ITS message - DENM", "DENM", "its.message.denm", proto_its, FT_BYTES); + proto_its_denmv1 = proto_register_protocol_in_name_only("ITS message - DENMv1", "DENMv1", "its.message.denmv1", proto_its, FT_BYTES); + proto_its_cam = proto_register_protocol_in_name_only("ITS message - CAM", "CAM", "its.message.cam", proto_its, FT_BYTES); + proto_its_camv1 = proto_register_protocol_in_name_only("ITS message - CAMv1", "CAMv1", "its.message.camv1", proto_its, FT_BYTES); + proto_its_spatemv1 = proto_register_protocol_in_name_only("ITS message - SPATEMv1", "SPATEMv1", "its.message.spatemv1", proto_its, FT_BYTES); + proto_its_spatem = proto_register_protocol_in_name_only("ITS message - SPATEM", "SPATEM", "its.message.spatem", proto_its, FT_BYTES); + proto_its_mapemv1 = proto_register_protocol_in_name_only("ITS message - MAPEMv1", "MAPEMv1", "its.message.mapemv1", proto_its, FT_BYTES); + proto_its_mapem = proto_register_protocol_in_name_only("ITS message - MAPEM", "MAPEM", "its.message.mapem", proto_its, FT_BYTES); + proto_its_ivimv1 = proto_register_protocol_in_name_only("ITS message - IVIMv1", "IVIMv1", "its.message.ivimv1", proto_its, FT_BYTES); + proto_its_ivim = proto_register_protocol_in_name_only("ITS message - IVIM", "IVIM", "its.message.ivim", proto_its, FT_BYTES); + proto_its_evrsr = proto_register_protocol_in_name_only("ITS message - EVRSR", "EVRSR", "its.message.evrsr", proto_its, FT_BYTES); + proto_its_srem = proto_register_protocol_in_name_only("ITS message - SREM", "SREM", "its.message.srem", proto_its, FT_BYTES); + proto_its_ssem = proto_register_protocol_in_name_only("ITS message - SSEM", "SSEM", "its.message.ssem", proto_its, FT_BYTES); + proto_its_rtcmemv1 = proto_register_protocol_in_name_only("ITS message - RTCMEMv1", "RTCMEMv1", "its.message.rtcmemv1", proto_its, FT_BYTES); + proto_its_rtcmem = proto_register_protocol_in_name_only("ITS message - RTCMEM", "RTCMEM", "its.message.rtcmem", proto_its, FT_BYTES); + proto_its_evcsn = proto_register_protocol_in_name_only("ITS message - EVCSN", "EVCSN", "its.message.evcsn", proto_its, FT_BYTES); + proto_its_tistpg = proto_register_protocol_in_name_only("ITS message - TISTPG", "TISTPG", "its.message.tistpg", proto_its, FT_BYTES); + proto_its_cpm = proto_register_protocol_in_name_only("ITS message - CPM", "CPM", "its.message.cpm", proto_its, FT_BYTES); + proto_its_vam = proto_register_protocol_in_name_only("ITS message - VAM", "VAM", "its.message.vam", proto_its, FT_BYTES); + proto_its_imzm = proto_register_protocol_in_name_only("ITS message - IMZM", "IMZM", "its.message.imzm", proto_its, FT_BYTES); + + proto_addgrpc = proto_register_protocol_in_name_only("DSRC Addition Grp C (EU)", "ADDGRPC", "dsrc.addgrpc", proto_its, FT_BYTES); + + // Decode as + static build_valid_func its_da_build_value[1] = {its_msgid_value}; + static decode_as_value_t its_da_values = {its_msgid_prompt, 1, its_da_build_value}; + static decode_as_t its_da = {"its", "its.msg_id", 1, 0, &its_da_values, NULL, NULL, + decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL}; + + register_decode_as(&its_da); +} + +#define BTP_SUBDISS_SZ 2 +#define BTP_PORTS_SZ 12 + +#define ITS_CAM_PROT_VER 2 +#define ITS_CAM_PROT_VERv1 1 +#define ITS_DENM_PROT_VER 2 +#define ITS_DENM_PROT_VERv1 1 +#define ITS_SPATEM_PROT_VERv1 1 +#define ITS_SPATEM_PROT_VER 2 +#define ITS_MAPEM_PROT_VERv1 1 +#define ITS_MAPEM_PROT_VER 2 +#define ITS_IVIM_PROT_VERv1 1 +#define ITS_IVIM_PROT_VER 2 +#define ITS_SREM_PROT_VER 2 +#define ITS_SSEM_PROT_VER 2 +#define ITS_RTCMEM_PROT_VERv1 1 +#define ITS_RTCMEM_PROT_VER 2 +#define ITS_TIS_TPG_PROT_VER 1 +#define ITS_CPM_PROT_VER 2 +#define ITS_VAM_PROT_VER 2 +#define ITS_IMZM_PROT_VER 2 + +void proto_reg_handoff_its(void) +{ + const char *subdissector[BTP_SUBDISS_SZ] = { "btpa.port", "btpb.port" }; + const guint16 ports[BTP_PORTS_SZ] = { ITS_WKP_DEN, ITS_WKP_CA, ITS_WKP_EVCSN, ITS_WKP_CHARGING, ITS_WKP_IVI, ITS_WKP_TPG, ITS_WKP_TLC_SSEM, ITS_WKP_GPC, ITS_WKP_TLC_SREM, ITS_WKP_RLT, ITS_WKP_TLM, ITS_WKP_CPS }; + int sdIdx, pIdx; + + // Register well known ports to btp subdissector table (BTP A and B) + for (sdIdx=0; sdIdx < BTP_SUBDISS_SZ; sdIdx++) { + for (pIdx=0; pIdx < BTP_PORTS_SZ; pIdx++) { + dissector_add_uint(subdissector[sdIdx], ports[pIdx], its_handle); + } + } + + // Enable decode as for its pdu's send via udp + dissector_add_for_decode_as("udp.port", its_handle); + + dissector_add_uint("its.msg_id", (ITS_DENM_PROT_VER << 16) + ITS_DENM, create_dissector_handle(dissect_denm_DenmPayload_PDU, proto_its_denm )); + dissector_add_uint("its.msg_id", (ITS_DENM_PROT_VERv1 << 16) + ITS_DENM, create_dissector_handle(dissect_denmv1_DecentralizedEnvironmentalNotificationMessageV1_PDU, proto_its_denmv1 )); + dissector_add_uint("its.msg_id", (ITS_CAM_PROT_VER << 16) + ITS_CAM, create_dissector_handle( dissect_cam_CamPayload_PDU, proto_its_cam )); + dissector_add_uint("its.msg_id", (ITS_CAM_PROT_VERv1 << 16) + ITS_CAM, create_dissector_handle( dissect_camv1_CoopAwarenessV1_PDU, proto_its_camv1)); + dissector_add_uint("its.msg_id", (ITS_SPATEM_PROT_VERv1 << 16) + ITS_SPATEM, create_dissector_handle( dissect_dsrc_SPAT_PDU, proto_its_spatemv1 )); + dissector_add_uint("its.msg_id", (ITS_SPATEM_PROT_VER << 16) + ITS_SPATEM, create_dissector_handle( dissect_dsrc_SPAT_PDU, proto_its_spatem )); + dissector_add_uint("its.msg_id", (ITS_MAPEM_PROT_VERv1 << 16) + ITS_MAPEM, create_dissector_handle( dissect_dsrc_MapData_PDU, proto_its_mapemv1 )); + dissector_add_uint("its.msg_id", (ITS_MAPEM_PROT_VER << 16) + ITS_MAPEM, create_dissector_handle( dissect_dsrc_MapData_PDU, proto_its_mapem )); + dissector_add_uint("its.msg_id", (ITS_IVIM_PROT_VERv1 << 16) + ITS_IVIM, create_dissector_handle( dissect_ivi_IviStructure_PDU, proto_its_ivimv1 )); + dissector_add_uint("its.msg_id", (ITS_IVIM_PROT_VER << 16) + ITS_IVIM, create_dissector_handle( dissect_ivi_IviStructure_PDU, proto_its_ivim )); + dissector_add_uint("its.msg_id", ITS_EV_RSR, create_dissector_handle( dissect_evrsr_EV_RSR_MessageBody_PDU, proto_its_evrsr )); + dissector_add_uint("its.msg_id", (ITS_SREM_PROT_VER << 16) + ITS_SREM, create_dissector_handle( dissect_dsrc_SignalRequestMessage_PDU, proto_its_srem )); + dissector_add_uint("its.msg_id", (ITS_SSEM_PROT_VER << 16) + ITS_SSEM, create_dissector_handle( dissect_dsrc_SignalStatusMessage_PDU, proto_its_ssem )); + dissector_add_uint("its.msg_id", (ITS_RTCMEM_PROT_VERv1 << 16) + ITS_RTCMEM, create_dissector_handle( dissect_dsrc_RTCMcorrections_PDU, proto_its_rtcmemv1)); + dissector_add_uint("its.msg_id", (ITS_RTCMEM_PROT_VER << 16) + ITS_RTCMEM, create_dissector_handle(dissect_dsrc_RTCMcorrections_PDU, proto_its_rtcmem)); + dissector_add_uint("its.msg_id", ITS_EVCSN, create_dissector_handle( dissect_evcsn_EVChargingSpotNotificationPOIMessage_PDU, proto_its_evcsn )); + dissector_add_uint("its.msg_id", (ITS_TIS_TPG_PROT_VER << 16) + ITS_TISTPGTRANSACTION, create_dissector_handle( dissect_tistpg_TisTpgTransaction_PDU, proto_its_tistpg )); + dissector_add_uint("its.msg_id", (ITS_CPM_PROT_VER << 16) + ITS_CPM, create_dissector_handle(dissect_cpm_CollectivePerceptionMessage_PDU, proto_its_cpm)); + dissector_add_uint("its.msg_id", (ITS_IMZM_PROT_VER << 16) + ITS_IMZM, create_dissector_handle(dissect_imzm_InterferenceManagementZoneMessage_PDU, proto_its_imzm)); + dissector_add_uint("its.msg_id", (ITS_VAM_PROT_VER << 16) + ITS_VAM, create_dissector_handle(dissect_vam_VruAwareness_PDU, proto_its_vam)); + + /* Missing definitions: ITS_POI, ITS_SAEM */ + + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_ConnectionManeuverAssist, create_dissector_handle(dissect_AddGrpC_ConnectionManeuverAssist_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_GenericLane, create_dissector_handle(dissect_AddGrpC_ConnectionTrajectory_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_NodeAttributeSetXY, create_dissector_handle(dissect_AddGrpC_NodeAttributeSet_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_IntersectionState, create_dissector_handle(dissect_AddGrpC_IntersectionState_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_MapData,create_dissector_handle(dissect_AddGrpC_MapData_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_Position3D, create_dissector_handle(dissect_AddGrpC_Position3D_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_RestrictionUserType, create_dissector_handle(dissect_AddGrpC_RestrictionUserType_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_SignalStatusPackage, create_dissector_handle(dissect_AddGrpC_SignalStatusPackage_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_LaneAttributes, create_dissector_handle(dissect_AddGrpC_LaneAttributes_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_MovementEvent, create_dissector_handle(dissect_AddGrpC_MovementEvent_addGrpC_PDU, proto_addgrpc )); + dissector_add_uint("dsrc.regionid", (addGrpC<<16)+Reg_RequestorDescription, create_dissector_handle(dissect_AddGrpC_RequestorDescription_addGrpC_PDU, proto_addgrpc )); + + dissector_add_uint("ieee1609dot2.ssp", psid_den_basic_services, create_dissector_handle(dissect_denmssp_pdu, proto_its_denm)); + dissector_add_uint("ieee1609dot2.ssp", psid_ca_basic_services, create_dissector_handle(dissect_camssp_pdu, proto_its_cam)); + dissector_add_uint("geonw.ssp", psid_den_basic_services, create_dissector_handle(dissect_denmssp_pdu, proto_its_denm)); + dissector_add_uint("geonw.ssp", psid_ca_basic_services, create_dissector_handle(dissect_camssp_pdu, proto_its_cam)); + + dissector_add_uint("cpm.container", 1, create_dissector_handle(dissect_cpm_OriginatingVehicleContainer_PDU, proto_its_cpm)); + dissector_add_uint("cpm.container", 2, create_dissector_handle(dissect_cpm_OriginatingRsuContainer_PDU, proto_its_cpm)); + dissector_add_uint("cpm.container", 3, create_dissector_handle(dissect_cpm_SensorInformationContainer_PDU, proto_its_cpm)); + dissector_add_uint("cpm.container", 4, create_dissector_handle(dissect_cpm_PerceptionRegionContainer_PDU, proto_its_cpm)); + dissector_add_uint("cpm.container", 5, create_dissector_handle(dissect_cpm_PerceivedObjectContainer_PDU, proto_its_cpm)); + + its_tap = register_tap("its"); +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ diff --git a/epan/dissectors/asn1/its/packet-its-template.h b/epan/dissectors/asn1/its/packet-its-template.h new file mode 100644 index 00000000..6381b753 --- /dev/null +++ b/epan/dissectors/asn1/its/packet-its-template.h @@ -0,0 +1,59 @@ +/* packet-its-template.h + * + * Intelligent Transport Systems Applications dissectors + * C. Guerber <cguerber@yahoo.com> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#ifndef __PACKET_ITS_H__ +#define __PACKET_ITS_H__ + +#include "packet-its-exp.h" + +#include "packet-its-val.h" + +typedef struct its_header { + guint32 version; + guint32 msgId; + guint32 stationId; + guint32 CpmContainerId; +} its_header_t; + +enum regext_type_enum { + Reg_AdvisorySpeed, + Reg_ComputedLane, + Reg_ConnectionManeuverAssist, + Reg_GenericLane, + Reg_IntersectionGeometry, + Reg_IntersectionState, + Reg_LaneAttributes, + Reg_LaneDataAttribute, + Reg_MapData, + Reg_MovementEvent, + Reg_MovementState, + Reg_NodeAttributeSetLL, + Reg_NodeAttributeSetXY, + Reg_NodeOffsetPointLL, + Reg_NodeOffsetPointXY, + Reg_Position3D, + Reg_RequestorDescription, + Reg_RequestorType, + Reg_RestrictionUserType, + Reg_RoadSegment, + Reg_SignalControlZone, + Reg_SignalRequest, + Reg_SignalRequestMessage, + Reg_SignalRequestPackage, + Reg_SignalStatus, + Reg_SignalStatusMessage, + Reg_SignalStatusPackage, + Reg_SPAT, + Reg_RTCMcorrections, +}; + +#endif /* __PACKET_ITS_H__ */ |