VehicleIOLegacyStructures.h

Go to the documentation of this file.

 
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//
 
#ifndef DW_VEHICLEIO_LEGACY_STRUCTURES_H_
#define DW_VEHICLEIO_LEGACY_STRUCTURES_H_
 
#include <dw/core/base/Types.h>
#include <dw/rig/Rig.h>
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct dwVehicleIOObject* dwVehicleIOHandle_t;
 
typedef enum dwVehicleIODrivingMode {
    DW_VEHICLEIO_DRIVING_LIMITED = 0x000,
 
    DW_VEHICLEIO_DRIVING_LIMITED_ND = 0x100,
 
    DW_VEHICLEIO_DRIVING_COLLISION_AVOIDANCE = 0x200,
 
    DW_VEHICLEIO_DRIVING_NO_SAFETY = 0x300,
 
    DW_VEHICLEIO_DRIVING_MODE_INVALID = 0x400
} dwVehicleIODrivingMode;
 
typedef enum dwVehicleIOType {
    DW_VEHICLEIO_DATASPEED    = 0,
    DW_VEHICLEIO_GENERIC      = 1,
    DW_VEHICLEIO_CUSTOM       = 2,
    DW_VEHICLEIO_DRIVER_COUNT = 3
} dwVehicleIOType;
 
typedef enum dwVehicleIOFaults {
    DW_VEHICLEIO_FAULT_NONE     = 0,
    DW_VEHICLEIO_FAULT_BRAKE    = 1 << 0,
    DW_VEHICLEIO_FAULT_STEERING = 1 << 1,
    DW_VEHICLEIO_FAULT_THROTTLE = 1 << 2,
    DW_VEHICLEIO_FAULT_GEAR     = 1 << 3,
    DW_VEHICLEIO_FAULT_SAFETY   = 1 << 4,
    DW_VEHICLEIO_FAULT_MAX      = UINT32_MAX
} dwVehicleIOFaults;
 
typedef enum dwVehicleIOOverrides {
    DW_VEHICLEIO_OVERRIDE_NONE     = 0,
    DW_VEHICLEIO_OVERRIDE_BRAKE    = 1 << 0,
    DW_VEHICLEIO_OVERRIDE_STEERING = 1 << 1,
    DW_VEHICLEIO_OVERRIDE_THROTTLE = 1 << 2,
    DW_VEHICLEIO_OVERRIDE_GEAR     = 1 << 3,
    DW_VEHICLEIO_OVERRIDE_MAX      = UINT32_MAX
} dwVehicleIOOverrides;
 
//# sergen(generate)
typedef enum dwVehicleIOGear {
    DW_VEHICLEIO_GEAR_UNKNOWN = 0,
 
    // Automatic vehicles
    DW_VEHICLEIO_GEAR_PARK    = 1,
    DW_VEHICLEIO_GEAR_REVERSE = 2,
    DW_VEHICLEIO_GEAR_NEUTRAL = 3,
    DW_VEHICLEIO_GEAR_DRIVE   = 4,
    DW_VEHICLEIO_GEAR_LOW     = 5,
 
    // Stick shift vehicles
    DW_VEHICLEIO_GEAR_MANUAL_REVERSE = 100,
    DW_VEHICLEIO_GEAR_1              = 101,
    DW_VEHICLEIO_GEAR_2              = 102,
    DW_VEHICLEIO_GEAR_3              = 103,
    DW_VEHICLEIO_GEAR_4              = 104,
    DW_VEHICLEIO_GEAR_5              = 105,
    DW_VEHICLEIO_GEAR_6              = 106,
    DW_VEHICLEIO_GEAR_7              = 107,
    DW_VEHICLEIO_GEAR_8              = 108,
    DW_VEHICLEIO_GEAR_9              = 109,
} dwVehicleIOGear;
 
typedef enum dwVehicleIOTurnSignal {
    DW_VEHICLEIO_TURNSIGNAL_UNKNOWN   = 0,
    DW_VEHICLEIO_TURNSIGNAL_OFF       = 1,
    DW_VEHICLEIO_TURNSIGNAL_LEFT      = 2,
    DW_VEHICLEIO_TURNSIGNAL_RIGHT     = 3,
    DW_VEHICLEIO_TURNSIGNAL_EMERGENCY = 4
} dwVehicleIOTurnSignal;
 
