From 2a3485cf98c757e884311eed2158541fa369c8ab Mon Sep 17 00:00:00 2001 From: Jon Trulson Date: Wed, 8 Apr 2015 17:33:24 -0600 Subject: [PATCH] uln200xa: Initial implementation This driver was tested on a Grove Geared Stepper with Driver, the uln2003a paired with a 28BYJ-48 unipolar stepper motor. Signed-off-by: Jon Trulson Signed-off-by: John Van Drasek --- examples/c++/CMakeLists.txt | 3 + examples/c++/uln200xa.cxx | 62 ++++++++ examples/javascript/uln200xa.js | 71 ++++++++++ examples/python/uln200xa.py | 66 +++++++++ src/uln200xa/CMakeLists.txt | 5 + src/uln200xa/jsupm_uln200xa.i | 8 ++ src/uln200xa/pyupm_uln200xa.i | 9 ++ src/uln200xa/uln200xa.cxx | 242 ++++++++++++++++++++++++++++++++ src/uln200xa/uln200xa.h | 157 +++++++++++++++++++++ 9 files changed, 623 insertions(+) create mode 100644 examples/c++/uln200xa.cxx create mode 100644 examples/javascript/uln200xa.js create mode 100644 examples/python/uln200xa.py create mode 100644 src/uln200xa/CMakeLists.txt create mode 100644 src/uln200xa/jsupm_uln200xa.i create mode 100644 src/uln200xa/pyupm_uln200xa.i create mode 100644 src/uln200xa/uln200xa.cxx create mode 100644 src/uln200xa/uln200xa.h diff --git a/examples/c++/CMakeLists.txt b/examples/c++/CMakeLists.txt index 09d258af..d12ca22c 100644 --- a/examples/c++/CMakeLists.txt +++ b/examples/c++/CMakeLists.txt @@ -111,6 +111,7 @@ add_executable (waterlevel-example waterlevel.cxx) add_executable (tm1637-example tm1637.cxx) add_executable (zfm20-example zfm20.cxx) add_executable (zfm20-register-example zfm20-register.cxx) +add_executable (uln200xa-example uln200xa.cxx) include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l) include_directories (${PROJECT_SOURCE_DIR}/src/grove) @@ -200,6 +201,7 @@ include_directories (${PROJECT_SOURCE_DIR}/src/apds9002) include_directories (${PROJECT_SOURCE_DIR}/src/waterlevel) include_directories (${PROJECT_SOURCE_DIR}/src/tm1637) include_directories (${PROJECT_SOURCE_DIR}/src/zfm20) +include_directories (${PROJECT_SOURCE_DIR}/src/uln200xa) target_link_libraries (hmc5883l-example hmc5883l ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (groveled-example grove ${CMAKE_THREAD_LIBS_INIT}) @@ -312,3 +314,4 @@ target_link_libraries (waterlevel-example waterlevel ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (tm1637-example tm1637 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (zfm20-example zfm20 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (zfm20-register-example zfm20 ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (uln200xa-example uln200xa ${CMAKE_THREAD_LIBS_INIT}) diff --git a/examples/c++/uln200xa.cxx b/examples/c++/uln200xa.cxx new file mode 100644 index 00000000..53a6958a --- /dev/null +++ b/examples/c++/uln200xa.cxx @@ -0,0 +1,62 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2015 Intel Corporation. + * + * 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. + */ + +#include +#include +#include "uln200xa.h" + +using namespace std; + +int main () +{ + //! [Interesting] + + // Instantiate a Stepper motor on a ULN200XA Dual H-Bridge. + + // This was tested with the Grove Gear Stepper Motor with Driver + + // Wire the pins so that I1 is pin D8, I2 is pin D9, I3 is pin D10 and + // I4 is pin D11 + upm::ULN200XA* uln200xa = new upm::ULN200XA(4096, 8, 9, 10, 11); + + uln200xa->setSpeed(5); + uln200xa->setDirection(upm::ULN200XA::DIR_CW); + cout << "Rotating 1 revolution clockwise." << endl; + uln200xa->stepperSteps(4096); + cout << "Sleeping for 2 seconds..." << endl; + sleep(2); + cout << "Rotating 1/2 revolution counter clockwise." << endl; + uln200xa->setDirection(upm::ULN200XA::DIR_CCW); + uln200xa->stepperSteps(2048); + + // turn off the power + uln200xa->release(); + + //! [Interesting] + cout << "Exiting..." << endl; + + delete uln200xa; + return 0; +} + diff --git a/examples/javascript/uln200xa.js b/examples/javascript/uln200xa.js new file mode 100644 index 00000000..41017078 --- /dev/null +++ b/examples/javascript/uln200xa.js @@ -0,0 +1,71 @@ +/*jslint node:true, vars:true, bitwise:true, unparam:true */ +/*jshint unused:true */ +/* +* Author: Jon Trulson +* Copyright (c) 2015 Intel Corporation. +* +* 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. +*/ + +var Uln200xa_lib = require('jsupm_uln200xa'); + +// Instantiate a Stepper motor on a ULN200XA Darlington Motor Driver +// This was tested with the Grove Geared Step Motor with Driver + +// Instantiate a ULN2003XA stepper object +var myUln200xa_obj = new Uln200xa_lib.ULN200XA(4096, 8, 9, 10, 11); + +myUln200xa_obj.goForward = function() +{ + myUln200xa_obj.setSpeed(5); // 5 RPMs + myUln200xa_obj.setDirection(Uln200xa_lib.ULN200XA.DIR_CW); + console.log("Rotating 1 revolution clockwise."); + myUln200xa_obj.stepperSteps(4096); +}; + +myUln200xa_obj.reverseDirection = function() +{ + console.log("Rotating 1/2 revolution counter clockwise."); + myUln200xa_obj.setDirection(Uln200xa_lib.ULN200XA.DIR_CCW); + myUln200xa_obj.stepperSteps(2048); +}; + +myUln200xa_obj.stop = function() +{ + myUln200xa_obj.release(); +}; + +myUln200xa_obj.quit = function() +{ + myUln200xa_obj = null; + Uln200xa_lib.cleanUp(); + Uln200xa_lib = null; + console.log("Exiting"); + process.exit(0); +}; + +// Run ULN200xa driven stepper +myUln200xa_obj.goForward(); +setTimeout(myUln200xa_obj.reverseDirection, 2000); +setTimeout(function() +{ + myUln200xa_obj.stop(); + myUln200xa_obj.quit(); +}, 2000); diff --git a/examples/python/uln200xa.py b/examples/python/uln200xa.py new file mode 100644 index 00000000..e926e468 --- /dev/null +++ b/examples/python/uln200xa.py @@ -0,0 +1,66 @@ +#!/usr/bin/python +# Author: Jon Trulson +# Copyright (c) 2015 Intel Corporation. +# +# 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. + + +import time, sys, signal, atexit +import pyupm_uln200xa as upmULN200XA + +# Instantiate a Stepper motor on a ULN200XA Darlington Motor Driver +# This was tested with the Grove Geared Step Motor with Driver + +# Instantiate a ULN2003XA stepper object +myUln200xa = upmULN200XA.ULN200XA(4096, 8, 9, 10, 11) + +## Exit handlers ## +# This stops python from printing a stacktrace when you hit control-C +def SIGINTHandler(signum, frame): + raise SystemExit + +# This lets you run code on exit, +# including functions from myUln200xa +def exitHandler(): + print "Exiting" + sys.exit(0) + +# Register exit handlers +atexit.register(exitHandler) +signal.signal(signal.SIGINT, SIGINTHandler) + + +myUln200xa.setSpeed(5) # 5 RPMs +myUln200xa.setDirection(upmULN200XA.ULN200XA.DIR_CW) + +print "Rotating 1 revolution clockwise." +myUln200xa.stepperSteps(4096) + +print "Sleeping for 2 seconds..." +time.sleep(2) + +print "Rotating 1/2 revolution counter clockwise." +myUln200xa.setDirection(upmULN200XA.ULN200XA.DIR_CCW) +myUln200xa.stepperSteps(2048) + +# release +myUln200xa.release() + +# exitHandler is called automatically diff --git a/src/uln200xa/CMakeLists.txt b/src/uln200xa/CMakeLists.txt new file mode 100644 index 00000000..3ac82ff5 --- /dev/null +++ b/src/uln200xa/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "uln200xa") +set (libdescription "upm uln200xa darlington stepper driver") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/uln200xa/jsupm_uln200xa.i b/src/uln200xa/jsupm_uln200xa.i new file mode 100644 index 00000000..48127af8 --- /dev/null +++ b/src/uln200xa/jsupm_uln200xa.i @@ -0,0 +1,8 @@ +%module jsupm_uln200xa +%include "../upm.i" + +%{ + #include "uln200xa.h" +%} + +%include "uln200xa.h" diff --git a/src/uln200xa/pyupm_uln200xa.i b/src/uln200xa/pyupm_uln200xa.i new file mode 100644 index 00000000..4a2eb3c9 --- /dev/null +++ b/src/uln200xa/pyupm_uln200xa.i @@ -0,0 +1,9 @@ +%module pyupm_uln200xa +%include "../upm.i" + +%feature("autodoc", "3"); + +%include "uln200xa.h" +%{ + #include "uln200xa.h" +%} diff --git a/src/uln200xa/uln200xa.cxx b/src/uln200xa/uln200xa.cxx new file mode 100644 index 00000000..cd03ede0 --- /dev/null +++ b/src/uln200xa/uln200xa.cxx @@ -0,0 +1,242 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2015 Intel Corporation. + * + * 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. + */ + +#include + +#include "uln200xa.h" + +using namespace upm; +using namespace std; + +ULN200XA::ULN200XA(int stepsPerRev, int i1, int i2, int i3, int i4) +{ + m_stepsPerRev = stepsPerRev; + m_currentStep = 0; + m_stepDelay = 0; + m_stepDirection = 1; // default is forward + + if ( !(m_stepI1 = mraa_gpio_init(i1)) ) + { + cerr << __FUNCTION__ << ": mraa_gpio_init(i1) failed" << endl; + return; + } + mraa_gpio_dir(m_stepI1, MRAA_GPIO_OUT); + + if ( !(m_stepI2 = mraa_gpio_init(i2)) ) + { + cerr << __FUNCTION__ << ": mraa_gpio_init(i2) failed" << endl; + mraa_gpio_close(m_stepI1); + return; + } + mraa_gpio_dir(m_stepI2, MRAA_GPIO_OUT); + + if ( !(m_stepI3 = mraa_gpio_init(i3)) ) + { + cerr << __FUNCTION__ << ": mraa_gpio_init(i3) failed" << endl; + mraa_gpio_close(m_stepI1); + mraa_gpio_close(m_stepI2); + return; + } + mraa_gpio_dir(m_stepI3, MRAA_GPIO_OUT); + + if ( !(m_stepI4 = mraa_gpio_init(i4)) ) + { + cerr << __FUNCTION__ << ": mraa_gpio_init(i4) failed" << endl; + mraa_gpio_close(m_stepI1); + mraa_gpio_close(m_stepI2); + mraa_gpio_close(m_stepI3); + + return; + } + mraa_gpio_dir(m_stepI4, MRAA_GPIO_OUT); + + // set default speed to 1 + setSpeed(1); +} + +void ULN200XA::initClock() +{ + gettimeofday(&m_startTime, NULL); +} + +uint32_t ULN200XA::getMillis() +{ + struct timeval elapsed, now; + uint32_t elapse; + + // get current time + gettimeofday(&now, NULL); + + // compute the delta since m_startTime + if( (elapsed.tv_usec = now.tv_usec - m_startTime.tv_usec) < 0 ) + { + elapsed.tv_usec += 1000000; + elapsed.tv_sec = now.tv_sec - m_startTime.tv_sec - 1; + } + else + { + elapsed.tv_sec = now.tv_sec - m_startTime.tv_sec; + } + + elapse = (uint32_t)((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000)); + + // never return 0 + if (elapse == 0) + elapse = 1; + + return elapse; +} + + +ULN200XA::~ULN200XA() +{ + mraa_gpio_close(m_stepI1); + mraa_gpio_close(m_stepI2); + mraa_gpio_close(m_stepI3); + mraa_gpio_close(m_stepI4); +} + +void ULN200XA::setSpeed(int speed) +{ + m_stepDelay = 60 * 1000 / m_stepsPerRev / speed; +} + +void ULN200XA::setDirection(ULN200XA_DIRECTION_T dir) +{ + switch (dir) + { + case DIR_CW: + m_stepDirection = 1; + break; + case DIR_CCW: + m_stepDirection = -1; + break; + } +} + +void ULN200XA::stepperStep() +{ + int step = m_currentStep % 8; + + // This motor requires a different sequencing order in 8-steps than + // usual. + + // Step I0 I1 I2 I3 + // 1 0 0 0 1 + // 2 0 0 1 1 + // 3 0 0 1 0 + // 4 0 1 1 0 + // 5 0 1 0 0 + // 6 1 1 0 0 + // 7 1 0 0 0 + // 8 1 0 0 1 + + switch (step) + { + case 0: // 0001 + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 1); + break; + case 1: // 0011 + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 1); + mraa_gpio_write(m_stepI4, 1); + break; + case 2: // 0010 + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 1); + mraa_gpio_write(m_stepI4, 0); + break; + case 3: // 0110 + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 1); + mraa_gpio_write(m_stepI3, 1); + mraa_gpio_write(m_stepI4, 0); + break; + case 4: // 0100 + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 1); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 0); + break; + case 5: // 1100 + mraa_gpio_write(m_stepI1, 1); + mraa_gpio_write(m_stepI2, 1); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 0); + break; + case 6: // 1000 + mraa_gpio_write(m_stepI1, 1); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 0); + break; + case 7: // 1001 + mraa_gpio_write(m_stepI1, 1); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 1); + break; + } +} + +void ULN200XA::stepperSteps(unsigned int steps) +{ + while (steps > 0) + { + if (getMillis() >= m_stepDelay) + { + // reset the clock + initClock(); + + m_currentStep += m_stepDirection; + + if (m_stepDirection == 1) + { + if (m_currentStep >= m_stepsPerRev) + m_currentStep = 0; + } + else + { + if (m_currentStep <= 0) + m_currentStep = m_stepsPerRev; + } + + steps--; + stepperStep(); + } + } +} + +void ULN200XA::release() +{ + mraa_gpio_write(m_stepI1, 0); + mraa_gpio_write(m_stepI2, 0); + mraa_gpio_write(m_stepI3, 0); + mraa_gpio_write(m_stepI4, 0); +} diff --git a/src/uln200xa/uln200xa.h b/src/uln200xa/uln200xa.h new file mode 100644 index 00000000..93696834 --- /dev/null +++ b/src/uln200xa/uln200xa.h @@ -0,0 +1,157 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2015 Intel Corporation. + * + * 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. + */ +#pragma once + +#include +#include + +#include +#include + +namespace upm { + + /** + * @brief UPM support for the ULN200XA series of Darlington Stepper drivers + * @defgroup uln200xa libupm-uln200xa + * @ingroup seeed gpio motor + */ + + /** + * @sensor uln200xa + * @library uln200xa + * @comname ULN200XA Stepper Driver + * @altname uln2001a uln2002a uln2003a uln2004a + * @type motor + * @man seeed + * @con gpio + * @web http://www.seeedstudio.com/depot/Gear-Stepper-Motor-with-Driver-p-1685.html?cPath=39_40 + * + * @brief UPM module for the ULN200XA Darlington Stepper driver + * + * This module was developed on a ULBN2003A Stepper Driver. It + * should support the uln2001a, 2002a, 2003a, and 2004a devices, for + * use in driving a unipolar stepper motor, the 28BYJ-48. + * + * Example driving a stepper motor + * @snippet uln200xa.cxx Interesting + */ + + + class ULN200XA { + public: + + /** + * Enum to specify the direction of a motor + */ + typedef enum { + DIR_CW = 0x01, + DIR_CCW = 0x02 + } ULN200XA_DIRECTION_T; + + /** + * ULN200XA constructor + * + * @param stepsPerRev number of steps per full revolution + * @param i1 digital pin to use for stepper input 1 + * @param i2 digital pin to use for stepper input 2 + * @param i3 digital pin to use for stepper input 3 + * @param i4 digital pin to use for stepper input 4 + */ + ULN200XA(int stepsPerRev, int i1, int i2, int i3, int i4); + + /** + * ULN200XA Destructor + */ + ~ULN200XA(); + + /** + * Return the number of milliseconds elapsed since initClock() + * was last called. + * + * @return elapsed milliseconds + */ + uint32_t getMillis(); + + /** + * Reset the Clock + * + */ + void initClock(); + + /** + * set the speed of the stepper in RPM (Rotation Per Minute + * + * @param speed speed to set the motor to in RPM's + */ + void setSpeed(int speed); + + /** + * set the direction of the motor, clockwise or counter clockwise + * + * @param dir direction to set the motor to + */ + void setDirection(ULN200XA_DIRECTION_T dir); + + /** + * step the stepper motor a specified number of steps + * + * @param steps number of steps to move the stepper motor + */ + void stepperSteps(unsigned int steps); + + /** + * release the stepper, by removing power + * + */ + void release(); + + private: + struct timeval m_startTime; + + // stepper (4-wire) + mraa_gpio_context m_stepI1; + mraa_gpio_context m_stepI2; + mraa_gpio_context m_stepI3; + mraa_gpio_context m_stepI4; + + // steps per revolution + int m_stepsPerRev; + int m_currentStep; + uint32_t m_stepDelay; + + /** + * step the motor one tick + * + */ + void stepperStep(); + + /** + * step direction - 1 = forward, -1 = backward + * + */ + int m_stepDirection; + }; +} + +