#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod etsi_its_dsrc {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::super::cdd_2_2_1::etsi_its_cdd::{
Iso3833VehicleType,
Latitude,
Longitude,
StationID,
};
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousAdvisorySpeedRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousAdvisorySpeedRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct AdvisorySpeedRegional(pub SequenceOf<AnonymousAdvisorySpeedRegional>);
#[doc = "This DF is used to convey a recommended traveling approach speed to an intersection"]
#[doc = "from the message issuer to various travelers and vehicle types. Besides support for various eco-driving applications, this"]
#[doc = "allows transmitting recommended speeds for specialty vehicles such as transit buses."]
#[doc = "- @field type: the type of advisory which this is."]
#[doc = "- @field speed: See @ref SpeedAdvice for converting and translating speed expressed in mph into units of m/s."]
#[doc = " This element is optional ONLY when superceded by the presence of a regional speed element found in Reg-AdvisorySpeed entry"]
#[doc = "- @field confidence: A confidence value for the above speed"]
#[doc = "- @field distance: The distance indicates the region for which the advised speed is recommended, it is specified upstream from the stop bar"]
#[doc = " along the connected egressing lane. Unit = 1 meter "]
#[doc = "- @field class: the vehicle types to which it applies when absent, the AdvisorySpeed applies to all motor vehicle types"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct AdvisorySpeed {
#[rasn(identifier = "type")]
pub r_type: AdvisorySpeedType,
pub speed: Option<SpeedAdvice>,
pub confidence: Option<SpeedConfidenceDSRC>,
pub distance: Option<ZoneLength>,
pub class: Option<RestrictionClassID>,
pub regional: Option<AdvisorySpeedRegional>,
}
impl AdvisorySpeed {
pub fn new(
r_type: AdvisorySpeedType,
speed: Option<SpeedAdvice>,
confidence: Option<SpeedConfidenceDSRC>,
distance: Option<ZoneLength>,
class: Option<RestrictionClassID>,
regional: Option<AdvisorySpeedRegional>,
) -> Self {
Self {
r_type,
speed,
confidence,
distance,
class,
regional,
}
}
}
#[doc = "This DF consists of a list of @ref AdvisorySpeed entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct AdvisorySpeedList(pub SequenceOf<AdvisorySpeed>);
#[doc = "This DE relates the type of travel to which a given speed refers. This element is"]
#[doc = "typically used as part of an @ref AdvisorySpeed data frame for signal phase and timing data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum AdvisorySpeedType {
none = 0,
greenwave = 1,
ecoDrive = 2,
transit = 3,
}
#[doc = "This DE relates the allowed (possible) maneuvers from a lane, typically a"]
#[doc = "motorized vehicle lane. It should be noted that in practice these values may be further restricted by vehicle class, local"]
#[doc = "regulatory environment and other changing conditions."]
#[doc = "\n\n@note: When used by data frames, the AllowedManeuvers data concept is used in two places: optionally in the"]
#[doc = " generic lane structure to list all possible maneuvers (as in what that lane can do at its stop line point); and within each"]
#[doc = " ConnectsTo structure. Each ConnectsTo structure contains a list used to provide a single valid maneuver in the context of"]
#[doc = " one lane connecting to another in the context of a signal phase that applies to that maneuver. It should be noted that, in"]
#[doc = " some intersections, multiple outbound lanes can be reached by the same maneuver (for example two independent left"]
#[doc = " turns might be found in a 5-legged intersection) but that to reach any given lane from the stop line of another lane is"]
#[doc = " always a single maneuver item (hence the use of a list). Not all intersection descriptions may contain an exhaustive set of"]
#[doc = " ConnectsTo information (unsignalized intersections for example) and in such cases the AllowedManeuvers in the generic"]
#[doc = " lane structure can be used. If present in both places, the data expressed in the generic lane shall not conflict with the data"]
#[doc = " found in the collection of ConnectsTo entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct AllowedManeuvers(pub FixedBitString<12usize>);
#[doc = "This DE is used to describe an angular measurement in units of degrees. This data"]
#[doc = "element is often used as a heading direction when in motion. In this use, the current heading of the sending device is"]
#[doc = "expressed in unsigned units of 0.0125 degrees from North, such that 28799 such degrees represent 359.9875 degrees."]
#[doc = "North shall be defined as the axis defined by the WGS-84 coordinate system and its reference ellipsoid. Any angle \"to the"]
#[doc = "east\" is defined as the positive direction. A value of 28800 shall be used when Angle is unavailable."]
#[doc = "\n\n@note: Note that other heading and angle data elements of various sizes and precisions are found in other parts of this standard and in ITS."]
#[doc = "\n\n@unit: 0.0125 degrees"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=28800"))]
pub struct Angle(pub u16);
#[doc = "This DF is a collection of three offset values in an orthogonal coordinate system"]
#[doc = "which describe how far the electrical phase center of an antenna is in each axis from a nearby known anchor point in units of 1 cm."]
#[doc = "When the antenna being described is on a vehicle, the signed offset shall be in the coordinate system defined in section 11.4."]
#[doc = "- @field antOffsetX: a range of +- 20.47 meters."]
#[doc = "- @field antOffsetY: a range of +- 2.55 meters."]
#[doc = "- @field antOffsetZ: a range of +- 5.11 meters."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct AntennaOffsetSet {
#[rasn(identifier = "antOffsetX")]
pub ant_offset_x: OffsetB12,
#[rasn(identifier = "antOffsetY")]
pub ant_offset_y: OffsetB09,
#[rasn(identifier = "antOffsetZ")]
pub ant_offset_z: OffsetB10,
}
impl AntennaOffsetSet {
pub fn new(
ant_offset_x: OffsetB12,
ant_offset_y: OffsetB09,
ant_offset_z: OffsetB10,
) -> Self {
Self {
ant_offset_x,
ant_offset_y,
ant_offset_z,
}
}
}
#[doc = "This DE is used to relate the index of an approach, either ingress or egress within the"]
#[doc = "subject lane. In general, an approach index in the context of a timing movement is not of value in the MAP and SPAT"]
#[doc = "process because the lane ID and signal group ID concepts handle this with more precision. This value can also be useful"]
#[doc = "as an aid as it can be used to indicate the gross position of a moving object (vehicle) when its lane level accuracy is"]
#[doc = "unknown. This value can also be used when a deployment represents sets of lanes as groups without further details (as is"]
#[doc = "done in Japan)."]
#[doc = "\n\n@note: zero to be used when valid value is unknown"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15"))]
pub struct ApproachID(pub u8);
#[doc = "This DE provides a means to indicate the current role that a DSRC device is playing"]
#[doc = "This is most commonly employed when a vehicle needs to take on another role in order to send certain DSRC message"]
#[doc = "types. As an example, when a public safety vehicle such as a police car wishes to send a signal request message (SRM)"]
#[doc = "to an intersection to request a preemption service, the vehicle takes on the role \"police\" from the below list in both the"]
#[doc = "SRM message itself and also in the type of security CERT which is sent (the SSP in the CERT it used to identify the"]
#[doc = "requester as being of type \"police\" and that they are allowed to send this message in this way). The BasicVehicleRole"]
#[doc = "entry is often used and combined with other information about the requester as well, such as details of why the request is"]
#[doc = "being made."]
#[doc = "- 0 - `basicVehicle` - Light duty passenger vehicle type"]
#[doc = "- 1 - `publicTransport` - Used in EU for Transit us"]
#[doc = "- 2 - `specialTransport` - Used in EU (e.g. heavy load)"]
#[doc = "- 3 - `dangerousGoods` - Used in EU for any HAZMAT"]
#[doc = "- 4 - `roadWork` - Used in EU for State and Local DOT uses"]
#[doc = "- 5 - `roadRescue` - Used in EU and in the US to include tow trucks."]
#[doc = "- 6 - `emergency` - Used in EU for Police, Fire and Ambulance units"]
#[doc = "- 7 - `safetyCar` - Used in EU for Escort vehicles"]
#[doc = "- 8 - `none-unknown` - added to follow current SAE style guidelines"]
#[doc = "- 9 - `truck` - Heavy trucks with additional BSM rights and obligations"]
#[doc = "- 10 - `motorcycle` - Motorcycle"]
#[doc = "- 11 - `roadSideSource` - For infrastructure generated calls such as fire house, rail infrastructure, roadwork site, etc."]
#[doc = "- 12 - `police` - Police vehicle"]
#[doc = "- 13 - `fire` - Firebrigade"]
#[doc = "- 14 - `ambulance` - (does not include private para-transit etc.)"]
#[doc = "- 15 - `dot` - all roadwork vehicles"]
#[doc = "- 16 - `transit` - all transit vehicles"]
#[doc = "- 17 - `slowMoving` - to also include oversize etc."]
#[doc = "- 18 - `stopNgo` - to include trash trucks, school buses and others"]
#[doc = "- 19 - `cyclist` - bicycles"]
#[doc = "- 20 - `pedestrian` - also includes those with mobility limitations"]
#[doc = "- 21 - `nonMotorized` - other, horse drawn, etc."]
#[doc = "- 22 - `military` - military vehicles"]
#[doc = "\n\n@note: It should be observed that devices can at times change their roles (i.e. a fire operated by a volunteer"]
#[doc = " fireman can assume a fire role for a period of time when in service, or a pedestrian may assume a cyclist role when using"]
#[doc = " a bicycle). It should be observed that not all devices (or vehicles) can assume all roles, nor that a given"]
#[doc = " device in a given role will be provided with a security certificate (CERT) that has suitable SSP credentials to provide the"]
#[doc = " ability to send a particular message or message content. The ultimate responsibility to determine what role is to be used,"]
#[doc = " and what CERTs would be provided for that role (which in turn controls the messages and message content that can be"]
#[doc = " sent within SAE-defined PSIDs) rests with the regional deployment."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum BasicVehicleRole {
basicVehicle = 0,
publicTransport = 1,
specialTransport = 2,
dangerousGoods = 3,
roadWork = 4,
roadRescue = 5,
emergency = 6,
safetyCar = 7,
#[rasn(identifier = "none-unknown")]
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,
#[rasn(extension_addition)]
tram = 23,
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum ComputedLaneOffsetXaxis {
small(DrivenLineOffsetSm),
large(DrivenLineOffsetLg),
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum ComputedLaneOffsetYaxis {
small(DrivenLineOffsetSm),
large(DrivenLineOffsetLg),
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousComputedLaneRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousComputedLaneRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct ComputedLaneRegional(pub SequenceOf<AnonymousComputedLaneRegional>);
#[doc = "This DE is used to contain information needed to compute one lane from another"]
#[doc = "(hence the name). This concept is used purely as a means of saving size in the message payload. The new lane is"]
#[doc = "expressed as an X,Y offset from the first point of the source lane. It can be optionally rotated and scaled. Any attribute"]
#[doc = "information found within the node of the source lane list cannot be changed and must be reused."]
#[doc = "- @field referenceLaneId: the lane ID upon which this computed lane will be based Lane Offset in X and Y direction"]
#[doc = "- @field offsetXaxis: A path X offset value for translations of the path's points when creating translated lanes."]
#[doc = "- @field offsetYaxis: The values found in the reference lane are all offset based on the X and Y values from"]
#[doc = " the coordinates of the reference lane's initial path point."]
#[doc = "- @field rotateXY: A path rotation value for the entire lane"]
#[doc = " Observe that this rotates the existing orientation"]
#[doc = " of the referenced lane, it does not replace it."]
#[doc = " Rotation occurs about the initial path point."]
#[doc = "- @field scaleXaxis: value for translations or zooming of the path's points. The values found in the reference lane"]
#[doc = "- @field scaleYaxis: are all expanded or contracted based on the X and Y and width values from the coordinates of the reference lane's initial path point."]
#[doc = " The Z axis remains untouched."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@note: The specified transformation shall be applied to the reference lane without any intermediary loss of precision"]
#[doc = " (truncation). The order of the transformations shall be: the East-West and North-South offsets, the scaling factors, and"]
#[doc = " finally the rotation."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct ComputedLane {
#[rasn(identifier = "referenceLaneId")]
pub reference_lane_id: LaneID,
#[rasn(identifier = "offsetXaxis")]
pub offset_xaxis: ComputedLaneOffsetXaxis,
#[rasn(identifier = "offsetYaxis")]
pub offset_yaxis: ComputedLaneOffsetYaxis,
#[rasn(identifier = "rotateXY")]
pub rotate_xy: Option<Angle>,
#[rasn(identifier = "scaleXaxis")]
pub scale_xaxis: Option<ScaleB12>,
#[rasn(identifier = "scaleYaxis")]
pub scale_yaxis: Option<ScaleB12>,
pub regional: Option<ComputedLaneRegional>,
}
impl ComputedLane {
pub fn new(
reference_lane_id: LaneID,
offset_xaxis: ComputedLaneOffsetXaxis,
offset_yaxis: ComputedLaneOffsetYaxis,
rotate_xy: Option<Angle>,
scale_xaxis: Option<ScaleB12>,
scale_yaxis: Option<ScaleB12>,
regional: Option<ComputedLaneRegional>,
) -> Self {
Self {
reference_lane_id,
offset_xaxis,
offset_yaxis,
rotate_xy,
scale_xaxis,
scale_yaxis,
regional,
}
}
}
#[doc = "The data concept ties a single lane to a single maneuver needed to reach it from another lane."]
#[doc = "It is typically used to connect the allowed maneuver from the end of a lane to the outbound lane so that these can be"]
#[doc = "mapped to the SPAT message to which both lanes apply."]
#[doc = "- @field lane: Index of the connecting lane."]
#[doc = "- @field maneuver: This data element allows only the description of a subset of possible manoeuvres and therefore"]
#[doc = " represents an incomplete list of possible travel directions. The connecting `lane` data element gives the"]
#[doc = " exact information about the manoeuvre relation from ingress to egress lane. Therefore the \"maneuver\""]
#[doc = " data element may be used only additionally if the travel direction of the manoeuvre is unanmbigoulsy"]
#[doc = " represented (e.g. left, right, straight, etc.)."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct ConnectingLane {
pub lane: LaneID,
pub maneuver: Option<AllowedManeuvers>,
}
impl ConnectingLane {
pub fn new(lane: LaneID, maneuver: Option<AllowedManeuvers>) -> Self {
Self { lane, maneuver }
}
}
#[doc = "This DF is used to combine/connect multiple physical lanes (i.e. within intersections or road"]
#[doc = "segments). For signalized movements, the `connectsTo` data frame defines e.g. the relation between"]
#[doc = "ingress and egress lanes within an intersection. It describes the allowed manoeuvres and includes the"]
#[doc = "link (`signalGroup` identifier) between the @ref MapData and the @ref PAT message. The data frame is also used"]
#[doc = "to describe the relation of lanes within a non signalized intersection (e.g. ingress lanes which are"]
#[doc = "bypassing the conflict area and ending in an egress lane without signalization). Within a road segment,"]
#[doc = "it is used to combine two or multiple physical lanes into a single lane object."]
#[doc = "- @field connectingLane: "]
#[doc = "- @field remoteIntersection: When the data element `remoteIntersection` is used, it indicates"]
#[doc = " that the connecting lane belongs to another intersection. "]
#[doc = " (see clause [ISO TS 19091] G.9.1 for further explainations)."]
#[doc = "- @field signalGroup: "]
#[doc = "- @field userClass: "]
#[doc = "- @field connectionID: "]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct Connection {
#[rasn(identifier = "connectingLane")]
pub connecting_lane: ConnectingLane,
#[rasn(identifier = "remoteIntersection")]
pub remote_intersection: Option<IntersectionReferenceID>,
#[rasn(identifier = "signalGroup")]
pub signal_group: Option<SignalGroupID>,
#[rasn(identifier = "userClass")]
pub user_class: Option<RestrictionClassID>,
#[rasn(identifier = "connectionID")]
pub connection_id: Option<LaneConnectionID>,
}
impl Connection {
pub fn new(
connecting_lane: ConnectingLane,
remote_intersection: Option<IntersectionReferenceID>,
signal_group: Option<SignalGroupID>,
user_class: Option<RestrictionClassID>,
connection_id: Option<LaneConnectionID>,
) -> Self {
Self {
connecting_lane,
remote_intersection,
signal_group,
user_class,
connection_id,
}
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousConnectionManeuverAssistRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousConnectionManeuverAssistRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct ConnectionManeuverAssistRegional(
pub SequenceOf<AnonymousConnectionManeuverAssistRegional>,
);
#[doc = "This DF contains information about the the dynamic flow of traffic for the lane(s)"]
#[doc = "and maneuvers in question (as determined by the @ref LaneConnectionID). Note that this information can be sent regarding"]
#[doc = "any lane-to-lane movement; it need not be limited to the lanes with active (non-red) phases when sent."]
#[doc = "- @field connectionID: the common connectionID used by all lanes to which this data applies"]
#[doc = " (this value traces to ConnectsTo entries in lanes)"]
#[doc = "- @field queueLength: The distance from the stop line to the back edge of the last vehicle in the queue,"]
#[doc = " as measured along the lane center line. (Unit = 1 meter, 0 = no queue)"]
#[doc = "- @field availableStorageLength: Distance (e.g. beginning from the downstream stop-line up to a given distance) with a high"]
#[doc = " probability for successfully executing the connecting maneuver between the two lanes"]
#[doc = " during the current cycle."]
#[doc = " Used for enhancing the awareness of vehicles to anticipate if they can pass the stop line"]
#[doc = " of the lane. Used for optimizing the green wave, due to knowledge of vehicles waiting in front"]
#[doc = " of a red light (downstream)."]
#[doc = " The element nextTime in @ref TimeChangeDetails in the containing data frame contains the next"]
#[doc = " timemark at which an active phase is expected, a form of storage flush interval."]
#[doc = " (Unit = 1 meter, 0 = no space remains)"]
#[doc = "- @field waitOnStop: If true, the vehicles on this specific connecting"]
#[doc = " maneuver have to stop on the stop-line and not to enter the collision area"]
#[doc = "- @field pedBicycleDetect: true if ANY ped or bicycles are detected crossing the above lanes. Set to false ONLY if there is a"]
#[doc = " high certainty that there are none present, otherwise element is not sent."]
#[doc = "- @field regional: This data element includes additional data content @ref ConnectionManeuverAssist-addGrpC defined in"]
#[doc = " this profile (see [ISO TS 19091] G.5.1.1). The content is included using the regional extension framework as defined in"]
#[doc = " @ref ConnectionManeuverAssist-addGrpC is used for position feedback to moving ITS stations for executing"]
#[doc = " safe manoeuvres and is included for this purpose in the data element \"intersectionState\""]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct ConnectionManeuverAssist {
#[rasn(identifier = "connectionID")]
pub connection_id: LaneConnectionID,
#[rasn(identifier = "queueLength")]
pub queue_length: Option<ZoneLength>,
#[rasn(identifier = "availableStorageLength")]
pub available_storage_length: Option<ZoneLength>,
#[rasn(identifier = "waitOnStop")]
pub wait_on_stop: Option<WaitOnStopline>,
#[rasn(identifier = "pedBicycleDetect")]
pub ped_bicycle_detect: Option<PedestrianBicycleDetect>,
pub regional: Option<ConnectionManeuverAssistRegional>,
}
impl ConnectionManeuverAssist {
pub fn new(
connection_id: LaneConnectionID,
queue_length: Option<ZoneLength>,
available_storage_length: Option<ZoneLength>,
wait_on_stop: Option<WaitOnStopline>,
ped_bicycle_detect: Option<PedestrianBicycleDetect>,
regional: Option<ConnectionManeuverAssistRegional>,
) -> Self {
Self {
connection_id,
queue_length,
available_storage_length,
wait_on_stop,
ped_bicycle_detect,
regional,
}
}
}
#[doc = "This DF is used in the generic lane descriptions to provide a sequence of other defined"]
#[doc = "lanes to which each lane connects beyond its stop point. See the Connection data frame entry for details. Note that this"]
#[doc = "data frame is not used in some lane object types."]
#[doc = "\n\n@note: The assignment of lanes in the Connection structure shall start with the leftmost lane from the vehicle"]
#[doc = " perspective (the u-turn lane in some cases) followed by subsequent lanes in a clockwise assignment order. Therefore, the"]
#[doc = " rightmost lane to which this lane connects would always be listed last. Note that this order is observed regardless of which"]
#[doc = " side of the road vehicles use. If this structure is used in the lane description, then all valid lanes to which the subject lane"]
#[doc = " connects shall be listed."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct ConnectsToList(pub SequenceOf<Connection>);
#[doc = "The DSRC style date is a compound value consisting of finite-length sequences of integers (not characters) of the"]
#[doc = "form: \"yyyy, mm, dd, hh, mm, ss (sss+)\" - as defined below."]
#[doc = "\n\n@note: Note that some elements of this structure may not be sent when not needed. At least one element shall be present."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct DDateTime {
pub year: Option<DYear>,
pub month: Option<DMonth>,
pub day: Option<DDay>,
pub hour: Option<DHour>,
pub minute: Option<DMinute>,
pub second: Option<DSecond>,
pub offset: Option<DOffset>,
}
impl DDateTime {
pub fn new(
year: Option<DYear>,
month: Option<DMonth>,
day: Option<DDay>,
hour: Option<DHour>,
minute: Option<DMinute>,
second: Option<DSecond>,
offset: Option<DOffset>,
) -> Self {
Self {
year,
month,
day,
hour,
minute,
second,
offset,
}
}
}
#[doc = "The DSRC style day is a simple value consisting of integer values from zero to 31. The value of zero shall represent an unknown value."]
#[doc = "\n\n@unit: days"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=31"))]
pub struct DDay(pub u8);
#[doc = "The DSRC hour consists of integer values from zero to 23 representing the hours within a day. The value of 31 shall"]
#[doc = "represent an unknown value. The range 24 to 30 is used in some transit applications to represent schedule adherence."]
#[doc = "\n\n@unit: hours"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=31"))]
pub struct DHour(pub u8);
#[doc = "The DSRC style minute is a simple value consisting of integer values from zero to 59 representing the minutes"]
#[doc = "within an hour. The value of 60 shall represent an unknown value."]
#[doc = "\n\n@unit: minutes"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=60"))]
pub struct DMinute(pub u8);
#[doc = "The DSRC month consists of integer values from one to 12, representing the month within a year. The value of 0"]
#[doc = "shall represent an unknown value."]
#[doc = "\n\n@unit: months"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=12"))]
pub struct DMonth(pub u8);
#[doc = "The DSRC (time zone) offset consists of a signed integer representing an hour and minute value set from -14:00 to"]
#[doc = "+14:00, representing all the world’s local time zones in units of minutes. The value of zero (00:00) may also represent an"]
#[doc = "unknown value. Note some time zones are do not align to hourly boundaries."]
#[doc = "\n\n@unit: minutes from UTC time"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-840..=840"))]
pub struct DOffset(pub i16);
#[doc = "The DSRC second expressed in this DE consists of integer values from zero to 60999, representing the"]
#[doc = "milliseconds within a minute. A leap second is represented by the value range 60000 to 60999. The value of 65535 shall"]
#[doc = "represent an unavailable value in the range of the minute. The values from 61000 to 65534 are reserved."]
#[doc = "\n\n@unit: milliseconds"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct DSecond(pub u16);
#[doc = "The DSRC year consists of integer values from zero to 4095 representing the year according to the Gregorian"]
#[doc = "calendar date system. The value of zero shall represent an unknown value."]
#[doc = "\n\n@unit: years"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4095"))]
pub struct DYear(pub u16);
#[doc = "This DF is used to provide basic (static) information on how a map fragment was processed or determined."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct DataParameters {
#[rasn(size("1..=255"), identifier = "processMethod")]
pub process_method: Option<Ia5String>,
#[rasn(size("1..=255"), identifier = "processAgency")]
pub process_agency: Option<Ia5String>,
#[rasn(size("1..=255"), identifier = "lastCheckedDate")]
pub last_checked_date: Option<Ia5String>,
#[rasn(size("1..=255"), identifier = "geoidUsed")]
pub geoid_used: Option<Ia5String>,
}
impl DataParameters {
pub fn new(
process_method: Option<Ia5String>,
process_agency: Option<Ia5String>,
last_checked_date: Option<Ia5String>,
geoid_used: Option<Ia5String>,
) -> Self {
Self {
process_method,
process_agency,
last_checked_date,
geoid_used,
}
}
}
#[doc = "This DE provides the final angle used in the last point of the lane path. Used to \"cant\" the stop line of the lane."]
#[doc = "With an angle range from negative 150 to positive 150 in one degree steps where zero is directly"]
#[doc = "along the axis or the lane center line as defined by the two closest points."]
#[doc = "\n\n@unit: degree"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-150..=150"))]
pub struct DeltaAngle(pub i16);
#[doc = "This DE provides a time definition for an object's schedule adherence (typically a transit"]
#[doc = "vehicle) within a limited range of time. When the reporting object is ahead of schedule, a positive value is used; when"]
#[doc = "behind, a negative value is used. A value of zero indicates schedule adherence. This value is typically sent from a vehicle"]
#[doc = "to the traffic signal controller's RSU to indicate the urgency of a signal request in the context of being within schedule or"]
#[doc = "not. In another use case, the traffic signal controller may advise the transit vehicle to speed up (DeltaTime > 0) or to slow"]
#[doc = "down (DeltaTime < 0) to optimize the transit vehicle distribution driving along a specific route (e.g. a Bus route)."]
#[doc = "Supporting a range of +/- 20 minute in steps of 10 seconds:"]
#[doc = "- the value of `-121` shall be used when more than -20 minutes"]
#[doc = "- the value of `+120` shall be used when more than +20 minutes"]
#[doc = "- the value `-122` shall be used when the value is unavailable"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-122..=121"))]
pub struct DeltaTime(pub i8);
#[doc = "This DE is used in maps and intersections to provide a human readable and"]
#[doc = "recognizable name for the feature that follows. It is typically used when debugging a data flow and not in production use."]
#[doc = "One key exception to this general rule is to provide a human-readable string for disabled travelers in the case of"]
#[doc = "crosswalks and sidewalk lane objects."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=63"))]
pub struct DescriptiveName(pub Ia5String);
#[doc = "This DE is an integer value expressing the offset in a defined axis from a"]
#[doc = "reference lane number from which a computed lane is offset. The measurement is taken from the reference lane center"]
#[doc = "line to the new center line, independent of any width values. The units are a signed value with an LSB of 1 cm."]
#[doc = "\n\n@unit: cm"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-32767..=32767"))]
pub struct DrivenLineOffsetLg(pub i16);
#[doc = "The DrivenLineOffsetSmall data element is an integer value expressing the offset in a defined axis from a reference"]
#[doc = "lane number from which a computed lane is offset. The measurement is taken from the reference lane center line to the"]
#[doc = "new center line, independent of any width values. The units are a signed value with an LSB of 1 cm."]
#[doc = "\n\n@unit: cm"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-2047..=2047"))]
pub struct DrivenLineOffsetSm(pub i16);
#[doc = "This DE represents the geographic position above or below the reference ellipsoid (typically WGS-84)."]
#[doc = "The number has a resolution of 1 decimeter and represents an asymmetric range of positive and negative"]
#[doc = "values. Any elevation higher than +6143.9 meters is represented as +61439."]
#[doc = "Any elevation lower than -409.5 meters is represented as -4095."]
#[doc = "If the sending device does not know its elevation, it shall encode the Elevation data element with -4096."]
#[doc = "\n\n@note: When a vehicle is being measured, the elevation is taken from the horizontal spatial center of the vehicle"]
#[doc = " projected downward, regardless of vehicle tilt, to the point where the vehicle meets the road surface."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-4096..=61439"))]
pub struct Elevation(pub i32);
#[doc = "This DE is used to provide the 95% confidence level for the currently reported value of @ref Elevation,"]
#[doc = "taking into account the current calibration and precision of the sensor(s) used to measure and/or"]
#[doc = "calculate the value. This data element is only to provide the listener with information on the limitations of the sensing"]
#[doc = "system, not to support any type of automatic error correction or to imply a guaranteed maximum error. This data element"]
#[doc = "should not be used for fault detection or diagnosis, but if a vehicle is able to detect a fault, the confidence interval should"]
#[doc = "be increased accordingly. The frame of reference and axis of rotation used shall be in accordance with that defined in Section 11."]
#[doc = "- `unavailable` - 0: B'0000 Not Equipped or unavailable"]
#[doc = "- `elev-500-00` - 1: B'0001 (500 m)"]
#[doc = "- `elev-200-00` - 2: B'0010 (200 m)"]
#[doc = "- `elev-100-00` - 3: B'0011 (100 m)"]
#[doc = "- `elev-050-00` - 4: B'0100 (50 m)"]
#[doc = "- `elev-020-00` - 5: B'0101 (20 m)"]
#[doc = "- `elev-010-00` - 6: B'0110 (10 m)"]
#[doc = "- `elev-005-00` - 7: B'0111 (5 m)"]
#[doc = "- `elev-002-00` - 8: B'1000 (2 m)"]
#[doc = "- `elev-001-00` - 9: B'1001 (1 m)"]
#[doc = "- `elev-000-50` - 10: B'1010 (50 cm)"]
#[doc = "- `elev-000-20` - 11: B'1011 (20 cm)"]
#[doc = "- `elev-000-10` - 12: B'1100 (10 cm)"]
#[doc = "- `elev-000-05` - 13: B'1101 (5 cm)"]
#[doc = "- `elev-000-02` - 14: B'1110 (2 cm)"]
#[doc = "- `elev-000-01` - 15: B'1111 (1 cm)"]
#[doc = "\n\n@note: Encoded as a 4 bit value"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum ElevationConfidence {
unavailable = 0,
#[rasn(identifier = "elev-500-00")]
elev_500_00 = 1,
#[rasn(identifier = "elev-200-00")]
elev_200_00 = 2,
#[rasn(identifier = "elev-100-00")]
elev_100_00 = 3,
#[rasn(identifier = "elev-050-00")]
elev_050_00 = 4,
#[rasn(identifier = "elev-020-00")]
elev_020_00 = 5,
#[rasn(identifier = "elev-010-00")]
elev_010_00 = 6,
#[rasn(identifier = "elev-005-00")]
elev_005_00 = 7,
#[rasn(identifier = "elev-002-00")]
elev_002_00 = 8,
#[rasn(identifier = "elev-001-00")]
elev_001_00 = 9,
#[rasn(identifier = "elev-000-50")]
elev_000_50 = 10,
#[rasn(identifier = "elev-000-20")]
elev_000_20 = 11,
#[rasn(identifier = "elev-000-10")]
elev_000_10 = 12,
#[rasn(identifier = "elev-000-05")]
elev_000_05 = 13,
#[rasn(identifier = "elev-000-02")]
elev_000_02 = 14,
#[rasn(identifier = "elev-000-01")]
elev_000_01 = 15,
}
#[doc = "This DF is a sequence of lane IDs for lane objects that are activated in the current map"]
#[doc = "configuration. These lanes, unlike most lanes, have their RevocableLane bit set to one (asserted). Such lanes are not"]
#[doc = "considered to be part of the current map unless they are in the Enabled Lane List. This concept is used to describe all the"]
#[doc = "possible regulatory states for a given physical lane. For example, it is not uncommon to enable or disable the ability to"]
#[doc = "make a right hand turn on red during different periods of a day. Another similar example would be a lane which is used for"]
#[doc = "driving during one period and where parking is allowed at another. Traditionally, this information is conveyed to the vehicle"]
#[doc = "driver by local signage. By using the Enabled Lane List data frame in conjunction with the RevocableLane bit and"]
#[doc = "constructing a separate lane object in the intersection map for each different configuration, a single unified map can be"]
#[doc = "developed and used."]
#[doc = "Contents are the unique ID numbers for each lane object which is 'active' as part of the dynamic map contents."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct EnabledLaneList(pub SequenceOf<LaneID>);
#[doc = "This DE provides the type of fuel used by a vehicle."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15"))]
pub struct FuelType(pub u8);
#[doc = "A complete report of the vehicle's position, speed, and heading at an instant in time. Used in the probe vehicle"]
#[doc = "message (and elsewhere) as the initial position information. Often followed by other data frames that may provide offset"]
#[doc = "path data."]
#[doc = "- @field utcTime: time with mSec precision"]
#[doc = "- @field long: Longitude in 1/10th microdegree"]
#[doc = "- @field lat: Latitude in 1/10th microdegree"]
#[doc = "- @field elevation: Elevation in units of 0.1 m"]
#[doc = "- @field heading: Heading value "]
#[doc = "- @field speed: Speed value"]
#[doc = "- @field posAccuracy: position accuracy"]
#[doc = "- @field timeConfidence: time confidence"]
#[doc = "- @field posConfidence: position confidence"]
#[doc = "- @field speedConfidence: speed confidence "]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct FullPositionVector {
#[rasn(identifier = "utcTime")]
pub utc_time: Option<DDateTime>,
pub long: Longitude,
pub lat: Latitude,
pub elevation: Option<Elevation>,
pub heading: Option<HeadingDSRC>,
pub speed: Option<TransmissionAndSpeed>,
#[rasn(identifier = "posAccuracy")]
pub pos_accuracy: Option<PositionalAccuracy>,
#[rasn(identifier = "timeConfidence")]
pub time_confidence: Option<TimeConfidence>,
#[rasn(identifier = "posConfidence")]
pub pos_confidence: Option<PositionConfidenceSet>,
#[rasn(identifier = "speedConfidence")]
pub speed_confidence: Option<SpeedandHeadingandThrottleConfidence>,
}
impl FullPositionVector {
pub fn new(
utc_time: Option<DDateTime>,
long: Longitude,
lat: Latitude,
elevation: Option<Elevation>,
heading: Option<HeadingDSRC>,
speed: Option<TransmissionAndSpeed>,
pos_accuracy: Option<PositionalAccuracy>,
time_confidence: Option<TimeConfidence>,
pos_confidence: Option<PositionConfidenceSet>,
speed_confidence: Option<SpeedandHeadingandThrottleConfidence>,
) -> Self {
Self {
utc_time,
long,
lat,
elevation,
heading,
speed,
pos_accuracy,
time_confidence,
pos_confidence,
speed_confidence,
}
}
}
#[doc = "This DE is used to relate the current state of a GPS/GNSS rover or base system in terms"]
#[doc = "of its general health, lock on satellites in view, and use of any correction information. Various bits can be asserted (made"]
#[doc = "to a value of one) to reflect these values. A GNSS set with unknown health and no tracking or corrections would be"]
#[doc = "represented by setting the unavailable bit to one. A value of zero shall be used when a defined data element is"]
#[doc = "unavailable. The term \"GPS\" in any data element name in this standard does not imply that it is only to be used for GPS-"]
#[doc = "type GNSS systems."]
#[doc = "- `unavailable` - 0: Not Equipped or unavailable"]
#[doc = "- `isHealthy` - 1:"]
#[doc = "- `isMonitored` - 2:"]
#[doc = "- `baseStationType` - 3: Set to zero if a moving base station, or if a rover device (an OBU), Set to one if it is a fixed base station"]
#[doc = "- `aPDOPofUnder5` - 4: A dilution of precision greater than 5"]
#[doc = "- `inViewOfUnder5` - 5: Less than 5 satellites in view"]
#[doc = "- `localCorrectionsPresent` - 6: DGPS type corrections used"]
#[doc = "- `networkCorrectionsPresen` - 7: RTK type corrections used"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct GNSSstatus(pub FixedBitString<8usize>);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousGenericLaneRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousGenericLaneRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct GenericLaneRegional(pub SequenceOf<AnonymousGenericLaneRegional>);
#[doc = "This DF is used for all types of lanes, e.g. motorized vehicle lanes, crosswalks, medians. The"]
#[doc = "GenericLane describes the basic attribute information of the lane. The LaneID value for each lane is unique within an"]
#[doc = "intersection. One use for the LaneID is in the SPAT message, where a given signal or movement phase is mapped to a"]
#[doc = "set of applicable lanes using their respective LaneIDs. The NodeList2 data frame includes a sequence of offset points (or"]
#[doc = "node points) representing the center line path of the lane. As described in this standard, node points are sets of variable"]
#[doc = "sized delta orthogonal offsets from the prior point in the node path. (The initial point is offset from the LLH anchor point"]
#[doc = "used in the intersection.) Each node point may convey optional attribute data as well. The use of attributes is described"]
#[doc = "further in the Node definition, and in a later clause, but an example use would be to indicate a node point where the lane"]
#[doc = "width changes."]
#[doc = "It should be noted that a \"lane\" is an abstract concept that can describe objects other than motorized vehicle lanes, and"]
#[doc = "that the generic lane structure (using features drawn from Japanese usage) also allows combining multiple physical lanes"]
#[doc = "into a single lane object. In addition, such lanes can describe connectivity points with other lanes beyond a single"]
#[doc = "intersection, extending such a lane description over multiple nearby physical intersections and side streets which"]
#[doc = "themselves may not be equipped or assigned an index number in the regional intersection numbering system. (See the"]
#[doc = "ConnectsTo entry for details) This has value when describing a broader service area in terms of the roadway network,"]
#[doc = "probably with less precision and detail."]
#[doc = "- @field laneID: The unique ID number assigned to this lane object"]
#[doc = "- @field name: often for debug use only but at times used to name ped crossings"]
#[doc = "- @field ingressApproach: inbound Approach ID to which this lane belongs"]
#[doc = "- @field egressApproach: outbound Approach ID to which this lane belongs"]
#[doc = "- @field laneAttributes: All Attribute information about the basic selected lane type"]
#[doc = " Directions of use, Geometric co-sharing and Type Specific Attributes"]
#[doc = " These Attributes are 'lane - global' that is, they are true for the entire length of the lane"]
#[doc = "- @field maneuvers: This data element allows only the description of a subset of possible manoeuvres and therefore"]
#[doc = " reperesents an incomplete list of possible travel directions. The connecting `lane` data element gives"]
#[doc = " the exact information about the manoeuvre relation from ingress to egress lane. Therefore the"]
#[doc = " \"maneuver\" data element is used only additionally if the travel direction of the manoeuvre is"]
#[doc = "- @field nodeList: Lane spatial path information as well as various Attribute information along the node path"]
#[doc = " Attributes found here are more general and may come and go over the length of the lane."]
#[doc = "- @field connectsTo: a list of other lanes and their signal group IDs each connecting lane and its signal group ID"]
#[doc = " is given, therefore this element provides the information formerly in \"signalGroups\" in prior editions."]
#[doc = "- @field overlays: A list of any lanes which have spatial paths that overlay (run on top of, and not simply cross)"]
#[doc = " the path of this lane when used"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@note: The data elements `ingressApproach` and `egressApproach` are used for grouping lanes whin an"]
#[doc = " approach (e.g. lanes defined in travel direction towards the intersection, lanes in exiting direction and"]
#[doc = " cross walks). For a bidirectrional lane (e.g. bike lane) both dataelements are used for the same lane. The"]
#[doc = " integer value used for identifying the `ingressApproach` and the `egressAproach`, based on the"]
#[doc = " topology, may be e.g. the same for all lanes within an approach of an intersection."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct GenericLane {
#[rasn(identifier = "laneID")]
pub lane_id: LaneID,
pub name: Option<DescriptiveName>,
#[rasn(identifier = "ingressApproach")]
pub ingress_approach: Option<ApproachID>,
#[rasn(identifier = "egressApproach")]
pub egress_approach: Option<ApproachID>,
#[rasn(identifier = "laneAttributes")]
pub lane_attributes: LaneAttributes,
pub maneuvers: Option<AllowedManeuvers>,
#[rasn(identifier = "nodeList")]
pub node_list: NodeListXY,
#[rasn(identifier = "connectsTo")]
pub connects_to: Option<ConnectsToList>,
pub overlays: Option<OverlayLaneList>,
pub regional: Option<GenericLaneRegional>,
}
impl GenericLane {
pub fn new(
lane_id: LaneID,
name: Option<DescriptiveName>,
ingress_approach: Option<ApproachID>,
egress_approach: Option<ApproachID>,
lane_attributes: LaneAttributes,
maneuvers: Option<AllowedManeuvers>,
node_list: NodeListXY,
connects_to: Option<ConnectsToList>,
overlays: Option<OverlayLaneList>,
regional: Option<GenericLaneRegional>,
) -> Self {
Self {
lane_id,
name,
ingress_approach,
egress_approach,
lane_attributes,
maneuvers,
node_list,
connects_to,
overlays,
regional,
}
}
}
#[doc = "The DE_HeadingConfidence data element is used to provide the 95% confidence level for the currently reported"]
#[doc = "calculate the value. This data element is only to provide the listener with information on the limitations of the sensing"]
#[doc = "value of DE_Heading, taking into account the current calibration and precision of the sensor(s) used to measure and/or"]
#[doc = "system, not to support any type of automatic error correction or to imply a guaranteed maximum error. This data element"]
#[doc = "should not be used for fault detection or diagnosis, but if a vehicle is able to detect a fault, the confidence interval should"]
#[doc = "be increased accordingly. The frame of reference and axis of rotation used shall be in accordance with that defined Section 11."]
#[doc = "- `unavailable` - 0: B'000 Not Equipped or unavailable"]
#[doc = "- `prec10deg` - 1: B'010 10 degrees"]
#[doc = "- `prec05deg` - 2: B'011 5 degrees"]
#[doc = "- `prec01deg` - 3: B'100 1 degrees"]
#[doc = "- `prec0-1deg` - 4: B'101 0.1 degrees"]
#[doc = "- `prec0-05deg` - 5: B'110 0.05 degrees"]
#[doc = "- `prec0-01deg` - 6: B'110 0.01 degrees"]
#[doc = "- `prec0-0125deg` - 7: B'111 0.0125 degrees, aligned with heading LSB"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum HeadingConfidenceDSRC {
unavailable = 0,
prec10deg = 1,
prec05deg = 2,
prec01deg = 3,
#[rasn(identifier = "prec0-1deg")]
prec0_1deg = 4,
#[rasn(identifier = "prec0-05deg")]
prec0_05deg = 5,
#[rasn(identifier = "prec0-01deg")]
prec0_01deg = 6,
#[rasn(identifier = "prec0-0125deg")]
prec0_0125deg = 7,
}
#[doc = "This DE provides the current heading of the sending device, expressed in unsigned units of"]
#[doc = "0.0125 degrees from North such that 28799 such degrees represent 359.9875 degrees. North shall be defined as the axis"]
#[doc = "prescribed by the WGS-84 coordinate system and its reference ellipsoid. Headings \"to the east\" are defined as the"]
#[doc = "positive direction. A value of 28800 shall be used when unavailable. This element indicates the direction of motion of the"]
#[doc = "device. When the sending device is stopped and the trajectory (path) over which it traveled to reach that location is well"]
#[doc = "known, the past heading may be used."]
#[doc = "Value provides a range of 0 to 359.9875 degrees"]
#[doc = "\n\n@unit: Note that other heading data elements of various sizes and precisions are found in other parts of this standard"]
#[doc = " and in ITS. This element should no longer be used for new work: the @ref Angle entry is preferred."]
#[doc = "\n\n@unit: 0.0125 degrees"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=28800"))]
pub struct HeadingDSRC(pub u16);
#[doc = "This DF is used to specify the index of either a single approach or a single lane at"]
#[doc = "which a service is needed. This is used, for example, with the Signal Request Message (SRM) to indicate the inbound"]
#[doc = "and outbound points by which the requestor (such as a public safety vehicle) can traverse an intersection."]
#[doc = "- @field lane: the representation of the point as lane identifier."]
#[doc = "- @field approach: the representation of the point as approach identifier."]
#[doc = "- @field connection: the representation of the point as connection identifier."]
#[doc = "\n\n@note: Note that the value of zero has a reserved meaning for these two indexing systems. In both cases, this value"]
#[doc = " is used to indicate the concept of \"none\" in use. When the value is of zero is used here, it implies the center of the"]
#[doc = " intersection itself. For example, requesting an outbound point of zero implies the requestor wishes to have the intersection"]
#[doc = " itself be the destination. Alternatively, an inbound value of zero implies the requestor is within the intersection itself and"]
#[doc = " wishes to depart for the outbound value provided. This special meaning for the value zero can be used in either the lane"]
#[doc = " or approach with the same results."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum IntersectionAccessPoint {
lane(LaneID),
approach(ApproachID),
connection(LaneConnectionID),
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousIntersectionGeometryRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousIntersectionGeometryRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct IntersectionGeometryRegional(pub SequenceOf<AnonymousIntersectionGeometryRegional>);
#[doc = "A complete description of an intersection's roadway geometry and its allowed navigational paths (independent of"]
#[doc = "any additional regulatory restrictions that may apply over time or from user classification)."]
#[doc = "- @field name: For debug use only"]
#[doc = "- @field id: A globally unique value set, consisting of a regionID and intersection ID assignment"]
#[doc = "- @field revision: This profile extends the purpose of the `revision` data element as defined in SAE J2735 as follows."]
#[doc = " The revision data element is used to communicate the valid release of the intersection geometry"]
#[doc = " description. If there are no changes in the deployed intersection description, the same revision counter"]
#[doc = " is transmitted. Due to a revised deployment of the intersection description (e.g. new lane added, ID's"]
#[doc = " changed, etc.), the revision is increased by one. After revision equal to 127, the increment restarts by 0."]
#[doc = " The intersection geometry and the signal phase and timing information is related each other. Therefore,"]
#[doc = " the revision of the intersection geometry of the MapData message shall be the same as the revision of"]
#[doc = " the intersection state of the SPAT (see data element `revision` of `DF_IntersectionState` in [ISO TS 19091] G.8.2.9)"]
#[doc = "- @field refPoint: The reference from which subsequent data points are offset until a new point is used."]
#[doc = "- @field laneWidth: Reference width used by all subsequent lanes unless a new width is given"]
#[doc = "- @field speedLimits: Reference regulatory speed limits used by all subsequent lanes unless a new speed is given"]
#[doc = "- @field laneSet: Data about one or more lanes (all lane data is found here) Data describing how to use and request preemption and"]
#[doc = " priority services from this intersection (if supported)"]
#[doc = "- @field preemptPriorityData: This DF is not used."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct IntersectionGeometry {
pub name: Option<DescriptiveName>,
pub id: IntersectionReferenceID,
pub revision: MsgCount,
#[rasn(identifier = "refPoint")]
pub ref_point: Position3D,
#[rasn(identifier = "laneWidth")]
pub lane_width: Option<LaneWidth>,
#[rasn(identifier = "speedLimits")]
pub speed_limits: Option<SpeedLimitList>,
#[rasn(identifier = "laneSet")]
pub lane_set: LaneList,
#[rasn(identifier = "preemptPriorityData")]
pub preempt_priority_data: Option<PreemptPriorityList>,
pub regional: Option<IntersectionGeometryRegional>,
}
impl IntersectionGeometry {
pub fn new(
name: Option<DescriptiveName>,
id: IntersectionReferenceID,
revision: MsgCount,
ref_point: Position3D,
lane_width: Option<LaneWidth>,
speed_limits: Option<SpeedLimitList>,
lane_set: LaneList,
preempt_priority_data: Option<PreemptPriorityList>,
regional: Option<IntersectionGeometryRegional>,
) -> Self {
Self {
name,
id,
revision,
ref_point,
lane_width,
speed_limits,
lane_set,
preempt_priority_data,
regional,
}
}
}
#[doc = "This DF consists of a list of IntersectionGeometry entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct IntersectionGeometryList(pub SequenceOf<IntersectionGeometry>);
#[doc = "This DE is used within a region to uniquely define an intersection within that country or region in a 16-bit"]
#[doc = "field. Assignment rules are established by the regional authority associated with the RoadRegulatorID under which this"]
#[doc = "IntersectionID is assigned. Within the region the policies used to ensure an assigned value’s uniqueness before that value"]
#[doc = "is reused (if ever) is the responsibility of that region. Any such reuse would be expected to occur over a long epoch (many years)."]
#[doc = "The values zero through 255 are allocated for testing purposes"]
#[doc = "\n\n@note: Note that the value assigned to an intersection will be unique within a given regional ID only"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct IntersectionID(pub u16);
#[doc = "This DF conveys the combination of an optional RoadRegulatorID and of an"]
#[doc = "IntersectionID that is unique within that region. When the RoadRegulatorID is present the IntersectionReferenceID is"]
#[doc = "guaranteed to be globally unique."]
#[doc = "- @field region: a globally unique regional assignment value typical assigned to a regional DOT authority"]
#[doc = " the value zero shall be used for testing needs"]
#[doc = "- @field id: a unique mapping to the intersection in question within the above region of use"]
#[doc = "\n\n@note: A fully qualified intersection consists of its regionally unique ID (the IntersectionID) and its region ID (the"]
#[doc = " RoadRegulatorID). Taken together these form a unique value which is never repeated."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct IntersectionReferenceID {
pub region: Option<RoadRegulatorID>,
pub id: IntersectionID,
}
impl IntersectionReferenceID {
pub fn new(region: Option<RoadRegulatorID>, id: IntersectionID) -> Self {
Self { region, id }
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousIntersectionStateRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousIntersectionStateRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct IntersectionStateRegional(pub SequenceOf<AnonymousIntersectionStateRegional>);
#[doc = "This DF is used to convey all the SPAT information for a single intersection. Both current"]
#[doc = "and future data can be sent."]
#[doc = "- @field name: human readable name for intersection to be used only in debug mode"]
#[doc = "- @field id: A globally unique value set, consisting of a regionID and intersection ID assignment"]
#[doc = " provides a unique mapping to the intersection MAP in question which provides complete location"]
#[doc = " and approach/move/lane data"]
#[doc = "- @field revision: The data element `revision` is used to communicate the actual valid release of the intersection"]
#[doc = " description. If there are no changes in the deployed intersection description, almost the same revision"]
#[doc = " counter is transmitted. Due to a revised deployment of the intersection description (e.g. introduction of"]
#[doc = " additional signal state element), the revision is increased by one. After revision equal to 127, the"]
#[doc = " increment leads to 0 (due to the element range)."]
#[doc = " The intersection state and the intersection geometry is related to each other. Therefore, the revision of"]
#[doc = " the intersection state shall be the same as the revision of the intersection geometry (see the data"]
#[doc = " element `revision` of `DF_IntersectionGeometry` in [ISO TS 19091] G.8.2.6)."]
#[doc = "- @field status: general status of the controller(s)"]
#[doc = "- @field moy: Minute of current UTC year, used only with messages to be archived."]
#[doc = "- @field timeStamp: the mSec point in the current UTC minute that this message was constructed."]
#[doc = "- @field enabledLanes: a list of lanes where the RevocableLane bit has been set which are now active and"]
#[doc = " therefore part of the current intersection"]
#[doc = "- @field states: Each Movement is given in turn and contains its signal phase state,"]
#[doc = " mapping to the lanes it applies to, and point in time it will end, and it"]
#[doc = " may contain both active and future states"]
#[doc = "- @field maneuverAssistList: Assist data"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct IntersectionState {
pub name: Option<DescriptiveName>,
pub id: IntersectionReferenceID,
pub revision: MsgCount,
pub status: IntersectionStatusObject,
pub moy: Option<MinuteOfTheYear>,
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<DSecond>,
#[rasn(identifier = "enabledLanes")]
pub enabled_lanes: Option<EnabledLaneList>,
pub states: MovementList,
#[rasn(identifier = "maneuverAssistList")]
pub maneuver_assist_list: Option<ManeuverAssistList>,
pub regional: Option<IntersectionStateRegional>,
}
impl IntersectionState {
pub fn new(
name: Option<DescriptiveName>,
id: IntersectionReferenceID,
revision: MsgCount,
status: IntersectionStatusObject,
moy: Option<MinuteOfTheYear>,
time_stamp: Option<DSecond>,
enabled_lanes: Option<EnabledLaneList>,
states: MovementList,
maneuver_assist_list: Option<ManeuverAssistList>,
regional: Option<IntersectionStateRegional>,
) -> Self {
Self {
name,
id,
revision,
status,
moy,
time_stamp,
enabled_lanes,
states,
maneuver_assist_list,
regional,
}
}
}
#[doc = "This DF consists of a list of IntersectionState entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct IntersectionStateList(pub SequenceOf<IntersectionState>);
#[doc = "The Intersection Status Object contains Advanced Traffic Controller (ATC) status information that may be sent to"]
#[doc = "local OBUs as part of the SPAT process."]
#[doc = "With bits as defined:"]
#[doc = "- `manualControlIsEnabled` - 0: Timing reported is per programmed values, etc. but person at cabinet can manually request that certain intervals are terminated early (e.g. green)."]
#[doc = "- `stopTimeIsActivated` - 1: And all counting/timing has stopped."]
#[doc = "- `failureFlash` - 2: Above to be used for any detected hardware failures, e.g. conflict monitor as well as for police flash"]
#[doc = "- `fixedTimeOperation` - 5: Schedule of signals is based on time only (i.e. the state can be calculated)"]
#[doc = "- `trafficDependentOperation` - 6: Operation is based on different levels of traffic parameters (requests, duration of gaps or more complex parameters)"]
#[doc = "- `standbyOperation` - 7: Controller: partially switched off or partially amber flashing"]
#[doc = "- `failureMode` - 8: Controller has a problem or failure in operation"]
#[doc = "- `off` - 9: Controller is switched off"]
#[doc = "- `recentMAPmessageUpdate` - 10: Map revision with content changes"]
#[doc = "- `recentChangeInMAPassignedLanesIDsUsed` - 11: Change in MAP's assigned lanes used (lane changes) Changes in the active lane list description"]
#[doc = "- `noValidMAPisAvailableAtThisTime` - 12: MAP (and various lanes indexes) not available"]
#[doc = "- `noValidSPATisAvailableAtThisTime` - 13: SPAT system is not working at this time"]
#[doc = "- Bits 14,15 reserved at this time and shall be zero"]
#[doc = "\n\n@note: All zeros indicate normal operating mode with no recent changes. The duration of the term 'recent' is defined by the system performance requirement in use."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct IntersectionStatusObject(pub FixedBitString<16usize>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LaneAttributesRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl LaneAttributesRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = "This DF holds all of the constant attribute information of any lane object (as well as"]
#[doc = "denoting the basic lane type itself) within a single structure. Constant attribute information are those values which do not"]
#[doc = "change over the path of the lane, such as the direction of allowed travel. Other lane attribute information can change at or"]
#[doc = "between each node."]
#[doc = "The structure consists of three element parts as follows: LaneDirection specifies the allowed directions of travel, if any."]
#[doc = "LaneSharing indicates whether this lane type is shared with other types of travel modes or users. The lane type is defined"]
#[doc = "in LaneTypeAttributes, along with additional attributes specific to that type."]
#[doc = "The fundamental type of lane object is described by the element selected in the LaneTypeAttributes data concept."]
#[doc = "Additional information specific or unique to a given lane type can be found there as well. A regional extension is provided"]
#[doc = "as well."]
#[doc = "Note that combinations of regulatory maneuver information such as \"both a left turn and straight ahead movement are"]
#[doc = "allowed, but never a u-turn,\" are expressed by the AllowedManeuvers data concept which typically follows after this"]
#[doc = "element and in the same structure. Note that not all lane objects require this information (for example a median). The"]
#[doc = "various values are set via bit flags to indicate the assertion of a value. Each defined lane type contains the bit flags"]
#[doc = "suitable for its application area."]
#[doc = "Note that the concept of LaneSharing is used to indicate that there are other users of this lane with equal regulatory rights"]
#[doc = "to occupy the lane (which is a term this standard does not formally define since it varies by world region). A typical case is"]
#[doc = "a light rail vehicle running along the same lane path as motorized traffic. In such a case, motor traffic may be allowed"]
#[doc = "equal access to the lane when a train is not present. Another case would be those intersection lanes (at the time of writing"]
#[doc = "rather unusual) where bicycle traffic is given full and equal right of way to an entire width of motorized vehicle lane. This"]
#[doc = "example would not be a bike lane or bike box in the traditional sense."]
#[doc = "- @field directionalUse: directions of lane use"]
#[doc = "- @field sharedWith: co-users of the lane path"]
#[doc = "- @field laneType: specific lane type data"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct LaneAttributes {
#[rasn(identifier = "directionalUse")]
pub directional_use: LaneDirection,
#[rasn(identifier = "sharedWith")]
pub shared_with: LaneSharing,
#[rasn(identifier = "laneType")]
pub lane_type: LaneTypeAttributes,
pub regional: Option<LaneAttributesRegional>,
}
impl LaneAttributes {
pub fn new(
directional_use: LaneDirection,
shared_with: LaneSharing,
lane_type: LaneTypeAttributes,
regional: Option<LaneAttributesRegional>,
) -> Self {
Self {
directional_use,
shared_with,
lane_type,
regional,
}
}
}
#[doc = "This DE relates specific properties found in a Barrier or Median lane type (a type of lane object used to separate traffic lanes)."]
#[doc = "It should be noted that various common lane attribute properties (such as travel directions and allowed movements or maneuvers) can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `median-RevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- Bits 10-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Barrier")]
pub struct LaneAttributesBarrier(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a bicycle lane type. It should be noted that various common lane attribute properties"]
#[doc = "(such as travel directions and allowed movements or maneuvers) can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `bikeRevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- `pedestrianUseAllowed` - 1: The path allows pedestrian traffic, if not set, this mode is prohibited"]
#[doc = "- `isBikeFlyOverLane` - 2: path of lane is not at grade"]
#[doc = "- `fixedCycleTime` - 3: the phases use preset times, i.e. there is not a 'push to cross' button"]
#[doc = "- `biDirectionalCycleTimes` - 4: ped walk phases use different SignalGroupID for each direction. The first SignalGroupID in the first Connection"]
#[doc = " represents 'inbound' flow (the direction of travel towards the first node point) while second SignalGroupID in the"]
#[doc = " next Connection entry represents the 'outbound' flow. And use of RestrictionClassID entries in the Connect follow this same pattern in pairs."]
#[doc = "-`isolatedByBarrier` - 5: The lane path is isolated by a fixed barrier"]
#[doc = "-`unsignalizedSegmentsPresent` - 6: The lane path consists of one of more segments which are not part of a signal group ID"]
#[doc = "- Bits 7-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Bike")]
pub struct LaneAttributesBike(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a crosswalk lane type. It should be noted that various common lane attribute properties"]
#[doc = "(such as travel directions and allowed movements or maneuvers) can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `crosswalkRevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- `bicyleUseAllowed` - 1: The path allows bicycle traffic, if not set, this mode is prohibited"]
#[doc = "- `isXwalkFlyOverLane` - 2: path of lane is not at grade"]
#[doc = "- `fixedCycleTime` - 3: ped walk phases use preset times. i.e. there is not a 'push to cross' button"]
#[doc = "- `biDirectionalCycleTimes` - 4: ped walk phases use different SignalGroupID for each direction. The first SignalGroupID"]
#[doc = " in the first Connection represents 'inbound' flow (the direction of travel towards the first"]
#[doc = " node point) while second SignalGroupID in the next Connection entry represents the 'outbound'"]
#[doc = " flow. And use of RestrictionClassID entries in the Connect follow this same pattern in pairs."]
#[doc = "- `hasPushToWalkButton` - 5: Has a demand input"]
#[doc = "- `audioSupport` - 6: audio crossing cues present"]
#[doc = "- `rfSignalRequestPresent` - 7: Supports RF push to walk technologies"]
#[doc = "- `unsignalizedSegmentsPresent` - 8: The lane path consists of one of more segments which are not part of a signal group ID"]
#[doc = "- Bits 9-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Crosswalk")]
pub struct LaneAttributesCrosswalk(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a vehicle parking lane type. It should be noted that various common lane attribute"]
#[doc = "properties can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `parkingRevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- `doNotParkZone` - 3: used to denote fire hydrants as well as short disruptions in a parking zone"]
#[doc = "- `noPublicParkingUse` - 6: private parking, as in front of private property"]
#[doc = "- Bits 7-15 reserved and set to zero*"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Parking")]
pub struct LaneAttributesParking(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a sidewalk lane type. It should be noted that various common lane attribute properties"]
#[doc = "(such as travel directions and allowed movements or maneuvers) can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `sidewalk-RevocableLane`- 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present."]
#[doc = "- `bicyleUseAllowed` - 1: The path allows bicycle traffic, if not set, this mode is prohibited"]
#[doc = "- `isSidewalkFlyOverLane` - 2: path of lane is not at grade"]
#[doc = "- `walkBikes` - 3: bike traffic must dismount and walk"]
#[doc = "- Bits 4-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Sidewalk")]
pub struct LaneAttributesSidewalk(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in various types of ground striping lane"]
#[doc = "types. This includes various types of painted lane ground striping and iconic information needs to convey information in a"]
#[doc = "complex intersection. Typically, this consists of visual guidance for drivers to assist them to connect across the"]
#[doc = "intersection to the correct lane. Such markings are typically used with restraint and only under conditions when the"]
#[doc = "geometry of the intersection makes them more beneficial than distracting. It should be noted that various common lane"]
#[doc = "attribute properties (such as travel directions and allowed movements or maneuvers) can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `stripeToConnectingLanesRevocableLane` - 0: this lane may be activated or not activated based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- `stripeToConnectingLanesAhead` - 5: the stripe type should be presented to the user visually to reflect stripes in the intersection for the type of movement indicated."]
#[doc = "- Bits 6-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Striping")]
pub struct LaneAttributesStriping(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a tracked vehicle lane types (trolley"]
#[doc = "and train lanes). The term “rail vehicle” can be considered synonymous. In this case, the term does not relate to vehicle"]
#[doc = "types with tracks or treads. It should be noted that various common lane attribute properties (such as travel directions and"]
#[doc = "allowed movements or maneuvers) can be found in other entries. It should also be noted that often this type of lane object"]
#[doc = "does not clearly relate to an approach in the traditional traffic engineering sense, although the message set allows"]
#[doc = "assigning a value when desired."]
#[doc = "With bits as defined:"]
#[doc = "- `spec-RevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present."]
#[doc = "- Bits 5-15 reserved and set to zero"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-TrackedVehicle")]
pub struct LaneAttributesTrackedVehicle(pub FixedBitString<16usize>);
#[doc = "This DE relates specific properties found in a vehicle lane type. This data element provides a means to denote that the use of a lane"]
#[doc = "is restricted to certain vehicle types. Various common lane attribute properties (such as travel directions and allowed movements or maneuvers)"]
#[doc = "can be found in other entries."]
#[doc = "With bits as defined:"]
#[doc = "- `isVehicleRevocableLane` - 0: this lane may be activated or not based on the current SPAT message contents if not asserted, the lane is ALWAYS present"]
#[doc = "- `isVehicleFlyOverLane` - 1: path of lane is not at grade"]
#[doc = "- `permissionOnRequest` - 7: e.g. to inform about a lane for e-cars"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "LaneAttributes-Vehicle", size("8", extensible))]
pub struct LaneAttributesVehicle(pub BitString);
#[doc = "This DE is used to state a connection index for a lane to lane connection. It is used to"]
#[doc = "relate this connection between the lane (defined in the MAP) and any dynamic clearance data sent in the SPAT. It should"]
#[doc = "be noted that the index may be shared with other lanes (for example, two left turn lanes may share the same dynamic"]
#[doc = "clearance data). It should also be noted that a given lane to lane connection may be part of more than one GroupID due"]
#[doc = "to signal phase considerations, but will only have one ConnectionID. The ConnectionID concept is not used (is not"]
#[doc = "present) when dynamic clearance data is not provided in the SPAT."]
#[doc = "\n\n@note: It should be noted that the LaneConnectionID is used as a means to index to a connection description"]
#[doc = " between two lanes. It is not the same as the laneID, which is the unique index to each lane itself."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct LaneConnectionID(pub u8);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousLaneDataAttributeRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousLaneDataAttributeRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct LaneDataAttributeRegional(pub SequenceOf<AnonymousLaneDataAttributeRegional>);
#[doc = "This DF is used to relate an attribute and a control value at a node point or along a"]
#[doc = "lane segment from an enumerated list of defined choices. It is then followed by a defined data value associated with it and"]
#[doc = "which is defined elsewhere in this standard."]
#[doc = "- @field pathEndPointAngle: adjusts final point/width slant of the lane to align with the stop line"]
#[doc = "- @field laneCrownPointCenter: sets the canter of the road bed from centerline point"]
#[doc = "- @field laneCrownPointLeft: sets the canter of the road bed from left edge"]
#[doc = "- @field laneCrownPointRight: sets the canter of the road bed from right edge"]
#[doc = "- @field laneAngle: the angle or direction of another lane this is required when a merge point angle is required"]
#[doc = "- @field speedLimits: Reference regulatory speed limits used by all segments"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@note: This data concept handles a variety of use case needs with a common and consistent message pattern. The"]
#[doc = " typical use of this data concept (and several similar others) is to inject the selected Attribute into the spatial description of"]
#[doc = " a lane's center line path (the segment list). In this way, attribute information which is true for a portion of the overall lane"]
#[doc = " can be described when needed. This attribute information applies from the node point in the stream of segment data until"]
#[doc = " changed again. Denoting the porous aspects of a lane along its path as it merges with another lane would be an example"]
#[doc = " of this use case. In this case the start and end node points would be followed by suitable segment attributes. Re-using a"]
#[doc = " lane path (previously called a computed lane) is another example. In this case the reference lane to be re-used appears"]
#[doc = " as a segment attribute followed by the lane value. It is then followed by one or more segment attributes which relate the"]
#[doc = " positional translation factors to be used (offset, rotate, scale) and any further segment attribute changes."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum LaneDataAttribute {
pathEndPointAngle(DeltaAngle),
laneCrownPointCenter(RoadwayCrownAngle),
laneCrownPointLeft(RoadwayCrownAngle),
laneCrownPointRight(RoadwayCrownAngle),
laneAngle(MergeDivergeNodeAngle),
speedLimits(SpeedLimitList),
regional(LaneDataAttributeRegional),
}
#[doc = "This DF consists of a list of LaneDataAttribute entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8"))]
pub struct LaneDataAttributeList(pub SequenceOf<LaneDataAttribute>);
#[doc = "This DE is used to denote the allowed direction of travel over a lane object. By convention, the lane object is always described"]
#[doc = "from the stop line outwards away from the intersection. Therefore, the ingress direction is from the end of the path to the stop"]
#[doc = "line and the egress direction is from the stop line outwards."]
#[doc = "It should be noted that some lane objects are not used for travel and that some lane objects allow bi-directional travel."]
#[doc = "With bits as defined:"]
#[doc = "- Allowed directions of travel in the lane object"]
#[doc = "- All lanes are described from the stop line outwards"]
#[doc = "- @field ingressPath: travel from rear of path to front is allowed"]
#[doc = "- @field egressPath: travel from front of path to rear is allowed"]
#[doc = "\n\n@note: No Travel, i.e. the lane object type does not support travel (medians, curbs, etc.) is indicated by not"]
#[doc = " asserting any bit value Bi-Directional Travel (such as a ped crosswalk) is indicated by asserting both of the bits."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct LaneDirection(pub FixedBitString<2usize>);
#[doc = "This DE conveys an assigned index that is unique within an intersection. It is used to refer to"]
#[doc = "that lane by other objects in the intersection map data structure. Lanes may be ingress (inbound traffic) or egress"]
#[doc = "(outbound traffic) in nature, as well as barriers and other types of specialty lanes. Each lane (each lane object) is"]
#[doc = "assigned a unique ID. The Lane ID, in conjunction with the intersection ID, forms a regionally unique way to address a"]
#[doc = "specific lane in that region."]
#[doc = "- the value 0 shall be used when the lane ID is not available or not known"]
#[doc = "- the value 255 is reserved for future use"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct LaneID(pub u8);
#[doc = "This DF consists of a list of GenericLane entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=255"))]
pub struct LaneList(pub SequenceOf<GenericLane>);
#[doc = "This DE is used to denote the presence of other user types (travel modes) who have an"]
#[doc = "equal right to access and use the lane. There may also be another lane object describing their use of a lane. This data"]
#[doc = "concept is used to indicate lanes and/or users that travel along the same path, and not those that simply cross over the"]
#[doc = "lane's segments path (such as a pedestrian crosswalk crossing a lane for motor vehicle use). The typical use is to alert"]
#[doc = "the user of the MAP data that additional traffic of another mode may be present in the same spatial lane."]
#[doc = "Bits used:"]
#[doc = "- 0 - overlappingLaneDescriptionProvided: Assert when another lane object is present to describe the"]
#[doc = " path of the overlapping shared lane this construct is not used for lane objects which simply cross"]
#[doc = "- 1 - multipleLanesTreatedAsOneLane: Assert if the lane object path and width details represents multiple lanes within it"]
#[doc = " that are not further described Various modes and type of traffic that may share this lane:"]
#[doc = "- 2 - otherNonMotorizedTrafficTypes: horse drawn etc."]
#[doc = "- 3 - individualMotorizedVehicleTraffic:"]
#[doc = "- 4 - busVehicleTraffic:"]
#[doc = "- 5 - taxiVehicleTraffic:"]
#[doc = "- 6 - pedestriansTraffic:"]
#[doc = "- 7 - cyclistVehicleTraffic:"]
#[doc = "- 8 - trackedVehicleTraffic:"]
#[doc = "- 9 - pedestrianTraffic:"]
#[doc = "\n\n@note: All zeros would indicate `not shared` and `not overlapping`"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct LaneSharing(pub FixedBitString<10usize>);
#[doc = "This DF is used to hold attribute information specific to a given lane type. It is typically"]
#[doc = "used in the DE_LaneAttributes data frame as part of an overall description of a lane object. Information unique to the"]
#[doc = "specific type of lane is found here. Information common to lanes is expressed in other entries. The various values are set"]
#[doc = "by bit flags to indicate the assertion of a value. Each defined lane type contains bit flags suitable for its application area."]
#[doc = "- @field vehicle: motor vehicle lanes"]
#[doc = "- @field crosswalk: pedestrian crosswalks"]
#[doc = "- @field bikeLane: bike lanes"]
#[doc = "- @field sidewalk: pedestrian sidewalk paths"]
#[doc = "- @field median: medians & channelization"]
#[doc = "- @field striping: roadway markings"]
#[doc = "- @field trackedVehicle: trains and trolleys"]
#[doc = "- @field parking: parking and stopping lanes"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum LaneTypeAttributes {
vehicle(LaneAttributesVehicle),
crosswalk(LaneAttributesCrosswalk),
bikeLane(LaneAttributesBike),
sidewalk(LaneAttributesSidewalk),
median(LaneAttributesBarrier),
striping(LaneAttributesStriping),
trackedVehicle(LaneAttributesTrackedVehicle),
parking(LaneAttributesParking),
}
#[doc = "This DE conveys the width of a lane in LSB units of 1 cm. Maximum value for a lane is 327.67 meters in width"]
#[doc = "\n\n@units: cm"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=32767"))]
pub struct LaneWidth(pub u16);
#[doc = "Large @ref MapData descriptions are not possible to be broadcast with a single message and have to be"]
#[doc = "fragmented using two or more messages over the air. Therefore, the LayerID allows defining an"]
#[doc = "index for fragmentation of large @ref MapData descriptions. The fragmentation of the messages shall be"]
#[doc = "executed on application layer. The fragmentation occurs on an approach base. This means that almost a"]
#[doc = "complete approach (e.g. lanes, connectsTo, etc.) has to be included within a fragment."]
#[doc = "The decimal value of the `layerID` is used to define the amount of maximum @ref MapData fragments. The"]
#[doc = "lower value defines the actual fragment."]
#[doc = "Example:"]
#[doc = "If a MapData consists of three fragments (e.g. three approaches), the fragments are identified as follows:"]
#[doc = "- `31` - first fragment of three (e.g. approach south);"]
#[doc = "- `33` - third fragment of three (e.g. approach north)."]
#[doc = "- `32` - second fragment of three (e.g. approach west);"]
#[doc = "If there are only two fragments, the fragment identification will be 21, 22."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=100"))]
pub struct LayerID(pub u8);
#[doc = "This DE is used to uniquely identify the type of information to be found in a layer of a geographic map fragment such as an intersection."]
#[doc = "- @field `mixedContent`: two or more of the below types"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum LayerType {
none = 0,
mixedContent = 1,
generalMapData = 2,
intersectionData = 3,
curveData = 4,
roadwaySectionData = 5,
parkingAreaData = 6,
sharedLaneData = 7,
}
#[doc = "This DE is used to provide the R09 line information."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4294967295"))]
pub struct LineNumber(pub u32);
#[doc = "This DF consists of a list of @ref ConnectionManeuverAssist entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct ManeuverAssistList(pub SequenceOf<ConnectionManeuverAssist>);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousMapDataRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousMapDataRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct MapDataRegional(pub SequenceOf<AnonymousMapDataRegional>);
#[doc = "This DF is used to convey many types of geographic road information. At the current time its primary"]
#[doc = "use is to convey one or more intersection lane geometry maps within a single message. The map message content"]
#[doc = "includes such items as complex intersection descriptions, road segment descriptions, high speed curve outlines (used in"]
#[doc = "curve safety messages), and segments of roadway (used in some safety applications). A given single MapData message"]
#[doc = "may convey descriptions of one or more geographic areas or intersections. The contents of this message involve defining"]
#[doc = "the details of indexing systems that are in turn used by other messages to relate additional information (for example, the"]
#[doc = "signal phase and timing via the SPAT message) to events at specific geographic locations on the roadway."]
#[doc = "- @field timeStamp: time reference"]
#[doc = "- @field msgIssueRevision: The MapData revision is defined by the data element `revision` for each intersection"]
#[doc = " geometry (see [ISO TS 19091] G.8.2.4.1). Therefore, an additional revision indication of the overall"]
#[doc = " MapData message is not used in this profile. It shall be set to \"0\" for this profile."]
#[doc = "- @field layerType: There is no need to additionally identify the topological content by an additional identifier. The ASN.1"]
#[doc = " definition of the data frames `intersections` and `roadSegments` are clearly defined and need no"]
#[doc = " additional identifier. Therefore, this optional data element shall not be used in this profile."]
#[doc = "- @field layerID: This profile extends the purpose of the `layerID` data element as defined in SAE J2735 as follows: For"]
#[doc = " large intersections, the length of a MapData description may exceed the maximum data length of the"]
#[doc = " communication message. Therefore, a fragmentation of the MapData message (at application layer) in"]
#[doc = " two or more MapData fragments may be executed. If no MapData fragmentation is needed, the `layerID`"]
#[doc = " shall not be used. For more details, see the definition of the data element @ref LayerID."]
#[doc = "- @field intersections: All Intersection definitions."]
#[doc = "- @field roadSegments: All roadway descriptions."]
#[doc = "- @field dataParameters: Any meta data regarding the map contents."]
#[doc = "- @field restrictionList: Any restriction ID tables which have established for these map entries"]
#[doc = "- @field regional: This profile extends the MapData message with the regional data element @ref MapData-addGrpC"]
#[doc = "\n\n@category: Road topology information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct MapData {
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<MinuteOfTheYear>,
#[rasn(identifier = "msgIssueRevision")]
pub msg_issue_revision: MsgCount,
#[rasn(identifier = "layerType")]
pub layer_type: Option<LayerType>,
#[rasn(identifier = "layerID")]
pub layer_id: Option<LayerID>,
pub intersections: Option<IntersectionGeometryList>,
#[rasn(identifier = "roadSegments")]
pub road_segments: Option<RoadSegmentList>,
#[rasn(identifier = "dataParameters")]
pub data_parameters: Option<DataParameters>,
#[rasn(identifier = "restrictionList")]
pub restriction_list: Option<RestrictionClassList>,
pub regional: Option<MapDataRegional>,
}
impl MapData {
pub fn new(
time_stamp: Option<MinuteOfTheYear>,
msg_issue_revision: MsgCount,
layer_type: Option<LayerType>,
layer_id: Option<LayerID>,
intersections: Option<IntersectionGeometryList>,
road_segments: Option<RoadSegmentList>,
data_parameters: Option<DataParameters>,
restriction_list: Option<RestrictionClassList>,
regional: Option<MapDataRegional>,
) -> Self {
Self {
time_stamp,
msg_issue_revision,
layer_type,
layer_id,
intersections,
road_segments,
data_parameters,
restriction_list,
regional,
}
}
}
#[doc = "The angle at which another lane path meets the current lanes at the node point. Typically found in the node"]
#[doc = "attributes and used to describe the angle of the departing or merging lane. Note that oblique and obtuse angles are allowed."]
#[doc = "The value `-180` shall be used to represent data is not available or unknown"]
#[doc = "\n\n@unit: 1.5 degrees from north"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-180..=180"))]
pub struct MergeDivergeNodeAngle(pub i16);
#[doc = "This DE expresses the number of elapsed minutes of the current year in the time system being used (typically UTC time)."]
#[doc = "It is typically used to provide a longer range time stamp indicating when a message was created."]
#[doc = "Taken together with the DSecond data element, it provides a range of one full year with a resolution of 1 millisecond."]
#[doc = "The value 527040 shall be used for invalid."]
#[doc = "\n\n@note: It should be noted that at the yearly roll-over point there is no \"zero\" minute, in the same way that there was"]
#[doc = " never a \"year zero\" at the very start of the common era (BC -> AD). By using the number of elapsed whole minutes here"]
#[doc = " this issue is avoided and the first valid value of every new year is zero, followed by one, etc. Leap years are"]
#[doc = " accommodated, as are leap seconds in the DSecond data concept."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=527040"))]
pub struct MinuteOfTheYear(pub u32);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousMovementEventRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousMovementEventRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct MovementEventRegional(pub SequenceOf<AnonymousMovementEventRegional>);
#[doc = "This DF contains details about a single movement. It is used by the movement state to"]
#[doc = "convey one of number of movements (typically occurring over a sequence of times) for a SignalGroupID."]
#[doc = "- @field eventState: Consisting of: Phase state (the basic 11 states), Directional, protected, or permissive state"]
#[doc = "- @field timing: Timing Data in UTC time stamps for event includes start and min/max end times of phase confidence and estimated next occurrence"]
#[doc = "- @field speeds: various speed advisories for use by general and specific types of vehicles supporting green-wave and other flow needs"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct MovementEvent {
#[rasn(identifier = "eventState")]
pub event_state: MovementPhaseState,
pub timing: Option<TimeChangeDetails>,
pub speeds: Option<AdvisorySpeedList>,
pub regional: Option<MovementEventRegional>,
}
impl MovementEvent {
pub fn new(
event_state: MovementPhaseState,
timing: Option<TimeChangeDetails>,
speeds: Option<AdvisorySpeedList>,
regional: Option<MovementEventRegional>,
) -> Self {
Self {
event_state,
timing,
speeds,
regional,
}
}
}
#[doc = "This DF consists of a list of @ref MovementEvent entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct MovementEventList(pub SequenceOf<MovementEvent>);
#[doc = "This DF consists of a list of @ref MovementState entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=255"))]
pub struct MovementList(pub SequenceOf<MovementState>);
#[doc = "This DE provides the overall current state of the movement (in many cases a signal state), including its core phase state"]
#[doc = " and an indication of whether this state is permissive or protected."]
#[doc = "It is expected that the allowed transitions from one state to another will be defined by regional deployments. Not all"]
#[doc = "regions will use all states; however, no new states are to be defined. In most regions a regulatory body provides precise"]
#[doc = "legal definitions of these state changes. For example, in the US the MUTCD is used, as is indicated in the US regional"]
#[doc = "variant of the above image. In various regions and modes of transportation, the visual expression of these states varies"]
#[doc = "(the precise meaning of various color combinations, shapes, and/or flashing etc.). The below definition is designed to to"]
#[doc = "be independent of these regional conventions."]
#[doc = "Values:"]
#[doc = "- `unavailable` - 0: This state is used for unknown or error"]
#[doc = "- `dark` - 1: The signal head is dark (unlit)"]
#[doc = "- `stop-Then-Proceed` - 2: Often called 'flashing red'"]
#[doc = " Driver Action:"]
#[doc = " - Stop vehicle at stop line."]
#[doc = " - Do not proceed unless it is safe."]
#[doc = " Note that the right to proceed either right or left when it is safe may be contained in the lane description to"]
#[doc = " handle what is called a 'right on red'"]
#[doc = "- `stop-And-Remain` - 3: e.g. called 'red light'"]
#[doc = " Driver Action:"]
#[doc = " - Stop vehicle at stop line."]
#[doc = " - Do not proceed."]
#[doc = " Note that the right to proceed either right or left when it is safe may be contained in the lane description to"]
#[doc = " handle what is called a 'right on red'"]
#[doc = "- `pre-Movement` - 4: Not used in the US, red+yellow partly in EU"]
#[doc = " Driver Action:"]
#[doc = " - Stop vehicle."]
#[doc = " - Prepare to proceed (pending green)"]
#[doc = " - (Prepare for transition to green/go)"]
#[doc = "- `permissive-Movement-Allowed` - 5: Often called 'permissive green'"]
#[doc = " Driver Action:"]
#[doc = " - Proceed with caution,"]
#[doc = " - must yield to all conflicting traffic"]
#[doc = " Conflicting traffic may be present in the intersection conflict area"]
#[doc = "- `protected-Movement-Allowed` - 6: Often called 'protected green'"]
#[doc = " Driver Action:"]
#[doc = " - Proceed, tossing caution to the wind, in indicated (allowed) direction."]
#[doc = "- `permissive-clearance` - 7: Often called 'permissive yellow'."]
#[doc = " The vehicle is not allowed to cross the stop bar if it is possible"]
#[doc = " to stop without danger."]
#[doc = " Driver Action:"]
#[doc = " - Prepare to stop."]
#[doc = " - Proceed if unable to stop,"]
#[doc = " - Clear Intersection."]
#[doc = " Conflicting traffic may be present in the intersection conflict area"]
#[doc = "- `protected-clearance` - 8: Often called 'protected yellow'"]
#[doc = " Driver Action:"]
#[doc = " - Prepare to stop."]
#[doc = " - Proceed if unable to stop, in indicated direction (to connected lane)"]
#[doc = " - Clear Intersection."]
#[doc = "- `caution-Conflicting-Traffic` - 9: Often called 'flashing yellow'"]
#[doc = " Often used for extended periods of time"]
#[doc = " Driver Action:"]
#[doc = " - Proceed with caution,"]
#[doc = " Conflicting traffic may be present in the intersection conflict area"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum MovementPhaseState {
unavailable = 0,
dark = 1,
#[rasn(identifier = "stop-Then-Proceed")]
stop_Then_Proceed = 2,
#[rasn(identifier = "stop-And-Remain")]
stop_And_Remain = 3,
#[rasn(identifier = "pre-Movement")]
pre_Movement = 4,
#[rasn(identifier = "permissive-Movement-Allowed")]
permissive_Movement_Allowed = 5,
#[rasn(identifier = "protected-Movement-Allowed")]
protected_Movement_Allowed = 6,
#[rasn(identifier = "permissive-clearance")]
permissive_clearance = 7,
#[rasn(identifier = "protected-clearance")]
protected_clearance = 8,
#[rasn(identifier = "caution-Conflicting-Traffic")]
caution_Conflicting_Traffic = 9,
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousMovementStateRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousMovementStateRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct MovementStateRegional(pub SequenceOf<AnonymousMovementStateRegional>);
#[doc = "This DF is used to convey various information about the current or future movement state of"]
#[doc = "a designated collection of one or more lanes of a common type. This is referred to as the GroupID. Note that lane object"]
#[doc = "types supported include both motorized vehicle lanes as well as pedestrian lanes and dedicated rail and transit lanes. Of"]
#[doc = "the reported data elements, the time to change (the time remaining in the current state) is often of the most value. Lanes"]
#[doc = "with a common state (typically adjacent sets of lanes in an approach) in a signalized intersection will have individual lane"]
#[doc = "values such as total vehicle counts, summed. It is used in the SPAT message to convey every active movement in a"]
#[doc = "given intersection so that vehicles, when combined with certain map information, can determine the state of the signal phases."]
#[doc = "- @field movementName: uniquely defines movement by name human readable name for intersection to be used only in debug mode."]
#[doc = "- @field signalGroup: is used to map to lists of lanes (and their descriptions) which this MovementState data applies to."]
#[doc = "- @field state-time-speed: Consisting of sets of movement data with @ref SignalPhaseState, @ref TimeChangeDetail and @ref AdvisorySpeed"]
#[doc = " *Note:* one or more of the movement events may be for a future time and that this allows conveying multiple"]
#[doc = " predictive phase and movement timing for various uses for the current signal group."]
#[doc = "- @field maneuverAssistList: This information may also be placed in the @ref IntersectionState when common information applies to different lanes in the same way"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@note: Note that the value given for the time to change will vary in many actuated signalized intersections based on"]
#[doc = " the sensor data received during the phase. The data transmitted always reflects the then most current timemark value"]
#[doc = " (which is the point in UTC time when the change will occur). As an example, in a phase which may vary from 15 to 25"]
#[doc = " seconds of duration based on observed traffic flows, a time to change value of 15 seconds in the future might be"]
#[doc = " transmitted for many consecutive seconds (and the time mark value extended for as much as 10 seconds depending on"]
#[doc = " the extension time logic used by the controller before it either times out or gaps out), followed by a final time mark value"]
#[doc = " reflecting the decreasing values as the time runs out, presuming the value was not again extended to a new time mark"]
#[doc = " due to other detection events. The time to change element can therefore generally be regarded as a guaranteed minimum"]
#[doc = " value of the time that will elapse unless a preemption event occurs."]
#[doc = " In use, the @ref SignalGroupID element is matched to lanes that are members of that ID. The type of lane (vehicle, crosswalk,"]
#[doc = " etc.) is known by the lane description as well as its allowed maneuvers and any vehicle class restrictions. Every lane type"]
#[doc = " is treated the same way (cross walks map to suitable meanings, etc.). Lane objects which are not part of the sequence of"]
#[doc = " signalized lanes do not appear in any GroupID. The visual details of how a given signal phase is presented to a mobile"]
#[doc = " user will vary based on lane type and with regional conventions. Not all signal states will be used in all regional"]
#[doc = " deployments. For example, a pre-green visual indication is not generally found in US deployments. Under such operating"]
#[doc = " conditions, the unused phase states are simply skipped."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct MovementState {
#[rasn(identifier = "movementName")]
pub movement_name: Option<DescriptiveName>,
#[rasn(identifier = "signalGroup")]
pub signal_group: SignalGroupID,
#[rasn(identifier = "state-time-speed")]
pub state_time_speed: MovementEventList,
#[rasn(identifier = "maneuverAssistList")]
pub maneuver_assist_list: Option<ManeuverAssistList>,
pub regional: Option<MovementStateRegional>,
}
impl MovementState {
pub fn new(
movement_name: Option<DescriptiveName>,
signal_group: SignalGroupID,
state_time_speed: MovementEventList,
maneuver_assist_list: Option<ManeuverAssistList>,
regional: Option<MovementStateRegional>,
) -> Self {
Self {
movement_name,
signal_group,
state_time_speed,
maneuver_assist_list,
regional,
}
}
}
#[doc = "This DE is used to provide a sequence number within a stream of messages with the same DSRCmsgID and from the same sender."]
#[doc = "A sender may initialize this element to any value in the range 0-127 when sending the first message with a given DSRCmsgID,"]
#[doc = "or if the sender has changed identity (e.g. by changing its TemporaryID) since sending the most recent message with that DSRCmsgID."]
#[doc = "Depending on the application the sequence number may change with every message or may remain fixed during a stream of messages when the content within each"]
#[doc = "message has not changed from the prior message sent. For this element, the value after 127 is zero."]
#[doc = "The receipt of a non-sequential MsgCount value (from the same sending device and message type) implies that one or"]
#[doc = "more messages from that sending device may have been lost, unless MsgCount has been re-initialized due to an identity"]
#[doc = "change."]
#[doc = "\n\n@note: In the absence of additional requirements defined in a standard using this data element, the follow guidelines shall be used."]
#[doc = "In usage, some devices change their Temporary ID frequently, to prevent identity tracking, while others do not. A change"]
#[doc = "in Temporary ID data element value (which also changes the message contents in which it appears) implies that the"]
#[doc = "MsgCount may also change value."]
#[doc = "If a sender is composing a message with new content with a given DSRCmsgID, and the TemporaryID has not changed"]
#[doc = "since it sent the previous message, the sender shall increment the previous value."]
#[doc = "If a sender is composing a message with new content with a given DSRCmsgID, and the TemporaryID has changed since"]
#[doc = "it sent the previous message, the sender may set the MsgCount element to any valid value in the range (including"]
#[doc = "incrementing the previous value)."]
#[doc = "If a sender is composing a message with the same content as the most recent message with the same DSRCmsgID, and"]
#[doc = "less than 10 seconds have elapsed since it sent the previous message with that DSRCmsgID, the sender will use the"]
#[doc = "same MsgCount as sent in the previous message."]
#[doc = "If a sender is composing a message with the same content as the most recent message with the same DSRCmsgID, and"]
#[doc = "at least 10 seconds have elapsed since it sent the previous message with that DSRCmsgID, the sender may set the"]
#[doc = "MsgCount element to any valid value in the range; this includes the re-use of the previous value."]
#[doc = "If a sending device sends more than one stream of messages from message types that utilize the MsgCount element, it"]
#[doc = "shall maintain a separate MsgCount state for each message type so that the MsgCount value in a given message"]
#[doc = "identifies its place in the stream of that message type. The MsgCount element is a function only of the message type in a"]
#[doc = "given sending device, not of the one or more applications in that device which may be sending the same type of message."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=127"))]
pub struct MsgCount(pub u8);
#[doc = "A 64-bit node type with lat-long values expressed in one tenth of a micro degree."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-LLmD-64b")]
pub struct NodeLLmD64b {
pub lon: Longitude,
pub lat: Latitude,
}
impl NodeLLmD64b {
pub fn new(lon: Longitude, lat: Latitude) -> Self {
Self { lon, lat }
}
}
#[doc = "A 20-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-20b")]
pub struct NodeXY20b {
pub x: OffsetB10,
pub y: OffsetB10,
}
impl NodeXY20b {
pub fn new(x: OffsetB10, y: OffsetB10) -> Self {
Self { x, y }
}
}
#[doc = "A 22-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-22b")]
pub struct NodeXY22b {
pub x: OffsetB11,
pub y: OffsetB11,
}
impl NodeXY22b {
pub fn new(x: OffsetB11, y: OffsetB11) -> Self {
Self { x, y }
}
}
#[doc = "A 24-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-24b")]
pub struct NodeXY24b {
pub x: OffsetB12,
pub y: OffsetB12,
}
impl NodeXY24b {
pub fn new(x: OffsetB12, y: OffsetB12) -> Self {
Self { x, y }
}
}
#[doc = "A 26-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-26b")]
pub struct NodeXY26b {
pub x: OffsetB13,
pub y: OffsetB13,
}
impl NodeXY26b {
pub fn new(x: OffsetB13, y: OffsetB13) -> Self {
Self { x, y }
}
}
#[doc = "A 28-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-28b")]
pub struct NodeXY28b {
pub x: OffsetB14,
pub y: OffsetB14,
}
impl NodeXY28b {
pub fn new(x: OffsetB14, y: OffsetB14) -> Self {
Self { x, y }
}
}
#[doc = "A 32-bit node type with offset values from the last point in X and Y."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Node-XY-32b")]
pub struct NodeXY32b {
pub x: OffsetB16,
pub y: OffsetB16,
}
impl NodeXY32b {
pub fn new(x: OffsetB16, y: OffsetB16) -> Self {
Self { x, y }
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousNodeAttributeSetXYRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousNodeAttributeSetXYRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct NodeAttributeSetXYRegional(pub SequenceOf<AnonymousNodeAttributeSetXYRegional>);
#[doc = "All the node attributes defined in this DF are valid in the direction of"]
#[doc = "node declaration and not in driving direction (i.e. along the sequence of the declared nodes). E.g. node"]
#[doc = "attributes of an `ingress` or an `egress` lane are defined from the conflict area (first node) to the"]
#[doc = "outside of the intersection (last node). Node attributes with ‘left’ and ‘right’ in their name are also"]
#[doc = "defined in the direction of the node declaration. This allows using attributes in a unambigious way also"]
#[doc = "for lanes with biderctional driving. See the following attribuets examples for additianl explanations."]
#[doc = "- @field localNode: Attribute states which pertain to this node point"]
#[doc = "- @field disabled: Attribute states which are disabled at this node point"]
#[doc = "- @field enabled: Attribute states which are enabled at this node point and which remain enabled until disabled or the lane ends"]
#[doc = "- @field data: Attributes which require an additional data values some of these are local to the node point, while others"]
#[doc = " persist with the provided values until changed and this is indicated in each entry"]
#[doc = "- @field dWidth: A value added to the current lane width at this node and from this node onwards, in 1cm steps"]
#[doc = " lane width between nodes are a linear taper between pts the value of zero shall not be sent here."]
#[doc = "- @field dElevation: A value added to the current Elevation at this node from this node onwards, in 10cm steps"]
#[doc = " elevations between nodes are a linear taper between pts the value of zero shall not be sent here"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct NodeAttributeSetXY {
#[rasn(identifier = "localNode")]
pub local_node: Option<NodeAttributeXYList>,
pub disabled: Option<SegmentAttributeXYList>,
pub enabled: Option<SegmentAttributeXYList>,
pub data: Option<LaneDataAttributeList>,
#[rasn(identifier = "dWidth")]
pub d_width: Option<OffsetB10>,
#[rasn(identifier = "dElevation")]
pub d_elevation: Option<OffsetB10>,
pub regional: Option<NodeAttributeSetXYRegional>,
}
impl NodeAttributeSetXY {
pub fn new(
local_node: Option<NodeAttributeXYList>,
disabled: Option<SegmentAttributeXYList>,
enabled: Option<SegmentAttributeXYList>,
data: Option<LaneDataAttributeList>,
d_width: Option<OffsetB10>,
d_elevation: Option<OffsetB10>,
regional: Option<NodeAttributeSetXYRegional>,
) -> Self {
Self {
local_node,
disabled,
enabled,
data,
d_width,
d_elevation,
regional,
}
}
}
#[doc = "This DE is an enumerated list of attributes which can pertain to the current node"]
#[doc = "point. The 'scope' of these values is limited to the node itself. That is, unlike other types of attributes which can be"]
#[doc = "switched on or off at any given node (and hence pertains to one or more segments), the DE_NodeAttribute is local to the"]
#[doc = "node in which it is found. These attributes are all binary flags in that they do not need to convey any additional data. Other"]
#[doc = "attributes allow sending short data values to reflect a setting which is set and persists in a similar fashion."]
#[doc = " - reserved: do not use"]
#[doc = " - stopLine: point where a mid-path stop line exists. See also 'do not block' for segments"]
#[doc = " - roundedCapStyleA: Used to control final path rounded end shape with edge of curve at final point in a circle"]
#[doc = " - roundedCapStyleB: Used to control final path rounded end shape with edge of curve extending 50% of width past final point in a circle"]
#[doc = " - mergePoint: merge with 1 or more lanes"]
#[doc = " - divergePoint: diverge with 1 or more lanes"]
#[doc = " - downstreamStopLine: downstream intersection (a 2nd intersection) stop line"]
#[doc = " - downstreamStartNode: downstream intersection (a 2nd intersection) start node"]
#[doc = " - closedToTraffic: where a pedestrian may NOT go to be used during construction events"]
#[doc = " - safeIsland: a pedestrian safe stopping point also called a traffic island"]
#[doc = " This usage described a point feature on a path, other entries can describe a path"]
#[doc = " - curbPresentAtStepOff: the sidewalk to street curb is NOT angled where it meets the edge of the roadway (user must step up/down)"]
#[doc = " - hydrantPresent: Or other services access"]
#[doc = "\n\n@note: See usage examples in [ISO TS 19091] G.8.2.8"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum NodeAttributeXY {
reserved = 0,
stopLine = 1,
roundedCapStyleA = 2,
roundedCapStyleB = 3,
mergePoint = 4,
divergePoint = 5,
downstreamStopLine = 6,
downstreamStartNode = 7,
closedToTraffic = 8,
safeIsland = 9,
curbPresentAtStepOff = 10,
hydrantPresent = 11,
}
#[doc = "This DF consists of a list of @ref NodeAttributeXY entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8"))]
pub struct NodeAttributeXYList(pub SequenceOf<NodeAttributeXY>);
#[doc = "This DF provides the sequence of signed offset node point values for determining the Xs and Ys"]
#[doc = "(and possibly Width or Zs when present), using the then current Position3D object to build a path for the centerline of"]
#[doc = "the subject lane type. Each X,Y point is referred to as a Node Point. The straight line paths between these points are"]
#[doc = "referred to as Segments."]
#[doc = "All nodes may have various optional attributes the state of which can vary along the path and which are enabled and"]
#[doc = "disabled by the sequence of objects found in the list of node structures. Refer to the explanatory text in Section 11 for a"]
#[doc = "description of how to correctly encode and decode this type of the data element. As a simple example, a motor vehicle"]
#[doc = "lane may have a section of the overall lane path marked \"do not block\", indicating that vehicles should not come to a stop"]
#[doc = "and remain in that region. This is encoded in the Node data structures by an element in one node to indicate the start of"]
#[doc = "the \"do not block\" lane attributes at a given offset, and then by a termination element when this attribute is set false. Other"]
#[doc = "types of elements in the segment choice allow inserting attributes containing data values affecting the segment or the"]
#[doc = "node."]
#[doc = "- @field nodes: a lane made up of two or more XY node points and any attributes defined in those nodes"]
#[doc = "- @field computed: a lane path computed by translating the data defined by another lane"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum NodeListXY {
nodes(NodeSetXY),
computed(ComputedLane),
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct NodeOffsetPointXYRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl NodeOffsetPointXYRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = "This DF presents a structure to hold different sized data frames for a single node"]
#[doc = "point in a lane. Nodes are described in terms of X and Y offsets in units of 1 centimeter (when zoom is 1:1). Changes in"]
#[doc = "elevation and in the lane width can be expressed in a similar way with the optional Attributes data entry which appears"]
#[doc = "alongside the NodeOffsetPoint in use."]
#[doc = "The choice of which node type is driven by the magnitude (size) of the offset data to be encoded. When the distance from"]
#[doc = "the last node point is smaller, the smaller entries can (and should) be chosen"]
#[doc = "Each single selected node is computed as an X and Y offset from the prior node point unless one of the entries reflecting"]
#[doc = "a complete lat-long representation is selected. In this case, subsequent entries become offsets from that point. This ability"]
#[doc = "was added for assistance with the development, storage, and back office exchange of messages where message size is"]
#[doc = "not a concern and should not be sent over the air due to its additional message payload size."]
#[doc = "The general usage guidance is to construct the content of each lane node point with the smallest possible element to"]
#[doc = "conserve message size. However, using an element which is larger than needed is not a violation of the ASN.1 rules."]
#[doc = "- @field node-XY1: node is within 5.11m of last node"]
#[doc = "- @field node-XY2: node is within 10.23m of last node"]
#[doc = "- @field node-XY3: node is within 20.47m of last node"]
#[doc = "- @field node-XY4: node is within 40.96m of last node"]
#[doc = "- @field node-XY5: node is within 81.91m of last node"]
#[doc = "- @field node-XY6: node is within 327.67m of last node"]
#[doc = "- @field node-LatLon: node is a full 32b Lat/Lon range"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum NodeOffsetPointXY {
#[rasn(identifier = "node-XY1")]
node_XY1(NodeXY20b),
#[rasn(identifier = "node-XY2")]
node_XY2(NodeXY22b),
#[rasn(identifier = "node-XY3")]
node_XY3(NodeXY24b),
#[rasn(identifier = "node-XY4")]
node_XY4(NodeXY26b),
#[rasn(identifier = "node-XY5")]
node_XY5(NodeXY28b),
#[rasn(identifier = "node-XY6")]
node_XY6(NodeXY32b),
#[rasn(identifier = "node-LatLon")]
node_LatLon(NodeLLmD64b),
regional(NodeOffsetPointXYRegional),
}
#[doc = "This DF consists of a list of Node entries using XY offsets."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("2..=63"))]
pub struct NodeSetXY(pub SequenceOf<NodeXY>);
#[doc = "This DF presents a structure to hold data for a single node point in a path. Each selected node"]
#[doc = "has an X and Y offset from the prior node point (or a complete lat-long representation in some cases) as well as optional"]
#[doc = "attribute information. The node list for a lane (or other object) is made up of a sequence of these to describe the desired"]
#[doc = "path. The X,Y points are selected to reflect the centerline of the path with sufficient accuracy for the intended applications."]
#[doc = "Simple lanes can be adequately described with only two node points, while lanes with curvature may require more points."]
#[doc = "Changes to the lane width and elevation can be expressed in the NodeAttributes entry, as well as various attributes that"]
#[doc = "pertain to either the current node point or to one of more subsequent segments along the list of lane node points. As a"]
#[doc = "broad concept, NodeAttributes are used to describe aspects of the lane that persist for only a portion of the overall lane"]
#[doc = "path (either at a node or over a set of segments)."]
#[doc = "A further description of the use of the NodeOffsetPoint and the Attributes data concepts can be found in the data"]
#[doc = "dictionary entries for each one. Note that each allows regional variants to be supported as well."]
#[doc = "- @field delta: A choice of which X,Y offset value to use this includes various delta values as well a regional choices."]
#[doc = "- @field attributes: Any optional Attributes which are needed. This includes changes to the current lane width and elevation."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct NodeXY {
pub delta: NodeOffsetPointXY,
pub attributes: Option<NodeAttributeSetXY>,
}
impl NodeXY {
pub fn new(delta: NodeOffsetPointXY, attributes: Option<NodeAttributeSetXY>) -> Self {
Self { delta, attributes }
}
}
#[doc = "This DF is the ODG Addition for Legancy R09 telegrams."]
#[doc = "- @field reportingPoint: reporting point as of R09 (maps to R09 field M Meldepunktnummer)"]
#[doc = "- @field priorityLevel: priority level as of R09 (maps to R09 field P Prioritaet)"]
#[doc = "- @field length: train length point as of R09 (maps to R09 field A Zuglaenge)"]
#[doc = "- @field route: route as of R09 (maps to R09 field K Kursnummer)"]
#[doc = "- @field line: line as of R09 (maps to R09 field L Liniennummer)"]
#[doc = "- @field direction: direction as of R09 (maps to R09 field H Richtung von Hand)"]
#[doc = "- @field tour: tour as of R09 (maps to R09 field Z Zielnummer)"]
#[doc = "- @field version: version of R09"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct OcitRequestorDescriptionContainer {
#[rasn(identifier = "reportingPoint")]
pub reporting_point: Option<ReportingPoint>,
#[rasn(identifier = "priorityLevel")]
pub priority_level: Option<PriorityLevel>,
pub length: Option<TrainLength>,
pub route: Option<RouteNumber>,
pub line: Option<LineNumber>,
pub direction: Option<TransitDirection>,
pub tour: Option<TourNumber>,
pub version: Option<VersionId>,
}
impl OcitRequestorDescriptionContainer {
pub fn new(
reporting_point: Option<ReportingPoint>,
priority_level: Option<PriorityLevel>,
length: Option<TrainLength>,
route: Option<RouteNumber>,
line: Option<LineNumber>,
direction: Option<TransitDirection>,
tour: Option<TourNumber>,
version: Option<VersionId>,
) -> Self {
Self {
reporting_point,
priority_level,
length,
route,
line,
direction,
tour,
version,
}
}
}
#[doc = "A 9-bit delta offset in X, Y or Z direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions. The most negative value shall be used to"]
#[doc = "indicate an unknown value."]
#[doc = "a range of +- 2.55 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B09", value("-256..=255"))]
pub struct OffsetB09(pub i16);
#[doc = "A 10-bit delta offset in X, Y or Z direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions. The most negative value shall be used to"]
#[doc = "indicate an unknown value."]
#[doc = "a range of +- 5.11 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B10", value("-512..=511"))]
pub struct OffsetB10(pub i16);
#[doc = "An 11-bit delta offset in X or Y direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions. The most negative value shall be used to"]
#[doc = "indicate an unknown value."]
#[doc = "a range of +- 10.23 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B11", value("-1024..=1023"))]
pub struct OffsetB11(pub i16);
#[doc = "A 12-bit delta offset in X, Y or Z direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, non-vehicle centric coordinate frames of reference, offset is positive to the East (X) and to the North (Y)"]
#[doc = "directions. The most negative value shall be used to indicate an unknown value."]
#[doc = "a range of +- 20.47 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B12", value("-2048..=2047"))]
pub struct OffsetB12(pub i16);
#[doc = "A 13-bit delta offset in X or Y direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions. The most negative value shall be used to"]
#[doc = "indicate an unknown value."]
#[doc = "a range of +- 40.95 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B13", value("-4096..=4095"))]
pub struct OffsetB13(pub i16);
#[doc = "A 14-bit delta offset in X or Y direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions."]
#[doc = "a range of +- 81.91 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B14", value("-8192..=8191"))]
pub struct OffsetB14(pub i16);
#[doc = "A 16-bit delta offset in X, Y or Z direction from some known point. For non-vehicle centric coordinate frames of"]
#[doc = "reference, offset is positive to the East (X) and to the North (Y) directions. The most negative value shall be used to"]
#[doc = "indicate an unknown value."]
#[doc = "a range of +- 327.68 meters"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Offset-B16", value("-32768..=32767"))]
pub struct OffsetB16(pub i16);
#[doc = "This DF is a sequence of lane IDs which refers to lane objects that overlap or overlay the current lane's spatial path."]
#[doc = "Contains the unique ID numbers for any lane object which have spatial paths that overlay (run on top of, and not"]
#[doc = "simply cross with) the current lane."]
#[doc = "Such as a train path that overlays a motor vehicle lane object for a roadway segment."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct OverlayLaneList(pub SequenceOf<LaneID>);
#[doc = "This DE is used to provide an indication of whether Pedestrians and/or Bicyclists have been detected in the crossing lane."]
#[doc = "true if ANY Pedestrians or Bicyclists are detected crossing the target lane or lanes"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(delegate)]
pub struct PedestrianBicycleDetect(pub bool);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousPosition3DRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousPosition3DRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct Position3DRegional(pub SequenceOf<AnonymousPosition3DRegional>);
#[doc = "This DF provides a precise location in the WGS-84 coordinate system, from which short"]
#[doc = "offsets may be used to create additional data using a flat earth projection centered on this location. Position3D is typically"]
#[doc = "used in the description of maps and intersections, as well as signs and traveler data."]
#[doc = "- @field lat: Latitude in 1/10th microdegrees"]
#[doc = "- @field long: Longitude in 1/10th microdegrees"]
#[doc = "- @field elevation: The elevation information is defined by the regional extension (see module ETSI-ITS-DSRC-AddGrpC). "]
#[doc = " Therefore, the `elevation` data element of `DF_Position3D` is not used."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct Position3D {
pub lat: Latitude,
pub long: Longitude,
pub elevation: Option<Elevation>,
pub regional: Option<Position3DRegional>,
}
impl Position3D {
pub fn new(
lat: Latitude,
long: Longitude,
elevation: Option<Elevation>,
regional: Option<Position3DRegional>,
) -> Self {
Self {
lat,
long,
elevation,
regional,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum PositionConfidence {
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,
}
#[doc = "This DF combines multiple related bit fields into a single concept."]
#[doc = "- @field pos: confidence for both horizontal directions"]
#[doc = "- @field elevation: confidence for vertical direction"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct PositionConfidenceSet {
pub pos: PositionConfidence,
pub elevation: ElevationConfidence,
}
impl PositionConfidenceSet {
pub fn new(pos: PositionConfidence, elevation: ElevationConfidence) -> Self {
Self { pos, elevation }
}
}
#[doc = "This DF consists of various parameters of quality used to model the accuracy of the"]
#[doc = "positional determination with respect to each given axis."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct PositionalAccuracy {
#[rasn(identifier = "semiMajor")]
pub semi_major: SemiMajorAxisAccuracy,
#[rasn(identifier = "semiMinor")]
pub semi_minor: SemiMinorAxisAccuracy,
pub orientation: SemiMajorAxisOrientation,
}
impl PositionalAccuracy {
pub fn new(
semi_major: SemiMajorAxisAccuracy,
semi_minor: SemiMinorAxisAccuracy,
orientation: SemiMajorAxisOrientation,
) -> Self {
Self {
semi_major,
semi_minor,
orientation,
}
}
}
#[doc = "This DF consists of a list of RegionalSignalControlZone entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct PreemptPriorityList(pub SequenceOf<SignalControlZone>);
#[doc = "This DE is used in the @ref PrioritizationResponse data frame to indicate the"]
#[doc = "general status of a prior prioritization request."]
#[doc = "- `unknown` - 0: Unknown state"]
#[doc = "- `requested` - 1: This prioritization request was detected by the traffic controller"]
#[doc = "- `processing` - 2: Checking request (request is in queue, other requests are prior)"]
#[doc = "- `watchOtherTraffic` - 3: Cannot give full permission, therefore watch for other traffic. Note that other requests may be present"]
#[doc = "- `granted` - 4: Intervention was successful and now prioritization is active"]
#[doc = "- `rejected` - 5: The prioritization or preemption request was rejected by the traffic controller"]
#[doc = "- `maxPresence` - 6: The Request has exceeded maxPresence time. Used when the controller has determined that the requester should then back off and request an alternative."]
#[doc = "- `reserviceLocked` - 7: Prior conditions have resulted in a reservice"]
#[doc = " locked event: the controller requires the passage of time before another similar request will be accepted"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum PrioritizationResponseStatus {
unknown = 0,
requested = 1,
processing = 2,
watchOtherTraffic = 3,
granted = 4,
rejected = 5,
maxPresence = 6,
reserviceLocked = 7,
}
#[doc = "This DE is used to provide the R09 priority."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct PriorityLevel(pub u8);
#[doc = "This DE provides a means to indicate if a request (found in the Signal RequestMessage) represents"]
#[doc = "a new service request, a request update, or a request cancellation for either preemption or priority services."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum PriorityRequestType {
priorityRequestTypeReserved = 0,
priorityRequest = 1,
priorityRequestUpdate = 2,
priorityCancellation = 3,
}
#[doc = "This DE provides the specific revision of the RTCM standard which is being used. This is"]
#[doc = "helpful to know precisely the mapping of the message types to their definitions, as well as some minor transport layer"]
#[doc = "ordering details when received in the mobile unit. All RTCM SC-104 messages follow a common message numbering"]
#[doc = "method (wherein all defined messages are given unique values) which can be decoded from the initial octets of the"]
#[doc = "message. This operation is typically performed by the GNSS rover that consumes the messages, so it is transparent at"]
#[doc = "the DSRC message set level."]
#[doc = "Values:"]
#[doc = "- `rtcmRev2`: Std 10402.x et al"]
#[doc = "- `rtcmRev3`: Std 10403.x et al"]
#[doc = "\n\n@note:: In order to fully support the use of networked transport of RTCM corrections (so-called Ntrip systems), the"]
#[doc = " enumerated list of protocol types provides for all the common types outlined in RTCM Standard 10410.0, Appendix B. It is"]
#[doc = " anticipated that revisions 3.x and 2.3 will predominate in practice as they do today. It should also be noted that RTCM"]
#[doc = " standards use the term `byte` for an 8-bit value, while in this standard the term `octet` is used."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated, identifier = "RTCM-Revision")]
#[non_exhaustive]
pub enum RTCMRevision {
unknown = 0,
rtcmRev2 = 1,
rtcmRev3 = 2,
reserved = 3,
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousRTCMcorrectionsRegional {
#[rasn(value("0..=255"), identifier = "regionId")]
pub region_id: u8,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousRTCMcorrectionsRegional {
pub fn new(region_id: u8, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct RTCMcorrectionsRegional(pub SequenceOf<AnonymousRTCMcorrectionsRegional>);
#[doc = "This DF is used to encapsulate RTCM differential corrections for GPS and other radio"]
#[doc = "navigation signals as defined by the RTCM (Radio Technical Commission For Maritime Services) special committee"]
#[doc = "number 104 in its various standards. Here, in the work of DSRC, these messages are \"wrapped\" for transport on the"]
#[doc = "DSRC media, and then can be re-constructed back into the final expected formats defined by the RTCM standard and"]
#[doc = "used directly by various positioning systems to increase the absolute and relative accuracy estimates produced."]
#[doc = "- @field msgCnt: monotonic incrementing identifier."]
#[doc = "- @field rev: the specific edition of the standard that is being sent."]
#[doc = "- @field timeStamp: time reference"]
#[doc = "- @field anchorPoint: Observer position, if needed."]
#[doc = "- @field rtcmHeader: Precise antenna position and noise data for a rover"]
#[doc = "- @field msgs: one or more RTCM messages."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RTCMcorrections {
#[rasn(identifier = "msgCnt")]
pub msg_cnt: MsgCount,
pub rev: RTCMRevision,
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<MinuteOfTheYear>,
#[rasn(identifier = "anchorPoint")]
pub anchor_point: Option<FullPositionVector>,
#[rasn(identifier = "rtcmHeader")]
pub rtcm_header: Option<RTCMheader>,
pub msgs: RTCMmessageList,
pub regional: Option<RTCMcorrectionsRegional>,
}
impl RTCMcorrections {
pub fn new(
msg_cnt: MsgCount,
rev: RTCMRevision,
time_stamp: Option<MinuteOfTheYear>,
anchor_point: Option<FullPositionVector>,
rtcm_header: Option<RTCMheader>,
msgs: RTCMmessageList,
regional: Option<RTCMcorrectionsRegional>,
) -> Self {
Self {
msg_cnt,
rev,
time_stamp,
anchor_point,
rtcm_header,
msgs,
regional,
}
}
}
#[doc = "This DF is a collection of data values used to convey RTCM information between users. It"]
#[doc = "is not required or used when sending RTCM data from a corrections source to end users (from a base station to devices"]
#[doc = "deployed in the field which are called rovers)."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RTCMheader {
pub status: GNSSstatus,
#[rasn(identifier = "offsetSet")]
pub offset_set: AntennaOffsetSet,
}
impl RTCMheader {
pub fn new(status: GNSSstatus, offset_set: AntennaOffsetSet) -> Self {
Self { status, offset_set }
}
}
#[doc = "This DE contains the stream of octets of the actual RTCM message that is being sent."]
#[doc = "The message’s contents are defined in RTCM Standard 10403.1 and in RTCM Standard 10402.1 and its successors."]
#[doc = "Note that most RTCM messages are considerably smaller than the size limit defined here, but that some messages may"]
#[doc = "need to be broken into smaller messages (as per the rules defined in the RTCM work) in order to be transmitted over DSRC."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=1023"))]
pub struct RTCMmessage(pub OctetString);
#[doc = "This DF consists of a list of @ref RTCMmessage entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct RTCMmessageList(pub SequenceOf<RTCMmessage>);
#[doc = "This DE is used to define regions where unique additional content may be added and"]
#[doc = "used in the message set. The index values defined below represent various regions known at the time of publication. This"]
#[doc = "list is expected to grow over time. The index values assigned here can be augmented by local (uncoordinated)"]
#[doc = "assignments in the allowed range. It should be noted that such a local value is specified in the \"REGION\" ASN module, so"]
#[doc = "there is no need to edit the DSRC ASN specification of the standard. This process is further described in Section 11.1."]
#[doc = "- `noRegion` - 0: Use default supplied stubs"]
#[doc = "- `addGrpA` - 1: USA"]
#[doc = "- `addGrpB` - 2: Japan"]
#[doc = "- `addGrpC` - 3: EU"]
#[doc = "\n\n@note: new registered regional IDs will be added here"]
#[doc = " The values 128 and above are for local region use"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct RegionId(pub u8);
#[doc = "This DF is used to convey a regulatory speed about a lane, lanes, or roadway segment."]
#[doc = "- @field type: The type of regulatory speed which follows"]
#[doc = "- @field speed: The speed in units of 0.02 m/s"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RegulatorySpeedLimit {
#[rasn(identifier = "type")]
pub r_type: SpeedLimitType,
pub speed: Velocity,
}
impl RegulatorySpeedLimit {
pub fn new(r_type: SpeedLimitType, speed: Velocity) -> Self {
Self { r_type, speed }
}
}
#[doc = "This DE is used to provide the R09 reporting point."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct ReportingPoint(pub u16);
#[doc = "This DE is used to provide a unique ID between two parties for various dialog exchanges."]
#[doc = "Combined with the sender's VehicleID (consisting of a TempID or a Station ID), this provides a unique string for some"]
#[doc = "mutually defined period of time. A typical example of use would be a signal preemption or priority request dialog"]
#[doc = "containing multiple requests from one sender (denoted by the unique RequestID with each). When such a request is"]
#[doc = "processed and reflected in the signal status messages, the original sender and the specific request can both be determined."]
#[doc = "\n\n@note: In typical use, this value is simply incremented in a modulo fashion to ensure a unique stream of values for the"]
#[doc = " device creating it. Any needs for uniqueness across multiple dialogs to one or more parties shall be the responsibility of"]
#[doc = " the device to manage. There are often normative restrictions on the device changing its TempID during various dialogs"]
#[doc = " when this data element is used. Further details of these operational concepts can be found in the relevant standards."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct RequestID(pub u8);
#[doc = "This DE is used to state what type of signal request is being made to a signal"]
#[doc = "controller by a DSRC device in a defined role (such as a police vehicle). The levels of the request typically convey a"]
#[doc = "sense of urgency or importance with respect to other demands to allow the controller to use predefined business rules to"]
#[doc = "determine how to respond. These rules will vary in terms of how details of overall importance and urgency are to be"]
#[doc = "ranked, so they are to be implemented locally. As a result of this regional process, the list below should be assigned well-"]
#[doc = "defined meanings by the local deployment. These meaning will typically result in assigning a set of values to list for each"]
#[doc = "vehicle role type that is to be supported."]
#[doc = "- `requestImportanceLevel1` 1: The least important request"]
#[doc = "- `requestImportanceLevel14` 14: The most important request"]
#[doc = "- `requestImportanceReserved` 15: Reserved for future use"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum RequestImportanceLevel {
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,
}
#[doc = "This DE is used to further define the details of the role which any DSRC device might"]
#[doc = "play when making a request to a signal controller. This value is not always needed. For example, perhaps in a"]
#[doc = "deployment all police vehicles are to be treated equally. The taxonomy of what details are selected to be entered into the"]
#[doc = "list is a regional choice but should be devised to allow the controller to use predefined business rules to respond using the"]
#[doc = "data. As another example, perhaps in a regional deployment a cross-city express type of transit vehicle is given a different"]
#[doc = "service response for the same request than another type of transit vehicle making an otherwise similar request. As a"]
#[doc = "result of this regional process, the list below should be assigned well-defined meanings by the local deployment. These"]
#[doc = "meanings will typically result in assigning a set of values to list for each vehicle role type that is to be supported."]
#[doc = "- `requestSubRole1` - 1: The first type of sub role"]
#[doc = "- `requestSubRole14` - 14: The last type of sub role"]
#[doc = "- `requestSubRoleReserved` - 15: Reserved for future use"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum RequestSubRole {
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,
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousRequestorDescriptionRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousRequestorDescriptionRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct RequestorDescriptionRegional(pub SequenceOf<AnonymousRequestorDescriptionRegional>);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RequestorDescriptionExtGroupOcit {
pub ocit: OcitRequestorDescriptionContainer,
}
impl RequestorDescriptionExtGroupOcit {
pub fn new(ocit: OcitRequestorDescriptionContainer) -> Self {
Self { ocit }
}
}
#[doc = "This DF is used to provide identity information about a selected vehicle or users."]
#[doc = "This data frame is typically used with fleet type vehicles which can (or which must) safely release such information for use"]
#[doc = "with probe measurements or with other interactions (such as a signal request)."]
#[doc = "- @field id: The ID used in the CAM of the requestor. This ID is presumed not to change during the exchange."]
#[doc = "- @field type: Information regarding all type and class data about the requesting vehicle"]
#[doc = "- @field position: The location of the requesting vehicle"]
#[doc = "- @field name: A human readable name for debugging use"]
#[doc = "- @field routeName: A string for transit operations use"]
#[doc = "- @field transitStatus: current vehicle state (loading, etc.)"]
#[doc = "- @field transitOccupancy: current vehicle occupancy"]
#[doc = "- @field transitSchedule: current vehicle schedule adherence"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "- @field ocit: Extension container for Legacy R09 data (as defined by)."]
#[doc = "\n\n@note: Note that the requestor description elements which are used when the request (the req) is made differ from"]
#[doc = " those used when the status of an active or pending request is reported (the ack). Typically, when reporting the status to"]
#[doc = " other parties, less information is required and only the temporaryID (contained in the VehicleID) and request number (a"]
#[doc = " unique ID used in the orginal request) are used."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RequestorDescription {
pub id: VehicleID,
#[rasn(identifier = "type")]
pub r_type: Option<RequestorType>,
pub position: Option<RequestorPositionVector>,
pub name: Option<DescriptiveName>,
#[rasn(identifier = "routeName")]
pub route_name: Option<DescriptiveName>,
#[rasn(identifier = "transitStatus")]
pub transit_status: Option<TransitVehicleStatus>,
#[rasn(identifier = "transitOccupancy")]
pub transit_occupancy: Option<TransitVehicleOccupancy>,
#[rasn(identifier = "transitSchedule")]
pub transit_schedule: Option<DeltaTime>,
pub regional: Option<RequestorDescriptionRegional>,
#[rasn(extension_addition_group, identifier = "SEQUENCE")]
pub ext_group_ocit: Option<RequestorDescriptionExtGroupOcit>,
}
impl RequestorDescription {
pub fn new(
id: VehicleID,
r_type: Option<RequestorType>,
position: Option<RequestorPositionVector>,
name: Option<DescriptiveName>,
route_name: Option<DescriptiveName>,
transit_status: Option<TransitVehicleStatus>,
transit_occupancy: Option<TransitVehicleOccupancy>,
transit_schedule: Option<DeltaTime>,
regional: Option<RequestorDescriptionRegional>,
ext_group_ocit: Option<RequestorDescriptionExtGroupOcit>,
) -> Self {
Self {
id,
r_type,
position,
name,
route_name,
transit_status,
transit_occupancy,
transit_schedule,
regional,
ext_group_ocit,
}
}
}
#[doc = "This DF provides a report of the requestor's position, speed, and heading."]
#[doc = "Used by a vehicle or other type of user to request services and at other times when the larger FullPositionVector is not required."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RequestorPositionVector {
pub position: Position3D,
pub heading: Option<Angle>,
pub speed: Option<TransmissionAndSpeed>,
}
impl RequestorPositionVector {
pub fn new(
position: Position3D,
heading: Option<Angle>,
speed: Option<TransmissionAndSpeed>,
) -> Self {
Self {
position,
heading,
speed,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RequestorTypeRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl RequestorTypeRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = "This DF is used when a DSRC-equipped device is requesting service from another"]
#[doc = "device. The most common use case is when a vehicle is requesting a signal preemption or priority service call from the"]
#[doc = "signal controller in an intersection. This data frame provides the details of the requestor class taxonomy required to"]
#[doc = "support the request. Depending on the precise use case and the local implementation, these details can vary"]
#[doc = "considerably. As a result, besides the basic role of the vehicle, the other classification systems supported are optional. It"]
#[doc = "should also be observed that often only a subset of the information in the RequestorType data frame is used to report the"]
#[doc = "\"results\" of such a request to others. As an example, a police vehicle might request service based on being in a police"]
#[doc = "vehicle role (and any further sub-type if required) and on the type of service call to which the vehicle is then responding"]
#[doc = "(perhaps a greater degree of emergency than another type of call), placing these information elements in the"]
#[doc = "RequestorType, which is then part of the Signal Request Message (SRM). This allows the roadway operator to define"]
#[doc = "suitable business rules regarding how to reply. When informing the requestor and other nearby drivers of the outcome,"]
#[doc = "using the Signal Status Message (SSM) message, only the fact that the preemption was granted or denied to some"]
#[doc = "vehicle with a unique request ID is conveyed."]
#[doc = "- @field role: Basic role of this user at this time."]
#[doc = "- @field subrole: A local list with role based items."]
#[doc = "- @field request: A local list with request items"]
#[doc = "- @field iso3883: Additional classification details"]
#[doc = "- @field hpmsType: HPMS classification types"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RequestorType {
pub role: BasicVehicleRole,
pub subrole: Option<RequestSubRole>,
pub request: Option<RequestImportanceLevel>,
pub iso3883: Option<Iso3833VehicleType>,
#[rasn(identifier = "hpmsType")]
pub hpms_type: Option<VehicleType>,
pub regional: Option<RequestorTypeRegional>,
}
impl RequestorType {
pub fn new(
role: BasicVehicleRole,
subrole: Option<RequestSubRole>,
request: Option<RequestImportanceLevel>,
iso3883: Option<Iso3833VehicleType>,
hpms_type: Option<VehicleType>,
regional: Option<RequestorTypeRegional>,
) -> Self {
Self {
role,
subrole,
request,
iso3883,
hpms_type,
regional,
}
}
}
#[doc = "The RestrictionAppliesTo data element provides a short list of common vehicle types which may have one or more"]
#[doc = "special movements at an intersection. In general, these movements are not visible to other traffic with signal heads, but"]
#[doc = "the SPAT data reflects the state of the movement. Various restricted movements at an intersection can be expressed"]
#[doc = "using this element to indicate where the movement applies."]
#[doc = "- `none` : applies to nothing"]
#[doc = "- `equippedTransit`: buses etc."]
#[doc = "- `equippedTaxis`:"]
#[doc = "- `equippedOther`: other vehicle types with necessary signal phase state reception equipment"]
#[doc = "- `emissionCompliant`: regional variants with more definitive items also exist"]
#[doc = "- `equippedBicycle`:"]
#[doc = "- `weightCompliant`:"]
#[doc = "- `heightCompliant`: Items dealing with traveler needs serviced by the infrastructure. These end users (which are not vehicles) are presumed to be suitably equipped"]
#[doc = "- `pedestrians`:"]
#[doc = "- `slowMovingPersons`:"]
#[doc = "- `wheelchairUsers`:"]
#[doc = "- `visualDisabilities`:"]
#[doc = "- `audioDisabilities`: hearing"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum RestrictionAppliesTo {
none = 0,
equippedTransit = 1,
equippedTaxis = 2,
equippedOther = 3,
emissionCompliant = 4,
equippedBicycle = 5,
weightCompliant = 6,
heightCompliant = 7,
pedestrians = 8,
slowMovingPersons = 9,
wheelchairUsers = 10,
visualDisabilities = 11,
audioDisabilities = 12,
otherUnknownDisabilities = 13,
}
#[doc = "This DF is used to assign (or bind) a single RestrictionClassID data"]
#[doc = "element to a list of all user classes to which it applies. A collection of these bindings is conveyed in the"]
#[doc = "RestrictionClassList data frame in the MAP message to travelers. The established index is then used in the lane object of"]
#[doc = "the MAP message, in the ConnectTo data frame, to qualify to whom a signal group ID applies when it is sent by the SPAT"]
#[doc = "message about a movement."]
#[doc = "- @field id: the unique value (within an intersection or local region) that is assigned to this group of users."]
#[doc = "- @field users: The list of user types/classes to which this restriction ID applies."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RestrictionClassAssignment {
pub id: RestrictionClassID,
pub users: RestrictionUserTypeList,
}
impl RestrictionClassAssignment {
pub fn new(id: RestrictionClassID, users: RestrictionUserTypeList) -> Self {
Self { id, users }
}
}
#[doc = "This DE defines an intersection-unique value to convey data about classes of users."]
#[doc = "The mapping used varies with each intersection and is defined in the MAP message if needed. The defined mappings"]
#[doc = "found there are used to determine when a given class is meant. The typical use of this element is to map additional"]
#[doc = "movement restrictions or rights (in both the MAP and SPAT messages) to special classes of users (trucks, high sided"]
#[doc = "vehicles, special vehicles etc.). There is the general presumption that in the absence of this data, any allowed movement"]
#[doc = "extends to all users."]
#[doc = "An index value to identify data about classes of users the value used varies with each intersection's"]
#[doc = "needs and is defined in the map to the assigned classes of supported users."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct RestrictionClassID(pub u8);
#[doc = "This DF is used to enumerate a list of user classes which belong to a given"]
#[doc = "assigned index. The resulting collection is treated as a group by the signal controller when it issues movement data"]
#[doc = "(signal phase information) with the GroupID for this group. This data frame is typically static for long periods of time"]
#[doc = "(months) and conveyed to the user by means of the MAP message."]
#[doc = "\n\n@note: The overall restriction class assignment process allows dynamic support within the framework of the common"]
#[doc = " message set for the various special cases that some signalized intersections must support. While the assigned value"]
#[doc = " needs to be unique only within the scope of the intersection that uses it, the resulting assignment lists will tend to be static"]
#[doc = " and stable for regional deployment areas such as a metropolitan area based on their operational practices and needs."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=254"))]
pub struct RestrictionClassList(pub SequenceOf<RestrictionClassAssignment>);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousRestrictionUserTypeRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousRestrictionUserTypeRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct RestrictionUserTypeRegional(pub SequenceOf<AnonymousRestrictionUserTypeRegional>);
#[doc = "This DF is used to provide a means to select one, and only one, user type or class"]
#[doc = "from a number of well-known lists. The selected entry is then used in the overall Restriction Class assignment process to"]
#[doc = "indicate that a given GroupID (a way of expressing a movement in the SPAT/MAP system) applies to (is restricted to) this"]
#[doc = "class of user."]
#[doc = "- @field basicType: a set of the most commonly used types."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
#[non_exhaustive]
pub enum RestrictionUserType {
basicType(RestrictionAppliesTo),
regional(RestrictionUserTypeRegional),
}
#[doc = "This DF consists of a list of @ref RestrictionUserType entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=16"))]
pub struct RestrictionUserTypeList(pub SequenceOf<RestrictionUserType>);
#[doc = "This DF consists of a list of GenericLane entries used to describe a segment of roadway."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=255"))]
pub struct RoadLaneSetList(pub SequenceOf<GenericLane>);
#[doc = "This DE is a 16-bit globally unique identifier assigned to an entity responsible for assigning"]
#[doc = "Intersection IDs in the region over which it has such authority. The value zero shall be used for testing, and should only be"]
#[doc = "used in the absence of a suitable assignment. A single entity which assigns intersection IDs may be assigned several"]
#[doc = "RoadRegulatorIDs. These assignments are presumed to be permanent."]
#[doc = "The value zero shall be used for testing only"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct RoadRegulatorID(pub u16);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousRoadSegmentRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousRoadSegmentRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct RoadSegmentRegional(pub SequenceOf<AnonymousRoadSegmentRegional>);
#[doc = "This DF is a complete description of a RoadSegment including its geometry and its"]
#[doc = "allowed navigational paths (independent of any additional regulatory restrictions that may apply over time or from user"]
#[doc = "classification) and any current disruptions such as a work zone or incident event."]
#[doc = "- @field name: some descriptive text."]
#[doc = "- @field id: a globally unique value for the segment."]
#[doc = "- @field revision: ."]
#[doc = "- @field refPoint: the reference from which subsequent data points are offset until a new point is used."]
#[doc = "- @field laneWidth: Reference width used by all subsequent lanes unless a new width is given."]
#[doc = "- @field speedLimits: Reference regulatory speed limits used by all subsequent lanes unless a new speed is given."]
#[doc = "- @field roadLaneSet: Data describing disruptions in the RoadSegment such as work zones etc will be added here."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct RoadSegment {
pub name: Option<DescriptiveName>,
pub id: RoadSegmentReferenceID,
pub revision: MsgCount,
#[rasn(identifier = "refPoint")]
pub ref_point: Position3D,
#[rasn(identifier = "laneWidth")]
pub lane_width: Option<LaneWidth>,
#[rasn(identifier = "speedLimits")]
pub speed_limits: Option<SpeedLimitList>,
#[rasn(identifier = "roadLaneSet")]
pub road_lane_set: RoadLaneSetList,
pub regional: Option<RoadSegmentRegional>,
}
impl RoadSegment {
pub fn new(
name: Option<DescriptiveName>,
id: RoadSegmentReferenceID,
revision: MsgCount,
ref_point: Position3D,
lane_width: Option<LaneWidth>,
speed_limits: Option<SpeedLimitList>,
road_lane_set: RoadLaneSetList,
regional: Option<RoadSegmentRegional>,
) -> Self {
Self {
name,
id,
revision,
ref_point,
lane_width,
speed_limits,
road_lane_set,
regional,
}
}
}
#[doc = "This DE is used to uniquely define a section of roadway within a country or region in a 16-bit field."]
#[doc = "Assignment rules for this value are established elsewhere and may use regional assignment schemas that vary. Within"]
#[doc = "the region the policies used to ensure an assigned value’s uniqueness before that value is reused is the responsibility of"]
#[doc = "that region. Such reuse is expected to occur, but over somewhat lengthy epoch (months)."]
#[doc = "The values zero to 255 shall be used for testing only"]
#[doc = "Note that the value assigned to an RoadSegment will be"]
#[doc = "unique within a given regional ID only during its use"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct RoadSegmentID(pub u16);
#[doc = "This DF consists of a list of @ref RoadSegment entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct RoadSegmentList(pub SequenceOf<RoadSegment>);
#[doc = "This DF is used to convey theRoadSegmentID which is unique to a given road segment of interest,"]
#[doc = "and also the RoadRegulatorID assigned to the region in which it is operating (when required)."]
#[doc = "- @field region: a globally unique regional assignment value typically assigned to a regional DOT authority the value zero shall be used for testing needs."]
#[doc = "- @field id: a unique mapping to the road segment in question within the above region of use during its period of assignment and use"]
#[doc = " note that unlike intersectionID values, this value can be reused by the region."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct RoadSegmentReferenceID {
pub region: Option<RoadRegulatorID>,
pub id: RoadSegmentID,
}
impl RoadSegmentReferenceID {
pub fn new(region: Option<RoadRegulatorID>, id: RoadSegmentID) -> Self {
Self { region, id }
}
}
#[doc = "The RoadwayCrownAngle data element relates the gross tangential angle of the roadway surface with respect to"]
#[doc = "the local horizontal axis and is measured at the indicated part of the lane. This measurement is typically made at the"]
#[doc = "crown (centerline) or at an edge of the lane path. Its typical use is to relate data used in speed warning and traction"]
#[doc = "calculations for the lane segment or roadway segment in which the measurement is taken."]
#[doc = "- The value -128 shall be used for unknown"]
#[doc = "- The value zero shall be used for angles which are between -0.15 and +0.15"]
#[doc = "\n\n@unit: 0.3 degrees of angle over a range of -38.1 to + 38.1 degrees"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("-128..=127"))]
pub struct RoadwayCrownAngle(pub i8);
#[doc = "This DE is used to provide the R09 route information."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4294967295"))]
pub struct RouteNumber(pub u32);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSPATRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSPATRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SPATRegional(pub SequenceOf<AnonymousSPATRegional>);
#[doc = "This DF is used to convey the current status of one or more signalized"]
#[doc = "intersections. Along with the MapData message (which describes a full geometric layout of an intersection) the"]
#[doc = "receiver of this message can determine the state of the signal phasing and when the next expected phase will occur."]
#[doc = "The SPAT message sends the current movement state of each active phase in the system as needed (such as values of"]
#[doc = "what states are active and values at what time a state has begun/does begin earliest, is expected to begin most likely and"]
#[doc = "will end latest). The state of inactive movements is not normally transmitted. Movements are mapped to specific"]
#[doc = "approaches and connections of ingress to egress lanes and by use of the SignalGroupID in the MapData message"]
#[doc = "The current signal preemption and priority status values (when present or active) are also sent. A more complete"]
#[doc = "summary of any pending priority or preemption events can be found in the Signal Status message."]
#[doc = "- @field timeStamp: time reference"]
#[doc = "- @field name: human readable name for this collection. to be used only in debug mode."]
#[doc = "- @field intersections: sets of SPAT data (one per intersection)"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SPAT {
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<MinuteOfTheYear>,
pub name: Option<DescriptiveName>,
pub intersections: IntersectionStateList,
pub regional: Option<SPATRegional>,
}
impl SPAT {
pub fn new(
time_stamp: Option<MinuteOfTheYear>,
name: Option<DescriptiveName>,
intersections: IntersectionStateList,
regional: Option<SPATRegional>,
) -> Self {
Self {
time_stamp,
name,
intersections,
regional,
}
}
}
#[doc = "A 12-bit signed scaling factor supporting scales from zero (which is not used) to >200%. In this data element, the"]
#[doc = "value zero is taken to represent a value of one (scale 1:1). Values above and below this add or remove exactly 0.05%"]
#[doc = "from the initial value of 100%. Hence, a value of 2047 adds 102.35% to 100%, resulting in a scale of 202.35% exactly (the"]
#[doc = "largest valid scale value). Negative values which would result in an effective final value below zero are not supported. The"]
#[doc = "smallest valid value allowed is -1999 and the remaining negative values are reserved for future definition."]
#[doc = "\n\n@unit: in steps of 0.05 percent"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, identifier = "Scale-B12", value("-2048..=2047"))]
pub struct ScaleB12(pub i16);
#[doc = "This DE is an enumerated list of attributes about the current lane segment which"]
#[doc = "may be enabled or disabled to indicate the presence or absence of the selected attribute on the segment. A segment is"]
#[doc = "one or more of the straight lines formed between each set of node points. It is common for a segment attribute to persist"]
#[doc = "for more than one set of node points if there is any curvature in the lane itself. The described attributes are all binary flags"]
#[doc = "in that they do not need to convey any additional data. Other attributes allow sending short data values to reflect a setting"]
#[doc = "which is set and persists in a similar fashion."]
#[doc = "Various values which can be Enabled and Disabled for a lane segment"]
#[doc = "- reserved:"]
#[doc = "- doNotBlock: segment where a vehicle may not come to a stop"]
#[doc = "- whiteLine: segment where lane crossing not allowed such as the final few meters of a lane "]
#[doc = "- mergingLaneLeft: indicates porous lanes"]
#[doc = "- mergingLaneRight: indicates porous lanes"]
#[doc = "- curbOnLeft: indicates presence of curbs"]
#[doc = "- curbOnRight: indicates presence of curbs"]
#[doc = "- loadingzoneOnLeft: loading or drop off zones"]
#[doc = "- loadingzoneOnRight: loading or drop off zones"]
#[doc = "- turnOutPointOnLeft: opening to adjacent street/alley/road"]
#[doc = "- turnOutPointOnRight: opening to adjacent street/alley/road"]
#[doc = "- adjacentParkingOnLeft: side of road parking"]
#[doc = "- adjacentParkingOnRight: side of road parking"]
#[doc = "- adjacentBikeLaneOnLeft: presence of marked bike lanes"]
#[doc = "- adjacentBikeLaneOnRight: presence of marked bike lanes"]
#[doc = "- sharedBikeLane: right of way is shared with bikes who may occupy entire lane width"]
#[doc = "- bikeBoxInFront:"]
#[doc = "- transitStopOnLeft: any form of bus/transit loading, with pull in-out access to lane on left"]
#[doc = "- transitStopOnRight: any form of bus/transit loading, with pull in-out access to lane on right"]
#[doc = "- transitStopInLane: any form of bus/transit loading, in mid path of the lane"]
#[doc = "- sharedWithTrackedVehicle: lane is shared with train or trolley, not used for crossing tracks "]
#[doc = "- safeIsland: begin/end a safety island in path"]
#[doc = "- lowCurbsPresent: for ADA support"]
#[doc = "- rumbleStripPresent: for ADA support"]
#[doc = "- audibleSignalingPresent: for ADA support"]
#[doc = "- adaptiveTimingPresent: for ADA support"]
#[doc = "- rfSignalRequestPresent: Supports RF push to walk technologies"]
#[doc = "- partialCurbIntrusion: path is blocked by a median or curb but at least 1 meter remains open for use"]
#[doc = " and at-grade passage Lane geometry details"]
#[doc = "- taperToLeft: Used to control final path shape (see standard for defined shapes)"]
#[doc = "- taperToRight: Used to control final path shape (see standard for defined shapes)"]
#[doc = "- taperToCenterLine: Used to control final path shape (see standard for defined shapes)"]
#[doc = "- parallelParking: Parking at an angle with the street"]
#[doc = "- headInParking: Parking at an angle with the street"]
#[doc = "- freeParking: No restriction on use of parking"]
#[doc = "- timeRestrictionsOnParking: Parking is not permitted at all times"]
#[doc = " typically used when the 'parking' lane becomes a driving lane at times"]
#[doc = "- costToPark: Used where parking has a cost"]
#[doc = "- midBlockCurbPresent: a protruding curb near lane edge"]
#[doc = "- unEvenPavementPresent: a disjoint height at lane edge"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum SegmentAttributeXY {
reserved = 0,
doNotBlock = 1,
whiteLine = 2,
mergingLaneLeft = 3,
mergingLaneRight = 4,
curbOnLeft = 5,
curbOnRight = 6,
loadingzoneOnLeft = 7,
loadingzoneOnRight = 8,
turnOutPointOnLeft = 9,
turnOutPointOnRight = 10,
adjacentParkingOnLeft = 11,
adjacentParkingOnRight = 12,
adjacentBikeLaneOnLeft = 13,
adjacentBikeLaneOnRight = 14,
sharedBikeLane = 15,
bikeBoxInFront = 16,
transitStopOnLeft = 17,
transitStopOnRight = 18,
transitStopInLane = 19,
sharedWithTrackedVehicle = 20,
safeIsland = 21,
lowCurbsPresent = 22,
rumbleStripPresent = 23,
audibleSignalingPresent = 24,
adaptiveTimingPresent = 25,
rfSignalRequestPresent = 26,
partialCurbIntrusion = 27,
taperToLeft = 28,
taperToRight = 29,
taperToCenterLine = 30,
parallelParking = 31,
headInParking = 32,
freeParking = 33,
timeRestrictionsOnParking = 34,
costToPark = 35,
midBlockCurbPresent = 36,
unEvenPavementPresent = 37,
}
#[doc = "This DF consists of a list of @ref SegmentAttributeXY entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=8"))]
pub struct SegmentAttributeXYList(pub SequenceOf<SegmentAttributeXY>);
#[doc = "This DE is used to express the radius (length) of the semi-major axis of an"]
#[doc = "ellipsoid representing the accuracy which can be expected from a GNSS system in 5cm steps,"]
#[doc = "typically at a one sigma level of confidence."]
#[doc = "Value is semi-major axis accuracy at one standard dev."]
#[doc = "- Range 0-12.7 meter, LSB = .05m"]
#[doc = "- 254 = any value equal or greater than 12.70 meter"]
#[doc = "- 255 = unavailable semi-major axis value"]
#[doc = "\n\n@unit: 0.05m"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct SemiMajorAxisAccuracy(pub u8);
#[doc = "This DE is used to orientate the angle of the semi-major axis of an"]
#[doc = "ellipsoid representing the accuracy which can be expected from a GNSS system with respect to the coordinate system."]
#[doc = "Value is orientation of semi-major axis"]
#[doc = "- relative to true north (0-359.9945078786 degrees)"]
#[doc = "- LSB units of 360/65535 deg = 0.0054932479"]
#[doc = "- a value of 0 shall be 0 degrees"]
#[doc = "- a value of 1 shall be 0.0054932479 degrees"]
#[doc = "- a value of 65534 shall be 359.9945078786 deg"]
#[doc = "- a value of 65535 shall be used for orientation unavailable"]
#[doc = "\n\n@unit: 360/65535 degree"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=65535"))]
pub struct SemiMajorAxisOrientation(pub u16);
#[doc = "This DE is used to express the radius of the semi-minor axis of an ellipsoid"]
#[doc = "representing the accuracy which can be expected from a GNSS system in 5cm steps, typically at a one sigma level of"]
#[doc = "confidence."]
#[doc = "Value is semi-minor axis accuracy at one standard dev"]
#[doc = "- range 0-12.7 meter, LSB = .05m"]
#[doc = "- 254 = any value equal or greater than 12.70 meter"]
#[doc = "- 255 = unavailable semi-minor axis value"]
#[doc = "\n\n@unit: 0.05m"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct SemiMinorAxisAccuracy(pub u8);
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct SignalControlZoneZone {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl SignalControlZoneZone {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = "This DF is a dummy placeholder to contain a regional SignalControlZone DF."]
#[doc = "It is not used, yet here for backwards compatibility."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalControlZone {
pub zone: SignalControlZoneZone,
}
impl SignalControlZone {
pub fn new(zone: SignalControlZoneZone) -> Self {
Self { zone }
}
}
#[doc = "This DE is an index used to map between the internal state machine of one or more signal controllers (or"]
#[doc = "other types of traffic flow devices) and a common numbering system that can represent all possible combinations of active"]
#[doc = "states (movements and phases in US traffic terminology). All possible movement variations are assigned a unique value"]
#[doc = "within the intersection. Conceptually, the ID represents a means to provide a list of lanes in a set which would otherwise"]
#[doc = "need to be enumerated in the message. The values zero and 255 are reserved, so there may up to 254 different signal"]
#[doc = "group IDs within one single intersection. The value 255 represents a protected-Movement-Allowed or permissive-"]
#[doc = "Movement-Allowed condition that exists at all times. This value is applied to lanes, with or without traffic control devices,"]
#[doc = "that operate as free-flow lanes. Typically referred to as Channelized Right/Left Turn Lanes (in right/left-hand drive"]
#[doc = "countries)."]
#[doc = "Values:"]
#[doc = "- the value `0` shall be used when the ID is not available or not known"]
#[doc = "- the value `255` is reserved to indicate a permanent green movement state"]
#[doc = "- therefore a simple 8 phase signal controller device might use 1..9 as its groupIDs"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct SignalGroupID(pub u8);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalRequestRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalRequestRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalRequestRegional(pub SequenceOf<AnonymousSignalRequestRegional>);
#[doc = "This DF is used (as part of a request message) to request either a priority or a preemption service"]
#[doc = "from a signalized intersection. It relates the intersection ID as well as the specific request information. Additional"]
#[doc = "information includes the approach and egress values or lanes to be used."]
#[doc = "- @field id: the unique ID of the target intersection"]
#[doc = "- @field requestID: The unique requestID used by the requestor"]
#[doc = "- @field requestType: The type of request or cancel for priority or preempt use when a prior request is canceled, only the requestID is needed."]
#[doc = "- @field inBoundLane: desired entry approach or lane."]
#[doc = "- @field outBoundLane: desired exit approach or lane. the value zero is used to indicate intent to stop within the intersection."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@note: In typical use either an approach or a lane number would be given, this indicates the requested"]
#[doc = " path through the intersection to the degree it is known."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalRequest {
pub id: IntersectionReferenceID,
#[rasn(identifier = "requestID")]
pub request_id: RequestID,
#[rasn(identifier = "requestType")]
pub request_type: PriorityRequestType,
#[rasn(identifier = "inBoundLane")]
pub in_bound_lane: IntersectionAccessPoint,
#[rasn(identifier = "outBoundLane")]
pub out_bound_lane: Option<IntersectionAccessPoint>,
pub regional: Option<SignalRequestRegional>,
}
impl SignalRequest {
pub fn new(
id: IntersectionReferenceID,
request_id: RequestID,
request_type: PriorityRequestType,
in_bound_lane: IntersectionAccessPoint,
out_bound_lane: Option<IntersectionAccessPoint>,
regional: Option<SignalRequestRegional>,
) -> Self {
Self {
id,
request_id,
request_type,
in_bound_lane,
out_bound_lane,
regional,
}
}
}
#[doc = "This DF consists of a list of @ref SignalRequest entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct SignalRequestList(pub SequenceOf<SignalRequestPackage>);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalRequestMessageRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalRequestMessageRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalRequestMessageRegional(pub SequenceOf<AnonymousSignalRequestMessageRegional>);
#[doc = "This DF is a message sent by a DSRC equipped entity (such as a vehicle) to the RSU in a"]
#[doc = "signalized intersection. It is used for either a priority signal request or a preemption signal request depending on the way"]
#[doc = "each request is set. Each request defines a path through the intersection which is desired in terms of lanes and"]
#[doc = "approaches to be used. Each request can also contain the time of arrival and the expected duration of the service."]
#[doc = "Multiple requests to multiple intersections are supported. The requestor identifies itself in various ways (using methods"]
#[doc = "supported by the @refRequestorDescription data frame), and its current speed, heading and location can be placed in this"]
#[doc = "structure as well. The specific request for service is typically based on previously decoding and examining the list of lanes"]
#[doc = "and approaches for that intersection (sent in MAP messages). The outcome of all of the pending requests to a signal can"]
#[doc = "be found in the Signal Status Message (SSM), and may be reflected in the SPAT message contents if successful."]
#[doc = "- @field timeStamp: time reference"]
#[doc = "- @field second: time reference"]
#[doc = "- @field sequenceNumber: monotonic incrementing identifier"]
#[doc = "- @field requests: Request Data for one or more signalized intersections that support SRM dialogs"]
#[doc = "- @field requestor: Requesting Device and other User Data contains vehicle ID (if from a vehicle) as well as type data and current"]
#[doc = " position and may contain additional transit data"]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalRequestMessage {
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<MinuteOfTheYear>,
pub second: DSecond,
#[rasn(identifier = "sequenceNumber")]
pub sequence_number: Option<MsgCount>,
pub requests: Option<SignalRequestList>,
pub requestor: RequestorDescription,
pub regional: Option<SignalRequestMessageRegional>,
}
impl SignalRequestMessage {
pub fn new(
time_stamp: Option<MinuteOfTheYear>,
second: DSecond,
sequence_number: Option<MsgCount>,
requests: Option<SignalRequestList>,
requestor: RequestorDescription,
regional: Option<SignalRequestMessageRegional>,
) -> Self {
Self {
time_stamp,
second,
sequence_number,
requests,
requestor,
regional,
}
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalRequestPackageRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalRequestPackageRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalRequestPackageRegional(pub SequenceOf<AnonymousSignalRequestPackageRegional>);
#[doc = "This DF contains both the service request itself (the preemption and priority"]
#[doc = "details and the inbound-outbound path details for an intersection) and the time period (start and end time) over which this"]
#[doc = "service is sought from one single intersection. One or more of these packages are contained in a list in the Signal"]
#[doc = "Request Message (SREM)."]
#[doc = "- @field request: The specific request to the intersection contains IntersectionID, request type, requested action (approach/lane request)."]
#[doc = "- @field minute: Time period start."]
#[doc = "- @field second: Time period start."]
#[doc = "- @field duration: The duration value is used to provide a short interval that extends the ETA so that the requesting vehicle can arrive at"]
#[doc = " the point of service with uncertainty or with some desired duration of service. This concept can be used to avoid needing"]
#[doc = " to frequently update the request. The requester must update the ETA and duration values if the"]
#[doc = " period of services extends beyond the duration time. It should be assumed that if the vehicle does not clear the"]
#[doc = " intersection when the duration is reached, the request will be cancelled and the intersection will revert to normal operation."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalRequestPackage {
pub request: SignalRequest,
pub minute: Option<MinuteOfTheYear>,
pub second: Option<DSecond>,
pub duration: Option<DSecond>,
pub regional: Option<SignalRequestPackageRegional>,
}
impl SignalRequestPackage {
pub fn new(
request: SignalRequest,
minute: Option<MinuteOfTheYear>,
second: Option<DSecond>,
duration: Option<DSecond>,
regional: Option<SignalRequestPackageRegional>,
) -> Self {
Self {
request,
minute,
second,
duration,
regional,
}
}
}
#[doc = "This DF is used to contain information regarding the entity that requested a given"]
#[doc = "signal behavior. In addition to the VehicleID, the data frame also contains a request reference number used to uniquely"]
#[doc = "refer to the request and some basic type information about the request maker which may be used by other parties."]
#[doc = "- @field id: to uniquely identify the requester and the specific request to all parties."]
#[doc = "- @field request: to uniquely identify the requester and the specific request to all parties."]
#[doc = "- @field sequenceNumber: to uniquely identify the requester and the specific request to all parties."]
#[doc = "- @field role: vehicle role"]
#[doc = "- @field typeData: Used when addition data besides the role is needed, at which point the role entry above is not sent."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalRequesterInfo {
pub id: VehicleID,
pub request: RequestID,
#[rasn(identifier = "sequenceNumber")]
pub sequence_number: MsgCount,
pub role: Option<BasicVehicleRole>,
#[rasn(identifier = "typeData")]
pub type_data: Option<RequestorType>,
}
impl SignalRequesterInfo {
pub fn new(
id: VehicleID,
request: RequestID,
sequence_number: MsgCount,
role: Option<BasicVehicleRole>,
type_data: Option<RequestorType>,
) -> Self {
Self {
id,
request,
sequence_number,
role,
type_data,
}
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalStatusRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalStatusRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalStatusRegional(pub SequenceOf<AnonymousSignalStatusRegional>);
#[doc = "This DF is used to provide the status of a single intersection to others, including any active"]
#[doc = "preemption or priority state in effect."]
#[doc = "- @field sequenceNumber: changed whenever the below contents have change"]
#[doc = "- @field id: this provides a unique mapping to the intersection map in question which provides complete location"]
#[doc = " and approach/movement/lane data as well as zones for priority/preemption."]
#[doc = "- @field sigStatus: a list of detailed status containing all priority or preemption state data, both active and pending,"]
#[doc = " and who requested it requests which are denied are also listed here for a short period of time."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalStatus {
#[rasn(identifier = "sequenceNumber")]
pub sequence_number: MsgCount,
pub id: IntersectionReferenceID,
#[rasn(identifier = "sigStatus")]
pub sig_status: SignalStatusPackageList,
pub regional: Option<SignalStatusRegional>,
}
impl SignalStatus {
pub fn new(
sequence_number: MsgCount,
id: IntersectionReferenceID,
sig_status: SignalStatusPackageList,
regional: Option<SignalStatusRegional>,
) -> Self {
Self {
sequence_number,
id,
sig_status,
regional,
}
}
}
#[doc = "This DF consists of a list of @ref SignalStatus entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct SignalStatusList(pub SequenceOf<SignalStatus>);
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalStatusMessageRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalStatusMessageRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalStatusMessageRegional(pub SequenceOf<AnonymousSignalStatusMessageRegional>);
#[doc = "This DF is a message sent by an RSU in a signalized intersection. It is used to relate the current"]
#[doc = "status of the signal and the collection of pending or active preemption or priority requests acknowledged by the controller."]
#[doc = "It is also used to send information about preemption or priority requests which were denied. This in turn allows a dialog"]
#[doc = "acknowledgment mechanism between any requester and the signal controller. The data contained in this message allows"]
#[doc = "other users to determine their \"ranking\" for any request they have made as well as to see the currently active events."]
#[doc = "When there have been no recently received requests for service messages, this message may not be sent. While the"]
#[doc = "outcome of all pending requests to a signal can be found in the Signal Status Message, the current active event (if any)"]
#[doc = "will be reflected in the SPAT message contents."]
#[doc = "- @field timeStamp: time reference"]
#[doc = "- @field second: time reference"]
#[doc = "- @field sequenceNumber: monotonic incrementing identifier"]
#[doc = "- @field status: Status Data for one of more signalized intersections."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalStatusMessage {
#[rasn(identifier = "timeStamp")]
pub time_stamp: Option<MinuteOfTheYear>,
pub second: DSecond,
#[rasn(identifier = "sequenceNumber")]
pub sequence_number: Option<MsgCount>,
pub status: SignalStatusList,
pub regional: Option<SignalStatusMessageRegional>,
}
impl SignalStatusMessage {
pub fn new(
time_stamp: Option<MinuteOfTheYear>,
second: DSecond,
sequence_number: Option<MsgCount>,
status: SignalStatusList,
regional: Option<SignalStatusMessageRegional>,
) -> Self {
Self {
time_stamp,
second,
sequence_number,
status,
regional,
}
}
}
#[doc = " Anonymous SEQUENCE OF member "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SEQUENCE")]
pub struct AnonymousSignalStatusPackageRegional {
#[rasn(identifier = "regionId")]
pub region_id: RegionId,
#[rasn(identifier = "regExtValue")]
pub reg_ext_value: Any,
}
impl AnonymousSignalStatusPackageRegional {
pub fn new(region_id: RegionId, reg_ext_value: Any) -> Self {
Self {
region_id,
reg_ext_value,
}
}
}
#[doc = " Inner type "]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=4"))]
pub struct SignalStatusPackageRegional(pub SequenceOf<AnonymousSignalStatusPackageRegional>);
#[doc = "This DF contains all the data needed to describe the preemption or priority state"]
#[doc = "of the signal controller with respect to a given request and to uniquely identify the party who requested that state to occur."]
#[doc = "It should be noted that this data frame describes both active and anticipated states of the controller. A requested service"]
#[doc = "may not be active when the message is created and issued. A requested service may be rejected. This structure allows"]
#[doc = "the description of pending requests that have been granted (accepted rather than rejected) but are not yet active and"]
#[doc = "being serviced. It also provides for the description of rejected requests so that the initial message is acknowledged"]
#[doc = "(completing a dialog using the broadcast messages)."]
#[doc = "- @field requester: The party that made the initial SREM request."]
#[doc = "- @field inboundOn: estimated lane / approach of vehicle."]
#[doc = "- @field outboundOn: estimated lane / approach of vehicle."]
#[doc = "- @field minute: The Estimated Time of Arrival (ETA) when the service is requested. This data echos the data of the request."]
#[doc = "- @field second: seconds part of ETA."]
#[doc = "- @field duration: duration part of ETA."]
#[doc = "- @field status: Status of request, this may include rejection."]
#[doc = "- @field regional: optional region specific data."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalStatusPackage {
pub requester: Option<SignalRequesterInfo>,
#[rasn(identifier = "inboundOn")]
pub inbound_on: IntersectionAccessPoint,
#[rasn(identifier = "outboundOn")]
pub outbound_on: Option<IntersectionAccessPoint>,
pub minute: Option<MinuteOfTheYear>,
pub second: Option<DSecond>,
pub duration: Option<DSecond>,
pub status: PrioritizationResponseStatus,
pub regional: Option<SignalStatusPackageRegional>,
}
impl SignalStatusPackage {
pub fn new(
requester: Option<SignalRequesterInfo>,
inbound_on: IntersectionAccessPoint,
outbound_on: Option<IntersectionAccessPoint>,
minute: Option<MinuteOfTheYear>,
second: Option<DSecond>,
duration: Option<DSecond>,
status: PrioritizationResponseStatus,
regional: Option<SignalStatusPackageRegional>,
) -> Self {
Self {
requester,
inbound_on,
outbound_on,
minute,
second,
duration,
status,
regional,
}
}
}
#[doc = "This DF consists of a list of @ref SignalStatusPackage entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=32"))]
pub struct SignalStatusPackageList(pub SequenceOf<SignalStatusPackage>);
#[doc = "This data element represents the recommended velocity of an object, typically a vehicle speed along a roadway,"]
#[doc = "expressed in unsigned units of 0.1 meters per second."]
#[doc = "- LSB units are 0.1 m/s"]
#[doc = "- the value 499 shall be used for values at or greater than 49.9 m/s"]
#[doc = "- the value 500 shall be used to indicate that speed is unavailable"]
#[doc = "\n\n@unit: 0.1 m/s"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=500"))]
pub struct SpeedAdvice(pub u16);
#[doc = "This DE is used to provide the 95% confidence level for the currently reported"]
#[doc = "value of @ref Speed, taking into account the current calibration and precision of the sensor(s) used to measure and/or"]
#[doc = "calculate the value. This data element is only to provide the listener with information on the limitations of the sensing"]
#[doc = "system, not to support any type of automatic error correction or to imply a guaranteed maximum error. This data element"]
#[doc = "should not be used for fault detection or diagnosis, but if a vehicle is able to detect a fault, the confidence interval should"]
#[doc = "be increased accordingly."]
#[doc = "- 0 - `unavailable` : Not Equipped or unavailable"]
#[doc = "- 1 - `prec100ms` : 100 meters / sec"]
#[doc = "- 2 - `prec10ms` : 10 meters / sec"]
#[doc = "- 3 - `prec5ms` : 5 meters / sec"]
#[doc = "- 4 - `prec1ms` : 1 meters / sec"]
#[doc = "- 5 - `prec0-1ms` : 0.1 meters / sec"]
#[doc = "- 6 - `prec0-05ms` : 0.05 meters / sec"]
#[doc = "- 7 - `prec0-01ms` : 0.01 meters / sec"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum SpeedConfidenceDSRC {
unavailable = 0,
prec100ms = 1,
prec10ms = 2,
prec5ms = 3,
prec1ms = 4,
#[rasn(identifier = "prec0-1ms")]
prec0_1ms = 5,
#[rasn(identifier = "prec0-05ms")]
prec0_05ms = 6,
#[rasn(identifier = "prec0-01ms")]
prec0_01ms = 7,
}
#[doc = "This DF consists of a list of SpeedLimit entries."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=9"))]
pub struct SpeedLimitList(pub SequenceOf<RegulatorySpeedLimit>);
#[doc = "This DE relates the type of speed limit to which a given speed refers."]
#[doc = "- unknown: Speed limit type not available"]
#[doc = "- maxSpeedInSchoolZone: Only sent when the limit is active"]
#[doc = "- maxSpeedInSchoolZoneWhenChildrenArePresent: Sent at any time"]
#[doc = "- maxSpeedInConstructionZone: Used for work zones, incident zones, etc. where a reduced speed is present"]
#[doc = "- vehicleMinSpeed: Regulatory speed limit for general traffic"]
#[doc = "- vehicleMaxSpeed: Regulatory speed limit for general traffic"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum SpeedLimitType {
unknown = 0,
maxSpeedInSchoolZone = 1,
maxSpeedInSchoolZoneWhenChildrenArePresent = 2,
maxSpeedInConstructionZone = 3,
vehicleMinSpeed = 4,
vehicleMaxSpeed = 5,
vehicleNightMaxSpeed = 6,
truckMinSpeed = 7,
truckMaxSpeed = 8,
truckNightMaxSpeed = 9,
vehiclesWithTrailersMinSpeed = 10,
vehiclesWithTrailersMaxSpeed = 11,
vehiclesWithTrailersNightMaxSpeed = 12,
}
#[doc = "This DF is a single data frame combining multiple related bit fields into one concept."]
#[doc = "- @field heading: confidence for heading values"]
#[doc = "- @field speed: confidence for speed values"]
#[doc = "- @field throttle: confidence for throttle values "]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct SpeedandHeadingandThrottleConfidence {
pub heading: HeadingConfidenceDSRC,
pub speed: SpeedConfidenceDSRC,
pub throttle: ThrottleConfidence,
}
impl SpeedandHeadingandThrottleConfidence {
pub fn new(
heading: HeadingConfidenceDSRC,
speed: SpeedConfidenceDSRC,
throttle: ThrottleConfidence,
) -> Self {
Self {
heading,
speed,
throttle,
}
}
}
#[doc = "This is the 4 octet random device identifier, called the TemporaryID. When used for a mobile OBU device, this value"]
#[doc = "will change periodically to ensure the overall anonymity of the vehicle, unlike a typical wireless or wired 802 device ID."]
#[doc = "Because this value is used as a means to identify the local vehicles that are interacting during an encounter, it is used in"]
#[doc = "the message set. Other devices, such as infrastructure (RSUs), may have a fixed value for the temporary ID value. See"]
#[doc = "also @ref StationId which is used in other deployment regions."]
#[doc = "\n\n@note: The circumstances and times at which various DSRC devices (notably OBUs) create and change their current"]
#[doc = " Temporary ID is a complex application level topic. It should be noted that the Temporary ID is not the same as a device"]
#[doc = " MAC value, although when used as a means to uniquely identify a device, both have many common properties. It should"]
#[doc = " further be noted that the MAC value for a mobile OBU device (unlike a typical wireless or wired 802 device) will"]
#[doc = " periodically change to a new random value to ensure the overall anonymity of the vehicle."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct TemporaryID(pub FixedOctetString<4usize>);
#[doc = "This DE is used to provide the 95% confidence level for the currently reported"]
#[doc = "value of DE @ref Throttle, taking into account the current calibration and precision of the sensor(s) used to measure and/or"]
#[doc = "calculate the value. This data element is only to provide information on the limitations of the sensing system, not to"]
#[doc = "support any type of automatic error correction or to imply a guaranteed maximum error. This data element should not be"]
#[doc = "used for fault detection or diagnosis, but if a vehicle is able to detect a fault, the confidence interval should be increased"]
#[doc = "accordingly. If a fault that triggers the MIL is of a nature to render throttle performance unreliable, then ThrottleConfidence"]
#[doc = "should be represented as \"notEquipped.\""]
#[doc = "- 0 - `unavailable`: B'00 Not Equipped or unavailable"]
#[doc = "- 1 - `prec10percent`: B'01 10 percent Confidence level"]
#[doc = "- 2 - `prec1percent`: B'10 1 percent Confidence level"]
#[doc = "- 3 - `prec0-5percent`: B'11 0.5 percent Confidence level"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum ThrottleConfidence {
unavailable = 0,
prec10percent = 1,
prec1percent = 2,
#[rasn(identifier = "prec0-5percent")]
prec0_5percent = 3,
}
#[doc = "This DF conveys details about the timing of a phase within a movement. The core"]
#[doc = "data concept expressed is the time stamp (time mark) at which the related phase will change to the next state. This is"]
#[doc = "often found in the MinEndTime element, but the other elements may be needed to convey the full concept when adaptive"]
#[doc = "timing is employed."]
#[doc = "- @field startTime: is used to relate when the phase itself started or is expected to start. This in turn allows the"]
#[doc = " indication that a set of time change details refers to a future phase, rather than a currently active phase."]
#[doc = " By this method, timing information about \"pre\" phase events (which are the short transitional phase used to alert OBUs to"]
#[doc = " an impending green/go or yellow/caution phase) and the longer yellow-caution phase data is supported in the same form"]
#[doc = " as various green/go phases. In theory, the time change details could be sent for a large sequence of phases if the signal"]
#[doc = " timing was not adaptive and the operator wished to do so. In practice, it is expected only the \"next\" future phase will"]
#[doc = " commonly be sent. It should be noted that this also supports the sending of time periods regarding various red phases;"]
#[doc = " however, this is not expected to be done commonly."]
#[doc = "- @field minEndTime: is used to convey the earliest time possible at which the phase could change, except when"]
#[doc = " unpredictable events relating to a preemption or priority call disrupt a currently active timing plan. In a phase where the"]
#[doc = " time is fixed (as in a fixed yellow or clearance time), this element shall be used alone. This value can be viewed as the"]
#[doc = " earliest possible time at which the phase could change, except when unpredictable events relating to a preemption or"]
#[doc = " priority call come into play and disrupt a currently active timing plan."]
#[doc = "- @field maxEndTime: is used to convey the latest time possible which the phase could change,"]
#[doc = " except when unpredictable events relating to a preemption or priority"]
#[doc = " call come into play and disrupt a currently active timing plan. In a phase where the time is fixed (as in a fixed yellow or"]
#[doc = " clearance time), this element shall be used alone."]
#[doc = "- @field likelyTime: is used to convey the most likely time the phase changes. This occurs between MinEndTime and"]
#[doc = " MaxEndTime and is only relevant for traffic-actuated control programs. This time might be calculated out of logged"]
#[doc = " historical values, detected events (e.g., from inductive loops), or from other sources."]
#[doc = "- @field confidence: is used to convey basic confidence data about the likelyTime."]
#[doc = "- @field nextTime: is used to express a general (and presumably less precise) value regarding when this phase will"]
#[doc = " next occur. This is intended to be used to alert the OBU when the next green/go may occur so that various ECO driving"]
#[doc = " applications can better manage the vehicle during the intervening stopped time."]
#[doc = "\n\n@note: Remarks: It should be noted that all times are expressed as absolute values and not as countdown timer values. When"]
#[doc = " the stated time mark is reached, the state changes to the next state. Several technical reasons led to this choice; among"]
#[doc = " these was that with a countdown embodiment, there is an inherent need to update the remaining time every time a SPAT"]
#[doc = " message is issued. This would require re-formulating the message content as as well as cryptographically signing the"]
#[doc = " message each time. With the use of absolute values (time marks) chosen here, the current count down time when the"]
#[doc = " message is created is added to the then-current time to create an absolute value and can be used thereafter without"]
#[doc = " change. The message content need only change when the signal controller makes a timing decision to be published. This"]
#[doc = " allows a clean separation of the logical functions of message creation from the logical functions of message scheduling"]
#[doc = " and sending, and fulfills the need to minimize further real time processing when possible. This Standard sets no limits on"]
#[doc = " where each of these functions is performed in the overall roadside system."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct TimeChangeDetails {
#[rasn(identifier = "startTime")]
pub start_time: Option<TimeMark>,
#[rasn(identifier = "minEndTime")]
pub min_end_time: TimeMark,
#[rasn(identifier = "maxEndTime")]
pub max_end_time: Option<TimeMark>,
#[rasn(identifier = "likelyTime")]
pub likely_time: Option<TimeMark>,
pub confidence: Option<TimeIntervalConfidence>,
#[rasn(identifier = "nextTime")]
pub next_time: Option<TimeMark>,
}
impl TimeChangeDetails {
pub fn new(
start_time: Option<TimeMark>,
min_end_time: TimeMark,
max_end_time: Option<TimeMark>,
likely_time: Option<TimeMark>,
confidence: Option<TimeIntervalConfidence>,
next_time: Option<TimeMark>,
) -> Self {
Self {
start_time,
min_end_time,
max_end_time,
likely_time,
confidence,
next_time,
}
}
}
#[doc = "This DE is used to provide the 95% confidence level for the currently reported value"]
#[doc = "of time, taking into account the current calibration and precision of the sensor(s) used to measure and/or calculate the"]
#[doc = "value. This data element is only to provide information on the limitations of the sensing system, not to support any type of"]
#[doc = "automatic error correction or to imply a guaranteed maximum error. This data element should not be used for fault"]
#[doc = "detection or diagnosis, but if a vehicle is able to detect a fault, the confidence interval should be increased accordingly."]
#[doc = "- 0 - `unavailable` : Not Equipped or unavailable"]
#[doc = "- 1 - `time-100-000` : Better than 100 Seconds"]
#[doc = "- 2 - `time-050-000` : Better than 50 Seconds"]
#[doc = "- 3 - `time-020-000` : Better than 20 Seconds"]
#[doc = "- 4 - `time-010-000` : Better than 10 Seconds"]
#[doc = "- 5 - `time-002-000` : Better than 2 Seconds"]
#[doc = "- 6 - `time-001-000` : Better than 1 Second"]
#[doc = "- 7 - `time-000-500` : Better than 0.5 Seconds"]
#[doc = "- 8 - `time-000-200` : Better than 0.2 Seconds"]
#[doc = "- 9 - `time-000-100` : Better than 0.1 Seconds"]
#[doc = "- 10 - `time-000-050` : Better than 0.05 Seconds"]
#[doc = "- 11 - `time-000-020` : Better than 0.02 Seconds"]
#[doc = "- 12 - `time-000-010` : Better than 0.01 Seconds"]
#[doc = "- 13 - `time-000-005` : Better than 0.005 Seconds"]
#[doc = "- 14 - `time-000-002` : Better than 0.001 Seconds"]
#[doc = "- 15 - `time-000-001` : Better than 0.001 Seconds"]
#[doc = "- 16 - `time-000-000-5` : Better than 0.000,5 Seconds"]
#[doc = "- 17 - `time-000-000-2` : Better than 0.000,2 Seconds"]
#[doc = "- 18 - `time-000-000-1` : Better than 0.000,1 Seconds"]
#[doc = "- 19 - `time-000-000-05` : Better than 0.000,05 Seconds"]
#[doc = "- 20 - `time-000-000-02` : Better than 0.000,02 Seconds"]
#[doc = "- 21 - `time-000-000-01` : Better than 0.000,01 Seconds"]
#[doc = "- 22 - `time-000-000-005` : Better than 0.000,005 Seconds"]
#[doc = "- 23 - `time-000-000-002` : Better than 0.000,002 Seconds"]
#[doc = "- 24 - `time-000-000-001` : Better than 0.000,001 Seconds"]
#[doc = "- 25 - `time-000-000-000-5` : Better than 0.000,000,5 Seconds"]
#[doc = "- 26 - `time-000-000-000-2` : Better than 0.000,000,2 Seconds"]
#[doc = "- 27 - `time-000-000-000-1` : Better than 0.000,000,1 Seconds"]
#[doc = "- 28 - `time-000-000-000-05` : Better than 0.000,000,05 Seconds"]
#[doc = "- 29 - `time-000-000-000-02` : Better than 0.000,000,02 Seconds"]
#[doc = "- 30 - `time-000-000-000-01` : Better than 0.000,000,01 Seconds"]
#[doc = "- 31 - `time-000-000-000-005` : Better than 0.000,000,005 Seconds"]
#[doc = "- 32 - `time-000-000-000-002` : Better than 0.000,000,002 Seconds"]
#[doc = "- 33 - `time-000-000-000-001` : Better than 0.000,000,001 Seconds"]
#[doc = "- 34 - `time-000-000-000-000-5` : Better than 0.000,000,000,5 Seconds"]
#[doc = "- 35 - `time-000-000-000-000-2` : Better than 0.000,000,000,2 Seconds"]
#[doc = "- 36 - `time-000-000-000-000-1` : Better than 0.000,000,000,1 Seconds"]
#[doc = "- 37 - `time-000-000-000-000-05` : Better than 0.000,000,000,05 Seconds"]
#[doc = "- 38 - `time-000-000-000-000-02` : Better than 0.000,000,000,02 Seconds"]
#[doc = "- 39 - `time-000-000-000-000-01` : Better than 0.000,000,000,01 Seconds"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum TimeConfidence {
unavailable = 0,
#[rasn(identifier = "time-100-000")]
time_100_000 = 1,
#[rasn(identifier = "time-050-000")]
time_050_000 = 2,
#[rasn(identifier = "time-020-000")]
time_020_000 = 3,
#[rasn(identifier = "time-010-000")]
time_010_000 = 4,
#[rasn(identifier = "time-002-000")]
time_002_000 = 5,
#[rasn(identifier = "time-001-000")]
time_001_000 = 6,
#[rasn(identifier = "time-000-500")]
time_000_500 = 7,
#[rasn(identifier = "time-000-200")]
time_000_200 = 8,
#[rasn(identifier = "time-000-100")]
time_000_100 = 9,
#[rasn(identifier = "time-000-050")]
time_000_050 = 10,
#[rasn(identifier = "time-000-020")]
time_000_020 = 11,
#[rasn(identifier = "time-000-010")]
time_000_010 = 12,
#[rasn(identifier = "time-000-005")]
time_000_005 = 13,
#[rasn(identifier = "time-000-002")]
time_000_002 = 14,
#[rasn(identifier = "time-000-001")]
time_000_001 = 15,
#[rasn(identifier = "time-000-000-5")]
time_000_000_5 = 16,
#[rasn(identifier = "time-000-000-2")]
time_000_000_2 = 17,
#[rasn(identifier = "time-000-000-1")]
time_000_000_1 = 18,
#[rasn(identifier = "time-000-000-05")]
time_000_000_05 = 19,
#[rasn(identifier = "time-000-000-02")]
time_000_000_02 = 20,
#[rasn(identifier = "time-000-000-01")]
time_000_000_01 = 21,
#[rasn(identifier = "time-000-000-005")]
time_000_000_005 = 22,
#[rasn(identifier = "time-000-000-002")]
time_000_000_002 = 23,
#[rasn(identifier = "time-000-000-001")]
time_000_000_001 = 24,
#[rasn(identifier = "time-000-000-000-5")]
time_000_000_000_5 = 25,
#[rasn(identifier = "time-000-000-000-2")]
time_000_000_000_2 = 26,
#[rasn(identifier = "time-000-000-000-1")]
time_000_000_000_1 = 27,
#[rasn(identifier = "time-000-000-000-05")]
time_000_000_000_05 = 28,
#[rasn(identifier = "time-000-000-000-02")]
time_000_000_000_02 = 29,
#[rasn(identifier = "time-000-000-000-01")]
time_000_000_000_01 = 30,
#[rasn(identifier = "time-000-000-000-005")]
time_000_000_000_005 = 31,
#[rasn(identifier = "time-000-000-000-002")]
time_000_000_000_002 = 32,
#[rasn(identifier = "time-000-000-000-001")]
time_000_000_000_001 = 33,
#[rasn(identifier = "time-000-000-000-000-5")]
time_000_000_000_000_5 = 34,
#[rasn(identifier = "time-000-000-000-000-2")]
time_000_000_000_000_2 = 35,
#[rasn(identifier = "time-000-000-000-000-1")]
time_000_000_000_000_1 = 36,
#[rasn(identifier = "time-000-000-000-000-05")]
time_000_000_000_000_05 = 37,
#[rasn(identifier = "time-000-000-000-000-02")]
time_000_000_000_000_02 = 38,
#[rasn(identifier = "time-000-000-000-000-01")]
time_000_000_000_000_01 = 39,
}
#[doc = "This is the statistical confidence for the predicted time of signal group state change. For evaluation, the formula"]
#[doc = "10^(x/a)-b with a=82.5 and b=1.3 was used. The values are encoded as probability classes with proposed values listed in"]
#[doc = "the below table in the ASN.1 specification."]
#[doc = "Value: Probability"]
#[doc = "- 0 - 21%"]
#[doc = "- 1 - 36%"]
#[doc = "- 2 - 47%"]
#[doc = "- 3 - 56%"]
#[doc = "- 4 - 62%"]
#[doc = "- 5 - 68%"]
#[doc = "- 6 - 73%"]
#[doc = "- 7 - 77%"]
#[doc = "- 8 - 81%"]
#[doc = "- 9 - 85%"]
#[doc = "- 10 - 88%"]
#[doc = "- 11 - 91%"]
#[doc = "- 12 - 94%"]
#[doc = "- 13 - 96%"]
#[doc = "- 14 - 98%"]
#[doc = "- 15 - 100%"]
#[doc = "\n\n@unit: percent"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=15"))]
pub struct TimeIntervalConfidence(pub u8);
#[doc = "This DE is used to relate a moment in UTC (Coordinated Universal Time)-based time when a"]
#[doc = "signal phase is predicted to change, with a precision of 1/10 of a second. A range of 60 full minutes is supported and it"]
#[doc = "can be presumed that the receiver shares a common sense of time with the sender which is kept aligned to within a"]
#[doc = "fraction of a second or better."]
#[doc = "If there is a need to send a value greater than the range allowed by the data element (over one hour in the future), the"]
#[doc = "value 36000 shall be sent and shall be interpreted to indicate an indefinite future time value. When the value to be used is"]
#[doc = "undefined or unknown a value of 36001 shall be sent. Note that leap seconds are also supported."]
#[doc = "The value is tenths of a second in the current or next hour in units of 1/10th second from UTC time"]
#[doc = "- A range of 0-36000 covers one hour"]
#[doc = "- The values 35991..35999 are used when a leap second occurs"]
#[doc = "- The value 36000 is used to indicate time >3600 seconds"]
#[doc = "- 36001 is to be used when value undefined or unknown"]
#[doc = "\n\n@note: Note that this is NOT expressed in GPS time or in local time"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=36001"))]
pub struct TimeMark(pub u16);
#[doc = "This DE is used to provide the R09 tour information."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4294967295"))]
pub struct TourNumber(pub u32);
#[doc = "This DE is used to provide the R09 train length."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=7"))]
pub struct TrainLength(pub u8);
#[doc = "This DE is used to provide the R09 direction information."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=255"))]
pub struct TransitDirection(pub u8);
#[doc = " This DE is used to relate basic level of current ridership."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum TransitVehicleOccupancy {
occupancyUnknown = 0,
occupancyEmpty = 1,
occupancyVeryLow = 2,
occupancyLow = 3,
occupancyMed = 4,
occupancyHigh = 5,
occupancyNearlyFull = 6,
occupancyFull = 7,
}
#[doc = "This DE is used to relate basic information about the transit run in progress. This is"]
#[doc = "typically used in a priority request to a signalized system and becomes part of the input processing for how that system"]
#[doc = "will respond to the request."]
#[doc = "- 0 - `loading`: parking and unable to move at this time"]
#[doc = "- 1 - `anADAuse`: an ADA access is in progress (wheelchairs, kneeling, etc.)"]
#[doc = "- 2 - `aBikeLoad`: loading of a bicycle is in progress"]
#[doc = "- 3 - `doorOpen`: a vehicle door is open for passenger access"]
#[doc = "- 4 - `charging`: a vehicle is connected to charging point"]
#[doc = "- 5 - `atStopLine`: a vehicle is at the stop line for the lane it is in"]
#[doc = "\n\n@note: Most of these values are used to detect that the transit vehicle in not in a state where movement can occur"]
#[doc = "(and that therefore any priority signal should be ignored until the vehicle is again ready to depart)."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate)]
pub struct TransitVehicleStatus(pub FixedBitString<8usize>);
#[doc = "This DF expresses the speed of the vehicle and the state of the transmission."]
#[doc = "The transmission state of 'reverse' can be used as a sign value for the speed element when needed."]
#[doc = "- @field transmisson: state of the transmission"]
#[doc = "- @field speed: speed of the vehicle"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
pub struct TransmissionAndSpeed {
pub transmisson: TransmissionState,
pub speed: Velocity,
}
impl TransmissionAndSpeed {
pub fn new(transmisson: TransmissionState, speed: Velocity) -> Self {
Self { transmisson, speed }
}
}
#[doc = "This DE is used to provide the current state of the vehicle transmission."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
pub enum TransmissionState {
neutral = 0,
park = 1,
forwardGears = 2,
reverseGears = 3,
reserved1 = 4,
reserved2 = 5,
reserved3 = 6,
unavailable = 7,
}
#[doc = "The height of the vehicle, measured from the ground to the highest surface, excluding any antenna(s), and"]
#[doc = "expressed in units of 5 cm. In cases of vehicles with adjustable ride heights, camper shells, and other devices which may"]
#[doc = "cause the overall height to vary, the largest possible height will be used."]
#[doc = "Value is the height of the vehicle, LSB units of 5 cm, range to 6.35 meters"]
#[doc = "\n\n@unit: 5cm"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=127"))]
pub struct VehicleHeight(pub u8);
#[doc = "This DF is used to contain either a (US) TemporaryID or an (EU) StationID in a simple frame."]
#[doc = "These two different value domains are used to uniquely identify a vehicle or other object in these two regional DSRC"]
#[doc = "value is unavailable but needed by another type of user (such as the roadside infrastructure sending data about an"]
#[doc = "environments. In normal use cases, this value changes over time to prevent tracking of the subject vehicle. When this"]
#[doc = "unequipped vehicle), the value zero shall be used. A typical restriction on the use of this value during a dialog or other"]
#[doc = "exchange is that the value remains constant for the duration of that exchange. Refer to the performance requirements for"]
#[doc = "a given application for details."]
#[doc = "- @field entityID: representation for US stations"]
#[doc = "- @field stationID: representation for EU stations"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(choice, automatic_tags)]
pub enum VehicleID {
entityID(TemporaryID),
stationID(StationID),
}
#[doc = "This DE is a type list (i.e., a classification list) of the vehicle in terms of overall size. The"]
#[doc = "data element entries follow the definitions defined in the US DOT Highway Performance Monitoring System (HPMS)."]
#[doc = "Many infrastructure roadway operators collect and classify data according to this list for regulatory reporting needs."]
#[doc = "Within the ITS industry and within the DSRC message set standards work, there are many similar lists of types for"]
#[doc = "overlapping needs and uses."]
#[doc = "- 0 - `none`: Not Equipped, Not known or unavailable"]
#[doc = "- 1 - `unknown`: Does not fit any other category"]
#[doc = "- 2 - `special`: Special use"]
#[doc = "- 3 - `moto`: Motorcycle"]
#[doc = "- 4 - `car`: Passenger car"]
#[doc = "- 5 - `carOther`: Four tire single units"]
#[doc = "- 6 - `bus`: Buses"]
#[doc = "- 7 - `axleCnt2`: Two axle, six tire single units"]
#[doc = "- 8 - `axleCnt3`: Three axle, single units"]
#[doc = "- 9 - `axleCnt4`: Four or more axle, single unit"]
#[doc = "- 10 - `axleCnt4Trailer`: Four or less axle, single trailer"]
#[doc = "- 11 - `axleCnt5Trailer`: Five or less axle, single trailer"]
#[doc = "- 12 - `axleCnt6Trailer`: Six or more axle, single trailer"]
#[doc = "- 13 - `axleCnt5MultiTrailer`: Five or less axle, multi-trailer"]
#[doc = "- 14 - `axleCnt6MultiTrailer`: Six axle, multi-trailer"]
#[doc = "- 15 - `axleCnt7MultiTrailer`: Seven or more axle, multi-trailer"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum VehicleType {
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,
}
#[doc = "This DE represents the velocity of an object, typically a vehicle speed or the recommended speed of"]
#[doc = "travel along a roadway, expressed in unsigned units of 0.02 meters per second. When used with motor vehicles it may be"]
#[doc = "combined with the transmission state to form a data frame for use. A value of 8191 shall be used when the speed is"]
#[doc = "unavailable. Note that Velocity as used here is intended to be a scalar value and not a vector."]
#[doc = "The value 8191 indicates that velocity is unavailable"]
#[doc = "\n\n@unit: 0.02 m/s"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=8191"))]
pub struct Velocity(pub u16);
#[doc = "This DE is used to provide the R09 version information."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V2.2.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=4294967295"))]
pub struct VersionId(pub u32);
#[doc = "This DE is used to indicate to the vehicle that it must stop at the stop line and not move past."]
#[doc = "If \"true\", the vehicles on this specific connecting maneuver have to stop on the stop-line and not to enter the collision area"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(delegate)]
pub struct WaitOnStopline(pub bool);
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=10000"))]
pub struct ZoneLength(pub u16);
pub const ADD_GRP_A: RegionId = RegionId(1);
pub const ADD_GRP_B: RegionId = RegionId(2);
pub const ADD_GRP_C: RegionId = RegionId(3);
pub const DIESEL: FuelType = FuelType(3);
pub const ELECTRIC: FuelType = FuelType(4);
pub const ETHANOL: FuelType = FuelType(2);
pub const GASOLINE: FuelType = FuelType(1);
pub const HYBRID: FuelType = FuelType(5);
pub const HYDROGEN: FuelType = FuelType(6);
pub const NAT_GAS_COMP: FuelType = FuelType(8);
pub const NAT_GAS_LIQUID: FuelType = FuelType(7);
pub const NO_REGION: RegionId = RegionId(0);
pub const PROPANE: FuelType = FuelType(9);
pub const UNKNOWN_FUEL: FuelType = FuelType(0);
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod etsi_its_dsrc_add_grp_c {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::super::cdd_2_2_1::etsi_its_cdd::{Altitude, DeltaAltitude, StationID, VehicleMass};
use super::super::dsrc_2_2_1::etsi_its_dsrc::{
DeltaTime,
FuelType,
IntersectionID,
LaneConnectionID,
LaneID,
NodeOffsetPointXY,
NodeSetXY,
PrioritizationResponseStatus,
SignalGroupID,
VehicleHeight,
};
#[doc = "This DE defines an enumerated list of battery states."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum BatteryStatus {
unknown = 0,
critical = 1,
low = 2,
good = 3,
}
#[doc = "This DF adds positioning support from the infrastructure to the vehicle."]
#[doc = "- @field itsStationPositions: defines a list of ITS stations (e.g. vehicles) and their corresponding position on"]
#[doc = " the driving lane as defined in the lane topology of the MapData message or the GNSS position"]
#[doc = " deviation of the ITS Station from the high precision reference position in X/Y coordinates. It"]
#[doc = " enables accurate, real-time positioning support to the moving ITS entities by the infrastructure.*"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "ConnectionManeuverAssist-addGrpC")]
#[non_exhaustive]
pub struct ConnectionManeuverAssistAddGrpC {
#[rasn(identifier = "itsStationPosition")]
pub its_station_position: Option<ItsStationPositionList>,
}
impl ConnectionManeuverAssistAddGrpC {
pub fn new(its_station_position: Option<ItsStationPositionList>) -> Self {
Self {
its_station_position,
}
}
}
#[doc = "This DF defines the trajectory for travelling through the conflict area of an intersection and connects "]
#[doc = "e.g an ingress with an egress lane. The trajectory is defined by two or more nodes. "]
#[doc = "The starting node overlaps e.g. with the node of the ingress lane towards the"]
#[doc = "conflict zone. The ending node overlaps e.g. with the first node of the connected egress lane. "]
#[doc = "See the example in clause [ISO TS 19091] G.8.2.5."]
#[doc = "- @field nodes: defines a list of nodes for the trajectory. It defines e.g. a geometric trajectory from an ingressing"]
#[doc = " to a connected egressing lane and the X/Y position value of the first node of the trajectory is the same as"]
#[doc = " the node of the ingress lane. The X/Y position of the last node is the same as the X/Y position of the first"]
#[doc = " node of the egressing lane."]
#[doc = "- @field connectionID: defines the identifier of an allowed `maneuver` (e.g. ingress / egress relation). "]
#[doc = " A generic Lane offers one or more allowed `maneuvers`, therefore the trajectory is reference to the related `maneuver`."]
#[doc = "\n\n@note: @ref Reg-GenericLane allows providing up to 4 connecting trajectories. In case a lane has more than 4 connecting trajectories,"]
#[doc = "priority should be given to connecting trajectories of motorized traffic and complex manoeuvres."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "ConnectionTrajectory-addGrpC")]
#[non_exhaustive]
pub struct ConnectionTrajectoryAddGrpC {
pub nodes: NodeSetXY,
#[rasn(identifier = "connectionID")]
pub connection_id: LaneConnectionID,
}
impl ConnectionTrajectoryAddGrpC {
pub fn new(nodes: NodeSetXY, connection_id: LaneConnectionID) -> Self {
Self {
nodes,
connection_id,
}
}
}
#[doc = "This DE defines an enumerated list of toxic emission types for vehicles."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum EmissionType {
euro1 = 0,
euro2 = 1,
euro3 = 2,
euro4 = 3,
euro5 = 4,
euro6 = 5,
}
#[doc = "This DE defines a list of reasons for sudden changes in"]
#[doc = "eventState parameters, thereby offering a reason for extended waiting times."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum ExceptionalCondition {
unknown = 0,
publicTransportPriority = 1,
emergencyVehiclePriority = 2,
trainPriority = 3,
bridgeOpen = 4,
vehicleHeight = 5,
weather = 6,
trafficJam = 7,
tunnelClosure = 8,
meteringActive = 9,
truckPriority = 10,
bicyclePlatoonPriority = 11,
vehiclePlatoonPriority = 12,
}
#[doc = "This DF defines a list of prioritization responses e.g. public transport acceleration."]
#[doc = "The signal prioritization (e.g. public transport) procedure in this profile follows two strategies."]
#[doc = "- For simple prioritization requests, the CAM/SPAT messages are used. "]
#[doc = " This allows the migration of old legal systems towards C-ITS."]
#[doc = " In this case, the CAM message is used to trigger the request towards the traffic light controller. "]
#[doc = " The traffic light controller checks the request and broadcasts the status for the priority request with this DF (see [ISO TS 19091] G.5.1.9)."]
#[doc = "- For more complex signal requests, the SignalRequestMessage/SignalStatusMessage messages are to be used."]
#[doc = "- @field activePrioritizations: list of Prioritizations."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "IntersectionState-addGrpC")]
#[non_exhaustive]
pub struct IntersectionStateAddGrpC {
#[rasn(identifier = "activePrioritizations")]
pub active_prioritizations: Option<PrioritizationResponseList>,
}
impl IntersectionStateAddGrpC {
pub fn new(active_prioritizations: Option<PrioritizationResponseList>) -> Self {
Self {
active_prioritizations,
}
}
}
#[doc = "This DF is used to provide real-time positioning information feedback to a specific ITS station "]
#[doc = "(e.g. vehicle, pedestrian, bicycle) by infrastructure equipment."]
#[doc = " The position information includes, for example, the driving, crossing lane and/or the X/Y coordinates in relation to"]
#[doc = "the reference position of the MapData. The `timeReference` indicates the time stamp of the the"]
#[doc = "message (received from an ITS station) for which the positioning feedback has been computed."]
#[doc = "- @field stationID: unique identifier."]
#[doc = "- @field laneID: LaneID."]
#[doc = "- @field nodeXY: NodeOffsetPointXY."]
#[doc = "- @field timeReference: TimeReference."]
#[doc = "\n\n@note: The computation of the positioning feedback is out of focus of this standard."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct ItsStationPosition {
#[rasn(identifier = "stationID")]
pub station_id: StationID,
#[rasn(identifier = "laneID")]
pub lane_id: Option<LaneID>,
#[rasn(identifier = "nodeXY")]
pub node_xy: Option<NodeOffsetPointXY>,
#[rasn(identifier = "timeReference")]
pub time_reference: Option<TimeReference>,
}
impl ItsStationPosition {
pub fn new(
station_id: StationID,
lane_id: Option<LaneID>,
node_xy: Option<NodeOffsetPointXY>,
time_reference: Option<TimeReference>,
) -> Self {
Self {
station_id,
lane_id,
node_xy,
time_reference,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct ItsStationPositionList(pub SequenceOf<ItsStationPosition>);
#[doc = "Lanes may have limitations regarding vehicle height (e.g. due to a tunnel) and vehicle weight (e.g. due to a bridge). "]
#[doc = "- @field maxVehicleHeight: maximum allowed vehicle height"]
#[doc = "- @field maxVehicleWeight: maximum allowed vehicle mass"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "LaneAttributes-addGrpC")]
#[non_exhaustive]
pub struct LaneAttributesAddGrpC {
#[rasn(identifier = "maxVehicleHeight")]
pub max_vehicle_height: Option<VehicleHeight>,
#[rasn(identifier = "maxVehicleWeight")]
pub max_vehicle_weight: Option<VehicleMass>,
}
impl LaneAttributesAddGrpC {
pub fn new(
max_vehicle_height: Option<VehicleHeight>,
max_vehicle_weight: Option<VehicleMass>,
) -> Self {
Self {
max_vehicle_height,
max_vehicle_weight,
}
}
}
#[doc = "This DF defines a list of three-dimensional positions of signal heads in an intersection. "]
#[doc = "It enables vehicles to identify the signal head location for optical evaluation of the traffic light. "]
#[doc = "Combined with the SPAT/MapData messages, it enables e.g. driving vehicles to enhance safety decision in critical situations."]
#[doc = "- @field signalHeadLocations: list of geo positions"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "MapData-addGrpC")]
#[non_exhaustive]
pub struct MapDataAddGrpC {
#[rasn(identifier = "signalHeadLocations")]
pub signal_head_locations: Option<SignalHeadLocationList>,
}
impl MapDataAddGrpC {
pub fn new(signal_head_locations: Option<SignalHeadLocationList>) -> Self {
Self {
signal_head_locations,
}
}
}
#[doc = "Priority and preemption have a considerable impact to the timing parameters in the SPAT message (eventState)."]
#[doc = "User acceptance is expected to increase if the reason for sudden changes in timing parameters is communicated to them."]
#[doc = "- @field stateChangeReason: reason code"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "MovementEvent-addGrpC")]
#[non_exhaustive]
pub struct MovementEventAddGrpC {
#[rasn(identifier = "stateChangeReason")]
pub state_change_reason: Option<ExceptionalCondition>,
}
impl MovementEventAddGrpC {
pub fn new(state_change_reason: Option<ExceptionalCondition>) -> Self {
Self {
state_change_reason,
}
}
}
#[doc = "This DF is used to to identify a node of a lane (waypoint) by its `lane` and node identifier `id`. "]
#[doc = "The `intersectionID` is used if the referenced lane belongs to an adjacent intersection. If the node"]
#[doc = "belongs to a connection trajectory ([ISO TS 19091] G.5.1.2) the `connectionID` is used."]
#[doc = "- @field id: unique identifier."]
#[doc = "- @field lane: identifier from lane."]
#[doc = "- @field connectionID: identifier from connection."]
#[doc = "- @field intersectionID: identifier from intersection."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct Node {
pub id: Integer,
pub lane: Option<LaneID>,
#[rasn(identifier = "connectionID")]
pub connection_id: Option<LaneConnectionID>,
#[rasn(identifier = "intersectionID")]
pub intersection_id: Option<IntersectionID>,
}
impl Node {
pub fn new(
id: Integer,
lane: Option<LaneID>,
connection_id: Option<LaneConnectionID>,
intersection_id: Option<IntersectionID>,
) -> Self {
Self {
id,
lane,
connection_id,
intersection_id,
}
}
}
#[doc = "This DF defines additional attributes to support public transport and to enable a simple way of defining lane links."]
#[doc = "- @field ptvRequest: defines control types attached to a node on a lane used by public transport for triggering"]
#[doc = " the transmission of messages (e.g. prioritization request). It includes control points for public transport prioritization. "]
#[doc = " These control points are currently implemented by legacy systems using hardware sensors mounted on the roadside."]
#[doc = "- @field nodeLink: defines a link to one or to a set of another node/lane from this node. The nodeLink allows to set a link between specific nodes "]
#[doc = " of generic lanes or trajectories. This supports e.g. lane merging/diverging situations ([ISO TS 19091] G.8.2.7) and the linking of trajectories "]
#[doc = " in the conflict zone to lanes (see example [ISO TS 19091] G.8.2.5)."]
#[doc = "- @field node: defines an identifier of this node."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "NodeAttributeSet-addGrpC")]
#[non_exhaustive]
pub struct NodeAttributeSetAddGrpC {
#[rasn(identifier = "ptvRequest")]
pub ptv_request: Option<PtvRequestType>,
#[rasn(identifier = "nodeLink")]
pub node_link: Option<NodeLink>,
pub node: Option<Node>,
}
impl NodeAttributeSetAddGrpC {
pub fn new(
ptv_request: Option<PtvRequestType>,
node_link: Option<NodeLink>,
node: Option<Node>,
) -> Self {
Self {
ptv_request,
node_link,
node,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=5"))]
pub struct NodeLink(pub SequenceOf<Node>);
#[doc = "This DF includes the altitude data element defined in the common data dictionary [ETSI CDD]."]
#[doc = "- @field elevation: the data element is replaced by the ETSI `altitude` data element using the regional extension. "]
#[doc = " The `altitude` data element is defined in Position3D-addGrpC of this profile."]
#[doc = " Position3D-addGrpC extends the @ref Position3D using the regional extension framework."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "Position3D-addGrpC")]
#[non_exhaustive]
pub struct Position3DAddGrpC {
pub altitude: Altitude,
}
impl Position3DAddGrpC {
pub fn new(altitude: Altitude) -> Self {
Self { altitude }
}
}
#[doc = "This DF is used to provide the prioritization status response and the"]
#[doc = "signal group identifier for a specific ITS station (e.g. vehicle)."]
#[doc = "- @field stationID: StationID."]
#[doc = "- @field priorState: PrioritizationResponseStatus."]
#[doc = "- @field signalGroup: SignalGroupID."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct PrioritizationResponse {
#[rasn(identifier = "stationID")]
pub station_id: StationID,
#[rasn(identifier = "priorState")]
pub prior_state: PrioritizationResponseStatus,
#[rasn(identifier = "signalGroup")]
pub signal_group: SignalGroupID,
}
impl PrioritizationResponse {
pub fn new(
station_id: StationID,
prior_state: PrioritizationResponseStatus,
signal_group: SignalGroupID,
) -> Self {
Self {
station_id,
prior_state,
signal_group,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=10"))]
pub struct PrioritizationResponseList(pub SequenceOf<PrioritizationResponse>);
#[doc = "This DE defines a list of activation requests used for C-ITS migration of legacy public "]
#[doc = "transport prioritization systems. "]
#[doc = "The activation points are used while approaching to an intersection."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum PtvRequestType {
preRequest = 0,
mainRequest = 1,
doorCloseRequest = 2,
cancelRequest = 3,
emergencyRequest = 4,
}
#[doc = "This DE defines a list of reasons for rejected priority requests."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
#[rasn(enumerated)]
#[non_exhaustive]
pub enum RejectedReason {
unknown = 0,
exceptionalCondition = 1,
maxWaitingTimeExceeded = 2,
ptPriorityDisabled = 3,
higherPTPriorityGranted = 4,
vehicleTrackingUnknown = 5,
}
#[doc = "Some road authorities like to give priority to vehicles based on the type of fuel they use. In addition,"]
#[doc = "electric vehicles may receive priority based on their battery status."]
#[doc = "- @field fuel: fuel used by vehicle."]
#[doc = "- @field batteryStatus: current batter status of vehicle."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "RequestorDescription-addGrpC")]
#[non_exhaustive]
pub struct RequestorDescriptionAddGrpC {
pub fuel: Option<FuelType>,
#[rasn(identifier = "batteryStatus")]
pub battery_status: Option<BatteryStatus>,
}
impl RequestorDescriptionAddGrpC {
pub fn new(fuel: Option<FuelType>, battery_status: Option<BatteryStatus>) -> Self {
Self {
fuel,
battery_status,
}
}
}
#[doc = "This DF defines the driving restriction based on toxic emission type. "]
#[doc = "The meaning of the word `restriction` is ambiguous as it may have a double interpretation, being:"]
#[doc = " - only these vehicles are allowed OR "]
#[doc = " - these vehicles are not allowed and all others are. "]
#[doc = "The former is what is intended by the base standard."]
#[doc = "- @field emission: restriction baesed on emission."]
#[doc = "- @field fuel: restriction baesed on fuel."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "RestrictionUserType-addGrpC")]
#[non_exhaustive]
pub struct RestrictionUserTypeAddGrpC {
pub emission: Option<EmissionType>,
pub fuel: Option<FuelType>,
}
impl RestrictionUserTypeAddGrpC {
pub fn new(emission: Option<EmissionType>, fuel: Option<FuelType>) -> Self {
Self { emission, fuel }
}
}
#[doc = "This DF defines the XYZ position of a signal head within an intersection"]
#[doc = "and indicates the related signal group identifier."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags)]
#[non_exhaustive]
pub struct SignalHeadLocation {
#[rasn(identifier = "nodeXY")]
pub node_xy: NodeOffsetPointXY,
#[rasn(identifier = "nodeZ")]
pub node_z: DeltaAltitude,
#[rasn(identifier = "signalGroupID")]
pub signal_group_id: SignalGroupID,
}
impl SignalHeadLocation {
pub fn new(
node_xy: NodeOffsetPointXY,
node_z: DeltaAltitude,
signal_group_id: SignalGroupID,
) -> Self {
Self {
node_xy,
node_z,
signal_group_id,
}
}
}
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, size("1..=64"))]
pub struct SignalHeadLocationList(pub SequenceOf<SignalHeadLocation>);
#[doc = "The traffic control centre (TCC) may advice a public transport vehicle (e.g. bus) to synchronize his travel time. "]
#[doc = "This may happen when, for example, two busses, due to special traffic conditions, are out of schedule. "]
#[doc = "The first might be too late, the second too fast. The consequence is that the second is driving"]
#[doc = "just behind the first and is empty as all passengers are within the first one. To avoid this often-occurring"]
#[doc = "situation, the TCC transmits time synchronization advices to the public transport vehicles using the"]
#[doc = "signal status message. "]
#[doc = "- @field synchToSchedule: DeltaTime."]
#[doc = "- @field rejectedReason: RejectedReason."]
#[doc = "\n\n@Note: The @ref PrioritizationResponseStatus provides optionally the reason for prioritization response rejection."]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(automatic_tags, identifier = "SignalStatusPackage-addGrpC")]
#[non_exhaustive]
pub struct SignalStatusPackageAddGrpC {
#[rasn(identifier = "synchToSchedule")]
pub synch_to_schedule: Option<DeltaTime>,
#[rasn(identifier = "rejectedReason")]
pub rejected_reason: Option<RejectedReason>,
}
impl SignalStatusPackageAddGrpC {
pub fn new(
synch_to_schedule: Option<DeltaTime>,
rejected_reason: Option<RejectedReason>,
) -> Self {
Self {
synch_to_schedule,
rejected_reason,
}
}
}
#[doc = "This DE defines a value in milliseconds in the current minute related to UTC time. "]
#[doc = "The range of 60 000 covers one minute (60 seconds * 1 000 milliseconds)"]
#[doc = "\n\n@category: Infrastructure information"]
#[doc = "\n\n@revision: V1.3.1"]
#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
#[rasn(delegate, value("0..=60000"))]
pub struct TimeReference(pub u16);
}
#[allow(
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
unused,
clippy::too_many_arguments
)]
pub mod etsi_its_dsrc_region {
extern crate alloc;
use core::borrow::Borrow;
use rasn::prelude::*;
use super::super::dsrc_2_2_1::etsi_its_dsrc::*;
use super::super::dsrc_2_2_1::etsi_its_dsrc_add_grp_c::{
ConnectionManeuverAssistAddGrpC,
ConnectionTrajectoryAddGrpC,
IntersectionStateAddGrpC,
LaneAttributesAddGrpC,
MapDataAddGrpC,
MovementEventAddGrpC,
NodeAttributeSetAddGrpC,
Position3DAddGrpC,
RequestorDescriptionAddGrpC,
RestrictionUserTypeAddGrpC,
SignalStatusPackageAddGrpC,
};
}