StepGenerator.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Teknic, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef __STEPGENERATOR_H__
#define __STEPGENERATOR_H__

#include <stdint.h>

namespace ClearCore {

#define FRACT_BITS 15

class StepGenerator {
    friend class MotorManager;
    friend class TestIO;

public:
#ifndef HIDE_FROM_DOXYGEN
    StepGenerator();
#endif

    typedef enum {
        MOVE_TARGET_ABSOLUTE,
        MOVE_TARGET_REL_END_POSN,
    } MoveTarget;

    virtual bool Move(int32_t dist,
                      MoveTarget moveTarget = MOVE_TARGET_REL_END_POSN);

    virtual bool MoveVelocity(int32_t velocity);

    void MoveStopAbrupt();

    void MoveStopDecel(uint32_t decelMax = 0);

    void PositionRefSet(int32_t posn) {
        m_posnAbsolute = posn;
    }

    volatile const int32_t &PositionRefCommanded() {
        return m_posnAbsolute;
    }

    int32_t VelocityRefCommanded();

    void VelMax(uint32_t velMax);

    void AccelMax(uint32_t accelMax);


    void EStopDecelMax(uint32_t decelMax);

    bool StepsComplete() {
        return MoveStateGet() == MS_IDLE;
    }

    bool CruiseVelocityReached() {
        return MoveStateGet() == MS_CRUISE;
    }

protected:
    struct LimitStatus {
        uint32_t LimitRampPos       : 1;    // True if we are ramping into the positive limit
        uint32_t LimitRampNeg       : 1;    // True if we are ramping into the negative limit
        uint32_t EnterHWLimit       : 1;    // True when entering HW limits
        uint32_t InPosHWLimit       : 1;    // True if we are in the positive HW limit
        uint32_t InNegHWLimit       : 1;    // True if we are in the negative HW limit
        uint32_t InPosHWLimitLast   : 1;
        uint32_t InNegHWLimitLast   : 1;

        public:
        LimitStatus()
            : LimitRampPos(0),
              LimitRampNeg(0),
              EnterHWLimit(0),
              InPosHWLimit(0),
              InNegHWLimit(0),
              InPosHWLimitLast(0),
              InNegHWLimitLast(0) {}
    };

    typedef enum {
        MS_IDLE,
        MS_START,
        MS_ACCEL,
        MS_CRUISE,
        MS_DECEL,
        MS_DECEL_VEL,
        MS_END,
        MS_CHANGE_DIR,
    } MoveStates;

    uint32_t m_stepsPrevious;
    uint32_t m_stepsPerSampleMax;
    MoveStates m_moveState;
    bool m_direction;
    // True if the last move commanded was a positional move (latched)
    bool m_lastMoveWasPositional;

    LimitStatus m_limitInfo;

    int32_t m_posnAbsolute;

    volatile const bool &Direction() {
        return m_direction;
    }

    volatile const MoveStates &MoveStateGet() {
        return m_moveState;
    }

    void StepsCalculated();

    uint32_t StepsPrevious() {
        return m_stepsPrevious;
    }

    bool CheckTravelLimits();

    void PosLimitActive(bool isActive) {
        m_limitInfo.InPosHWLimit = isActive;
    }

    void NegLimitActive(bool isActive) {
        m_limitInfo.InNegHWLimit = isActive;
    }

private:

    int32_t m_stepsCommanded;
    int32_t m_stepsSent;      // Accumulated integer position

    bool m_velocityMove;      // A Velocity move is active
    bool m_moveDirChange;     // The move is changing direction
    bool m_dirCommanded;      // The direction of the commanded move


    // All of the position, velocity and acceleration parameters are signed and
    // in Q format, with all arithmetic performed in fixed point.
    // FRACT_BITS defines the Q value - the number of bits that are treated as
    // fractional values.

    int32_t m_velLimitQx;     // Velocity limit
    int32_t m_altVelLimitQx;  // Velocity move Velocity limit
    int32_t m_accelLimitQx;   // Acceleration limit
    int32_t m_altDecelLimitQx;// E-Stop Deceleration limit
    int64_t m_posnCurrentQx;  // Current position
    int32_t m_velCurrentQx;   // Current velocity
    int32_t m_accelCurrentQx; // Current acceleration
    int64_t m_posnTargetQx;   // Move length
    int32_t m_velTargetQx;    // Adjusted velocity limit
    int64_t m_posnDecelQx;    // Position to start decelerating

    // Pending velocity and acceleration parameters that shouldn't be applied
    // until a Move function is called again
    int32_t m_velLimitPendingQx;     // Velocity limit
    int32_t m_altVelLimitPendingQx;  // Velocity move Velocity limit
    int32_t m_accelLimitPendingQx;   // Acceleration limit
    int32_t m_altDecelLimitPendingQx;// E-Stop Deceleration limit

    virtual void OutputDirection() = 0;
    void StepsPerSampleMaxSet(uint32_t maxSteps);

    void AltVelMax(int32_t velMax);

    void UpdatePendingMoveLimits() {
        m_velLimitQx = m_velLimitPendingQx;
        m_altVelLimitQx = m_altVelLimitPendingQx;
        m_accelLimitQx = m_accelLimitPendingQx;
        m_altDecelLimitQx = m_altDecelLimitPendingQx;
    }
};

} // ClearCore namespace

#endif // __STEPGENERATOR_H__