stepper.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/gpio/pin.h>
 
namespace PropWare {
 
class Stepper {
    public:
        enum class Step {
                HALF,
                ONE,
                ONE_AND_A_HALF,
                TWO,
                TWO_AND_A_HALF,
                THREE,
                THREE_AND_A_HALF,
                FOUR
        };
 
        static const unsigned int DEFAULT_DELAY      = 10000;
        static const Step         DEFAULT_START_STEP = Step::HALF;
 
    public:
        Stepper (const Pin::Mask phase1Mask, const Pin::Mask phase2Mask, const Pin::Mask phase3Mask,
                 const Pin::Mask phase4Mask, const Step start = DEFAULT_START_STEP)
            : m_currentStep(start),
              m_phase1(phase1Mask, Pin::Dir::OUT),
              m_phase2(phase2Mask, Pin::Dir::OUT),
              m_phase3(phase3Mask, Pin::Dir::OUT),
              m_phase4(phase4Mask, Pin::Dir::OUT) {
            this->rotate();
        }
 
        void step_to (const Stepper::Step step) {
            this->m_currentStep = step;
            this->rotate();
        }
 
        Step get_current_step () const {
            return this->m_currentStep;
        }
 
        bool full_power_hold (const bool direction, const unsigned int usDelay = DEFAULT_DELAY) {
            const bool movementNeeded = static_cast<bool>(static_cast<uint32_t>(this->m_currentStep) % 2);
            if (movementNeeded) {
                if (direction)
                    this->half_forward(1, usDelay);
                else
                    this->half_reverse(1, usDelay);
            }
            return movementNeeded;
        }
 
        bool half_power_hold (const bool direction, const unsigned int usDelay = DEFAULT_DELAY) {
            const bool movementNeeded = !static_cast<bool>(static_cast<uint32_t>(this->m_currentStep) % 2);
            if (movementNeeded) {
                if (direction)
                    this->half_forward(1, usDelay);
                else
                    this->half_reverse(1, usDelay);
            }
            return movementNeeded;
        }
 
        void step_forward (unsigned int steps, const unsigned int usDelay = DEFAULT_DELAY) {
            while (steps--) {
                const unsigned int stepNumber = static_cast<unsigned int>(this->m_currentStep) + 2;
                this->m_currentStep = static_cast<Step>(stepNumber % 8);
                this->rotate();
                waitcnt(usDelay * MICROSECOND + CNT);
            }
        }
 
        void half_forward (unsigned int halfSteps, const unsigned int usDelay = DEFAULT_DELAY) {
            while (halfSteps--) {
                const unsigned int stepNumber = static_cast<unsigned int>(this->m_currentStep) + 1;
                this->m_currentStep = static_cast<Step>(stepNumber % 8);
                this->rotate();
                waitcnt(usDelay * MICROSECOND + CNT);
            }
        }
 
        void step_reverse (unsigned int steps, const unsigned int usDelay = DEFAULT_DELAY) {
            while (steps--) {
                const unsigned int stepNumber = static_cast<unsigned int>(this->m_currentStep) + 6;
                this->m_currentStep = static_cast<Step>(stepNumber % 8);
                this->rotate();
                waitcnt(usDelay * MICROSECOND + CNT);
            }
        }
 
        void half_reverse (unsigned int halfSteps, const unsigned int usDelay = DEFAULT_DELAY) {
            while (halfSteps--) {
                const unsigned int stepNumber = static_cast<unsigned int>(this->m_currentStep) + 7;
                this->m_currentStep = static_cast<Step>(stepNumber % 8);
                this->rotate();
                waitcnt(usDelay * MICROSECOND + CNT);
            }
        }
 
    private:
        virtual void rotate () {
            switch (this->m_currentStep) {
                case Step::HALF:
                    this->m_phase1.set();
                    this->m_phase2.clear();
                    this->m_phase3.clear();
                    this->m_phase4.set();
                    break;
                case Step::ONE:
                    this->m_phase1.set();
                    this->m_phase2.clear();
                    this->m_phase3.clear();
                    this->m_phase4.clear();
                    break;
                case Step::ONE_AND_A_HALF:
                    this->m_phase1.set();
                    this->m_phase2.set();
                    this->m_phase3.clear();
                    this->m_phase4.clear();
                    break;
                case Step::TWO:
                    this->m_phase1.clear();
                    this->m_phase2.set();
                    this->m_phase3.clear();
                    this->m_phase4.clear();
                    break;
                case Step::TWO_AND_A_HALF:
                    this->m_phase1.clear();
                    this->m_phase2.set();
                    this->m_phase3.set();
                    this->m_phase4.clear();
                    break;
                case Step::THREE:
                    this->m_phase1.clear();
                    this->m_phase2.clear();
                    this->m_phase3.set();
                    this->m_phase4.clear();
                    break;
                case Step::THREE_AND_A_HALF:
                    this->m_phase1.clear();
                    this->m_phase2.clear();
                    this->m_phase3.set();
                    this->m_phase4.set();
                    break;
                case Step::FOUR:
                    this->m_phase1.clear();
                    this->m_phase2.clear();
                    this->m_phase3.clear();
                    this->m_phase4.set();
                    break;
            }
        }
 
    private:
        Step m_currentStep;
        Pin  m_phase1;
        Pin  m_phase2;
        Pin  m_phase3;
        Pin  m_phase4;
};
 
}