diff --git a/osi_vehicle.proto b/osi_vehicle.proto new file mode 100644 index 000000000..19fdd99cf --- /dev/null +++ b/osi_vehicle.proto @@ -0,0 +1,1030 @@ +syntax = "proto2"; + +option optimize_for = SPEED; + +import "osi_version.proto"; +import "osi_common.proto"; +import "osi_object.proto"; +import "osi_occupant.proto"; + +package osi3; + +// +// \brief The first message describes a single vehicle in a deeper way than any other osi-class. +// As it is an description of the whole vehicle it can be used as interface for various reasons, +// e.g. to the vehicle/dynamic-model for kinematics calculation or even for measurements in real vehicles. +// It is based on the message VehicleClass, which is also defined later in this proto. +// The vehicle can be the host but also any other participant. +// +message Vehicle +{ + // + // The interface version used by the sender (i.e. the simulation environment). + // + optional InterfaceVersion version = 1; + + // + // The data timestamp of the simulation environment. The zero time point is + // arbitrary but must be identical for all messages. + // Recommendation: Zero time point for start point of the simulation. + // + optional Timestamp timestamp = 2; + + // + // True, if the following vehicle-object is the host. + // + optional bool is_host_vehicle = 3; + + // + // Deeper going description of one vehicle regarding these aspects: + // Vehicle-Basics, Vehicle-Kinematics, Vehicle-Powertrain, Vehicle-SteeringWheel, Vehicle-Wheels, + // Vehicle-Light-State, Vehicle-Localization, Vehicle-Automated-Driving-Functions. + // + optional VehicleClass vehicle = 4; +} + +// +// \brief The second message describes the traffic on the map (or an implementation-specific area). +// This can also include the host-vehicle. +// The main-usage so far is the visualisation of traffic in a graphic-engine. +// It is based on the message VehicleClass, which is also defined next in this proto. +// +message Traffic +{ + // + // The interface version used by the sender (i.e. the simulation environment). + // + optional InterfaceVersion version = 1; + + // + // The data timestamp of the simulation environment. The zero time point is + // arbitrary but must be identical for all messages. + // Recommendation: Zero time point for start point of the simulation. + // + optional Timestamp timestamp = 2; + + // + // The ID of the host vehicle object. + // + optional Identifier host_vehicle_id = 3; + + // + // Deeper going description of one or more vehicle regarding these aspects: + // Vehicle-Basics, Vehicle-Kinematics, Vehicle-Powertrain, Vehicle-SteeringWheel, Vehicle-Wheels, + // Vehicle-Light-State, Vehicle-Localization, Vehicle-Automated-Driving-Functions. + // + repeated VehicleClass vehicle = 4; +} + +// +// \brief The vehicle-class is a deeper description of a vehicle. +// It consists of different messages categorizing the vehicle in: +// Vehicle-Basics, Vehicle-Kinematics, Vehicle-Powertrain, Vehicle-SteeringWheel, Vehicle-Wheels, +// Vehicle-Light-State, Vehicle-Localization, Vehicle-Automated-Driving-Functions. +// As it is an description of the whole vehicle (focus on cars) it can be used as interface for various reasons, +// e.g. to the vehicle-model for kinematics calculation or even for the visualisation in a graphic-engine. +// +message VehicleClass +{ + // The identifier of the vehicle in the simulation. + // + optional Identifier vehicle_id = 1; + + // + // The basic parameters of the vehicle. + // + optional VehicleBasics vehicle_basics = 2; + + // + // This is the interface, that describes how the vehicle is moving. + // All coordinates and orientations are relative to the global ground truth + // coordinate system. + // + optional VehicleKinematics vehicle_kinematics = 3; + + // + // Interface regarding the powertrain. + // + optional VehiclePowertrain vehicle_powertrain = 4; + + // + // Interface regarding the SteeringWheel. + // The focus here is on the steering wheel. + // + optional VehicleSteeringWheel vehicle_steering_wheel = 5; + + // + // Interface regarding the wheels. + // The focus here is on the physical description of a wheel. + // + optional VehicleWheels vehicle_wheels = 6; + + // + // Interface regarding the light. + // The focus here is on the states of the lights. + // + optional MovingObject.VehicleClassification.LightState vehicle_light_state = 7; + + // + // Interface regarding the navigation. + // + optional VehicleLocalization vehicle_localization = 8; + + // + // Interface regarding automated-driving functions. + // The focus here is on states and intentions of a function. + // + repeated VehicleAutomatedDrivingFunction vehicle_automated_driving_function = 9; + + // + // \brief The absolut base parameters of the vehicle. + // + message VehicleBasics + { + // The reference_string to the vehicle (e.g. CAD-Modell). + // + // \note It is implementation-specific how the string is filled. + // + optional string reference_string = 1; + + // The license plate of the vehicle. + // There is no international standardization. + // Recommendation: Use the discription in DIN 74069:1996-07. + // If single-line: maximum of 8 Characters. + // two-line: 9-13 Characters. + // + optional string license_plate = 2; + + // Option, if the vehicle should be visible or not for visualisation reasons. + // + optional bool is_visible = 3; + } + + // + // \brief So this is the interface, that describes how the vehicle is + // moving. + // All coordinates and orientations are relative to the global ground truth + // coordinate system. + // + message VehicleKinematics + { + // The base parameters of the vehicle. + // + // \note The bounding box does NOT include mirrors for vehicles. + // + optional BaseMoving base = 1; + + // The total mass of the vehicle (curb weight). + // + // Unit: [kg] + // + optional double weight = 2; + } + + // + // \brief Interface to the vehicle-model. + // The focus here is on the powertrain. + // + message VehiclePowertrain + { + // The positions of the pedals. + // + optional Pedalry pedalry = 1; + + // Rounds per minute of the crankshaft. + // + // Unit: [1/min] + // + optional double engine_rpm = 2; + + // Torque in Nm. + // + // Unit: [N*m] + // + optional double engine_torque = 3; + + // Consumption in liters per 100 km. + // + // Unit: [l/100km] + // + optional double fuel_consumption = 4; + + // Consumption of electrical or hybrid vehicle per 100 km + // + // Unit: [kW/100kmh] + // + optional double electrical_energy_consumption = 5; + + // The actual gear of the gear lever. + // + optional GearLeverState gear_lever_state = 6; + + // The actual gear of the transmission. + // E.g. gear_lever can be in "D" and transmission in "4", but not the + // other way around. + // + // The sign of this field is linked to the gear's mode as following: + // - zero: neutral position + // - positive: driving forward mode + // - negative: reverse mode (generally -1, but few vehicles have several + // reverse mode gears) + // + optional int32 gear_transmission = 7; + + // Position of the handbrake. + // A value of 0% means fully released and 100% means fully pressed + // + // Unit: [%] + // + optional double handbrake_position = 8; + + // Description how the powertrain is providing power to the wheels. + // + optional PowertrainMode powertrain_mode = 9; + + // Definition how the powertrain is providing power to the wheels. + // + enum PowertrainMode + { + // The powertrain mode is unknown. + // + POWERTRAIN_MODE_UNKNOWN = 0; + + // It is another powertrain mode. + // + POWERTRAIN_MODE_OTHER = 1; + + // All-wheel drive (AWD). + // + POWERTRAIN_MODE_ALL_WHEEL_DRIVE = 2; + + // Front-wheel drive (FWD). + // + POWERTRAIN_MODE_FRONT_WHEEL_DRIVE = 3; + + // Rear-wheel drive (RWD). + // + POWERTRAIN_MODE_REAR_WHEEL_DRIVE = 4; + } + } + + // + // \brief Interface to the vehicle-model. + // The focus here is on the steering wheel. + // + message VehicleSteeringWheel + { + // Angle, angle-speed and torque. + // See osi_common_extension. + // + optional SteeringWheel steering_wheel = 1; + + // Spring-stiffness of the steering in Nm/deg. + // + // Unit: [N*m/deg] + // + optional double steering_springstiffness = 2; + + // Damping of the steering in Nm*s/deg. + // + // Unit: [N*m*s/deg] + // + optional double steering_damping = 3; + + // Friction of the steering in Nm. + // + // Unit: [N*m] + // + optional double steering_friction = 4; + + // Describes the state of the passenger's hands related to the steering + // wheel (mostly driver). + // + optional Occupant.Classification.SteeringControl steering_control = 5; + } + + // + // \brief The focus here is on the physical description of the wheels. + // + message VehicleWheels + { + // Contains the physical description of a wheel. + // + repeated Wheel wheel = 1; + + // + // \brief The focus here is on the physical description of a wheel. + // + message Wheel + { + // Information about how the wheel is arranged. + // + optional Arrangement arrangement = 1; + + // Dry friction is a force that opposes the relative lateral motion of two solid surfaces + // in contact. It is subdivided into static friction between non-moving surfaces and kinetic + // friction between moving surfaces. + // Ued here is the dry friction coefficient of the paired materials (see reference). + // Dimensionless. + // + // Unit: [] + // + // \par References: + // - http://adaptivemap.ma.psu.edu/websites/6_friction/dry_friction/dryfriction.html + // + optional double kinetic_friction_coefficient = 2; + + // Contact point of the mid of the tire tread with the world. + // Absolute coordinates (x, y, z). + // + // Unit: [m] + // + optional Vector3d contact_point = 3; + + // Contains the rotational speed of each wheel per second. + // + // Unit: [rad/s] + // + optional double rotational_speed = 4; + + // Contains the steering angle of each wheel. + // Right < 0; 0 = straight; 0 < left. + // + // Unit: [rad] + // + optional double steeringangle = 5; + + // Contains the relativ position of the center of the wheel to the center of the bounding-box. + // Possibility to get the spring deflection and the camber (https://en.wikipedia.org/wiki/Camber_angle). + // + // Unit: [m] + // + optional MountingPosition position = 6; + + // Contains the tirepressure of the tire. + // + // Unit: [Pa] + // + optional double tirepressure = 7; + + // Contains the longitudinal slip of the tire. + // \par References: + // - https://www.kfz-tech.de/Biblio/Formelsammlung/Schlupf.htm + // + // Unit: [%] + // + optional double slip = 8; + + // Information about how the wheel is arranged. + // + enum Arrangement + { + // The description is about a wheel that has an unknown arrangement. + // + ARRANGEMENT_UNKNOWN = 0; + + // The description is about a wheel that has another arrangement (e.g. more than six wheels). + // + ARRANGEMENT_OTHER = 1; + + // The description is about the front-left wheel. + // + ARRANGEMENT_FRONT_LEFT = 2; + + // The description is about the front-right wheel. + // + ARRANGEMENT_FRONT_RIGHT = 3; + + // The description is about the rear-left wheel. + // + ARRANGEMENT_REAR_LEFT = 4; + + // The description is about the rear-right wheel. + // + ARRANGEMENT_REAR_RIGHT = 5; + + // The description is about the mid-left wheel. + // + ARRANGEMENT_MID_LEFT = 6; + + // The description is about the mid-right wheel. + // + ARRANGEMENT_MID_RIGHT = 7; + } + } + } + + // + // \brief This message contains all the necessary information of the localization solution. + // + message VehicleLocalization + { + // Longitude in decimal degrees. + // + // Unit: [degree] + // + optional double longitude = 1; + + // Latitude in decimal degrees. + // + // Unit: [degree] + // + optional double latitude = 2; + + // Altitude in meters. + // + // Unit: [m] + // + optional double altitude = 3; + + // Heading in degrees. + // + // Unit: [degree] + // + optional double heading = 4; + + // Accuracy of localization measurement measured in percentage of the units + // + // Unit: [%] + // + optional double localization_accuracy = 5; + + // Number of satellites + // + optional int32 number_of_satellites = 6; + } + + // + // \brief Interface to an automated driving system. + // + // Important is the differentiation between internal states, intentions and external requests: + // Internal states: Description of absolute states of an ad-function (e.g. available/unavailable). + // Intentions: Description of how the function would like to control the vehicle. + // External requests: Description of requests to the function (e.g. driver wants the function to start). + // + message VehicleAutomatedDrivingFunction + { + // + // Here the name of the function can be chosen out of VDA-based enums. + // + optional FunctionName function_name = 1; + + // + // Internal states of the ad-function (Output). + // + optional FunctionStates function_states = 2; + + // + // Intentions, requests or wishes from the function to change the vehicle-state (Output). + // + optional FunctionIntentions function_intentions = 3; + + // + // Requests from an external participant to change the internal states of the ad-function (Input). + // E.g. driver pressed activation button, but this is just a request. The function itself has to + // decide if this is possible. + // + optional FunctionExternalRequests function_external_requests = 4; + + // The possible functions. + // References: + // - https://www.vda.de/en/topics/innovation-and-technology/automated-driving/automated-driving + // + enum FunctionName + { + // The function name is unknown. + // + FUNCTION_NAME_UNKNOWN = 0; + + // It is another function. + // + FUNCTION_NAME_OTHER = 1; + + // Autopilot in urban areas. + // + FUNCTION_NAME_LEVEL_4_URBAN_DRIVING = 2; + + // Driverless parking. + // + FUNCTION_NAME_LEVEL_4_VALET_PARKING = 3; + + // Autopilot on the highway. + // + FUNCTION_NAME_LEVEL_3_HIGHWAY_DRIVING = 4; + + // Autopilot for traffic jams. + // + FUNCTION_NAME_LEVEL_3_TRAFFIC_JAM_DRIVING = 5; + + // Parking done by function lateral and longitudinal. + // + FUNCTION_NAME_LEVEL_2_PARKING_ASSISTANT = 6; + + // Parking done by function lateral. + // + FUNCTION_NAME_LEVEL_1_PARKING_STEERING_ASSISTANT = 7; + + // Longitudinal control with distance keeping by function. + // + FUNCTION_NAME_LEVEL_1_ADAPTIVE_CRUISE_CONTROL = 8; + + // Lateral control by function to keep the lane. + // + FUNCTION_NAME_LEVEL_1_LANE_KEEP_ASSISTANT = 9; + + // Longitudinal control by function. + // + FUNCTION_NAME_LEVEL_1_CRUISE_CONTROL = 10; + + // The maximum speed is limited by a function. + // + FUNCTION_NAME_LEVEL_1_LIMIT = 11; + + // Warning when the vehicle drives over the lane border markings. + // + FUNCTION_NAME_LEVEL_0_LANE_DEPARTURE_WARNING = 12; + + // Monitoring of the blind spot. + // + FUNCTION_NAME_LEVEL_0_BLIND_SPOT_MONITORING = 13; + + // Warning by the danger of a collision. + // + FUNCTION_NAME_LEVEL_0_FORWARD_COLLISION_WARNING = 14; + } + + // + // \brief Internal states of an automated-driving function. + // + message FunctionStates + { + // The state of the function. + // + optional State state = 1; + + // This is the speed the function targets. + // E.g.: At the point of activation, the actual speed could be 80 km/h, + // but the function tries to accelerate to 130 km/h. + // + // Unit: [km/h] + // + optional double targeted_speed = 2; + + // The timegap describes the targeted distance to the next vehicle in front. + // + // Unit: [s] + // + optional double targeted_distance = 3; + + // Possibility to inform about an error, warning or just to give an information. + // + // \note It is implementation-specific which information should be sent. + // + optional Notification notification = 4; + + // Definition of possible function-states. + // + enum State + { + // The function-state is unknown. + // + STATE_UNKNOWN = 0; + + // The function has another state. + // + STATE_OTHER = 1; + + // The function is not working. + // + STATE_OFF = 2; + + // The function is initializing. + // Transition: STATE_OFF ==> STATE_UNAVAILABLE or STATE_AVAILABLE. + // + STATE_INITIALIZING = 3; + + // The function is initialized but not ready to start. + // + STATE_UNAVAILABLE = 4; + + // The function is initialized and ready to start. + // + STATE_AVAILABLE = 5; + + // The function is starting. + // Transition: STATE_AVAILABLE ==> STATE_RUNNING. + // + STATE_STARTING = 6; + + // The function is running. + // + STATE_RUNNING = 7; + + // The function is stopping. + // Transition: STATE_RUNNING ==> STATE_UNAVAILABLE or STATE_AVAILABLE. + // + STATE_STOPPING = 8; + + // An Error occured in the function. + // Recommendation: Send an error-description via notification. + // + STATE_FAILURE = 9; + } + } + + // + // \brief Intentions of the an automated-driving function as output to control the vehicle. + // \note There are many ways to control a vehicle e.g. to steer by trajectory or curvature + // or (steering)wheel angle. This interface enables all of them until there is a common sense. + // + message FunctionIntentions + { + // All information about the trajectory the vehicle should follow. + // + optional Trajectory trajectory = 1; + + // Desired angle, angle-speed and torque. + // + optional SteeringWheel steering_wheel = 2; + + // Factor to scale the steeringtorque of the function output. + // + // \note 0 = no force of the function, 0.5 = half the force, 1 = 100% torque. + // + // Range: [0, 1] + // + optional double steering_override_factor = 3; + + // Desired acceleration-, brakepedal and clutch. + // + optional Pedalry pedalry = 4; + + // Intention to change the light state of the vehicle (e.g. indicators for a lane change). + // + optional MovingObject.VehicleClassification.LightState light_state = 5; + + // Request that the driver has to take over. + // + // \note 0 = off; 1 = on. + // + optional bool driver_take_over_request = 6; + } + + // + // \brief External Requests to an automated-driving function as input. + // E.g. Driver presses the function-activation-button a requested state can be send, + // the function itself can then decide if an activation can be done and change its internal state. + // + // + message FunctionExternalRequests + { + // External request to change the state of the function. + // + optional StateCommand state_command = 1; + + // By that signal the targeted speed (e.g. adaptive cruise control) can be reduced or risen. + // + // Unit: [km/h] + // + optional ChangeTargetedValue change_targeted_speed = 2; + + // By that signal the minimum timegap to the next vehicle can be reduced or risen. + // + // Unit: [s] + // + optional ChangeTargetedValue change_targeted_distance = 3; + + // Possibility to inform about an error, warning or just to give an information. + // + // \note It is implementation-specific which information should be sent. + // + optional Notification notification = 4; + + // Definition of possible inputs to change a targeted value of a function. + // + enum ChangeTargetedValue + { + // The command is unknown. + // + CHANGE_TARGETED_VALUE_UNKNOWN = 0; + + // The command is another one. + // + CHANGE_TARGETED_VALUE_OTHER = 1; + + // The targeted value should rise by a small step. + // + CHANGE_TARGETED_VALUE_RISE_SMALL_STEP = 2; + + // The targeted value should rise by a big step. + // + CHANGE_TARGETED_VALUE_RISE_BIG_STEP = 3; + + // The targeted value should be reduced by a small step. + // + CHANGE_TARGETED_VALUE_REDUCE_SMALL_STEP = 4; + + // The targeted value should be reduced by a big step. + // + CHANGE_TARGETED_VALUE_REDUCE_BIG_STEP = 5; + } + + // Definition of possible commands to change the state of a function. + // + enum StateCommand + { + // The command is unknown. + // + STATE_COMMAND_UNKNOWN = 0; + + // The command is another one. + // + STATE_COMMAND_OTHER = 1; + + // The function should initialize. + // + STATE_COMMAND_INITIALIZE = 2; + + // The function should reach STATE_RUNNING. + // + STATE_COMMAND_START = 3; + + // The function should change from STATE_RUNNING to another state. + // + STATE_COMMAND_STOP = 4; + + // The function should reset. + // + STATE_COMMAND_RESET = 5; + } + } + } +} + + +// +// \brief A description for the steering wheel. +// +message SteeringWheel +{ + // Angle of the steering wheel. + // Right < 0; 0 = straight; 0 < left. + // + // Unit: [rad] + // + optional double angle = 1; + + // Angular-speed of the steering wheel. + // Right < 0; 0 = straight; 0 < left. + // + // Unit: [rad/s] + // + optional double angular_speed = 2; + + // Torque of the steering wheel to the hand. + // Right < 0; 0 = straight; 0 < left. + // + // Unit: [N*m] + // + optional double torque = 3; +} + +// +// \brief A description for the positions of the pedals. +// +// +message Pedalry +{ + // Position of the acceleration-pedal. + // Unit: [0-1] (Unpressed - fully pressed) + // + optional double pedal_position_acceleration = 1; + + // Position of the brake-pedal. + // Unit: [0-1] (Unpressed - fully pressed) + // + optional double pedal_position_brake = 2; + + // Position of the clutch-pedal. + // Unit: [0-1] (Unpressed - fully pressed) + // + optional double pedal_position_clutch = 3; +} + +// +// \brief This is a message to describe, which trajectory the vehicle should +// follow. +// +// +message Trajectory +{ + // Contains the timestamp where the trajectorypoint should be reached. + // + // Unit: [s] + // + optional Timestamp timestamp = 1; + + // Contains the X-Position the vehicle should be at the timestamp. + // + optional double targeted_pos_x = 2; + + // Contains the Y-Position the vehicle should be at the timestamp. + // + optional double targeted_pos_y = 3; + + // Direction of the vehicle at the timestamp. + // + // Unit: [rad] + // + optional double track_angle = 4; + + // Contains the curvature at the timestamp. + // + // Unit: [1/m] + // + optional double curvature = 5; + + // Contains the curvature change at the timestamp. + // + // Unit: [1/(m*s)] + // + optional double curvature_change = 6; + + // Contains the velocity of the vehicle at the timestamp. + // + // Unit: [m/s] + // + optional double velocity = 7; + + // Contains the acceleration of the vehicle at the timestamp. + // + // Unit: [m/s^2] + // + optional double acceleration = 8; + + // Contains the interpolation method. + // + optional InterpolationMethod interpolation_method = 9; + + // Contains the interpolation method. + // + enum InterpolationMethod + { + // The interpolation method is unknown. + // + INTERPOLATION_METHOD_UNKNOWN = 0; + + // Other (unspecified but known) interpolation method. + // + INTERPOLATION_METHOD_OTHER = 1; + + // Stay on the actual lane. + // + INTERPOLATION_METHOD_LINEAR = 2; + + // Change to the left. + // + INTERPOLATION_METHOD_CUBIC = 3; + } +} + +// +// \brief The actual gear of the vehicle. +// +// +message GearLeverState +{ + // Current set gear of the gear lever. It is optional if none of these + // conditions is fulfilled: + // - the gear lever controls a manual transmission + // - the gear lever controls an automatic transmission with the manual override mode set. + // + // The sign of this field set the gear's mode as following: + // - zero: neutral position + // - positive: driving forward mode + // - negative: reverse mode (generally -1, but some vehicles have several + // reverse mode gears) + // + optional int32 gear = 1; + + // This Gear Lever controls an automatic transmission. + // + optional bool controls_automatic_transmission = 2; + + // Transmission mode of an automatic transmission. + // + // Optional if the transmission is manual. + // + optional AutomaticTransmissionMode automatic_transmission_mode = 3; + + // The request from the driver to shift gear if the transmission mode is + // MANUAL_OVERRIDE_MODE. + // + optional ManualOverrideRequest manual_override_request = 4; + + // Describe the possible mode of an automatic transmission. + // + enum AutomaticTransmissionMode + { + // The gear transmission mode is unknown (must not be + // used in ground truth). + // + AUTOMATIC_TRANSMISSION_MODE_UNKNOWN = 0; + + // Other (unspecified but known) transmisson mode. + // + AUTOMATIC_TRANSMISSION_MODE_OTHER = 1; + + // The gear lever is in automatic parking mode. + // + AUTOMATIC_TRANSMISSION_MODE_PARK = 2; + + // The gear lever is in reverse motion mode. + // + AUTOMATIC_TRANSMISSION_MODE_REVERSE = 3; + + // The gear lever is in automatic neutral mode. + // + AUTOMATIC_TRANSMISSION_MODE_NEUTRAL = 4; + + // The gear lever is in automatic driving mode. + // + AUTOMATIC_TRANSMISSION_MODE_DRIVE = 5; + + // The gear lever is in a manual override mode. + // + AUTOMATIC_TRANSMISSION_MODE_MANUAL_OVERRIDE = 6; + } + + // Describe a request for a gear change on automatic transmission vehicle + // with a gear shifter. + // + enum ManualOverrideRequest + { + // The manual override request is unknown (must not be + // used in ground truth). + // + MANUAL_OVERRIDE_REQUEST_UNKNOWN = 0; + + // Other (unspecified but known) manual override request. + // + MANUAL_OVERRIDE_REQUEST_OTHER = 1; + + // The driver shifts down on his own. + // + MANUAL_OVERRIDE_REQUEST_GEAR_DOWN = 2; + + // The automatic transmission is in manual override mode + // but the driver is not shifting the gear. + // + MANUAL_OVERRIDE_REQUEST_GEAR_MID = 3; + + // The driver shifts up on his own. + // + MANUAL_OVERRIDE_REQUEST_GEAR_UP = 4; + } +} + +// +// \brief Possibility to send a notification. +// Can be used to send e.g. error-messages. +// +message Notification +{ + // The content of the notification. + // + optional string notification = 1; + + // Defines the type of the notification. + // + optional NotificationType notification_type = 2; + + // Definition of possible notification-types. + // + enum NotificationType + { + // The notification has no type. + // + NOTIFICATION_TYPE_UNKNOWN = 0; + + // The notification has another type. + // + NOTIFICATION_TYPE_OTHER = 1; + + // An error occurred. + // + NOTIFICATION_TYPE_ERROR = 2; + + // The notificiation is a warning. + // + NOTIFICATION_TYPE_WARNING = 3; + + // The notificiation is just an information. + // + NOTIFICATION_TYPE_INFORMATION = 4; + + // The notificiation is used for debugging. + // + NOTIFICATION_TYPE_DEBUG = 5; + } +} diff --git a/setup.py b/setup.py index 03057e679..05dfc7497 100644 --- a/setup.py +++ b/setup.py @@ -67,7 +67,8 @@ def find_protoc(): 'osi_sensordata.proto', 'osi_sensorviewconfiguration.proto', 'osi_sensorspecific.proto', - 'osi_sensorview.proto') + 'osi_sensorview.proto', + 'osi_vehicle.proto') """ Generate Protobuf Messages """