typedef enum {
    DW_VEHICLEIO_DOOR_UNKNOWN = 0,
    DW_VEHICLEIO_DOOR_UNLOCK  = 1,
    DW_VEHICLEIO_DOOR_LOCK    = 2
} dwVehicleIODoorLock;
 
typedef enum dwVehicleIOMoonroof {
    DW_VEHICLEIO_MOONROOF_UNKNOWN = 0,
    DW_VEHICLEIO_MOONROOF_CLOSE   = 1,
    DW_VEHICLEIO_MOONROOF_OPEN    = 2
} dwVehicleIOMoonroof;
 
typedef enum dwVehicleIOMirror {
    DW_VEHICLEIO_MIRROR_UNKNOWN      = 0,
    DW_VEHICLEIO_MIRROR_FOLD         = 1,
    DW_VEHICLEIO_MIRROR_UNFOLD       = 2,
    DW_VEHICLEIO_MIRROR_ADJUST_LEFT  = 3,
    DW_VEHICLEIO_MIRROR_ADJUST_RIGHT = 4
} dwVehicleIOMirror;
 
typedef enum dwVehicleIOHeadlights {
    DW_VEHICLEIO_HEADLIGHTS_UNKNOWN   = 0,
    DW_VEHICLEIO_HEADLIGHTS_OFF       = 1,
    DW_VEHICLEIO_HEADLIGHTS_LOW_BEAM  = 2,
    DW_VEHICLEIO_HEADLIGHTS_HIGH_BEAM = 3,
    DW_VEHICLEIO_HEADLIGHTS_DRL       = 4 //DAYTIME RUNNING LIGHTS
} dwVehicleIOHeadlights;
 
// AEB - Automatic Emergency Braking System Status to report externally
typedef enum dwVehicleIOAEBState {
    DW_VEHICLEIO_AEB_STATE_UNKNOWN = 0, // System is in an unknown state
    DW_VEHICLEIO_AEB_STATE_OFF     = 1, // System is off
    DW_VEHICLEIO_AEB_STATE_READY   = 2  // System is operational and ready to fire if necessary
} dwVehicleIOAEBState;
 
// FCW - Forward Collision Warning Status to report externally
typedef enum dwVehicleIOFCWState {
    DW_VEHICLEIO_FCW_STATE_UNKNOWN = 0, // System is in an unknown state
    DW_VEHICLEIO_FCW_STATE_OFF     = 1, // System is off
    DW_VEHICLEIO_FCW_STATE_READY   = 2  // System is operational and ready to fire if necessary
} dwVehicleIOFCWState;
 
// CDW - Close Distance Warning Status to report externally
typedef enum dwVehicleIOCDWRequestType {
    DW_VEHICLEIO_CDW_REQUEST_NONE    = 0, // no activation
    DW_VEHICLEIO_CDW_REQUEST_LEVEL_1 = 1, // level 1 warning (short distance)
    DW_VEHICLEIO_CDW_REQUEST_LEVEL_2 = 2  // level 2 warning (extremely short distance)
} dwVehicleIOCDWRequestType;
 
// BSM - Blind Spot Monitoring Request
typedef enum dwVehicleIOBSMRequest {
    DW_VEHICLEIO_BSM_REQUEST_UNKNOWN    = 0, // Unknown request from Blind Spot Monitor
    DW_VEHICLEIO_BSM_REQUEST_NONE       = 1, // No request from Blind Spot Monitor
    DW_VEHICLEIO_BSM_REQUEST_CONTINUOUS = 2, // Continuous response request from Blind Spot Monitor
    DW_VEHICLEIO_BSM_REQUEST_FLASHING   = 3  // Flashing response request from Blind Spot Monitor
} dwVehicleIOBSMRequest;
 
