TorqueControllerLoadCellVectoring Class Reference

#include <LoadCellVectoringController.h>

Inheritance diagram for TorqueControllerLoadCellVectoring:

Collaboration diagram for TorqueControllerLoadCellVectoring:

Public Member Functions
	TorqueControllerLoadCellVectoring (float rearTorqueScale, float regenTorqueScale)
	load cell TC with tunable F/R torque balance. Accel torque balance can be tuned independently of regen torque balance More...
	TorqueControllerLoadCellVectoring ()
	default contructor with balanced default values: rearTorqueScale = 1.0, regenTorqueScale = 1.0 More...
void	tick (const SysTick_s &tick, const PedalsSystemData_s &pedalsData, const LoadCellInterfaceOutput_s &loadCellData)
	Calculates speed set point based on normal force applied to wheels individually. More...
TorqueControllerOutput_s	evaluate (const SharedCarState_s &state) override
virtual TorqueControllerOutput_s	evaluate (const SharedCarState_s &state)=0
	This mehod must be implemented by every controller in the Tc Muxer. This is called in the Muxer whenever the drivetrain command is obtained. TorqueControllerMux.cpp to see that in every tick of the system, the active controller must be ticked through this method. More...

Private Attributes
float	frontTorqueScale_ = 1.0
float	rearTorqueScale_ = 1.0
float	frontRegenTorqueScale_ = 1.0
float	rearRegenTorqueScale_ = 1.0
TorqueControllerOutput_s	writeout_
float	FIRTaps_ [numFIRTaps_]
int	FIRCircBufferHead = 0
float	loadCellForcesRaw_ [4][numFIRTaps_] = {}
float	loadCellForcesFiltered_ [4] = {}
const int	errorCountThreshold_ = 25
int	loadCellsErrorCounter_ [4] = {}
bool	FIRSaturated_ = false
bool	ready_ = false

Static Private Attributes
static const int	numFIRTaps_ = 5

Detailed Description

Definition at line 5 of file LoadCellVectoringController.h.

Constructor & Destructor Documentation

TorqueControllerLoadCellVectoring() [1/2]

TorqueControllerLoadCellVectoring::TorqueControllerLoadCellVectoring ( float  rearTorqueScale, float  regenTorqueScale  )

inline

load cell TC with tunable F/R torque balance. Accel torque balance can be tuned independently of regen torque balance

Parameters

writeout	the reference to the torque controller output being sent that contains the drivetrain command
rearTorqueScale	0 to 2 scale on forward torque to rear wheels. 0 = FWD, 1 = Balanced, 2 = RWD
regenTorqueScale	same as rearTorqueScale but applies to regen torque split. 0 = All regen torque on the front, 1 = 50/50, 2 = all regen torque on the rear

Definition at line 51 of file LoadCellVectoringController.h.

        : frontTorqueScale_(2.0 - rearTorqueScale),
          rearTorqueScale_(rearTorqueScale),
          frontRegenTorqueScale_(2.0 - regenTorqueScale),
          rearRegenTorqueScale_(regenTorqueScale)
    {
        writeout_.command = BaseControllerParams::TC_COMMAND_NO_TORQUE;
        writeout_.ready = false;
    }

TorqueControllerLoadCellVectoring() [2/2]

TorqueControllerLoadCellVectoring::TorqueControllerLoadCellVectoring ( )

inline

default contructor with balanced default values: rearTorqueScale = 1.0, regenTorqueScale = 1.0

Definition at line 61 of file LoadCellVectoringController.h.

: TorqueControllerLoadCellVectoring(1.0, 1.0) {}

Member Function Documentation

evaluate()

TorqueControllerOutput_s TorqueControllerLoadCellVectoring::evaluate ( const SharedCarState_s &  state )

overridevirtual

Note

refer to parent class for function documentation

Implements Controller.

Definition at line 96 of file LoadCellVectoringController.cpp.

{
    tick(state.systick, state.pedals_data, state.loadcell_data);
    return writeout_;
}

tick()

void TorqueControllerLoadCellVectoring::tick	(	const SysTick_s &	tick,
		const PedalsSystemData_s &	pedalsData,
		const LoadCellInterfaceOutput_s &	loadCellData
	)

Calculates speed set point based on normal force applied to wheels individually.

