Functions
chibios_rt::BinarySemaphore	knockSem (true)

void	onKnockSamplingComplete ()

void	onStartKnockSampling (uint8_t cylinderNumber, float samplingSeconds, uint8_t channelIdx)

void	initSoftwareKnock ()

static uint8_t	toDb (const float &voltage)

static void	processLastKnockEvent ()

Variables
static size_t	spectrogramStartIndex = 0

static SpectrogramData	spectrogramData0

static SpectrogramData *	spectrogramData = &spectrogramData0

static NO_CACHE adcsample_t	sampleBuffer [1800]

static int8_t	currentCylinderNumber = 0

static int8_t	channelNumber = 0

static efitick_t	lastKnockSampleTime = 0

static Biquad	knockFilter

static volatile bool	knockIsSampling = false

static volatile bool	knockNeedsProcess = false

static volatile size_t	sampleCount = 0

static KnockThread	kt

Function Documentation

◆ initSoftwareKnock()

void initSoftwareKnock ( )

Definition at line 91 of file software_knock.cpp.

                         {
    if (engineConfiguration->enableSoftwareKnock) {
 
        float frequencyHz = 1000 * bore2frequency(engineConfiguration->cylinderBore);
        frequencyHz = engineConfiguration->knockDetectionUseDoubleFrequency ? 2 * frequencyHz : frequencyHz;
 
        if (engineConfiguration->knockFrequency > 0.01) {
            frequencyHz = engineConfiguration->knockFrequency;
        }
 
        knockFilter.configureBandpass(KNOCK_SAMPLE_RATE, frequencyHz, 3);
 
    #ifdef KNOCK_SPECTROGRAM
        if (engineConfiguration->enableKnockSpectrogram) {
 
            // TODO: use big buffer
            //buffer = getBigBuffer(BigBufferUser::KnockSpectrogram);
            // if (!buffer) {
            //  engineConfiguration->enableKnockSpectrogram = false;
            //      return;
            //  }
            //spectrogramData = buffer.get<SpectrogramData>();
 
            fft::blackmanharris(spectrogramData->window, FFT_SIZE, true);
 
            int freqStartConst = START_SPECTRORGAM_FREQUENCY;
            int minFreqDiff = freqStartConst;
            int freqStart = 0;
            float freqStep = 0;
 
            for (size_t i = 0; i < FFT_SIZE/2; i++)
            {
                float freq = float(i * KNOCK_SAMPLE_RATE) / FFT_SIZE;
                int min = abs(freq - freqStartConst);
 
                // next after freq start index
                if(i == spectrogramStartIndex + 1) {
                    freqStep = abs(freq - freqStart);
                }
 
                if(min < minFreqDiff) {
                    minFreqDiff = min;
                    spectrogramStartIndex = i;
                    freqStart = freq;
                }
            }
 
            engine->module<KnockController>()->m_knockFrequencyStart = (uint16_t)freqStart;
            engine->module<KnockController>()->m_knockFrequencyStep = freqStep;
        }
    #endif
 
  // fun fact: we do not offer any ADC channel flexibility like we have for many other kinds of inputs
        efiSetPadMode("knock ch1", KNOCK_PIN_CH1, PAL_MODE_INPUT_ANALOG);
#if KNOCK_HAS_CH2
        efiSetPadMode("knock ch2", KNOCK_PIN_CH2, PAL_MODE_INPUT_ANALOG);
#endif
        kt.start();
    }
}

Referenced by initHardware().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ knockSem()

chibios_rt::BinarySemaphore knockSem ( true )

Referenced by onKnockSamplingComplete().

Here is the caller graph for this function:

◆ onKnockSamplingComplete()

void onKnockSamplingComplete ( )

Definition at line 41 of file software_knock.cpp.

                               {
    knockNeedsProcess = true;
 
    // Notify the processing thread that it's time to process this sample
    chSysLockFromISR();
    knockSem.signalI();
    chSysUnlockFromISR();
}

Referenced by knockCompletionCallback(), and knockCompletionCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ onStartKnockSampling()

void onStartKnockSampling	(	uint8_t	cylinderNumber,
		float	samplingSeconds,
		uint8_t	channelIdx
	)