typedef enum dwVehicleIOLaneChangeFeedbackRequest {
    DW_VEHICLEIO_LCF_OFF            = 0,
    DW_VEHICLEIO_LCF_AVAILABLE      = 1,
    DW_VEHICLEIO_LCF_ACTIVE_LEFT    = 2,
    DW_VEHICLEIO_LCF_ACTIVE_RIGHT   = 3,
    DW_VEHICLEIO_LCF_PROPOSED_LEFT  = 4,
    DW_VEHICLEIO_LCF_PROPOSED_RIGHT = 5,
    DW_VEHICLEIO_LCF_CANCEL_LEFT    = 6,
    DW_VEHICLEIO_LCF_CANCEL_RIGHT   = 7,
} dwVehicleIOLaneChangeFeedbackRequest;
 
typedef enum dwVehicleIOLateralActuatorInterface {
    DW_VEHICLEIO_LATERAL_ACTUATOR_UNKNOWN     = 0, // lateral control actuator interface is unknown
    DW_VEHICLEIO_LATERAL_STEERING_WHEEL_ANGLE = 1, // uses steering wheel angle for lateral control
    DW_VEHICLEIO_LATERAL_FRONT_WHEEL_ANGLE    = 2, // use front wheel angle for lateral control
    DW_VEHICLEIO_LATERAL_CURVATURE            = 3, // use curvature for lateral control
} dwVehicleIOLateralActuatorInterface;
 
// Lateral ADAS mode
// Note: all modes may not be supported depending on vehicle
typedef enum dwVehicleIOLatMode {
    DW_VEHICLEIO_LAT_MODE_UNKNOWN = 0,
    DW_VEHICLEIO_LAT_MODE_IDLE    = 1,
    DW_VEHICLEIO_LAT_MODE_L2      = 2,
    DW_VEHICLEIO_LAT_MODE_L2_PLUS = 3,
    DW_VEHICLEIO_LAT_MODE_L3      = 4,
    DW_VEHICLEIO_LAT_MODE_PARK    = 5,
    DW_VEHICLEIO_LAT_MODE_LSS     = 6,
    DW_VEHICLEIO_LAT_MODE_AES     = 7,
} dwVehicleIOLatMode;
 
// Longitudinal ADAS mode
// Note: all modes may not be supported depending on vehicle
typedef enum dwVehicleIOLonMode {
    DW_VEHICLEIO_LON_MODE_UNKNOWN  = 0,
    DW_VEHICLEIO_LON_MODE_IDLE     = 1,
    DW_VEHICLEIO_LON_MODE_PARK     = 2,
    DW_VEHICLEIO_LON_MODE_CA       = 3, // Collision avoidance
    DW_VEHICLEIO_LON_MODE_DRIVE_L2 = 4,
    DW_VEHICLEIO_LON_MODE_DRIVE_L3 = 5,
} dwVehicleIOLonMode;
 
// Trailer connected status
typedef enum dwVehicleIOTrailerConnectedStatus {
    DW_VEHICLEIO_TRAILER_CONNECTED_UNKNOWN = 0,
    DW_VEHICLEIO_TRAILER_CONNECTED_NO      = 1,
    DW_VEHICLEIO_TRAILER_CONNECTED_YES     = 2,
    DW_VEHICLEIO_TRAILER_CONNECTED_ERROR   = 3,
} dwVehicleIOTrailerConnectedStatus;
 
// Generic struct representing signal quality
typedef enum dwVehicleIOSignalQuality {
    DW_VEHICLEIO_SIGNAL_QUALITY_NOT_OK = 0,
    DW_VEHICLEIO_SIGNAL_QUALITY_OK     = 1,
} dwVehicleIOSignalQuality;
 
typedef enum dwVehicleIOSpeedDirectionESC {
    DW_VEHICLEIO_SPEED_DIRECTION_E_S_C_VOID = 0,
    DW_VEHICLEIO_SPEED_DIRECTION_E_S_C_FORWARD = 1,
    DW_VEHICLEIO_SPEED_DIRECTION_E_S_C_BACKWARD = 2
} dwVehicleIOSpeedDirectionESC;
 
