#include <hellen_board_id.h>

Inheritance diagram for HellenBoardIdFinder< NumPins >:

Collaboration diagram for HellenBoardIdFinder< NumPins >:

[legend]

Public Member Functions
	HellenBoardIdFinder (brain_pin_e(&rP)[NumPins])

bool	measureChargingTimes (int i, float &Tc1_us, float &Tc2_us)

bool	measureChargingTimesAveraged (int i, float &Tc1_us, float &Tc2_us)

Public Member Functions inherited from HellenBoardIdFinderBase
float	calc (float Tc1_us, float Tc2_us, float Rest, float C, bool testOnlyMajorSeries, float Rmeasured, float Cest, int *rIdx)

float	findClosestResistor (float R, bool testOnlyMajorSeries, int *rIdx)

float	calcEstimatedResistance (float Tc1_us, float C)

Data Fields
brain_pin_e(&	rPins )[NumPins]

HellenBoardIdFinderState	state

Data Fields inherited from HellenBoardIdFinderBase
HellenBoardIdFinderState	state

Detailed Description

template<size_t NumPins>
class HellenBoardIdFinder< NumPins >

Definition at line 64 of file hellen_board_id.h.

Constructor & Destructor Documentation

◆ HellenBoardIdFinder()

template<size_t NumPins>

HellenBoardIdFinder< NumPins >::HellenBoardIdFinder ( brain_pin_e(&) rP[NumPins] )

inline

Definition at line 67 of file hellen_board_id.h.

67: rPins(rP) {}

HellenBoardIdFinder::rPins

brain_pin_e(& rPins)[NumPins]

Definition hellen_board_id.h:74

Member Function Documentation

◆ measureChargingTimes()

template<size_t NumPins>

bool HellenBoardIdFinder< NumPins >::measureChargingTimes	(	int	i,
		float &	Tc1_us,
		float &	Tc2_us
	)

