pwm_generator_logic.cpp File Reference

Detailed Description

This PWM implementation keep track of when it would be the next time to toggle the signal. It constantly sets timer to that next toggle time, then sets the timer again from the callback, and so on.

Date

Mar 2, 2014

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file pwm_generator_logic.cpp.

Functions
static efitick_t	getNextSwitchTimeNt (PwmConfig *state)
static void	timerCallback (PwmConfig *state)
void	copyPwmParameters (PwmConfig *state, MultiChannelStateSequence const *seq)
void	startSimplePwm (SimplePwm *state, const char *msg, Scheduler *executor, OutputPin *output, float frequency, float dutyCycle, pwm_gen_callback *callback)
void	startSimplePwmExt (SimplePwm *state, const char *msg, Scheduler *executor, brain_pin_e brainPin, OutputPin *output, float frequency, float dutyCycle, pwm_gen_callback *callback)
void	startSimplePwmHard (SimplePwm *state, const char *msg, Scheduler *executor, brain_pin_e brainPin, OutputPin *output, float frequency, float dutyCycle)
void	applyPinState (int stateIndex, PwmConfig *state)

Function Documentation

applyPinState()

void applyPinState	(	int	stateIndex,
		PwmConfig *	state
	)

This method controls the actual hardware pins

Definition at line 403 of file pwm_generator_logic.cpp.

                                                       {
#if EFI_PROD_CODE
    if (!engine->isPwmEnabled) {
        for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) {
            OutputPin *output = state->outputPins[channelIndex];
            output->setValue(0);
        }
        return;
    }
#endif // EFI_PROD_CODE
 
    efiAssertVoid(ObdCode::CUSTOM_ERR_6663, stateIndex < PWM_PHASE_MAX_COUNT, "invalid stateIndex");
    efiAssertVoid(ObdCode::CUSTOM_ERR_6664, state->multiChannelStateSequence->waveCount <= PWM_PHASE_MAX_WAVE_PER_PWM, "invalid waveCount");
    for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) {
        OutputPin *output = state->outputPins[channelIndex];
        state->applyPwmValue(output, stateIndex, channelIndex);
    }
}

Referenced by emulatorApplyPinState(), and startSimplePwm().

Here is the call graph for this function:

Here is the caller graph for this function:

copyPwmParameters()

void copyPwmParameters	(	PwmConfig *	state,
		MultiChannelStateSequence const *	seq
	)

Incoming parameters are potentially just values on current stack, so we have to copy into our own permanent storage, right?

Definition at line 279 of file pwm_generator_logic.cpp.

                                                                                {
    state->multiChannelStateSequence = seq;
    if (state->mode == PM_NORMAL) {
        state->multiChannelStateSequence->checkSwitchTimes(1);
    }
}

Referenced by updateTriggerWaveformIfNeeded(), and PwmConfig::weComplexInit().

Here is the call graph for this function:

Here is the caller graph for this function:

getNextSwitchTimeNt()

static efitick_t getNextSwitchTimeNt ( PwmConfig *  state )

static

returns absolute timestamp of state change

Once 'iteration' gets relatively high, we might lose calculation precision here. This is addressed by iterationLimit below, using any many cycles as possible without overflowing timeToSwitchNt Shall we reuse 'sumTickAndFloat' here?

Definition at line 96 of file pwm_generator_logic.cpp.

                                                       {
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, state->safe.phaseIndex < PWM_PHASE_MAX_COUNT, "phaseIndex range", 0);
    int iteration = state->safe.iteration;
    // we handle PM_ZERO and PM_FULL separately
    float switchTime = state->mode == PM_NORMAL ? state->multiChannelStateSequence->getSwitchTime(state->safe.phaseIndex) : 1;
    float periodNt = state->safe.periodNt;
#if DEBUG_PWM
    efiPrintf("iteration=%d switchTime=%.2f period=%.2f", iteration, switchTime, period);
#endif /* DEBUG_PWM */
 
    /**
     * Once 'iteration' gets relatively high, we might lose calculation precision here.
     * This is addressed by iterationLimit below, using any many cycles as possible without overflowing timeToSwitchNt
     * Shall we reuse 'sumTickAndFloat' here?
     */
    uint32_t timeToSwitchNt = (uint32_t)((iteration + switchTime) * periodNt);
 
#if DEBUG_PWM
    efiPrintf("start=%d timeToSwitch=%d", state->safe.start, timeToSwitch);
#endif /* DEBUG_PWM */
    return state->safe.startNt + timeToSwitchNt;
}

Referenced by PwmConfig::togglePwmState().

Here is the call graph for this function:

Here is the caller graph for this function:

startSimplePwm()

void startSimplePwm	(	SimplePwm *	state,
		const char *	msg,
		Scheduler *	executor,
		OutputPin *	output,
		float	frequency,
		float	dutyCycle,
		pwm_gen_callback *	callback = NULL
	)

Start a one-channel software PWM driver.

This method should be called after scheduling layer is started by initSignalExecutor()

