PedalsSystem Class Reference

#include <PedalsSystem.h>

Collaboration diagram for PedalsSystem:

Public Member Functions
	PedalsSystem (const PedalsParams &accelParams, const PedalsParams &brakeParams)
	pedals system class that evaluates pedals for both accel and brake percent as well as implausibilities More...
void	setParams (const PedalsParams &accelParams, const PedalsParams &brakeParams)
const PedalsSystemData_s &	getPedalsSystemData ()
PedalsSystemData_s	getPedalsSystemDataCopy ()
float	getMechBrakeActiveThreshold ()
void	tick (const SysTick_s &tick, const AnalogConversion_s &accel1, const AnalogConversion_s &accel2, const AnalogConversion_s &brake)
	overloaded tick function that runs the evaluation of the pedals system. evaluates brake using only min and max params for sensor 1 (min_pedal_1 / max_pedal_1). More...
void	tick (const SysTick_s &tick, const AnalogConversion_s &accel1, const AnalogConversion_s &accel2, const AnalogConversion_s &brake1, const AnalogConversion_s &brake2)
PedalsSystemData_s	evaluate_pedals (const AnalogConversion_s &accel1, const AnalogConversion_s &accel2, const AnalogConversion_s &brake1, const AnalogConversion_s &brake2, unsigned long curr_time)
PedalsSystemData_s	evaluate_pedals (const AnalogConversion_s &accel1, const AnalogConversion_s &accel2, const AnalogConversion_s &brake, unsigned long curr_time)

Private Member Functions
float	remove_deadzone_ (float conversion_input, float deadzone)
bool	max_duration_of_implausibility_exceeded_ (unsigned long curr_time)
bool	evaluate_pedal_implausibilities_ (const AnalogConversion_s &pedalData1, const AnalogConversion_s &pedalData2, const PedalsParams &params, float max_percent_diff)
	Evaluate pedal implausibilities_ determines if there is a software implausibility in the pedals caused by them going out of range. Our max/min sensor ranges are calcuated from the pedal min/max values The pedal min/max values are defined in MCU_defs and are the real world raw values that we determine from the pedal output. The max/min sensor values are then a certain percent higher than these real world values as determined by the implausibility margin. This protects against physical damage to the sensor or pedal, but will not accidentally trip implausibility if pedal values fluctuate. More...
bool	evaluate_pedal_implausibilities_ (const AnalogConversion_s &pedalData, const PedalsParams &params)
	overloaded pedal implaus check that doesnt need to check for percent diff between sensors since only one sensor More...
bool	evaluate_brake_and_accel_pressed_ (const AnalogConversion_s &accelPedalData1, const AnalogConversion_s &accelPedalData2, const AnalogConversion_s &brakePedalData1, const AnalogConversion_s &brakePedalData2)
	function to determine if the pedals and the brakes are pressed at the same time. evaluates brake being pressed with mech brake activation threshold AFTER removing deadzones for both brake and accel More...
bool	evaluate_brake_and_accel_pressed_ (const AnalogConversion_s &accelPedalData1, const AnalogConversion_s &accelPedalData2, const AnalogConversion_s &brakePedalData)
	overloaded version that evaluates with only one brake pedal value More...