Definition at line 178 of file hellen_board_id.cpp.

                                                                                             {
#if EFI_PROD_CODE && defined( HELLEN_BOARD_ID_PIN_1) && !defined(HW_HELLEN_SKIP_BOARD_TYPE)
    chSemReset(&state.boardId_wake, 0);
 
    // full charge/discharge time, and also 'timeout' time
    const int Tf_us = 50000; // 50 ms is more than enough to "fully" discharge the capacitor with any two resistors used at the same time.
 
    // 1. Fully discharge the capacitor through both resistors (faster)
    for (size_t k = 0; k < NumPins; k++) {
        palClearPad(getBrainPinPort(rPins[k]), getBrainPinIndex(rPins[k]));
        palSetPadMode(getBrainPinPort(rPins[k]), getBrainPinIndex(rPins[k]), PAL_MODE_OUTPUT_PUSHPULL);
    }
    // wait max. time because we don't know the resistor values yet
    chThdSleepMicroseconds(Tf_us);
 
    // use one pin as an charge/discharge controlling output
    state.rOutputPinPort = getBrainPinPort(rPins[i]);
    state.rOutputPinIdx = getBrainPinIndex(rPins[i]);
    palSetPadMode(state.rOutputPinPort, state.rOutputPinIdx, PAL_MODE_OUTPUT_PUSHPULL);
 
    // use another pin as an input to detect 0->1 crossings
    int inputIdx = 1 - i;
    state.rInputPinPort = getBrainPinPort(rPins[inputIdx]);
    state.rInputPinIdx = getBrainPinIndex(rPins[inputIdx]);
    // set only high-Z input mode, no pull-ups/pull-downs allowed!
    palSetPadMode(state.rInputPinPort, state.rInputPinIdx, PAL_MODE_INPUT);
    efiExtiEnablePin("boardId", rPins[inputIdx], PAL_EVENT_MODE_RISING_EDGE, hellenBoardIdInputCallback, (void *)&state);
 
    int pinState = palReadPad(state.rInputPinPort, state.rInputPinIdx);
    if (pinState != 0) {
        // the input pin state should be low when the capacitor is fully discharged
        efiPrintf("* Board detection error!");
        return false;
    }
 
    // Timestamps:
    // t1 = Starts charging from 0v
    // t2 = Threshold reached, starts discharging
    // t3 = Random voltage reached, starts charging again
    // t4 = Threshold reached again, process finished.
 
    // 2. Start charging until the input pin triggers (V01 threshold is reached)
    state.timeChargeNt = 0;
    efitick_t t1 = getTimeNowNt();
    palSetPad(state.rOutputPinPort, state.rOutputPinIdx);
    chSemWaitTimeout(&state.boardId_wake, TIME_US2I(Tf_us));
    efitick_t t2 = state.timeChargeNt;
 
    // 3. At the moment, the discharging has already been started!
    // Meanwhile we need to do some checks - until some pre-selected voltage is presumably reached.
 
    // if voltage didn't change on the input pin (or changed impossibly fast), then the charging didn't start,
    // meaning there's no capacitor and/or resistors on these pins.
    if (t2 - t1 < US2NT(100)) {
        efiPrintf("* Hellen Board ID circuitry wasn't detected! Aborting!");
        return false;
    }
 
    // 4. calculate the first charging time
    efidur_t Tc1_nt = t2 - t1;
    Tc1_us = NT2USF(Tc1_nt);
    // We use the same 'charging time' to discharge the capacitor to some random voltage below the threshold voltage.
    efidur_t Td_nt = Tc1_nt;
 
    // 5. And now just wait for the rest of the discharge process...
    // Spin wait since chThdSleepMicroseconds() lacks the resolution we need
    efitick_t t3 = t2 + Td_nt;
    while (getTimeNowNt() < t3) ;
 
    // the input pin state should be low when the capacitor is discharged to Vl
    pinState = palReadPad(state.rInputPinPort, state.rInputPinIdx);
 
    // 6. And immediately begin charging again until the threshold voltage is reached!
    state.timeChargeNt = 0;
    palSetPad(state.rOutputPinPort, state.rOutputPinIdx);
 
    // Wait for the charging completion
    chSemReset(&state.boardId_wake, 0);
    chSemWaitTimeout(&state.boardId_wake, TIME_US2I(Tf_us));
    efitick_t t4 = state.timeChargeNt;
 
    // 7. calculate the second charge time
    Tc2_us = NT2USF(t4 - t3);
 
    float Td_us = NT2USF(Td_nt);
#ifdef HELLEN_BOARD_ID_DEBUG
    efiPrintf("* dTime2-1 = %d", (int)(t2 - t1));
    efiPrintf("* dTime3-2 = %d", (int)(t3 - t2));
    efiPrintf("* dTime4-3 = %d", (int)(t4 - t3));
    efiPrintf("* Tc1 = %f, Tc2 = %f, Td = %f", Tc1_us, Tc2_us, Td_us);
#endif /* HELLEN_BOARD_ID_DEBUG */
 
    // sanity checks
    if (pinState != 0) {
        efiPrintf("* Board detection error! (Td=%f is too small)", Td_us);
        return false;
    }
 
    if (t4 <= t3) {
        efiPrintf("* Estimates are out of limit! Something went wrong. Aborting!");
        return false;
    }
 
    efiExtiDisablePin(rPins[inputIdx]);
#endif /* EFI_PROD_CODE */
    return true;
}

Here is the call graph for this function:

◆ measureChargingTimesAveraged()

template<size_t NumPins>

bool HellenBoardIdFinder< NumPins >::measureChargingTimesAveraged	(	int	i,
		float &	Tc1_us,
		float &	Tc2_us
	)

Definition at line 287 of file hellen_board_id.cpp.

                                                                                                     {
    const int numTries = 3;
 
    Tc1_us = 0;
    Tc2_us = 0;
    for (int tries = 0; tries < numTries; tries++) {
        // get the charging times
        float Tc1i_us = 0, Tc2i_us = 0;
        if (!measureChargingTimes(i, Tc1i_us, Tc2i_us))
            return false;
        Tc1_us += Tc1i_us;
        Tc2_us += Tc2i_us;
    }
 
    // averaging
    Tc1_us /= numTries;
    Tc2_us /= numTries;
 
    return true;
}