Detailed Description

Board-Id detector for Hellen boards.

Author: andreika prome.nosp@m.theu.nosp@m.s.pcb.nosp@m.@gma.nosp@m.il.co.nosp@m.m; Andrey Belomutskiy, (c) 2012-2022

The main idea is to measure the capacitor charge/discharge time through a series resistors using standard digital I/O pins. One pin is used to provide a Vcc(3.3) or Vdd(0) voltage to the capacitor through a resistor, and another pin is used as a digital input. Then vice versa.

The algo: 1) Completely discharge the capacitor (all pins are low) 2) Charge the capacitor until the voltage crosses the 0->1 voltage threshold (Vt) and measure the charging time #1 (Tc1). 3) Immediately discharge the capacitor to some unknown low voltage (Vl) - it should be well below the Vt threshold, using the same period of time used for charging as the discharge period (Td = Tc1). 4) Immediately charge the capacitor again and measure the time crossing the same 0->1 voltage threshold again (Tc2). 5) Repeat the procedure several times to get more precise timings. 6) Do some math and find the R and C values. 7) Board_Id = the unique combination of indices of the "measured" R1 and R2.

The math proof:

Charging formula #1: Vt = V�� * (1 - exp(-Tc1 / RC))
Discharging formula: Vl = Vt * exp(-Td / RC)
Charging formula #2: Vl = V�� * (1 - exp(-Tl / (RC)))
Where Tl is a charging time from 0 to Vl: Tl = Tc1 - Tc2
Solve the equations: Vl = V�� * (1 - exp(-Tl / RC)) = Vt * exp(-Td / RC) V�� * (1 - exp(-Tl / RC)) = V�� * (1 - exp(-Tc1 / RC)) * exp(-Td / RC) (1 - exp(-Tl / RC)) = (1 - exp(-Tc1 / RC)) * exp(-Td / RC)
Simplify the equation: X = exp(-1/(RC)) (1 - X^Tc1) * X^Td + X^Tl - 1 = 0

X^Td - X^(Tc1+Td) + X^(Tc2-Tc1) - 1 = 0

Td, Tc1 and Tc2 are known.
Solve the power function for X and get the desired R or C.

We use Newton's method (a fast-converging numerical solver when the 1st derivative is known) with estimated initial values.

Definition in file hellen_board_id.cpp.

Functions
static void	hellenBoardIdInputCallback (void *arg, efitick_t nowNt)

int	detectHellenBoardId ()

Function Documentation

◆ detectHellenBoardId()

int detectHellenBoardId ( )

Definition at line 308 of file hellen_board_id.cpp.

                          {
    int boardId = -1;
#if defined( HELLEN_BOARD_ID_PIN_1) && !defined(HW_HELLEN_SKIP_BOARD_TYPE)
    efiPrintf("Starting Hellen Board ID detection...");
    Timer t;
    t.reset();
 
    const int numPins = 2;
    Gpio rPins[numPins] = { HELLEN_BOARD_ID_PIN_1, HELLEN_BOARD_ID_PIN_2};
 
    // We start from the estimated capacitance, but the real one can be +-10%
    float C = HELLEN_BOARD_ID_CAPACITOR;
 
    // we need to find the resistor values connected to the mcu pins and to the capacitor.
    float R[numPins] = { 0 };
    int rIdx[numPins] = { 0 };
 
    HellenBoardIdFinder<numPins> finder(rPins);
 
    // init some ChibiOs objects
    chSemObjectInit(&finder.state.boardId_wake, 0);
 
    // R1 is the first, R2 is the second
    for (int i = 0; i < numPins; i++) {
#ifdef HELLEN_BOARD_ID_DEBUG
        efiPrintf("*** Resistor R%d...", i + 1);
#endif /* HELLEN_BOARD_ID_DEBUG */
 
        float Tc1_us = 0, Tc2_us = 0;
        // We need several measurements for each resistor to increase the precision.
        // But if any of the measurements fails, then abort!
        if (!finder.measureChargingTimesAveraged(i, Tc1_us, Tc2_us))
            break;
 
        // Now roughly estimate the resistor value using the approximate threshold voltage.
        float Rest = finder.calcEstimatedResistance(Tc1_us, C);
        // check if we are inside the range
        if (Rest < 300.0f || Rest > 15000.0f) {
            efiPrintf("* Unrealistic estimated resistor value (%f)! Aborting!", Rest);
            break;
        }
 
        // for the first resistor, we test only "major" values because we don't know the exact capacitance yet
        bool testOnlyMajorSeries = (i == 0);
 
        float Rmeasured, newC;
        // Now calculate the R and C
        R[i] = finder.calc(Tc1_us, Tc2_us, Rest, C, testOnlyMajorSeries, &Rmeasured, &newC, &rIdx[i]);
        C = newC;
 
#ifdef HELLEN_BOARD_ID_DEBUG
        efiPrintf("* R = %f, Rmeasured = %f, Rest = %f, Creal = %f", R[i], Rmeasured, Rest, C);
#endif /* HELLEN_BOARD_ID_DEBUG */
    }
 
    // in case the process was aborted
    for (size_t k = 0; k < numPins; k++) {
        efiExtiDisablePin(rPins[k]);
        // release the pins
        palSetPadMode(getBrainPinPort(rPins[k]), getBrainPinIndex(rPins[k]), PAL_MODE_RESET);
    }
 
    float elapsed_Ms = t.getElapsedSeconds() * 1000;
 
    // Check that all resistors were actually detected
    bool allRValid = true;
    for (size_t i = 0; i < numPins; i++) {
        allRValid &= R[i] != 0;
    }
 
    // Decode board ID only if all resistors could be decoded, otherwise we return -1
    if (allRValid) {
        boardId = HELLEN_GET_BOARD_ID(rIdx[0], rIdx[1]);
    } else {
        boardId = -1;
    }
 
    efiPrintf("* RESULT: BoardId = %d, R1 = %.0f, R2 = %.0f (Elapsed time: %.1f ms)", boardId, R[0], R[1], elapsed_Ms);
#endif /* HELLEN_BOARD_ID_PIN_1 */
    return boardId;
}

Referenced by detectHellenBoardType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hellenBoardIdInputCallback()

static void hellenBoardIdInputCallback	(	void *	arg,
		efitick_t	nowNt
	)

static

Definition at line 68 of file hellen_board_id.cpp.

                                                                   {
    UNUSED(arg);
    HellenBoardIdFinderState *state = (HellenBoardIdFinderState *)arg;
    // Now start discharging immediately! This should be the first command in the interrupt handler.
    palClearPad(state->rOutputPinPort, state->rOutputPinIdx);
 
    state->timeChargeNt = nowNt;
 
    chibios_rt::CriticalSectionLocker csl;
    chSemSignalI(&state->boardId_wake);  // no need to call chSchRescheduleS() because we're inside the ISR
}

Referenced by HellenBoardIdFinder< NumPins >::measureChargingTimes().