#include <stepper.h>

Inheritance diagram for StepperMotorBase:

Collaboration diagram for StepperMotorBase:

[legend]

Public Member Functions
virtual void	initialize (StepperHw *hardware, int totalSteps)

void	doIteration ()

void	setTargetPosition (float targetPositionSteps)

float	getTargetPosition () const

bool	isBusy () const

Data Fields
int	m_currentPosition = 0

int	m_totalSteps = 0

Protected Member Functions
void	setInitialPosition (void)

void	saveStepperPos (int pos)

int	loadStepperPos ()

void	changeCurrentPosition (bool positive)

void	postCurrentPosition (void)

Protected Attributes
StepperHw *	m_hw = nullptr

float	m_targetPosition = 0

bool	initialPositionSet = false

bool	m_isBusy = false

Detailed Description

Definition at line 66 of file stepper.h.

Member Function Documentation

◆ changeCurrentPosition()

void StepperMotorBase::changeCurrentPosition ( bool positive )

protected

Definition at line 51 of file stepper.cpp.

                                                          {
    if (positive) {
        m_currentPosition++;
    } else {
        m_currentPosition--;
    }
    postCurrentPosition();
}

Referenced by doIteration(), and setInitialPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ doIteration()

void StepperMotorBase::doIteration ( )

Definition at line 125 of file stepper.cpp.

                                   {
    int targetPosition = efiRound(getTargetPosition(), 1);
    int currentPosition = m_currentPosition;
 
    // stepper requires +12V
    if (!isIgnVoltage()) {
      initialPositionSet = false;
        m_hw->pause();
        return;
    }
 
    if (!initialPositionSet) {
        setInitialPosition();
        return;
    }
 
    if (targetPosition == currentPosition) {
        m_hw->sleep();
        m_isBusy = false;
        return;
    }
 
    m_isBusy = true;
 
    bool isIncrementing = targetPosition > currentPosition;
 
    if (m_hw->step(isIncrementing)) {
        changeCurrentPosition(isIncrementing);
    }
 
    // save position to backup RTC register
#if EFI_PROD_CODE
    saveStepperPos(m_currentPosition);
#endif
}

Referenced by StepperMotor::ThreadTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTargetPosition()

float StepperMotorBase::getTargetPosition ( ) const

Definition at line 14 of file stepper.cpp.

                                                {
    return m_targetPosition;
}

Referenced by doIteration(), and IdleController::getIdlePosition().

Here is the caller graph for this function:

◆ initialize()

void StepperMotorBase::initialize	(	StepperHw *	hardware,
		int	totalSteps
	)

virtual

Reimplemented in StepperMotor.

Definition at line 26 of file stepper.cpp.

                                                                     {
    m_totalSteps = maxI(3, totalSteps);
 
    m_hw = hardware;
}

Referenced by StepperMotor::initialize().

Here is the caller graph for this function:

◆ isBusy()

bool StepperMotorBase::isBusy ( ) const

Definition at line 161 of file stepper.cpp.

                                    {
    return m_isBusy;
}

◆ loadStepperPos()

int StepperMotorBase::loadStepperPos ( )

protected

Definition at line 43 of file stepper.cpp.

                                     {
#if EFI_PROD_CODE && EFI_BACKUP_SRAM
    return (int)backupRamLoad(backup_ram_e::StepperPosition) - 1;
#else
    return 0;
#endif
}

Referenced by setInitialPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postCurrentPosition()

void StepperMotorBase::postCurrentPosition ( void )

protected

Definition at line 60 of file stepper.cpp.

                                           {
    if (engineConfiguration->debugMode == DBG_STEPPER_IDLE_CONTROL) {
#if EFI_TUNER_STUDIO
        engine->outputChannels.debugIntField5 = m_currentPosition;
#endif /* EFI_TUNER_STUDIO */
    }
}

Referenced by changeCurrentPosition(), and saveStepperPos().

Here is the caller graph for this function:

◆ saveStepperPos()

void StepperMotorBase::saveStepperPos ( int pos )

protected

Definition at line 35 of file stepper.cpp.

                                             {
    // use backup-power RTC registers to store the data
#if EFI_PROD_CODE && EFI_BACKUP_SRAM
    backupRamSave(backup_ram_e::StepperPosition, pos + 1);
#endif
    postCurrentPosition();
}

Referenced by doIteration(), and setInitialPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setInitialPosition()

void StepperMotorBase::setInitialPosition ( void )

protected

let's park the motor in a known position to begin with

I believe it's safer to retract the valve for parking - at least on a bench I've seen valves disassembling themselves while pushing too far out.

Add extra steps to compensate step skipping by some old motors.

Definition at line 68 of file stepper.cpp.

                                          {
    // try to get saved stepper position (-1 for no data)
    m_currentPosition = loadStepperPos();
 
#if HAL_USE_ADC
    // first wait until at least 1 slowADC sampling is complete
    waitForSlowAdc();
#endif
 
#if EFI_SHAFT_POSITION_INPUT
    bool isRunning = engine->rpmCalculator.isRunning();
#else
    bool isRunning = false;
#endif /* EFI_SHAFT_POSITION_INPUT */
    // now check if stepper motor re-initialization is requested - if the throttle pedal is pressed at startup
    auto tpsPos = Sensor::getOrZero(SensorType::DriverThrottleIntent);
    bool forceStepperParking = !isRunning && tpsPos > STEPPER_PARKING_TPS;
    if (engineConfiguration->stepperForceParkingEveryRestart)
        forceStepperParking = true;
    efiPrintf("Stepper: savedStepperPos=%d forceStepperParking=%d (tps=%.2f)", m_currentPosition, (forceStepperParking ? 1 : 0), tpsPos);
 
    if (m_currentPosition < 0 || forceStepperParking) {
        efiPrintf("Stepper: starting parking time=%lums", getTimeNowMs());
        // reset saved value
        saveStepperPos(-1);
 
        /**
         * let's park the motor in a known position to begin with
         *
         * I believe it's safer to retract the valve for parking - at least on a bench I've seen valves
         * disassembling themselves while pushing too far out.
         *
         * Add extra steps to compensate step skipping by some old motors.
         */
        int numParkingSteps = (int)efiRound((1.0f + (float)engineConfiguration->stepperParkingExtraSteps / PERCENT_MULT) * m_totalSteps, 1.0f);
        for (int i = 0; i < numParkingSteps; i++) {
            if (!m_hw->step(false)) {
                initialPositionSet = false;
                return;
            }
            changeCurrentPosition(false);
        }
 
        // set & save zero stepper position after the parking completion
        m_currentPosition = 0;
        saveStepperPos(m_currentPosition);
        // todo: is this a slow operation on the start-up path?
        efiPrintf("Stepper: parking finished time=%lums", getTimeNowMs());
    } else {
        // The initial target position should correspond to the saved stepper position.
        // Idle thread starts later and sets a new target position.
        setTargetPosition(m_currentPosition);
    }
 
    initialPositionSet = true;
}

Referenced by doIteration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setTargetPosition()

void StepperMotorBase::setTargetPosition ( float targetPositionSteps )

Definition at line 18 of file stepper.cpp.

                                                                  {
    // When the IAC position value change is insignificant (lower than this threshold), leave the poor valve alone
    // When we get a larger change, actually update the target stepper position
    if (std::abs(m_targetPosition - targetPositionSteps) >= 1) {
        m_targetPosition = targetPositionSteps;
    }
}