HellenBoardIdFinderBase Class Reference

#include <hellen_board_id.h>

Inheritance diagram for HellenBoardIdFinderBase:

Collaboration diagram for HellenBoardIdFinderBase:

Public Member Functions
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
HellenBoardIdFinderState	state

Detailed Description

Definition at line 51 of file hellen_board_id.h.

Member Function Documentation

calc()

float HellenBoardIdFinderBase::calc	(	float	Tc1_us,
		float	Tc2_us,
		float	Rest,
		float	C,
		bool	testOnlyMajorSeries,
		float *	Rmeasured,
		float *	Cest,
		int *	rIdx
	)

Definition at line 147 of file hellen_board_id.cpp.

                                                                                                                                                       {
    constexpr float Cest = HELLEN_BOARD_ID_CAPACITOR;
    // Now calculate the resistance value
    HellenBoardIdSolver rSolver;
 
    // solve the equation for R (1 Ohm precision is more than enough)
    *Rmeasured = rSolver.solve(Tc1_us, Tc2_us, Rest, C, 1.0f);
 
    // add 22 Ohms for pin's internal resistance
    // (according to the STM32 datasheets, the voltage drop on an output pin can be up to 0.4V for 8 mA current)
    // Actual measured value was is in the low-20s on most chips.
    constexpr float Rinternal = 22.0f;
    float R = findClosestResistor(*Rmeasured - Rinternal, testOnlyMajorSeries, rIdx);
 
    // Find the 'real' capacitance value and use it for the next resistor iteration (gives more precision)
    HellenBoardIdSolver cSolver;
 
    // We expect the capacitance to be +-10%
    constexpr float capacitorPrecision = 0.1f;
    constexpr float Cmin = Cest * (1.0f - capacitorPrecision);
    constexpr float Cmax = Cest * (1.0f + capacitorPrecision);
 
    // solve the equation for C (1% precision)
    *newC = cSolver.solve(Tc1_us, Tc2_us, Cmin, R + Rinternal, 0.01f);
    // in case something went wrong, we must be in the allowed range
    *newC = clampF(Cmin, *newC, Cmax);
 
    return R;
}

Referenced by detectHellenBoardId().

Here is the call graph for this function:

Here is the caller graph for this function:

calcEstimatedResistance()

float HellenBoardIdFinderBase::calcEstimatedResistance	(	float	Tc1_us,
		float	C
	)

Definition at line 137 of file hellen_board_id.cpp.

                                                                            {
    constexpr float Vcc = 3.3f - 0.1f;  // STM32 digital I/O voltage (adjusted for minor voltage drop)
    constexpr float V01 = Vcc * 0.5f;   // let it be 1.6 volts (closer to the datasheet value), the exact value doesn't matter
    // macos compiler doesn't like log() in constexpr
    float log1V01Vcc = log(1.0f - V01 / Vcc);
    // this is only an estimated value, we cannot use it for Board-ID detection!
    float Rest = -Tc1_us / (C * log1V01Vcc);
    return Rest;
}

Referenced by detectHellenBoardId().

Here is the caller graph for this function:

findClosestResistor()

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

Definition at line 105 of file hellen_board_id.cpp.

                                                                                               {
    // the first "major" resistor uses less values (with more spacing between them) so that even less precise method cannot fail.
    static const float rOnlyMajorValues[] = {
        HELLEN_BOARD_ID_MAJOR_RESISTORS
    };
    // the minor resistor is always measured after the major one, when the exact capacitance is already knows,
    // so we can use more values and detect them with better precision.
    static const float rAllValues[] = {
        // these are equal to the major values and should be used first
        HELLEN_BOARD_ID_MAJOR_RESISTORS
        // these are extended series if 256 board IDs aren't enough (16*16).
        HELLEN_BOARD_ID_MINOR_RESISTORS
    };
 
    size_t rValueSize = testOnlyMajorSeries ? efi::size(rOnlyMajorValues) : efi::size(rAllValues);
 
    *rIdx = -1;
    float minDelta = 1.e6f;
    for (size_t i = 0; i < rValueSize; i++) {
        // Find the nearest resistor by least ratio error
        float delta = std::abs(1 - (R / rAllValues[i]));
        if (delta < minDelta) {
            minDelta = delta;
            *rIdx = i;
#ifdef HELLEN_BOARD_ID_DEBUG
            efiPrintf("* [%d] R = %.0f, delta = %f", i, rAllValues[i], delta);
#endif /* HELLEN_BOARD_ID_DEBUG */
        }
    }
    return rAllValues[*rIdx];
}

Referenced by calc().

Here is the caller graph for this function:

Field Documentation

state

HellenBoardIdFinderState HellenBoardIdFinderBase::state

Definition at line 60 of file hellen_board_id.h.

---

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

• config/boards/hellen/hellen_board_id.h
• config/boards/hellen/hellen_board_id.cpp