Definition at line 50 of file software_knock.cpp.

                                                                                             {
    if (!engineConfiguration->enableSoftwareKnock) {
        return;
    }
 
    // Cancel if ADC isn't ready
    if (!((KNOCK_ADC.state == ADC_READY) ||
            (KNOCK_ADC.state == ADC_ERROR))) {
        return;
    }
 
    // If there's pending processing, skip this event
    if (knockNeedsProcess) {
        return;
    }
 
    // Convert sampling time to number of samples
    constexpr int sampleRate = KNOCK_SAMPLE_RATE;
    sampleCount = 0xFFFFFFFE & static_cast<size_t>(clampF(100, samplingSeconds * sampleRate, efi::size(sampleBuffer)));
 
    // Select the appropriate conversion group - it will differ depending on which sensor this cylinder should listen on
    auto conversionGroup = getKnockConversionGroup(channelIdx);
 
  //current chanel number for spectrum TS plugin
    channelNumber = channelIdx;
 
    // Stash the current cylinder's number so we can store the result appropriately
    currentCylinderNumber = cylinderNumber;
 
    adcStartConversionI(&KNOCK_ADC, conversionGroup, sampleBuffer, sampleCount);
    lastKnockSampleTime = getTimeNowNt();
}

Referenced by startKnockSampling().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processLastKnockEvent()

static void processLastKnockEvent ( )

static

Definition at line 160 of file software_knock.cpp.

                                    {
    if (!knockNeedsProcess) {
        return;
    }
 
    float sumSq = 0;
 
    // todo: reduce magic constants. engineConfiguration->adcVcc?
    constexpr float ratio = 3.3f / 4095.0f;
 
    size_t localCount = sampleCount;
 
    // Prepare the steady state at vcc/2 so that there isn't a step
    // when samples begin
    // todo: reduce magic constants. engineConfiguration->adcVcc?
    knockFilter.cookSteadyState(3.3f / 2);
 
    // Compute the sum of squares
    for (size_t i = 0; i < localCount; i++) {
        float volts = ratio * sampleBuffer[i];
 
        float filtered = knockFilter.filter(volts);
        if (i == localCount - 1 && engineConfiguration->debugMode == DBG_KNOCK) {
            engine->outputChannels.debugFloatField1 = volts;
            engine->outputChannels.debugFloatField2 = filtered;
        }
 
        sumSq += filtered * filtered;
    }
 
    // take a local copy
    auto lastKnockTime = lastKnockSampleTime;
 
    // We're done with inspecting the buffer, another sample can be taken
    knockNeedsProcess = false;
 
#ifdef KNOCK_SPECTROGRAM
    if (engineConfiguration->enableKnockSpectrogram) {
        ScopePerf perf(PE::KnockAnalyzer);
 
        if (engineConfiguration->enableKnockSpectrogramFilter) {
            fft::fft_adc_sample_filtered(knockFilter, spectrogramData->window, ratio, engineConfiguration->knockSpectrumSensitivity, sampleBuffer, spectrogramData->fftBuffer, FFT_SIZE);
        } else {
            fft::fft_adc_sample(spectrogramData->window, ratio, engineConfiguration->knockSpectrumSensitivity, sampleBuffer, spectrogramData->fftBuffer, FFT_SIZE);
        }
 
        auto* spectrum = &engine->module<KnockController>()->m_knockSpectrum[0];
        for(uint8_t i = 0; i < COMPRESSED_SPECTRUM_PROTOCOL_SIZE; ++i) {
 
            uint8_t startIndex = spectrogramStartIndex + (i * 4);
 
            uint8_t a = toDb(fft::amplitude(spectrogramData->fftBuffer[startIndex]));
            uint8_t b = toDb(fft::amplitude(spectrogramData->fftBuffer[startIndex + 1]));
            uint8_t c = toDb(fft::amplitude(spectrogramData->fftBuffer[startIndex + 2]));
            uint8_t d = toDb(fft::amplitude(spectrogramData->fftBuffer[startIndex + 3]));
 
            uint32_t compressed = uint32_t(a << 24 | b << 16 | c << 8 | d);
 
      {
            chibios_rt::CriticalSectionLocker csl;
              spectrum[i] = compressed;
            }
        }
 
        uint16_t compressedChannelCyl = uint16_t(channelNumber << 8 | currentCylinderNumber);
 
        {
          chibios_rt::CriticalSectionLocker csl;
          engine->module<KnockController>()->m_knockSpectrumChannelCyl = compressedChannelCyl;
        }
    }
 
#endif
 
    // mean of squares (not yet root)
    float meanSquares = sumSq / localCount;
 
    // RMS
    float db = 10 * log10(meanSquares);
 
    // clamp to reasonable range
    db = clampF(-100, db, 100);
 
    engine->module<KnockController>()->onKnockSenseCompleted(currentCylinderNumber, db, lastKnockTime);
}

Here is the call graph for this function:

◆ toDb()

static uint8_t toDb ( const float & voltage )

static

Definition at line 153 of file software_knock.cpp.

                                          {
    float db = 200 * log10(voltage*voltage) + 40; // best scaling for view
    db = clampF(0, db, 255);
    return uint8_t(db);
}