can_vss.cpp File Reference

Detailed Description

This file handles incoming vss values from can.

Date

Apr 19, 2020

Author

Alex Miculescu, (c) 2020

Definition in file can_vss.cpp.

Functions
static expected< uint16_t >	look_up_rpm_can_id (can_vss_nbc_e type)
static expected< uint16_t >	look_up_vss_can_id (can_vss_nbc_e type)
static uint16_t	look_up_second_vss_can_id (can_vss_nbc_e type)
float	processBMW_e46 (const CANRxFrame &frame)
float	processNissan (const CANRxFrame &frame)
float	processBMW_e90 (const CANRxFrame &frame)
float	processW202 (const CANRxFrame &frame)
float	processHyundai (const CANRxFrame &frame, efitick_t nowNt)
expected< float >	processCanRxVssImpl (const CANRxFrame &frame, efitick_t nowNt)
static void	processNissanSecondVss (const CANRxFrame &frame, efitick_t nowNt)
void	processCanRxSecondVss (const CANRxFrame &frame, efitick_t nowNt)
void	processCanRxVss (const CANRxFrame &frame, efitick_t nowNt)
void	initCanVssSupport ()
void	setCanVss (int type)

Variables
static bool	isInit = false
static uint16_t	filterVssCanID = 0
static uint16_t	filterSecondVssCanID = 0
static uint16_t	filterRpmCanID = 0
static StoredValueSensor	wheelSlipRatio (SensorType::WheelSlipRatio, MS2NT(1000))
static int	nissanFrontAxle = 0
static StoredValueSensor	canSpeed (SensorType::VehicleSpeed, MS2NT(500))

Function Documentation

initCanVssSupport()

void initCanVssSupport

(

)

Definition at line 199 of file can_vss.cpp.

                         {
    if (engineConfiguration->enableCanVss) {
        if (auto canId = look_up_vss_can_id(engineConfiguration->canVssNbcType)) {
            filterVssCanID = canId.Value;
            filterSecondVssCanID = look_up_second_vss_can_id(engineConfiguration->canVssNbcType);
            canSpeed.Register();
            wheelSlipRatio.Register();
            isInit = true;
        } else {
            isInit = false;
        }
 
 
        // todo: how do we handle 'isInit' for case with only RPM without VSS for instance?
        if (engineConfiguration->canInputBCM) {
            if (auto canId = look_up_rpm_can_id(engineConfiguration->canVssNbcType))
            filterRpmCanID = canId.Value;
        }
 
    }
}

Referenced by initHardware().

Here is the call graph for this function:

Here is the caller graph for this function:

look_up_rpm_can_id()

static expected< uint16_t > look_up_rpm_can_id ( can_vss_nbc_e  type )

static

Definition at line 24 of file can_vss.cpp.

                                                                 {
    switch (type) {
        case HONDA_CIVIC9:
          return 0x17C;
//      case HYUNDAI_PB:
        case NISSAN_350:
          return 0x23D;
        case BMW_e46:
        case W202:
        case BMW_e90:
        case HYUNDAI_PB:
            firmwareError(ObdCode::OBD_Vehicle_Speed_SensorB, "RPM Can type not implemented yet: %d", type);
            return unexpected;
        default:
            firmwareError(ObdCode::OBD_Vehicle_Speed_SensorB, "Wrong RPM Can type: %d", type);
            return unexpected;
    }
}

Referenced by initCanVssSupport().

Here is the call graph for this function:

Here is the caller graph for this function:

look_up_second_vss_can_id()

static uint16_t look_up_second_vss_can_id ( can_vss_nbc_e  type )

static

Definition at line 65 of file can_vss.cpp.

                                                              {
    switch (type) {
        case NISSAN_350:
          // decimal 640 0x280 has cluster speed but we use wheel speeds
          return /*0x285*/645;
        default:
          // it's OK not to require second packet
            return 0;
    }
}

Referenced by initCanVssSupport().

Here is the caller graph for this function:

look_up_vss_can_id()