Definition at line 315 of file pwm_generator_logic.cpp.

                                                                                         {
    efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_STATE_ASSERT, state != NULL, "state");
    efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_DUTY_ASSERT, dutyCycle >= 0 && dutyCycle <= PWM_MAX_DUTY, "dutyCycle");
    if (frequency < 1) {
        warning(ObdCode::CUSTOM_OBD_LOW_FREQUENCY, "low frequency %.2f %s", frequency, msg);
        return;
    }
 
#if EFI_PROD_CODE
#if (BOARD_EXT_GPIOCHIPS > 0)
    if (!callback) {
        /* No specific scheduler, we can try enabling HW PWM */
        if (brain_pin_is_ext(output->brainPin)) {
            /* this pin is driven by external gpio chip, let's see if it can PWM */
            state->hardPwm = gpiochip_tryInitPwm(msg, output->brainPin, frequency, dutyCycle);
        }
        /* TODO: sohuld we try to init MCU PWM on on-chip brainPin?
         * Or this should be done only on startSimplePwmHard() call? */
    }
 
    /* We have succesufully started HW PWM on this output, no need to continue with SW */
    if (state->hardPwm) {
        return;
    }
#endif
#endif
 
    /* Set default executor for SW PWM */
    if (!callback) {
        callback = applyPinState;
    }
 
    state->seq.setSwitchTime(0, dutyCycle);
    state->seq.setSwitchTime(1, PWM_MAX_DUTY);
    state->seq.setChannelState(0, 0, TriggerValue::FALL);
    state->seq.setChannelState(0, PWM_MAX_DUTY, TriggerValue::RISE);
 
    state->outputPins[0] = output;
 
    state->setFrequency(frequency);
    state->setSimplePwmDutyCycle(dutyCycle);
    state->weComplexInit(executor, &state->seq, nullptr, callback);
}

Referenced by applyIACposition(), TachometerModule::init(), Generic4TransmissionController::init(), Gm4l6xTransmissionController::init(), initAlternatorCtrl(), initGpPwm(), initSpeedometer(), startBoostPin(), and startSimplePwmExt().

Here is the call graph for this function:

Here is the caller graph for this function:

startSimplePwmExt()

void startSimplePwmExt	(	SimplePwm *	state,
		const char *	msg,
		Scheduler *	executor,
		brain_pin_e	brainPin,
		OutputPin *	output,
		float	frequency,
		float	dutyCycle,
		pwm_gen_callback *	callback = NULL
	)

initialize GPIO pin and start a one-channel software PWM driver.

This method should be called after scheduling layer is started by initSignalExecutor()

Definition at line 361 of file pwm_generator_logic.cpp.

                                                     {
 
    output->initPin(msg, brainPin);
 
    startSimplePwm(state, msg, executor, output, frequency, dutyCycle, callback);
}

Referenced by startPwm(), startSimplePwmHard(), and turnVvtPidOn().

Here is the call graph for this function:

Here is the caller graph for this function:

startSimplePwmHard()

void startSimplePwmHard	(	SimplePwm *	state,
		const char *	msg,
		Scheduler *	executor,
		brain_pin_e	brainPin,
		OutputPin *	output,
		float	frequency,
		float	dutyCycle
	)

Parameters

dutyCycle

value between 0 and 1

Definition at line 374 of file pwm_generator_logic.cpp.

                         {
#if EFI_PROD_CODE && HAL_USE_PWM
    auto hardPwm = hardware_pwm::tryInitPin(msg, brainPin, frequency, dutyCycle);
 
    if (hardPwm) {
        state->hardPwm = hardPwm;
    } else {
#endif
        startSimplePwmExt(state, msg, executor, brainPin, output, frequency, dutyCycle);
#if EFI_PROD_CODE && HAL_USE_PWM
    }
#endif
}

Referenced by initVrThresholdPwm(), and DcHardware::start().

Here is the call graph for this function:

Here is the caller graph for this function:

timerCallback()

static void timerCallback ( PwmConfig *  state )

static

Main PWM loop: toggle pin & schedule next invocation

First invocation happens on application thread

Definition at line 255 of file pwm_generator_logic.cpp.

                                            {
    ScopePerf perf(PE::PwmGeneratorCallback);
 
    state->dbgNestingLevel++;
    efiAssertVoid(ObdCode::CUSTOM_ERR_6581, state->dbgNestingLevel < 25, "PWM nesting issue");
 
    efitick_t switchTimeNt = state->togglePwmState();
    if (switchTimeNt == 0) {
        // we are here when PWM gets stopped
        return;
    }
    if (state->m_executor == nullptr) {
        firmwareError(ObdCode::CUSTOM_NULL_EXECUTOR, "exec on %s", state->m_name);
        return;
    }
 
    state->m_executor->schedule(state->m_name, &state->scheduling, switchTimeNt, action_s::make<timerCallback>( state ));
    state->dbgNestingLevel--;
}

Referenced by PwmConfig::weComplexInit().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.