/**
* \par Function
* moveTo
* \par Description
* Stepper moves to the aim.
* \param[in]
* absolute - The absolute length to Stepper's movement.
* \par Output
* None
* \par Return
* None
* \par Others
* None
*/
void MeStepper::moveTo(long absolute)
{
if (_targetPos != absolute)
{
_targetPos = absolute;
computeNewSpeed();
}
}
boolean MeStepper::run()
{
if (_targetPos == _currentPos)
return false;
if (runSpeed())
computeNewSpeed();
return true;
}
void moveTo(Stepper_t* motor, long absolute)
{
if (motor->_targetPos != absolute)
{
motor->_targetPos = absolute;
computeNewSpeed(motor);
// compute new n?
}
}
void AccelStepper::moveTo(long absolute)
{
if (_targetPos != absolute)
{
_targetPos = absolute;
computeNewSpeed();
// compute new n?
}
}
void AsyncDriver::setMaxSpeed(float speed){
//uint8_t oldSREG = SREG;
// noInterrupts();
if (_maxSpeed != speed){
_maxSpeed = speed;
_cmin = 1000000.0 / speed;
if (_n > 0){ // Recompute _n from current speed and adjust speed if accelerating or cruising
_n = (long)((_speed * _speed) / (2.0 * _acceleration)); // Equation 16
computeNewSpeed(true);
}
}
// SREG = oldSREG;
}
/**
* \par Function
* run
* \par Description
* Stepper's status----run or not.
* \param[in]
* None
* \par Output
* None
* \par Return
* Return the status.
* \par Others
* None
*/
boolean MeStepper::run()
{
if((_speed == 0.0) || (distanceToGo() == 0))
{
return false;
}
if (runSpeed())
{
computeNewSpeed();
return true;
}
}
void setAcceleration(Stepper_t* motor, float acceleration)
{
if (acceleration == 0.0)
return;
if (motor->_acceleration != acceleration)
{
// Recompute _n per Equation 17
motor->_n = motor->_n * (motor->_acceleration / acceleration);
// New c0 per Equation 7, with correction per Equation 15
motor->_c0 = 0.676 * sqrt(2.0 / acceleration) * 1000000.0;// Equation 15
motor->_acceleration = acceleration;
computeNewSpeed(motor);
}
}
void setMaxSpeed(Stepper_t* motor, float speed)
{
if (motor->_maxSpeed != speed)
{
motor->_maxSpeed = speed;
motor->_cmin = 1000000.0 / speed;
// Recompute _n from current speed and adjust speed if accelerating or cruising
if (motor->_n > 0)
{
motor->_n = (long)((motor->_speed * motor->_speed) / (2.0 * motor->_acceleration)); // Equation 16
computeNewSpeed(motor);
}
}
}
void AccelStepper::setAcceleration(float acceleration)
{
if (acceleration == 0.0)
return;
if (_acceleration != acceleration)
{
// Recompute _n per Equation 17
_n = _n * (_acceleration / acceleration);
// New c0 per Equation 7
_c0 = sqrt(2.0 / acceleration) * 1000000.0;
_acceleration = acceleration;
computeNewSpeed();
}
}
void AccelStepper::setMaxSpeed(float speed)
{
if (_maxSpeed != speed)
{
_maxSpeed = speed;
_cmin = 1000000.0 / speed;
// Recompute _n from current speed and adjust speed if accelerating or cruising
if (_n > 0)
{
_n = (long)((_speed * _speed) / (2.0 * _acceleration)); // Equation 16
computeNewSpeed();
}
}
}
/**
* \par Function
* setAcceleration
* \par Description
* Set Acceleration for Stepper.
* \param[in]
* acceleration - The acceleration for Stepper.
* \par Output
* None
* \par Return
* None
* \par Others
* None
*/
void MeStepper::setAcceleration(float acceleration)
{
if(acceleration == 0.0)
{
return;
}
if(_acceleration != acceleration)
{
_n = _n * (_acceleration / acceleration);
// _c0 = sqrt(2.0 / acceleration) * 1000000.0;
// Accelerates at half the expected rate. Why?
_c0 = sqrt(1.0/acceleration) * 1000000.0;
_acceleration = acceleration;
computeNewSpeed();
}
}
void AsyncDriver::moveTo(long absolute){
uint8_t oldSREG = SREG;
noInterrupts();
if ( _targetPos == absolute ){
if( _targetPos ==_currentPos){
onReady();
}
}else{
if( disable_on_ready && is_disabled ){
enableOutputs();
}
_targetPos = absolute;
computeNewSpeed(true);
}
SREG = oldSREG;
}
boolean AccelStepper::runStepBuffer()
{
if (!is_full(_step_buffer))
{
if (_stepInterval == 0)
{
computeNewSpeed();
if (_stepInterval != 0)
{
_halfstepInterval = _stepInterval/2;
_stepInterval -= _halfstepInterval;
if (_direction == DIRECTION_CW)
{
// Clockwise
_currentPos += 1;
}
else
{
// Anticlockwise
_currentPos -= 1;
}
}
else
return 0;
}
if (_halfstepInterval != 0)
{
pushStep(_halfstepInterval);
}
else if (_stepInterval != 0)
{
pushStep(_stepInterval);
}
}
return 1;
}
// Run the motor to implement speed and acceleration in order to proceed to the target position
// You must call this at least once per step, preferably in your main loop
// If the motor is in the desired position, the cost is very small
// returns true if the motor is still running to the target position.
uint8_t run(Stepper_t* motor)
{
if (runSpeed(motor)) computeNewSpeed(motor);
return motor->_speed != 0.0 || distanceToGo(motor) != 0;
}
// Run the motor to implement speed and acceleration in order to proceed to the target position
// You must call this at least once per step, preferably in your main loop
// If the motor is in the desired position, the cost is very small
// returns true if the motor is still running to the target position.
boolean AccelStepper::run()
{
if (runSpeed())
computeNewSpeed();
return ((_speed != 0.0) || (distanceToGo() != 0));
}
void MeStepper::setAcceleration(float acceleration)
{
_acceleration = acceleration;
computeNewSpeed();
}
void AccelStepper::moveTo(long absolute)
{
_targetPos = absolute;
computeNewSpeed();
}
// Run the motor to implement speed and acceleration in order to proceed to the target position
// You must call this at least once per step, preferably in your main loop
// If the motor is in the desired position, the cost is very small
// returns true if we are still running to position
void AsyncDriver::run(){
if (haveToRun()){
computeNewSpeed(false);
}
}
// Run the motor to implement speed and acceleration in order to proceed to the target position
// You must call this at least once per step, preferably in your main loop
// If the motor is in the desired position, the cost is very small
// returns true if we are still running to position
bool AccelStepper::run()
{
if (runSpeed())
computeNewSpeed();
return true;
}
// Useful during initialisations or after initial positioning
void AccelStepper::setCurrentPosition(long position)
{
_targetPos = _currentPos = position;
computeNewSpeed(); // Expect speed of 0
}
// Run the motor to implement speed and acceleration in order to proceed to the target position
// You must call this at least once per step, preferably in your main loop
// If the motor is in the desired position, the cost is very small
// returns true if the motor is still running to the target position.
boolean AccelStepper::run()
{
if (runSpeed())
computeNewSpeed();
return _speed != 0.0 || distanceToGo() != 0;
}
void MeStepper::setMaxSpeed(float speed)
{
_maxSpeed = speed;
computeNewSpeed();
}
void AccelStepper::setAcceleration(float acceleration)
{
_acceleration = acceleration;
_sqrt_twoa = sqrt(2.0f * _acceleration);
computeNewSpeed();
}
