Multi-channel software PWM output configuration. More...

#include <pwm_generator_logic.h>

Inheritance diagram for PwmConfig:

Collaboration diagram for PwmConfig:

[legend]

Public Member Functions
	PwmConfig ()

void	weComplexInit (Scheduler executor, MultiChannelStateSequence const seq, pwm_cycle_callback pwmCycleCallback, pwm_gen_callback callback)

void	setFrequency (float frequency)

void	handleCycleStart ()

efitick_t	togglePwmState ()

void	stop ()

void	applyPwmValue (OutputPin *output, int stateIndex, int channelIndex=0)

Data Fields
Scheduler *	m_executor = nullptr

pwm_mode_e	mode

bool	isStopRequested = false

const char *	m_name

OutputPin *	outputPins [PWM_PHASE_MAX_WAVE_PER_PWM]

MultiChannelStateSequence const *	multiChannelStateSequence = nullptr

int	dbgNestingLevel

scheduling_s	scheduling

pwm_config_safe_state_s	safe

pwm_cycle_callback *	m_pwmCycleCallback = nullptr

pwm_gen_callback *	m_stateChangeCallback = nullptr

Private Attributes
float	periodNt

bool	forceCycleStart = true

Detailed Description

Multi-channel software PWM output configuration.

Definition at line 50 of file pwm_generator_logic.h.

Constructor & Destructor Documentation

◆ PwmConfig()

PwmConfig::PwmConfig ( )

Definition at line 34 of file pwm_generator_logic.cpp.

                     {
    memset((void*)&scheduling, 0, sizeof(scheduling));
    memset((void*)&safe, 0, sizeof(safe));
    dbgNestingLevel = 0;
    periodNt = NAN;
    mode = PM_NORMAL;
    memset(&outputPins, 0, sizeof(outputPins));
    m_name = "[noname]";
}

Member Function Documentation

◆ applyPwmValue()

void PwmConfig::applyPwmValue	(	OutputPin *	output,
		int	stateIndex,
		int	channelIndex = `0`
	)

default implementation of pwm_gen_callback which simply toggles the pins

Definition at line 395 of file pwm_generator_logic.cpp.

                                                                                  {
    TriggerValue value = multiChannelStateSequence->getChannelState(channelIndex, stateIndex);
    output->setValue(value == TriggerValue::RISE);
}

Here is the call graph for this function:

◆ handleCycleStart()

void PwmConfig::handleCycleStart ( )

period length has changed - we need to reset internal state

Definition at line 136 of file pwm_generator_logic.cpp.

                                 {
    if (safe.phaseIndex != 0) {
        // https://github.com/rusefi/rusefi/issues/1030
        firmwareError(ObdCode::CUSTOM_PWM_CYCLE_START, "handleCycleStart %d", safe.phaseIndex);
        return;
    }
 
    if (m_pwmCycleCallback) {
        m_pwmCycleCallback(this);
    }
 
    // Compute the maximum number of iterations without overflowing a uint32_t worth of timestamp
    uint32_t iterationLimitInt32 = (0xFFFFFFFF / periodNt) - 2;
 
    // Maximum number of iterations that don't lose precision due to 32b float (~7 decimal significant figures)
    // We want at least 0.01% timing precision (aka 1/10000 cycle, 0.072 degree for trigger stimulator), which
    // means we can't do any more than 2^23 / 10000 cycles = 838 iterations before a reset
    uint32_t iterationLimitFloat = 838;
 
    uint32_t iterationLimit = minI(iterationLimitInt32, iterationLimitFloat);
 
    efiAssertVoid(ObdCode::CUSTOM_ERR_6580, periodNt != 0, "period not initialized");
    efiAssertVoid(ObdCode::CUSTOM_ERR_6580, iterationLimit > 0, "iterationLimit invalid");
    if (forceCycleStart || safe.periodNt != periodNt || safe.iteration == iterationLimit) {
        /**
         * period length has changed - we need to reset internal state
         */
        safe.startNt = getTimeNowNt();
        safe.iteration = 0;
        safe.periodNt = periodNt;
 
        forceCycleStart = false;
#if DEBUG_PWM
        efiPrintf("state reset start=%d iteration=%d", state->safe.start, state->safe.iteration);
#endif
    }
}

Referenced by togglePwmState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFrequency()

void PwmConfig::setFrequency ( float frequency )

Parameters

use	NAN frequency to pause PWM

see handleCycleStart() 'periodNt' is below 10 seconds here so we use 32 bit type for performance reasons

Definition at line 119 of file pwm_generator_logic.cpp.

                                            {
    if (std::isnan(frequency)) {
        // explicit code just to be sure
        periodNt = NAN;
        return;
    }
    /**
     * see #handleCycleStart()
     * 'periodNt' is below 10 seconds here so we use 32 bit type for performance reasons
     */
    periodNt = USF2NT(frequency2periodUs(frequency));
}

