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__