typedef enum dwVehicleIOTirePressureMonitoringState {
    DW_VEHICLEIO_TIRE_PRESSURE_MONITORING_STATE_ACTIVE = 0,
    DW_VEHICLEIO_TIRE_PRESSURE_MONITORING_STATE_WAIT = 1,
    DW_VEHICLEIO_TIRE_PRESSURE_MONITORING_STATE_ERROR = 2,
    DW_VEHICLEIO_TIRE_PRESSURE_MONITORING_STATE_NO_SENSORS = 3,
    DW_VEHICLEIO_TIRE_PRESSURE_MONITORING_STATE_RESET_ACK = 4
} dwVehicleIOTirePressureMonitoringState;
 
typedef enum dwVehicleIOIgnitionStatus {
    DW_VEHICLEIO_IGNITION_STATUS_IGN_LOCK = 0,
    DW_VEHICLEIO_IGNITION_STATUS_IGN_OFF = 1,
    DW_VEHICLEIO_IGNITION_STATUS_IGN_ACC = 2,
    DW_VEHICLEIO_IGNITION_STATUS_IGN_ON = 3,
    DW_VEHICLEIO_IGNITION_STATUS_IGN_START = 4
} dwVehicleIOIgnitionStatus;
 
typedef enum dwVehicleIOESCOperationalState {
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_NORM = 0,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_INIT = 1,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_DIAG = 2,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_EMT = 3,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_TBCC = 4,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_FLT = 5,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_ESP_ASR_CTRL_ACTV = 6,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_SPORT_OFF = 7,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_OFF_SPORT_PLUS = 8,
    DW_VEHICLEIO__E_S_C_OPERATIONAL_STATE_ABS_CTRL_ACTV = 9
} dwVehicleIOESCOperationalState;
 
typedef enum dwVehicleIOAbsIntervention {
    DW_VEHICLEIO_ABS_INTERVENTION_NORM = 0,
    DW_VEHICLEIO_ABS_INTERVENTION_INIT = 1,
    DW_VEHICLEIO_ABS_INTERVENTION_DIAG = 2,
    DW_VEHICLEIO_ABS_INTERVENTION_EMT = 3,
    DW_VEHICLEIO_ABS_INTERVENTION_TBCC = 4,
    DW_VEHICLEIO_ABS_INTERVENTION_FLT = 5,
    DW_VEHICLEIO_ABS_INTERVENTION_ESP_ASR_CTRL_ACTV = 6,
    DW_VEHICLEIO_ABS_INTERVENTION_SPORT_OFF = 7,
    DW_VEHICLEIO_ABS_INTERVENTION_SPORT2_OFF = 8,
    DW_VEHICLEIO_ABS_INTERVENTION_ABS_CTRL_ACTV = 9
} dwVehicleIOAbsIntervention;
 
typedef enum dwVehicleIODrivePositionTarget {
    DW_VEHICLEIO_DRIVE_POSITION_TARGET_D = 0,
    DW_VEHICLEIO_DRIVE_POSITION_TARGET_N = 1,
    DW_VEHICLEIO_DRIVE_POSITION_TARGET_R = 2,
    DW_VEHICLEIO_DRIVE_POSITION_TARGET_P = 3
} dwVehicleIODrivePositionTarget;
 
typedef struct dwStateValueFloat
{
    float32_t value;
    dwTime_t timestamp;
    bool valid;
} dwStateValueFloat;
 
typedef enum dwVehicleIOEmStandStill {
    DW_VEHICLEIO_EM_STAND_STILL_FALSE = 0,
    DW_VEHICLEIO_EM_STAND_STILL_TRUE = 1,
    DW_VEHICLEIO_EM_STAND_STILL_UNKNOWN = 2
} dwVehicleIOEmStandStill;
 
typedef enum dwVehicleIOLatCtrlInterventionDirectionLKA {
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_L_K_A_EVENT_DIRECTION_INVALID = 0,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_L_K_A_EVENT_DIRECTION_FRONT   = 1,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_L_K_A_EVENT_DIRECTION_LEFT    = 2,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_L_K_A_EVENT_DIRECTION_RIGHT   = 3,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_L_K_A_EVENT_DIRECTION_REAR    = 4
} dwVehicleIOLatCtrlInterventionDirectionLKA;
 