static expected< uint16_t > look_up_vss_can_id ( can_vss_nbc_e  type )

static

Definition at line 43 of file can_vss.cpp.

                                                                 {
    switch (type) {
        case BMW_e46:
            return 0x01F0; /* BMW e46 ABS Message */
        case BMW_e90:
            return 0x1A0;   // BMW E90 ABS speed frame (not wheel speeds, vehicle speed)
        case NISSAN_350:
          // decimal 640 0x280 has cluster speed but we use wheel speeds
          return /*0x284*/644;
        case HYUNDAI_PB:
          // decimal 1264 0x4F0 CLU1 has cluster speed but we use wheel speeds
          return /*0x1F1*/497;
        case HONDA_CIVIC9:
          return 0x309;
        case W202:
            return 0x0200; /* W202 C180 ABS signal */
        default:
            firmwareError(ObdCode::OBD_Vehicle_Speed_SensorB, "Wrong VSS Can type selected: %d", type);
            return unexpected;
    }
}

Referenced by initCanVssSupport().

Here is the call graph for this function:

Here is the caller graph for this function:

processBMW_e46()

float processBMW_e46

(

const CANRxFrame &

frame

)

Definition at line 78 of file can_vss.cpp.

                                              {
    // average the rear wheels since those are the driven ones (more accurate gear detection!)
    uint16_t left =  getTwoBytesLsb(frame, 4);
    uint16_t right = getTwoBytesLsb(frame, 6);
 
    return (left + right) / (16 * 2);
}

Referenced by processCanRxVssImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

processBMW_e90()

float processBMW_e90

(

const CANRxFrame &

frame

)

Definition at line 99 of file can_vss.cpp.

                                              {
    return 0.1f * getTwoBytesLsb(frame, 0);
}

Referenced by processCanRxVssImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

processCanRxSecondVss()

void processCanRxSecondVss	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

Definition at line 167 of file can_vss.cpp.

                                                                     {
    switch (engineConfiguration->canVssNbcType) {
        case NISSAN_350:
          processNissanSecondVss(frame, nowNt);
          return;
        default:
          criticalError("Unexpected processCanRxSecondVss %d", (int)engineConfiguration->canVssNbcType);
    }
}

Referenced by processCanRxVss().

Here is the call graph for this function:

Here is the caller graph for this function:

processCanRxVss()

void processCanRxVss	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

Definition at line 177 of file can_vss.cpp.

                                                               {
    if ((!engineConfiguration->enableCanVss) || (!isInit)) {
        return;
    }
 
    //filter it we need to process the can message or not
    if (CAN_SID(frame) == filterVssCanID) {
      if (auto speed = processCanRxVssImpl(frame, nowNt)) {
          canSpeed.setValidValue(speed.Value * engineConfiguration->canVssScaling, nowNt);
    }
    }
 
    if (CAN_SID(frame) == filterSecondVssCanID) {
      processCanRxSecondVss(frame, nowNt);
    }
 
 
    if (CAN_SID(frame) == filterRpmCanID) {
  }
 
}

Referenced by processCanRxMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

processCanRxVssImpl()

expected< float > processCanRxVssImpl	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

Definition at line 132 of file can_vss.cpp.

                                                                              {
    switch (engineConfiguration->canVssNbcType) {
        case BMW_e46:
            return processBMW_e46(frame);
        case BMW_e90:
            return processBMW_e90(frame);
        case W202:
            return processW202(frame);
        case HYUNDAI_PB:
            return processHyundai(frame, nowNt);
        case NISSAN_350:
            return processNissan(frame);
        default:
            efiPrintf("vss unsupported can option selected %x", engineConfiguration->canVssNbcType );
    }
 
    return unexpected;
}

Referenced by processCanRxVss().

Here is the call graph for this function:

Here is the caller graph for this function:

processHyundai()

float processHyundai	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