Parameters

SysTick_s	&tick
PedalsSystemData_s	&pedalsData
LoadCellInterfaceOutput_s	&loadCellData

Definition at line 4 of file LoadCellVectoringController.cpp.

{
    // Calculate torque commands at 100hz
    if (tick.triggers.trigger100)
    {
        // Apply FIR filter to load cell data
        loadCellForcesRaw_[0][FIRCircBufferHead] = loadCellData.loadCellForcesFiltered.FL;
        loadCellForcesRaw_[1][FIRCircBufferHead] = loadCellData.loadCellForcesFiltered.FR;
        loadCellForcesRaw_[2][FIRCircBufferHead] = loadCellData.loadCellForcesFiltered.RL;
        loadCellForcesRaw_[3][FIRCircBufferHead] = loadCellData.loadCellForcesFiltered.RR;
 
        for (int i = 0; i < 4; i++)
        {
            loadCellForcesFiltered_[i] = 0.0f;
            for (int FIROffset = 0; FIROffset < numFIRTaps_; FIROffset++)
            {
                int index = (FIRCircBufferHead + FIROffset) % numFIRTaps_;
                loadCellForcesFiltered_[i] += loadCellForcesRaw_[i][index] * FIRTaps_[FIROffset];
            }
        }
        FIRCircBufferHead = (FIRCircBufferHead + 1) % numFIRTaps_;
        if (FIRCircBufferHead == numFIRTaps_ - 1)
            FIRSaturated_ = true;
 
        // Do sanity checks on raw data
        loadCellsErrorCounter_[0] = loadCellData.loadCellConversions.FL.raw != 4095 && loadCellData.loadCellConversions.FL.status != AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED ? 0 : loadCellsErrorCounter_[0] + 1;
        loadCellsErrorCounter_[1] = loadCellData.loadCellConversions.FR.raw != 4095 && loadCellData.loadCellConversions.FR.status != AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED ? 0 : loadCellsErrorCounter_[1] + 1;
        loadCellsErrorCounter_[2] = loadCellData.loadCellConversions.RL.raw != 4095 && loadCellData.loadCellConversions.RL.status != AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED ? 0 : loadCellsErrorCounter_[2] + 1;
        loadCellsErrorCounter_[3] = loadCellData.loadCellConversions.RR.raw != 4095 && loadCellData.loadCellConversions.RR.status != AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED ? 0 : loadCellsErrorCounter_[3] + 1;
        ready_ = FIRSaturated_ && loadCellsErrorCounter_[0] < errorCountThreshold_ && loadCellsErrorCounter_[1] < errorCountThreshold_ && loadCellsErrorCounter_[2] < errorCountThreshold_ && loadCellsErrorCounter_[3] < errorCountThreshold_;
 
        writeout_.ready = ready_;
 
        if (ready_)
        {
            // Calculate total normal force
            float sumNormalForce = 0.0f;
            for (int i = 0; i < 4; i++)
            {
                sumNormalForce += loadCellForcesFiltered_[i];
            }
 
            // Both pedals are not pressed and no implausibility has been detected
            // accelRequest goes between 1.0 and -1.0
            float accelRequest = pedalsData.accelPercent - pedalsData.regenPercent;
            float torquePool;
            float torqueRequest;
 
            if (accelRequest >= 0.0)
            {
                // Positive torque request
                // NOTE: using "torquePool" here instead of torqueRequest for legibility
                torquePool = accelRequest * PhysicalParameters::AMK_MAX_TORQUE * 4;
 
                writeout_.command.speeds_rpm[FL] = PhysicalParameters::AMK_MAX_RPM;
                writeout_.command.speeds_rpm[FR] = PhysicalParameters::AMK_MAX_RPM;
                writeout_.command.speeds_rpm[RL] = PhysicalParameters::AMK_MAX_RPM;
                writeout_.command.speeds_rpm[RR] = PhysicalParameters::AMK_MAX_RPM;
 
                writeout_.command.inverter_torque_limit[FL] = torquePool * frontTorqueScale_ * loadCellForcesFiltered_[0] / sumNormalForce;
                writeout_.command.inverter_torque_limit[FR] = torquePool * frontTorqueScale_ * loadCellForcesFiltered_[1] / sumNormalForce;
                writeout_.command.inverter_torque_limit[RL] = torquePool * rearTorqueScale_ * loadCellForcesFiltered_[2] / sumNormalForce;
                writeout_.command.inverter_torque_limit[RR] = torquePool * rearTorqueScale_ * loadCellForcesFiltered_[3] / sumNormalForce;
            }
            else
            {
                // Negative torque request
                // No load cell vectoring on regen
                torqueRequest = PhysicalParameters::MAX_REGEN_TORQUE * accelRequest * -1.0;
 
                writeout_.command.speeds_rpm[FL] = 0.0;
                writeout_.command.speeds_rpm[FR] = 0.0;
                writeout_.command.speeds_rpm[RL] = 0.0;
                writeout_.command.speeds_rpm[RR] = 0.0;
 
                writeout_.command.inverter_torque_limit[FL] = torqueRequest * frontRegenTorqueScale_;
                writeout_.command.inverter_torque_limit[FR] = torqueRequest * frontRegenTorqueScale_;
                writeout_.command.inverter_torque_limit[RL] = torqueRequest * rearRegenTorqueScale_;
                writeout_.command.inverter_torque_limit[RR] = torqueRequest * rearRegenTorqueScale_;
            }
        }
        else
        {
            writeout_.command = BaseControllerParams::TC_COMMAND_NO_TORQUE;
        }
    }
}