typedef enum dwVehicleIOLatCtrlInterventionDirectionELK {
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_E_L_K_EVENT_DIRECTION_INVALID = 0,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_E_L_K_EVENT_DIRECTION_FRONT   = 1,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_E_L_K_EVENT_DIRECTION_LEFT    = 2,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_E_L_K_EVENT_DIRECTION_RIGHT   = 3,
    DW_VEHICLEIO_LAT_CTRL_INTERVENTION_DIRECTION_E_L_K_EVENT_DIRECTION_REAR    = 4
} dwVehicleIOLatCtrlInterventionDirectionELK;
 
typedef struct dwVehicleIOEgoFeedback
{
    dwStateValueFloat linearVelocity[3];        
    dwStateValueFloat angularVelocity[3];       
    dwStateValueFloat linearAcceleration[3];    
    dwStateValueFloat emLinearVelocityStdev[3]; 
    dwStateValueFloat emAngularAccel[3];        
    dwStateValueFloat emOrientation[3];         
    dwStateValueFloat emOrientationStdev[3];    
    float64_t emTranslation[3];                 
    dwTime_t emTimestamp;                       
    dwVehicleIOEmStandStill emStandStill;       
} dwVehicleIOEgoFeedback;
 
typedef struct dwVehicleIOCommand
{
    bool enable; 
 
    // Steering command
    float32_t steeringWheelAngle;    
    float32_t maxSteeringWheelSpeed; 
 
    float32_t frontSteeringAngle;    
    float32_t maxFrontSteeringSpeed; 
    float32_t steeringWheelTorque;   
 
    float32_t rearAxleCurvatureValue; 
 
    float32_t rearSteeringAngle; 
 
    // Throttle command - command to the accelerator pedal deflection as a value from 0 to 1
    float32_t throttleValue; 
 
    // Brake command - command to the brake pedal deflection as a value from 0 to 1
    float32_t brakeValue; 
 
    // Deceleration command - target deceleration rate for the vehicle. NOTE: Depending on IO driver,
    // there are potentially multiple ways to command the vehicle - directly with actuator commands
    // or with targets (deceleration for example) to downstream systems (brake controller).
    float32_t decelerationValue; 
 
    // Acceleration command
    float32_t lonAccelerationValue; 
    float32_t latAccelerationValue; 
 
    // Other commands
    dwVehicleIOGear gear;          
    dwVehicleIOTurnSignal turnSig; 
 
    // Clear CAN bus errors
    bool clearFaults; 
 
    // Booleans validating commands
    bool throttleValid;            
    bool brakeValid;               
    bool steeringWheelValid;       
    bool frontSteeringValid;       
    bool steeringWheelTorqueValid; 
    bool rearAxleCurvatureValid;   
    bool rearSteeringValid;        
    bool gearValid;                
    bool turnSigValid;             
    bool decelerationValid;        
    bool lonAccelerationValid;     
    bool latAccelerationValid;     
    bool remainingDistanceValid;   
    bool maxSpeedValid;            
    bool latModeValid;             
    bool lonModeValid;             
 
    // AEB signals
    bool aebRequest;              
    bool dbsRequest;              
    bool holdRequest;             
    bool prefillRequest;          
    dwVehicleIOAEBState aebState; 
 
    // FCW signals
    bool fcwRequest;              
    dwVehicleIOFCWState fcwState; 
 
    // CDW signals
    dwVehicleIOCDWRequestType cdwRequest; 
 
    uint64_t heartbeatCounter; 
 
    // High accuracy maneuver
    float32_t remainingDistance; 
    float32_t maxSpeed;          
 
    dwVehicleIOLatMode latMode;
    dwVehicleIOLonMode lonMode;
 
    // Motion manager feedback
    dwVehicleIOEgoFeedback egomotionResult;
 
    // Collaborative Steering
    bool latCtrlReadyForCollaborativeSteering; 
 
    float32_t latCtrlCrossTrackError; 
    float32_t latCtrlCurvReqPred;     
 
    dwTime_t timestamp_us;                                                      
    dwVehicleIOLatCtrlInterventionDirectionLKA latCtrlInterventionDirectionLKA; 
    dwVehicleIOLatCtrlInterventionDirectionELK latCtrlInterventionDirectionELK; 
    uint8_t latCtrlLaneChangePushingLaterally;                                  
} dwVehicleIOCommand;
 
