VehicleIO.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// 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 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. 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 products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2015-2020 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//

#ifndef DW_VEHICLEIO_H_
#define DW_VEHICLEIO_H_

#include <dw/core/Config.h>
#include <dw/core/Exports.h>
#include <dw/core/Context.h>
#include <dw/core/Types.h>
#include <dw/sensors/Sensors.h>
#include <dw/sensors/canbus/CAN.h>
#include <dw/sensors/data/Data.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
} dwVehicleIODrivingMode;

typedef enum dwVehicleIOType {
    DW_VEHICLEIO_DATASPEED    = 0,
    DW_VEHICLEIO_GENERIC      = 1,
    DW_VEHICLEIO_SPACEDRIVE   = 2,
    DW_VEHICLEIO_STARDRIVE    = 3,
    DW_VEHICLEIO_CUSTOM       = 4,
    DW_VEHICLEIO_AUDIHYPERION = 5,
    DW_VEHICLEIO_DRIVER_COUNT = 6
} 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,
} 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
} dwVehicleIOOverrides;

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;

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;

typedef struct dwVehicleIOCommand
{
    bool enable; 

    // Steering command
    float32_t steeringWheelAngle;    
    float32_t maxSteeringWheelSpeed; 

    float32_t frontSteeringAngle;    
    float32_t maxFrontSteeringSpeed; 

    float32_t rearAxleCurvatureValue; 

    // 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 accelerationValue; 

    // Other commands
    dwVehicleIOGear gear;          
    dwVehicleIOTurnSignal turnSig; 

    // Clear CAN bus errors
    bool clearFaults; 

    // Booleans validating commands
    bool throttleValid;          
    bool brakeValid;             
    bool steeringWheelValid;     
    bool frontSteeringValid;     
    bool rearAxleCurvatureValid; 
    bool speedValid;             
    bool gearValid;              
    bool turnSigValid;           
    bool decelerationValid;      
    bool accelerationValid;      

    // AEB signals
    bool aebRequest;              
    dwVehicleIOAEBState aebState; 

    // FCW signals
    bool fcwRequest;              
    dwVehicleIOFCWState fcwState; 

    uint64_t heartbeatCounter; 

} dwVehicleIOCommand;

typedef struct dwVehicleIOMiscCommand
{

    //basic body controls
    dwVehicleIODoorLock doorLock;     
    dwVehicleIOMoonroof moonroof;     
    dwVehicleIOMirror mirrors;        
    dwVehicleIOHeadlights headlights; 
    dwVehicleIOTurnSignal turnSig;    

    //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;           
} 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;
} dwVehicleIOCapabilityState;

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];         

    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;

    float32_t fuelLevel;              
    dwVehicleIOGear gear;             
    dwVehicleIOGear gearCmd;          
    dwVehicleIOTurnSignal turnSignal; 

    dwVehicleIOOverrides overrides; 
    dwVehicleIOFaults faults;       

    dwVehicleIODrivingMode drivingMode;

    bool enabled;

    bool brakeEnabled;    
    bool throttleEnabled; 
    bool steeringEnabled; 

    float32_t rearAxleCurvature;         
    dwTime_t rearAxleCurvatureTimestamp; 

    dwVehicleIOCapabilityState capability;

    dwVector2f radarVelocity; 
    dwTime_t radarVelocityTimestamp;
    dwTime_t engineSpeedTimestamp; 
    float32_t engineSpeed;         
} dwVehicleIOState;

#define DW_VEHICLEIO_SPEED_LUT_MAX_ENTRIES 50

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]; 
} dwVehicleIOCapabilities;

DW_API_PUBLIC
dwStatus dwVehicleIO_initialize(dwVehicleIOHandle_t* obj, dwVehicleIOType type, const dwVehicle* properties,
                                dwContextHandle_t ctx);
DW_API_PUBLIC
dwStatus dwVehicleIO_initializeFromDBC(dwVehicleIOHandle_t* obj, dwVehicleIOType type, const dwVehicle* properties,
                                       const char* dbcFilePath, dwContextHandle_t ctx);

DW_API_PUBLIC
dwStatus dwVehicleIO_initializeFromRig(dwVehicleIOHandle_t* obj,
                                       dwConstRigHandle_t rig,
                                       dwContextHandle_t ctx);

DW_API_PUBLIC
dwStatus dwVehicleIO_reset(dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_release(dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_selectDriverOverrides(bool throttleOverride, bool steeringOverride,
                                           bool brakeOverride, bool gearOverride,
                                           dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_consumeCANFrame(const dwCANMessage* msg, uint32_t sensorId, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_consumeDataPacket(const dwDataPacket* pkt, uint32_t sensorId, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_sendCommand(const dwVehicleIOCommand* cmd,
                                 dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_sendMiscCommand(const dwVehicleIOMiscCommand* cmd,
                                     dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_getVehicleState(dwVehicleIOState* state, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_getCapabilities(dwVehicleIOCapabilities* caps, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_setDrivingMode(dwVehicleIODrivingMode mode, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_addCANSensor(uint32_t vehicleIOId, dwSensorHandle_t sensorHandle, dwVehicleIOHandle_t obj);

DW_API_PUBLIC
dwStatus dwVehicleIO_addDataSensor(uint32_t vehicleIOId, dwSensorHandle_t sensorHandle, dwVehicleIOHandle_t obj);

#ifdef __cplusplus
}
#endif

#endif // DW_VehicleIO_ACTUATORS_H_