Member Data Documentation

errorCountThreshold_

const int TorqueControllerLoadCellVectoring::errorCountThreshold_ = 25

private

Definition at line 41 of file LoadCellVectoringController.h.

FIRCircBufferHead

int TorqueControllerLoadCellVectoring::FIRCircBufferHead = 0

private

Definition at line 37 of file LoadCellVectoringController.h.

FIRSaturated_

bool TorqueControllerLoadCellVectoring::FIRSaturated_ = false

private

Definition at line 43 of file LoadCellVectoringController.h.

FIRTaps_

float TorqueControllerLoadCellVectoring::FIRTaps_[numFIRTaps_]

private

Initial value:

= {
        0.07022690881526232,
        0.27638313122745306,
        0.408090001549378,
        0.27638313122745306,
        0.07022690881526232}

Definition at line 31 of file LoadCellVectoringController.h.

frontRegenTorqueScale_

float TorqueControllerLoadCellVectoring::frontRegenTorqueScale_ = 1.0

private

Definition at line 10 of file LoadCellVectoringController.h.

frontTorqueScale_

float TorqueControllerLoadCellVectoring::frontTorqueScale_ = 1.0

private

Definition at line 8 of file LoadCellVectoringController.h.

loadCellForcesFiltered_

float TorqueControllerLoadCellVectoring::loadCellForcesFiltered_[4] = {}

private

Definition at line 39 of file LoadCellVectoringController.h.

loadCellForcesRaw_

float TorqueControllerLoadCellVectoring::loadCellForcesRaw_[4][numFIRTaps_] = {}

private

Definition at line 38 of file LoadCellVectoringController.h.

loadCellsErrorCounter_

int TorqueControllerLoadCellVectoring::loadCellsErrorCounter_[4] = {}

private

Definition at line 42 of file LoadCellVectoringController.h.

numFIRTaps_

const int TorqueControllerLoadCellVectoring::numFIRTaps_ = 5

staticprivate

Definition at line 30 of file LoadCellVectoringController.h.

ready_

bool TorqueControllerLoadCellVectoring::ready_ = false

private

Definition at line 44 of file LoadCellVectoringController.h.

rearRegenTorqueScale_

float TorqueControllerLoadCellVectoring::rearRegenTorqueScale_ = 1.0

private

Definition at line 11 of file LoadCellVectoringController.h.

rearTorqueScale_

float TorqueControllerLoadCellVectoring::rearTorqueScale_ = 1.0

private

Definition at line 9 of file LoadCellVectoringController.h.

writeout_

TorqueControllerOutput_s TorqueControllerLoadCellVectoring::writeout_

private

Definition at line 13 of file LoadCellVectoringController.h.

---

The documentation for this class was generated from the following files:

• lib/systems/include/Controllers/LoadCellVectoringController.h
• lib/systems/src/Controllers/LoadCellVectoringController.cpp