typedef enum dwVehicleIOLaneDepartureWarningState {
    DW_VIO_LANE_DEPARTURE_WARNING_STATE_OFF = 0, 
    DW_VIO_LANE_DEPARTURE_WARNING_STATE_ON  = 1, 
 
    DW_VIO_LANE_DEPARTURE_WARNING_STATE_COUNT 
} dwVehicleIOLaneDepartureWarningState;
 
typedef enum dwVehicleIOLaneDepartureWarningSide {
    DW_VIO_LANE_DEPARTURE_WARNING_SIDE_NONE  = 0, 
    DW_VIO_LANE_DEPARTURE_WARNING_SIDE_LEFT  = 1, 
    DW_VIO_LANE_DEPARTURE_WARNING_SIDE_RIGHT = 2, 
 
    DW_VIO_LANE_DEPARTURE_WARNING_SIDE_COUNT 
} dwVehicleIOLaneDepartureWarningSide;
 
typedef struct dwVehicleIOMiscCommand
{
 
    //basic body controls
    dwVehicleIODoorLock doorLock;                  
    dwVehicleIOMoonroof moonroof;                  
    dwVehicleIOMirror mirrors;                     
    dwVehicleIOHeadlights headlights;              
    dwVehicleIOTurnSignal turnSig;                 
    dwVehicleIOLaneDepartureWarningState ldwState; 
    dwVehicleIOLaneDepartureWarningSide ldwSide;   
    float32_t ldwSeverity;                         
    //specifically for mirrors
    float32_t mirrorAdjustX; 
    float32_t mirrorAdjustY; 
    //specifically for center console display brightness
    uint8_t displayBrightnessValue;
 
    bool enable;
    bool clearFaults;
    bool doorLockValid;          
    bool moonroofValid;          
    bool mirrorFoldValid;        
    bool mirrorAdjustValid;      
    bool headlightsValid;        
    bool displayBrightnessValid; 
    bool turnSigValid;           
 
    float32_t accSetSpeed; 
 
    bool longitudinalTOR; 
 
    dwVehicleIOBSMRequest bsmLeftRequest;  
    dwVehicleIOBSMRequest bsmRightRequest; 
    dwVehicleIOBSMRequest bsmAudioRequest; 
 
    dwVehicleIOLaneChangeFeedbackRequest lcfRequest; 
 
    dwTime_t timestamp_us; 
} dwVehicleIOMiscCommand;
 
typedef struct dwVehicleIOCapabilityState
{
    float32_t longVelocityForwardMin; 
    dwTime_t longVelocityForwardMinTimestamp;
    float32_t longVelocityForwardMax; 
    dwTime_t longVelocityForwardMaxTimestamp;
 
    float32_t rearAxleCurvatureMax; 
    float32_t rearAxleCurvatureMin; 
    dwTime_t rearAxleCurvatureCapabilityTimestamp;
 
    dwStateValueFloat frontWheelAngleMax; 
    dwStateValueFloat frontWheelAngleMin; 
    dwStateValueFloat rearWheelAngleMax;  
    dwStateValueFloat lonAccelerationMax; 
} dwVehicleIOCapabilityState;
 
typedef struct dwVehicleIOTrailerState
{
    dwStateValueFloat mass;              
    dwStateValueFloat articulationAngle; 
    dwVehicleIOTrailerConnectedStatus connected;
} dwVehicleIOTrailerState;
 
typedef struct dwVehicleIOAxleStatus
{
    dwStateValueFloat frontLoad;   
    dwStateValueFloat pusherLoad;  
    dwStateValueFloat driverLoad;  
    dwStateValueFloat trailerLoad; 
} dwVehicleIOAxleStatus;
 
typedef enum dwVehicleIOLatCtrlLoopStatus {
    DW_VEHICLEIO_LAT_CTRL_LOOP_STATUS_UNKNOWN  = 0, 
    DW_VEHICLEIO_LAT_CTRL_LOOP_STATUS_OPEN     = 1, 
    DW_VEHICLEIO_LAT_CTRL_LOOP_STATUS_BLENDING = 2, 
    DW_VEHICLEIO_LAT_CTRL_LOOP_STATUS_CLOSED   = 3  
} dwVehicleIOLatCtrlLoopStatus;
 