bool	evaluate_pedal_oor (const AnalogConversion_s &pedalData, int min, int max)
	This checks to see if any pedal sensor is out of range :(. More...
bool	evaluate_min_max_pedal_implausibilities_ (const AnalogConversion_s &pedalData, int min, int max, float implaus_margin_scale)
bool	pedal_is_active_ (float pedal1ConvertedData, float pedal2ConvertedData, const PedalsParams &params, bool check_mech_activation)
	check whether or not pedal is active according to input parameters. returns true if either pedal is over threshold. removes the deadzone before checking. More...

Private Attributes
PedalsSystemData_s	data_ {}
PedalsParams	accelParams_ {}
PedalsParams	brakeParams_ {}
unsigned long	implausibilityStartTime_

Detailed Description

Definition at line 41 of file PedalsSystem.h.

Constructor & Destructor Documentation

PedalsSystem()

PedalsSystem::PedalsSystem ( const PedalsParams &  accelParams, const PedalsParams &  brakeParams  )

inline

pedals system class that evaluates pedals for both accel and brake percent as well as implausibilities

Parameters

accelParams	accel pedal parameters. by rules, 2 sensors must be used for redundancy and evaluated w.r.t each other
brakeParams	brake pedal params. when used with only one pedal sensor, the pedal parameter evaluation for brakes only looks at the min and max for min_pedal_1 / max_pedal_1

Definition at line 48 of file PedalsSystem.h.

    {
        setParams(accelParams, brakeParams);
        implausibilityStartTime_ = 0;
    }

Member Function Documentation

evaluate_brake_and_accel_pressed_() [1/2]

bool PedalsSystem::evaluate_brake_and_accel_pressed_ ( const AnalogConversion_s &  accelPedalData1, const AnalogConversion_s &  accelPedalData2, const AnalogConversion_s &  brakePedalData  )

private

overloaded version that evaluates with only one brake pedal value

Parameters

accelPedalData1
accelPedalData2
brakePedalData

Returns

Definition at line 205 of file PedalsSystem.cpp.

{
 
    
    
    bool accel_pressed = pedal_is_active_(accelPedalData1.conversion, accelPedalData2.conversion, accelParams_, false); // .1
    float brake_pedal_real = remove_deadzone_(brakePedalData.conversion, brakeParams_.deadzone_margin);
    bool mech_brake_pressed = brake_pedal_real >= brakeParams_.mechanical_activation_percentage;
    bool both_pedals_implausible = (accel_pressed && mech_brake_pressed);
    return both_pedals_implausible;
}

evaluate_brake_and_accel_pressed_() [2/2]

bool PedalsSystem::evaluate_brake_and_accel_pressed_ ( const AnalogConversion_s &  accelPedalData1, const AnalogConversion_s &  accelPedalData2, const AnalogConversion_s &  brakePedalData1, const AnalogConversion_s &  brakePedalData2  )

private

function to determine if the pedals and the brakes are pressed at the same time. evaluates brake being pressed with mech brake activation threshold AFTER removing deadzones for both brake and accel

Parameters

accelPedalData1
accelPedalData2
brakePedalData1
brakePedalData2

Returns

true if accel and brake pressed at the same time, false otherwise

Definition at line 219 of file PedalsSystem.cpp.

{
 
 
    bool accel_pressed = pedal_is_active_(accelPedalData1.conversion, accelPedalData2.conversion, accelParams_, false); // .1
    bool mech_brake_pressed = pedal_is_active_(brakePedalData1.conversion, brakePedalData2.conversion, brakeParams_, true);  // 0.40
    
    
    bool both_pedals_implausible = (accel_pressed && mech_brake_pressed);
    return both_pedals_implausible;
}

evaluate_min_max_pedal_implausibilities_()

bool PedalsSystem::evaluate_min_max_pedal_implausibilities_ ( const AnalogConversion_s &  pedalData, int  min, int  max, float  implaus_margin_scale  )

private

Parameters

pedalData
min
max
implaus_margin_scale

Returns

Definition at line 151 of file PedalsSystem.cpp.

{
 
    bool pedal_swapped = false;
 
    // get the pedal margin. The margin will be a percentage of the range of the measured max values
    int pedal_margin = abs(max - min) * implaus_margin_scale;
 
    if (min > max)
    {
        pedal_swapped = true;
        // swap the logic: need to check and see if it is greater than min and less than max
    }
    // FSAE EV.5.5
    // FSAE T.4.2.10
    bool pedal_less_than_min = pedal_swapped ? (pedalData.raw > (min + pedal_margin))
                                             : (pedalData.raw < (min - pedal_margin));
 
    bool pedal_greater_than_max = pedal_swapped ? (pedalData.raw < (max - pedal_margin))
                                                : (pedalData.raw > (max + pedal_margin));
 
    if (pedal_less_than_min)
    {
        return true;
    }
    else if (pedal_greater_than_max)
    {
        return true;
    }
    else
    {
        return false;
    }
}

evaluate_pedal_implausibilities_() [1/2]

bool PedalsSystem::evaluate_pedal_implausibilities_ ( const AnalogConversion_s &  pedalData, const PedalsParams &  params  )

private

overloaded pedal implaus check that doesnt need to check for percent diff between sensors since only one sensor

Parameters

pedalData
params

Returns

Definition at line 124 of file PedalsSystem.cpp.

{
    return evaluate_min_max_pedal_implausibilities_(pedalData, params.min_pedal_1, params.max_pedal_1, params.implausibility_margin);
}

evaluate_pedal_implausibilities_() [2/2]

bool PedalsSystem::evaluate_pedal_implausibilities_ ( const AnalogConversion_s &  pedalData1, const AnalogConversion_s &  pedalData2, const PedalsParams &  params, float  max_percent_diff  )

private

Evaluate pedal implausibilities_ determines if there is a software implausibility in the pedals caused by them going out of range. Our max/min sensor ranges are calcuated from the pedal min/max values The pedal min/max values are defined in MCU_defs and are the real world raw values that we determine from the pedal output. The max/min sensor values are then a certain percent higher than these real world values as determined by the implausibility margin. This protects against physical damage to the sensor or pedal, but will not accidentally trip implausibility if pedal values fluctuate.

Parameters

pedalData1
pedalData2
params
max_percent_diff

Returns

Definition at line 129 of file PedalsSystem.cpp.

{
    bool pedal1_min_max_implaus = evaluate_min_max_pedal_implausibilities_(pedalData1, params.min_pedal_1, params.max_pedal_1, params.implausibility_margin);
    bool pedal2_min_max_implaus = evaluate_min_max_pedal_implausibilities_(pedalData2, params.min_pedal_2, params.max_pedal_2, params.implausibility_margin);
    bool sens_not_within_req_percent = (fabs(pedalData1.conversion - pedalData2.conversion) > max_percent_diff);
    if (pedal1_min_max_implaus || pedal2_min_max_implaus)
    {
        return true;
    }
    else if (sens_not_within_req_percent)
    {
        return true;
    }
    else
    {
        return false;
    }
}

evaluate_pedal_oor()

bool PedalsSystem::evaluate_pedal_oor ( const AnalogConversion_s &  pedalData, int  min, int  max  )

private

This checks to see if any pedal sensor is out of range :(.

Parameters

PedalData

The analog pedal Value

Returns

Definition at line 251 of file PedalsSystem.cpp.

{
    return (pedalData.raw >= max || pedalData.raw <= min);
}

evaluate_pedals() [1/2]

PedalsSystemData_s PedalsSystem::evaluate_pedals	(	const AnalogConversion_s &	accel1,
		const AnalogConversion_s &	accel2,
		const AnalogConversion_s &	brake,
		unsigned long	curr_time
	)

Parameters

accel1
accel2
brake
curr_time

Returns

Definition at line 21 of file PedalsSystem.cpp.

{
    PedalsSystemData_s out;
    
    
    out.accelPressed = pedal_is_active_(accel1.conversion, accel2.conversion, accelParams_, false);
    out.accelImplausible = evaluate_pedal_implausibilities_(accel1, accel2, accelParams_, 0.1);
    out.accelPercent = (out.accelImplausible) ? accel1.conversion : (accel1.conversion + accel2.conversion) / 2.0;
    out.accelPercent = remove_deadzone_(out.accelPercent, accelParams_.deadzone_margin);
    out.accelPercent = std::max(out.accelPercent, 0.0f);
    out.brakeImplausible = evaluate_pedal_implausibilities_(brake, brakeParams_);
    out.brakeAndAccelPressedImplausibility = evaluate_brake_and_accel_pressed_(accel1, accel2, brake);
    bool implausibility = (out.brakeAndAccelPressedImplausibility || out.brakeImplausible || out.accelImplausible);
    
    if (implausibility && (implausibilityStartTime_ == 0))
    {
        implausibilityStartTime_ = curr_time;
    }
    else if ((!implausibility) && ((out.accelPercent <= 0.05)))
    {
        implausibilityStartTime_ = 0;
    }
 
    bool oor = implausibility && (evaluate_pedal_oor(accel1, accelParams_.min_sensor_pedal_1, accelParams_.max_sensor_pedal_1) 
            || evaluate_pedal_oor(accel2, accelParams_.min_sensor_pedal_2, accelParams_.max_sensor_pedal_2));
    out.accelPercent = (oor) ? 0 : out.accelPercent;
 
    
    out.brakePercent = brake.conversion;
    out.brakePercent = remove_deadzone_(out.brakePercent, brakeParams_.deadzone_margin);
    out.brakePressed = brake.conversion >= brakeParams_.activation_percentage;
 
    out.mechBrakeActive = out.brakePercent >= brakeParams_.mechanical_activation_percentage;
    out.regenPercent = std::max(std::min(out.brakePercent / brakeParams_.mechanical_activation_percentage, 1.0f), 0.0f);
 
    
    out.implausibilityExceededMaxDuration = max_duration_of_implausibility_exceeded_(curr_time);
    return out;
}

evaluate_pedals() [2/2]

PedalsSystemData_s PedalsSystem::evaluate_pedals	(	const AnalogConversion_s &	accel1,
		const AnalogConversion_s &	accel2,
		const AnalogConversion_s &	brake1,
		const AnalogConversion_s &	brake2,
		unsigned long	curr_time
	)

Parameters

accel1
accel2
brake1
brake2
curr_time

Returns

Definition at line 64 of file PedalsSystem.cpp.

{
 
    PedalsSystemData_s out;
    out.accelPressed = pedal_is_active_(accel1.conversion, accel2.conversion, accelParams_, false);
    out.accelImplausible = evaluate_pedal_implausibilities_(accel1, accel2, accelParams_, 0.1);
    
    auto percent = (out.accelImplausible) ? accel1.conversion : (accel1.conversion + accel2.conversion) / 2.0;
    out.accelPercent = remove_deadzone_(percent, accelParams_.deadzone_margin);
    out.accelPercent = std::max(out.accelPercent, 0.0f);
    
 
    out.brakeImplausible = evaluate_pedal_implausibilities_(brake1, brake2, brakeParams_, 0.25);
    out.brakeAndAccelPressedImplausibility = evaluate_brake_and_accel_pressed_(accel1, accel2, brake1, brake2);
    bool implausibility = (out.brakeAndAccelPressedImplausibility || out.brakeImplausible || out.accelImplausible);
     
    if (implausibility && (implausibilityStartTime_ == 0))
    {
        implausibilityStartTime_ = curr_time;
    }
    else if ((!implausibility) && (!(out.accelPercent > 0.05)))
    {
        implausibilityStartTime_ = 0;
    }
 
    bool oor = implausibility && (evaluate_pedal_oor(accel1, accelParams_.min_sensor_pedal_1, accelParams_.max_sensor_pedal_1) 
            || evaluate_pedal_oor(accel2, accelParams_.min_sensor_pedal_2, accelParams_.max_sensor_pedal_2));
    out.accelPercent = (oor) ? 0 : out.accelPercent;
 
    out.brakePercent = (brake1.conversion + brake2.conversion) / 2.0;
    
    out.brakePercent = remove_deadzone_(out.brakePercent, brakeParams_.deadzone_margin);
 
    out.regenPercent = std::max(std::min(out.brakePercent / brakeParams_.mechanical_activation_percentage, 1.0f), 0.0f);
    
    out.brakePressed = pedal_is_active_(brake1.conversion, brake2.conversion, brakeParams_, false);
    out.mechBrakeActive = pedal_is_active_(brake1.conversion, brake2.conversion, brakeParams_, true);
    out.implausibilityExceededMaxDuration = max_duration_of_implausibility_exceeded_(curr_time);
 
    return out;
}

getMechBrakeActiveThreshold()

float PedalsSystem::getMechBrakeActiveThreshold ( )

inline

Definition at line 72 of file PedalsSystem.h.

    {
        return brakeParams_.mechanical_activation_percentage;
    }

getPedalsSystemData()

const PedalsSystemData_s & PedalsSystem::getPedalsSystemData ( )

inline

Definition at line 62 of file PedalsSystem.h.

    {
        return data_;
    }

getPedalsSystemDataCopy()

PedalsSystemData_s PedalsSystem::getPedalsSystemDataCopy ( )

inline

Definition at line 67 of file PedalsSystem.h.

    {
        return data_;
    }

max_duration_of_implausibility_exceeded_()

bool PedalsSystem::max_duration_of_implausibility_exceeded_ ( unsigned long  curr_time )

private

Definition at line 111 of file PedalsSystem.cpp.

{
    if (implausibilityStartTime_ != 0)
    {
        return ((curr_time - implausibilityStartTime_) > 100);
    }
    else
    {
        return false;
    }
}

pedal_is_active_()

bool PedalsSystem::pedal_is_active_ ( float  pedal1ConvertedData, float  pedal2ConvertedData, const PedalsParams &  params, bool  check_mech_activation  )

private

check whether or not pedal is active according to input parameters. returns true if either pedal is over threshold. removes the deadzone before checking.

Parameters

pedal1ConvertedData	the value 0 to 1 of the first pedal without deadzone removed
pedal2ConvertedData	... second pedal 0 to 1 val
params	the pedal parameters for this specific pedal
check_mech_activation	if this is true, function will check percentages against the mechanical activation percentage

Returns

true or false accordingly

Definition at line 234 of file PedalsSystem.cpp.

{
    float val1_deadzone_removed = remove_deadzone_(pedal1ConvertedData, params.deadzone_margin);
    float val2_deadzone_removed = remove_deadzone_(pedal2ConvertedData, params.deadzone_margin);
    bool pedal_1_is_active;
    bool pedal_2_is_active;
    if(check_mech_activation)
    {
        pedal_1_is_active = val1_deadzone_removed >= params.mechanical_activation_percentage;
        pedal_2_is_active = val2_deadzone_removed >= params.mechanical_activation_percentage;
    } else {
        pedal_1_is_active = val1_deadzone_removed >= params.activation_percentage;
        pedal_2_is_active = val2_deadzone_removed >= params.activation_percentage;
    }
    return (pedal_1_is_active || pedal_2_is_active);
}

remove_deadzone_()

float PedalsSystem::remove_deadzone_ ( float  conversion_input, float  deadzone  )

private

Definition at line 189 of file PedalsSystem.cpp.

{
    float range = 1.0 - (deadzone * 2);
    // e.g. vals from 0 to 1, deadzone is .05, range is .1
    // subtract deadzone to be -.05 to .95 & clamp at 0
    float out = std::max(conversion_input - deadzone, 0.0f);
    // values now are 0 to .95
    // divide by range of values to scale up (.9)
    out /= range;
    // values are now 0 to 1.0555...
    // clamp at 0 to 1
    out = std::min(out, 1.0f);
 
    return out;
}

setParams()

void PedalsSystem::setParams ( const PedalsParams &  accelParams, const PedalsParams &  brakeParams  )

inline

Definition at line 55 of file PedalsSystem.h.

    {
        accelParams_ = accelParams;
        brakeParams_ = brakeParams;
    }

tick() [1/2]

void PedalsSystem::tick	(	const SysTick_s &	tick,
		const AnalogConversion_s &	accel1,
		const AnalogConversion_s &	accel2,
		const AnalogConversion_s &	brake
	)

overloaded tick function that runs the evaluation of the pedals system. evaluates brake using only min and max params for sensor 1 (min_pedal_1 / max_pedal_1).

Parameters

tick	current system time tick
accel1	accel 1 sensor reading with scaled and offset value from 0 to 1
accel2	accel 2 sensor reading with scaled and offset value from 0 to 1
brake	brake sensor reading with scaled and offset value from 0 to 1

Definition at line 12 of file PedalsSystem.cpp.

{
    data_ = evaluate_pedals(accel1, accel2, brake, tick.millis);
}

tick() [2/2]

void PedalsSystem::tick	(	const SysTick_s &	tick,
		const AnalogConversion_s &	accel1,
		const AnalogConversion_s &	accel2,
		const AnalogConversion_s &	brake1,
		const AnalogConversion_s &	brake2
	)

Parameters

tick
accel1
accel2
brake1
brake2

Definition at line 7 of file PedalsSystem.cpp.

{
    data_ = evaluate_pedals(accel1, accel2, brake1, brake2, tick.millis);
}

Member Data Documentation

accelParams_

PedalsParams PedalsSystem::accelParams_ {}

private

Definition at line 125 of file PedalsSystem.h.

brakeParams_

PedalsParams PedalsSystem::brakeParams_ {}

private

Definition at line 126 of file PedalsSystem.h.

data_

PedalsSystemData_s PedalsSystem::data_ {}

private

Definition at line 124 of file PedalsSystem.h.

implausibilityStartTime_

unsigned long PedalsSystem::implausibilityStartTime_

private

Definition at line 127 of file PedalsSystem.h.

---

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

• lib/systems/include/PedalsSystem.h
• lib/systems/src/PedalsSystem.cpp