Definition at line 112 of file can_vss.cpp.

                                                               {
  int frontL = getBitRangeLsb(frame.data8, 16, 12);
  int frontR = getBitRangeLsb(frame.data8, 28, 12);
  int rearL = getBitRangeLsb(frame.data8, 40, 12);
  int rearR = getBitRangeLsb(frame.data8, 52, 12);
 
  int frontAxle = (frontL + frontR);
  int rearAxle = (rearL + rearR);
 
  if (engineConfiguration->verboseCan) {
    efiPrintf("processHyundai: frontL %d rearL %d", frontL, rearL);
  }
 
  wheelSlipRatio.setValidValue(SLIP_RATIO(frontAxle, rearAxle), nowNt);
 
  return frontAxle / /*average*/2 / /* scale */8;
}

Referenced by processCanRxVssImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

processNissan()

float processNissan

(

const CANRxFrame &

frame

)

Definition at line 89 of file can_vss.cpp.

                                             {
    // todo: open question which one is left which one is right
    int left =  getTwoBytesMsb(frame, 0);
    int right = getTwoBytesMsb(frame, 2);
 
    nissanFrontAxle = left + right;
 
    return nissanFrontAxle / (100.0 * 2);
}

Referenced by processCanRxVssImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

processNissanSecondVss()

static void processNissanSecondVss ( const CANRxFrame &  frame, efitick_t  nowNt  )

static

Definition at line 153 of file can_vss.cpp.

                                                                             {
    // todo: open question which one is left which one is right
  int left =  getTwoBytesMsb(frame, 0);
    int right = getTwoBytesMsb(frame, 2);
 
    int rearAxle = left + right;
 
  if (engineConfiguration->verboseCan) {
      efiPrintf("processNissan: front %d rear %d", nissanFrontAxle, rearAxle);
    }
 
    wheelSlipRatio.setValidValue(SLIP_RATIO(nissanFrontAxle, rearAxle), nowNt);
}

Referenced by processCanRxSecondVss().

Here is the call graph for this function:

Here is the caller graph for this function:

processW202()

float processW202

(

const CANRxFrame &

frame

)

Definition at line 103 of file can_vss.cpp.

                                           {
  // todo: reuse one of the getTwoBytes methods!
    uint16_t tmp = (frame.data8[2] << 8);
    tmp |= frame.data8[3];
    return tmp * 0.0625;
}

Referenced by processCanRxVssImpl().

Here is the caller graph for this function:

setCanVss()

void setCanVss

(

int

type

)

Definition at line 221 of file can_vss.cpp.

                         {
    engineConfiguration->canVssNbcType = (can_vss_nbc_e)type;
}

Variable Documentation

canSpeed

StoredValueSensor canSpeed(SensorType::VehicleSpeed, MS2NT(500)) ( SensorType::VehicleSpeed  , MS2NT(500)    )

static

Referenced by initCanVssSupport(), and processCanRxVss().

filterRpmCanID

uint16_t filterRpmCanID = 0

static

Definition at line 20 of file can_vss.cpp.

Referenced by initCanVssSupport(), and processCanRxVss().

filterSecondVssCanID

uint16_t filterSecondVssCanID = 0

static

Definition at line 19 of file can_vss.cpp.

Referenced by initCanVssSupport(), and processCanRxVss().

filterVssCanID

uint16_t filterVssCanID = 0

static

Definition at line 18 of file can_vss.cpp.

Referenced by initCanVssSupport(), and processCanRxVss().

isInit

bool isInit = false

static

Definition at line 17 of file can_vss.cpp.

Referenced by initCanVssSupport(), and processCanRxVss().

nissanFrontAxle

int nissanFrontAxle = 0

static

Definition at line 87 of file can_vss.cpp.

Referenced by processNissan(), and processNissanSecondVss().

wheelSlipRatio

StoredValueSensor wheelSlipRatio(SensorType::WheelSlipRatio, MS2NT(1000)) ( SensorType::WheelSlipRatio  , MS2NT(1000)    )

static

Referenced by initCanVssSupport(), processHyundai(), and processNissanSecondVss().

Go to the source code of this file.