Detailed Description

Date: Mar 2, 2014

Author: Andrey Belomutskiy, (c) 2012-2020

Definition in file pwm_generator_logic.h.

Data Structures
struct	pwm_config_safe_state_s

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

struct	IPwm

class	SimplePwm

Typedefs
typedef void()	pwm_cycle_callback(PwmConfig *state)

typedef void()	pwm_gen_callback(int stateIndex, PwmConfig *pwm)

Enumerations
enum	pwm_mode_e { PM_ZERO , PM_NORMAL , PM_FULL }

Functions
void	applyPinState (int stateIndex, PwmConfig *state)

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

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

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

void	copyPwmParameters (PwmConfig state, MultiChannelStateSequence const seq)

Typedef Documentation

◆ pwm_cycle_callback

typedef void() pwm_cycle_callback(PwmConfig *state)

Definition at line 38 of file pwm_generator_logic.h.

◆ pwm_gen_callback

typedef void() pwm_gen_callback(int stateIndex, PwmConfig *pwm)

Definition at line 39 of file pwm_generator_logic.h.

Enumeration Type Documentation

◆ pwm_mode_e

enum pwm_mode_e

Enumerator
PM_ZERO
PM_NORMAL
PM_FULL

Definition at line 41 of file pwm_generator_logic.h.

             {
    PM_ZERO,
    PM_NORMAL,
    PM_FULL
} pwm_mode_e;

Function Documentation

◆ applyPinState()

void applyPinState	(	int	stateIndex,
		PwmConfig *	state
	)

default implementation of pwm_gen_callback which simply toggles the pins

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:

◆ 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
}