Referenced by TachometerModule::onFastCallback(), DcHardware::setFrequency(), setTriggerEmulatorRPM(), and speedoUpdate().

Here is the caller graph for this function:

◆ stop()

void PwmConfig::stop ( )

Definition at line 132 of file pwm_generator_logic.cpp.

                     {
    isStopRequested = true;
}

Referenced by disableTriggerStimulator().

Here is the caller graph for this function:

◆ togglePwmState()

efitick_t PwmConfig::togglePwmState ( )

Returns: Next time for signal toggle

Here is where the 'business logic' - the actual pin state change is happening

Definition at line 177 of file pwm_generator_logic.cpp.

                                    {
    if (isStopRequested) {
        return 0;
    }
 
#if DEBUG_PWM
    efiPrintf("togglePwmState phaseIndex=%d iteration=%d", safe.phaseIndex, safe.iteration);
    efiPrintf("period=%.2f safe.period=%.2f", period, safe.periodNt);
#endif
 
    if (std::isnan(periodNt)) {
        // NaN period means PWM is paused, we also set the pin low
        if (m_stateChangeCallback) {
            m_stateChangeCallback(0, this);
        }
 
        return getTimeNowNt() + MS2NT(NAN_FREQUENCY_SLEEP_PERIOD_MS);
    }
    if (mode != PM_NORMAL) {
        // in case of ZERO or FULL we are always at starting index
        safe.phaseIndex = 0;
    }
 
    if (safe.phaseIndex == 0) {
        handleCycleStart();
    }
 
    /**
     * Here is where the 'business logic' - the actual pin state change is happening
     */
    int cbStateIndex;
    if (mode == PM_NORMAL) {
        // callback state index is offset by one. todo: why? can we simplify this?
        cbStateIndex = safe.phaseIndex == 0 ? multiChannelStateSequence->phaseCount - 1 : safe.phaseIndex - 1;
    } else if (mode == PM_ZERO) {
        cbStateIndex = 0;
    } else {
        cbStateIndex = 1;
    }
 
    {
        ScopePerf perf(PE::PwmConfigStateChangeCallback);
        if (m_stateChangeCallback) {
            m_stateChangeCallback(cbStateIndex, this);
        }
    }
 
    efitick_t nextSwitchTimeNt = getNextSwitchTimeNt(this);
#if DEBUG_PWM
    efiPrintf("%s: nextSwitchTime %d", state->m_name, nextSwitchTime);
#endif /* DEBUG_PWM */
 
    // If we're very far behind schedule, restart the cycle fresh to avoid scheduling a huge pile of events all at once
    // This can happen during config write or debugging where CPU is halted for multiple seconds
    bool isVeryBehindSchedule = nextSwitchTimeNt < getTimeNowNt() - MS2NT(10);
 
    safe.phaseIndex++;
    if (isVeryBehindSchedule || safe.phaseIndex == multiChannelStateSequence->phaseCount || mode != PM_NORMAL) {
        safe.phaseIndex = 0; // restart
        safe.iteration++;
 
        if (isVeryBehindSchedule) {
            forceCycleStart = true;
        }
    }
#if EFI_UNIT_TEST
    printf("PWM: nextSwitchTimeNt=%d phaseIndex=%d iteration=%d\r\n", nextSwitchTimeNt,
            safe.phaseIndex,
            safe.iteration);
#endif /* EFI_UNIT_TEST */
    return nextSwitchTimeNt;
}

Here is the call graph for this function:

◆ weComplexInit()

void PwmConfig::weComplexInit	(	Scheduler *	executor,
		MultiChannelStateSequence const *	seq,
		pwm_cycle_callback *	pwmCycleCallback,
		pwm_gen_callback *	stateChangeCallback
	)

this method also starts the timer cycle See also startSimplePwm

Definition at line 290 of file pwm_generator_logic.cpp.

                                                                                     {
    m_executor = executor;
    isStopRequested = false;
 
    // NaN is 'not initialized' but zero is not expected
    criticalAssertVoid(periodNt != 0, "period is not initialized");
    criticalAssertVoid(seq->phaseCount != 0, "signal length cannot be zero");
    criticalAssertVoid(seq->phaseCount <= PWM_PHASE_MAX_COUNT, "too many phases in PWM");
    criticalAssertVoid(seq->waveCount > 0, "waveCount should be positive");
 
    m_pwmCycleCallback = pwmCycleCallback;
    m_stateChangeCallback = stateChangeCallback;
 
    copyPwmParameters(this, seq);
 
    safe.phaseIndex = 0;
    safe.periodNt = -1;
    safe.iteration = -1;
 
    // let's start the indefinite callback loop of PWM generation
    timerCallback(this);
}