GenericGearController Class Reference

#include <gc_generic.h>

Inheritance diagram for GenericGearController:

Collaboration diagram for GenericGearController:

Public Member Functions
	GenericGearController ()
void	update ()
void	init ()
GearControllerMode	getMode () const
Public Member Functions inherited from AutomaticGearController
	AutomaticGearController ()
void	findDesiredGear ()
Public Member Functions inherited from GearControllerBase
virtual gear_e	getDesiredGear () const

Private Member Functions
bool	isNearest (float value, int pinIndex, float *rangeStates)
SensorType	getAnalogSensorType (int zeroBasedSensorIndex)

Private Attributes
Timer	shiftTimer
SelectedGear	lastRange

Additional Inherited Members
Data Fields inherited from GearControllerBase
TransmissionControllerBase *	transmissionController
Protected Member Functions inherited from GearControllerBase
virtual gear_e	setDesiredGear (gear_e)
void	initTransmissionController ()
float *	getRangeStateArray (int)

Detailed Description

Definition at line 7 of file gc_generic.h.

Constructor & Destructor Documentation

GenericGearController()

GenericGearController::GenericGearController

(

)

Definition at line 9 of file gc_generic.cpp.

                                             {
}

Member Function Documentation

getAnalogSensorType()

SensorType GenericGearController::getAnalogSensorType ( int  zeroBasedSensorIndex )

private

Definition at line 24 of file gc_generic.cpp.

                                                                              {
    return static_cast<SensorType>(zeroBasedSensorIndex + static_cast<int>(SensorType::RangeInput1));
}

Referenced by update().

Here is the caller graph for this function:

getMode()

GearControllerMode GenericGearController::getMode ( ) const

inlinevirtual

Reimplemented from AutomaticGearController.

Definition at line 13 of file gc_generic.h.

                                       {
        return GearControllerMode::Generic;
    }

init()

void GenericGearController::init ( )

virtual

Reimplemented from GearControllerBase.

Definition at line 12 of file gc_generic.cpp.

                                 {
#if EFI_PROD_CODE
    for (size_t i = 0; i < efi::size(engineConfiguration->tcu_rangeInput); i++) {
        if (isBrainPinValid(engineConfiguration->tcu_rangeInput[i])) {
            efiSetPadMode("Range Input", engineConfiguration->tcu_rangeInput[i], getInputMode(engineConfiguration->tcu_rangeInputMode[i]));
        }
    }
#endif /* EFI_PROD_CODE */
 
    GearControllerBase::init();
}

Here is the call graph for this function:

isNearest()

bool GenericGearController::isNearest ( float  value, int  pinIndex, float *  rangeStates  )

private

Definition at line 28 of file gc_generic.cpp.

                                                                                   {
    float distance = fabs(rangeStates[pinIndex] - value);
    for (int i = 1; i <= TCU_RANGE_COUNT; i++) {
        float pinDistance = fabs(getRangeStateArray(i)[pinIndex] - value);
        if (pinDistance < distance) {
            return false;
        }
    }
    return true;
}

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void GenericGearController::update ( )

virtual

Reimplemented from AutomaticGearController.

Definition at line 39 of file gc_generic.cpp.

                                   {
    SelectedGear gear = SelectedGear::Invalid;
    // Loop through possible range states
    // 1 based because 0 is SelectedGear::Invalid
    for (int i = 1; i <= TCU_RANGE_COUNT; i++) {
        float *rangeStates = getRangeStateArray(i);
        // Loop through inputs
        for (size_t p = 0; p < efi::size(engineConfiguration->tcu_rangeInput); p++) {
            float cellState = rangeStates[p];
            // We allow the user to configure either a digital input or an analog input for each pin,
            //  so we need to check which is valid.
            if (isAdcChannelValid(engineConfiguration->tcu_rangeAnalogInput[p])) {
                float pinState = Sensor::getOrZero(getAnalogSensorType(p));
                if (getRangeStateArray(i)[p] == 0 || isNearest(pinState, p, rangeStates)) {
                    // Set the gear to the one we're checking, and continue to the next pin
                    gear = static_cast<SelectedGear>(i);
                } else {
                    // This possibility doesn't match, set to invalid
                    gear = SelectedGear::Invalid;
                    break;
                }
            } else if (isBrainPinValid(engineConfiguration->tcu_rangeInput[p])) {
                bool pinState = efiReadPin(engineConfiguration->tcu_rangeInput[p]) ^ (engineConfiguration->tcu_rangeInputMode[p] == PI_PULLUP);
                // If the pin doesn't matter, or if it matches the cellState
                if (cellState == 2 || (pinState && cellState == 1) || (!pinState && cellState == 0)) {
                    // Set the gear to the one we're checking, and continue to the next pin
                    gear = static_cast<SelectedGear>(i);
                } else {
                    // This possibility doesn't match, set to invalid
                    gear = SelectedGear::Invalid;
                    break;
                }
            }
        }
        // If we didn't find it, try the next range
        if (gear == SelectedGear::Invalid) {
            continue;
        // We found a match
        } else {
            break;
        }
    }
    if (gear != SelectedGear::Invalid) {
        switch (gear) {
        case SelectedGear::Manual3 :
            setDesiredGear(GEAR_3);
            break;
        case SelectedGear::Manual2 :
            setDesiredGear(GEAR_2);
            break;
        case SelectedGear::Manual1 :
            setDesiredGear(GEAR_1);
            break;
        case SelectedGear::Reverse :
            setDesiredGear(REVERSE);
            break;
        case SelectedGear::Park :
        case SelectedGear::Neutral :
            setDesiredGear(NEUTRAL);
            break;
        case SelectedGear::ManualPlus :
            // Only allow manual shift once per 500 ms,
            // and if the selected range was Manual prior to this update
            if (!shiftTimer.hasElapsedMs(500) || lastRange != SelectedGear::Manual) {
                break;
            }
            shiftTimer.reset();
            switch (getDesiredGear()) {
            case GEAR_1 :
                setDesiredGear(GEAR_2);
                break;
            case GEAR_2 :
                setDesiredGear(GEAR_3);
                break;
            case GEAR_3 :
                setDesiredGear(GEAR_4);
                break;
            default:
                break;
            }
            break;
        case SelectedGear::ManualMinus :
            // Only allow manual shift once per 500 ms,
            // and if the selected range was Manual prior to this update
            if (!shiftTimer.hasElapsedMs(500) || lastRange != SelectedGear::Manual) {
                break;
            }
            shiftTimer.reset();
            switch (getDesiredGear()) {
            case GEAR_2 :
                setDesiredGear(GEAR_1);
                break;
            case GEAR_3 :
                setDesiredGear(GEAR_2);
                break;
            case GEAR_4 :
                setDesiredGear(GEAR_3);
                break;
            default:
                break;
            }
            break;
        case SelectedGear::Drive :
            // If the gear selector is in drive, let AutomaticGearController,
            // which this class inherits from, decide what gear the transmission should be in.
            AutomaticGearController::update();
            return;
        default:
            break;
        }
 
        lastRange = gear;
    }
 
    GearControllerBase::update();
}

Here is the call graph for this function:

Field Documentation

lastRange

SelectedGear GenericGearController::lastRange

private

Definition at line 18 of file gc_generic.h.

Referenced by update().

shiftTimer

Timer GenericGearController::shiftTimer

private

Definition at line 17 of file gc_generic.h.

Referenced by update().

---

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

• controllers/tcu/gc_generic.h
• controllers/tcu/gc_generic.cpp