exploringBB::StepperMotor Class Reference

A class to control a stepper motor using a motor driver board, such as the Easy Driver board, or compatible. The class uses five GPIOs to control each motor. More...

#include <StepperMotor.h>

Public Types
enum	STEP_MODE { STEP_FULL, STEP_HALF, STEP_QUARTER, STEP_EIGHT }
enum	DIRECTION { CLOCKWISE, ANTICLOCKWISE }

Public Member Functions
	StepperMotor (GPIO *gpio_MS1, GPIO *gpio_MS2, GPIO *gpio_STEP, GPIO *gpio_SLP, GPIO *gpio_DIR, int speedRPM=60, int stepsPerRevolution=200)
	StepperMotor (int gpio_MS1, int gpio_MS2, int gpio_STEP, int gpio_SLP, int gpio_DIR, int speedRPM=60, int stepsPerRevolution=200)
virtual void	step ()
virtual void	step (int numberOfSteps)
virtual int	threadedStepForDuration (int numberOfSteps, int duration_ms)
virtual void	threadedStepCancel ()
virtual void	rotate (float degrees)
virtual void	setDirection (DIRECTION direction)
virtual DIRECTION	getDirection ()
virtual void	reverseDirection ()
virtual void	setStepMode (STEP_MODE mode)
virtual STEP_MODE	getStepMode ()
virtual void	setSpeed (float rpm)
virtual float	getSpeed ()
virtual void	setStepsPerRevolution (int steps)
virtual int	getStepsPerRevolution ()
virtual void	sleep ()
virtual void	wake ()
virtual bool	isAsleep ()
virtual	~StepperMotor ()

Friends
void *	threadedStep (void *value)

Detailed Description

A class to control a stepper motor using a motor driver board, such as the Easy Driver board, or compatible. The class uses five GPIOs to control each motor.

Member Enumeration Documentation

enum exploringBB::StepperMotor::DIRECTION

Enumerator
CLOCKWISE
ANTICLOCKWISE

{ CLOCKWISE, ANTICLOCKWISE };

enum exploringBB::StepperMotor::STEP_MODE

Enumerator
STEP_FULL
STEP_HALF
STEP_QUARTER
STEP_EIGHT

{ STEP_FULL, STEP_HALF, STEP_QUARTER, STEP_EIGHT };

Constructor & Destructor Documentation

exploringBB::StepperMotor::StepperMotor	(	GPIO *	gpio_MS1,
		GPIO *	gpio_MS2,
		GPIO *	gpio_STEP,
		GPIO *	gpio_SLP,
		GPIO *	gpio_DIR,
		int	speedRPM = 60,
		int	stepsPerRevolution = 200
	)

                                                                      {
        this->gpio_MS1  = gpio_MS1;
        this->gpio_MS2  = gpio_MS2;
        this->gpio_STEP = gpio_STEP;
        this->gpio_SLP  = gpio_SLP;
        this->gpio_DIR  = gpio_DIR;
        // the default speed in rpm
        this->setSpeed(speedRPM);
        this->stepsPerRevolution = stepsPerRevolution;
        this->init(speedRPM, stepsPerRevolution);
}

exploringBB::StepperMotor::StepperMotor	(	int	gpio_MS1,
		int	gpio_MS2,
		int	gpio_STEP,
		int	gpio_SLP,
		int	gpio_DIR,
		int	speedRPM = 60,
		int	stepsPerRevolution = 200
	)

                                                                           {
        this->gpio_MS1 = new GPIO(gpio_MS1);
        this->gpio_MS2 = new GPIO(gpio_MS2);
        this->gpio_STEP = new GPIO(gpio_STEP);
        this->gpio_SLP = new GPIO(gpio_SLP);
        this->gpio_DIR = new GPIO(gpio_DIR);
        this->gpio_MS1->setDirection(GPIO::OUTPUT);
        this->gpio_MS2->setDirection(GPIO::OUTPUT);
        this->gpio_STEP->setDirection(GPIO::OUTPUT);
        this->gpio_SLP->setDirection(GPIO::OUTPUT);
        this->gpio_DIR->setDirection(GPIO::OUTPUT);
        this->init(speedRPM, stepsPerRevolution);
}

exploringBB::StepperMotor::~StepperMotor ( )

virtual

{}

Member Function Documentation

virtual DIRECTION exploringBB::StepperMotor::getDirection ( )

inlinevirtual

{ return this->direction; }

virtual float exploringBB::StepperMotor::getSpeed ( )

inlinevirtual

{ return speed; }

virtual STEP_MODE exploringBB::StepperMotor::getStepMode ( )

inlinevirtual

{ return stepMode; }

virtual int exploringBB::StepperMotor::getStepsPerRevolution ( )

inlinevirtual

{ return stepsPerRevolution; }

virtual bool exploringBB::StepperMotor::isAsleep ( )