typedef enum dwVehicleIOVehicleStopped {
    DW_VEHICLEIO_VEHICLE_STOPPED_UNKNOWN = 0,
    DW_VEHICLEIO_VEHICLE_STOPPED_FALSE = 1,
    DW_VEHICLEIO_VEHICLE_STOPPED_TRUE = 2
} dwVehicleIOVehicleStopped;
 
typedef enum dwVehicleIOHoldStatus {
    DW_VEHICLEIO_HOLD_STATUS_UNKNOWN    = 0, 
    DW_VEHICLEIO_HOLD_STATUS_NOHOLD     = 1, 
    DW_VEHICLEIO_HOLD_STATUS_HOLD       = 2, 
    DW_VEHICLEIO_HOLD_STATUS_TRANSITION = 3  
} dwVehicleIOHoldStatus;
 
typedef enum dwVehicleIOFrontSteeringAngleQuality {
    DW_VEHICLEIO_FRONT_STEERING_ANGLE_QUALITY_NOT_DEFINED = 0,
    DW_VEHICLEIO_FRONT_STEERING_ANGLE_QUALITY_NORMAL_OPERATION = 1,
    DW_VEHICLEIO_FRONT_STEERING_ANGLE_QUALITY_REDUCED_QUALITY = 2,
    DW_VEHICLEIO_FRONT_STEERING_ANGLE_QUALITY_SIG_DEF = 3
} dwVehicleIOFrontSteeringAngleQuality;
 
#define DW_VEHICLEIO_NUM_LAT_CTRL_CURV_CAP 10
 
typedef struct dwVehicleIOState
{
    dwVector2f velocity;     
    float32_t speed;         
    dwTime_t speedTimestamp; 
 
    dwVector2f acceleration;        
    dwTime_t accelerationTimestamp; 
 
    dwTime_t steeringTimestamp;      
    float32_t steeringWheelAngle;    
    float32_t steeringWheelAngleCmd; 
    float32_t steeringWheelTorque;   
 
    float32_t inverseSteeringR;      
    float32_t frontSteeringAngleCmd; 
    float32_t frontSteeringAngle;    
 
    float32_t throttleValue;    
    float32_t throttleCmd;      
    float32_t throttleState;    
    dwTime_t throttleTimestamp; 
 
    float32_t brakeValue;           
    float32_t brakeCmd;             
    float32_t brakeState;           
    float32_t brakeTorqueRequested; 
    float32_t brakeTorqueActual;    
    dwTime_t brakeTimestamp;        
 
    float32_t wheelSpeed[DW_VEHICLE_NUM_WHEELS];         
    dwTime_t wheelSpeedTimestamp[DW_VEHICLE_NUM_WHEELS]; 
    float32_t suspension[DW_VEHICLE_NUM_WHEELS];         
    dwTime_t suspensionTimestamp[DW_VEHICLE_NUM_WHEELS]; 
 
    int16_t wheelPosition[DW_VEHICLE_NUM_WHEELS];           
    dwTime_t wheelPositionTimestamp[DW_VEHICLE_NUM_WHEELS]; 
 
    float32_t tirePressure[DW_VEHICLE_NUM_WHEELS]; 
 
    // Vehicle Miscellanoeus data
    bool buttonCruiseControlOnOff;
    bool buttonCruiseControlReset;
    bool buttonCruiseControlCancel;
    bool buttonCruiseControlResetCancel;
    bool buttonCruiseControlIncrement;
    bool buttonCruiseControlDecrement;
    bool buttonCruiseControlGapIncrement;
    bool buttonCruiseControlGapDecrement;
    bool buttonLaneAssistOnOff;
    bool doorDriver;
    bool doorPassenger;
    bool doorRearLeft;
    bool doorRearRight;
    bool doorHood;
    bool doorTrunk;
    bool passengerDetect;
    bool passengerAirbag;
    bool buckleDriver;
    bool bucklePassenger;
    bool highBeamHeadlights;
    bool wiper;
    bool buttonLeftKeypadOk;
    bool buttonLeftKeypadUp;
    bool buttonLeftKeypadDown;
    bool buttonTimeGapCycle;
    bool handsOnWheel;
 
    float32_t fuelLevel;              
    dwVehicleIOGear gear;             
    dwVehicleIOGear gearCmd;          
    dwVehicleIOTurnSignal turnSignal; 
 
    uint32_t overrides; 
    uint32_t faults;    
 
    dwVehicleIODrivingMode drivingMode;
    dwVehicleIOLatMode latMode;
    dwVehicleIOLonMode lonMode;
 
    bool enabled;
 
    bool brakeEnabled;    
    bool throttleEnabled; 
    bool steeringEnabled; 
 
    float32_t rearAxleCurvature;         
    dwTime_t rearAxleCurvatureTimestamp; 
 
    dwStateValueFloat rearWheelAngle; 
 
    dwVehicleIOCapabilityState capability;
 
    dwVector2f radarVelocity; 
    dwTime_t radarVelocityTimestamp;
 
    dwTime_t engineSpeedTimestamp; 
    float32_t engineSpeed;         
 
    dwStateValueFloat outsideTemperature; 
 
    dwStateValueFloat mass;                
    dwVehicleIOSignalQuality speedQuality; 
 
    dwVehicleIOTrailerState trailer;
    dwVehicleIOAxleStatus axles;
 
    float32_t brakeTorqueDriver; 
    bool brakeActive;            
    bool brakePedalPressed;      
 
    dwVehicleIOLatCtrlLoopStatus latCtrlLoopStatus;                     
    dwVehicleIOSpeedDirectionESC speedDirectionESC;                     
    dwVehicleIOTirePressureMonitoringState tirePressureMonitoringState; 
    dwVehicleIOIgnitionStatus ignitionStatus;                           
    dwVehicleIOESCOperationalState ESCOperationalState;                 
    dwVehicleIOAbsIntervention absIntervention;                         
 
    float32_t latCtrlCurvCapMax[DW_VEHICLEIO_NUM_LAT_CTRL_CURV_CAP]; 
    float32_t latCtrlCurvCapMin[DW_VEHICLEIO_NUM_LAT_CTRL_CURV_CAP]; 
    dwVehicleIODrivePositionTarget drivePositionTarget;              
    dwVehicleIOVehicleStopped vehicleStopped;                        
    dwVehicleIOFrontSteeringAngleQuality frontSteeringAngleQuality;  
    dwTime_t timestamp_us;                                           
    dwVehicleIOHoldStatus holdStatus;                                
 
    float32_t speedMin; 
    float32_t speedMax; 
} dwVehicleIOState;
 
#define DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES 50
#define DW_VEHICLEIO_LOW_SPEED_THRESHOLD 4
 
typedef struct dwVehicleIOCapabilities
{
    float32_t reverseSpeedLimit;                                         
    int32_t brakeValueLUTSize;                                           
    float32_t brakeValueLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];         
    int32_t throttleValueLUTSize;                                        
    float32_t throttleValueLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];      
    int32_t steeringSpeedLUTSize;                                        
    float32_t steeringSpeedLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];      
    int32_t steeringWheelAngleLUTSize;                                   
    float32_t steeringWheelAngleLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES]; 
 
    int32_t frontSteeringSpeedLUTSize;                                           
    float32_t frontSteeringSpeedLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];         
    int32_t frontSteeringAngleLUTSize;                                           
    float32_t frontSteeringAngleLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];         
    int32_t curvatureLUTSize;                                                    
    float32_t curvatureLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];                  
    int32_t frontSteeringSpeedLowSpeedLUTSize;                                   
    float32_t frontSteeringSpeedLowSpeedLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES]; 
    int32_t frontSteeringAngleLowSpeedLUTSize;                                   
    float32_t frontSteeringAngleLowSpeedLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES]; 
    int32_t maxAccelerationLUTSize;                                              
    float32_t maxAccelerationLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];            
    int32_t minAccelerationLUTSize;                                              
    float32_t minAccelerationLUT[DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES];            
} dwVehicleIOCapabilities;
 
#ifdef __cplusplus
}
#endif
#endif // DW_VEHICLEIO_LEGACY_STRUCTURES_H_