inlinevirtual

{ return asleep; }

void exploringBB::StepperMotor::reverseDirection ( )

virtual

                                   {
        if(this->direction==CLOCKWISE){
                this->setDirection(ANTICLOCKWISE);
        }
        else this->setDirection(CLOCKWISE);
}

void exploringBB::StepperMotor::rotate ( float  degrees )

virtual

                                      {
        float degreesPerStep = 360.0f/getStepsPerRevolution();
        int numberOfSteps = floor(((this->delayFactor*degrees)/degreesPerStep)+0.5);
        //cout << "The number of steps is " << numberOfSteps << endl;
        //cout << "The delay factor is " << delayFactor << endl;
        step(numberOfSteps);
}

void exploringBB::StepperMotor::setDirection ( DIRECTION  direction )

virtual

                                                  {
        this->direction = direction;
        if(this->direction==CLOCKWISE) this->gpio_DIR->setValue(GPIO::HIGH);
                else this->gpio_DIR->setValue(GPIO::LOW);
}

void exploringBB::StepperMotor::setSpeed ( float  rpm )

virtual

                                     {
        this->speed = rpm;
        float delayPerSec = (60/rpm)/stepsPerRevolution;    // delay per step in seconds
        this->uSecDelay = (int)(delayPerSec * 1000 * 1000); // in microseconds
}

void exploringBB::StepperMotor::setStepMode ( STEP_MODE  mode )

virtual

                                             {
        this->stepMode = mode;
        switch(stepMode){
        case STEP_FULL:
                this->gpio_MS1->setValue(GPIO::LOW);
                this->gpio_MS2->setValue(GPIO::LOW);
                this->delayFactor = 1;
                break;
        case STEP_HALF:
                this->gpio_MS1->setValue(GPIO::HIGH);
                this->gpio_MS2->setValue(GPIO::LOW);
                this->delayFactor = 2;
                break;
        case STEP_QUARTER:
                this->gpio_MS1->setValue(GPIO::LOW);
                this->gpio_MS2->setValue(GPIO::HIGH);
                this->delayFactor = 4;
                break;
        case STEP_EIGHT:
                this->gpio_MS1->setValue(GPIO::HIGH);
                this->gpio_MS2->setValue(GPIO::HIGH);
                this->delayFactor = 8;
                break;
        }
}

virtual void exploringBB::StepperMotor::setStepsPerRevolution ( int  steps )

inlinevirtual

{ stepsPerRevolution = steps; }

void exploringBB::StepperMotor::sleep ( )

virtual

                        {
        this->asleep = true;
        this->gpio_SLP->setValue(GPIO::LOW);
}

void exploringBB::StepperMotor::step ( )

virtual

                       {
    this->gpio_STEP->setValue(GPIO::LOW);
    this->gpio_STEP->setValue(GPIO::HIGH);
}

void exploringBB::StepperMotor::step ( int  numberOfSteps )

virtual

                                        {
        //cout << "Doing "<< numberOfSteps << " steps and going to sleep for " << uSecDelay/delayFactor << "uS\n";
        int sleepDelay = uSecDelay/delayFactor;
        if(numberOfSteps<0) {
                this->reverseDirection();
                numberOfSteps = -numberOfSteps;
        }
        for(int i=0; i<numberOfSteps; i++){
                this->step();
                usleep(sleepDelay);
        }
}

virtual void exploringBB::StepperMotor::threadedStepCancel ( )

inlinevirtual

{ this->threadRunning = false; }

int exploringBB::StepperMotor::threadedStepForDuration ( int  numberOfSteps, int  duration_ms  )

virtual

                                                                            {
        this->threadedStepNumber = numberOfSteps;
        this->threadedStepPeriod = duration_ms/numberOfSteps;
        this->threadRunning = true;
    if(pthread_create(&this->thread, NULL, &threadedStep, static_cast<void*>(this))){
        perror("StepperMotor: Failed to create the stepping thread");
        this->threadRunning = false;
        return -1;
    }
    return 0;
}

void exploringBB::StepperMotor::wake ( )

virtual

                       {
        this->asleep = false;
        this->gpio_SLP->setValue(GPIO::HIGH);
}

Friends And Related Function Documentation

void* threadedStep ( void *  value )

friend

                               {
        StepperMotor *stepper = static_cast<StepperMotor*>(value);
        while(stepper->threadRunning){
                stepper->step();
                usleep(stepper->threadedStepPeriod * 1000);  // convert from ms to us
                if(stepper->threadedStepNumber>0) stepper->threadedStepNumber--;
                if(stepper->threadedStepNumber==0) stepper->threadRunning = false;
        }
        return 0;
}

---

The documentation for this class was generated from the following files:

• /home/molloyd/exploringBB/library/motor/StepperMotor.h
• /home/molloyd/exploringBB/library/motor/StepperMotor.cpp