stepmotor: made some small API changes for consistency and usability

Signed-off-by: Mihai Tudor Panu <mihai.tudor.panu@intel.com>

examples/c++/stepmotor.cxx

 
     while (doWork) {
         cout << "1 Revolution forward and back at 60 rpm" << endl;
-        sensor->setSpeed (60);
+        sensor->setSpeed(60);
         sensor->stepForward(200);
-        usleep (1000000);
-        sensor->stepBackwards(200);
-        usleep (1000000);
+        usleep(1000000);
+        sensor->stepBackward(200);
+        usleep(1000000);
 
         cout << "1 Revolution forward and back at 150 rpm" << endl;
-        sensor->setSpeed (150);
+        sensor->setSpeed(150);
         sensor->stepForward(200);
-        usleep (1000000);
-        sensor->stepBackwards(200);
-        usleep (1000000);
+        usleep(1000000);
+        sensor->stepBackward(200);
+        usleep(1000000);
 
         cout << "1 Revolution forward and back at 300 rpm" << endl;
-        sensor->setSpeed (300);
-        sensor->stepForward (200);
+        sensor->setSpeed(300);
+        sensor->stepForward(200);
         usleep (1000000);
-        sensor->stepBackwards (200);
+        sensor->stepBackward(200);
         usleep (1000000);
     }
 

examples/java/StepMotorSample.java

             sensor.setSpeed(60);
             sensor.stepForward(200);
             Thread.sleep(1000);
-            sensor.stepBackwards(200);
+            sensor.stepBackward(200);
             Thread.sleep(1000);
 
             System.out.println("One complete rotation forward and back at 150 rpm.");
             sensor.setSpeed(150);
             sensor.stepForward(200);
             Thread.sleep(1000);
-            sensor.stepBackwards(200);
+            sensor.stepBackward(200);
             Thread.sleep(1000);
 
             System.out.println("One complete rotation forward and back at 300 rpm.");
             sensor.setSpeed(300);
             sensor.stepForward(200);
             Thread.sleep(1000);
-            sensor.stepBackwards(200);
+            sensor.stepBackward(200);
             Thread.sleep(1000);
         }
         // ! [Interesting]

examples/javascript/stepmotor.js

 stepper.setSpeed(60);
 stepper.stepForward(200);
 delay(1000);
-stepper.stepBackwards(200);
+stepper.stepBackward(200);
 delay(1000);
 
 console.log("Rotating 1 revolution forward and back at 150 rpm.");
 stepper.setSpeed(150);
 stepper.stepForward(200);
 delay(1000);
-stepper.stepBackwards(200);
+stepper.stepBackward(200);
 delay(1000);
 
 console.log("Rotating 1 revolution forward and back at 300 rpm.");
 stepper.setSpeed(300);
 stepper.stepForward(200);
 delay(1000);
-stepper.stepBackwards(200);
+stepper.stepBackward(200);
 delay(1000);
 
 stepper.quit();

examples/python/stepmotor.py

 stepper.setSpeed(60)
 stepper.stepForward(200)
 time.sleep(1)
-stepper.stepBackwards(200)
+stepper.stepBackward(200)
 time.sleep(1)
 
 print "Rotating 1 revolution forward and back at 150 rpm."
 stepper.setSpeed(150)
 stepper.stepForward(200)
 time.sleep(1)
-stepper.stepBackwards(200)
+stepper.stepBackward(200)
 time.sleep(1)
 
 print "Rotating 1 revolution forward and back at 300 rpm."
 stepper.setSpeed(300)
 stepper.stepForward(200)
 time.sleep(1)
-stepper.stepBackwards(200)
+stepper.stepBackward(200)
 time.sleep(1)

src/stepmotor/stepmotor.cxx

 using namespace std;
 
 StepMotor::StepMotor (int dirPin, int stePin, int steps, int enPin)
-                    : m_dirPinCtx(dirPin), m_stePinCtx(stePin), m_enPinCtx(0), m_steps(steps) {
+                    : m_dirPinCtx(dirPin),
+                      m_stePinCtx(stePin),
+                      m_enPinCtx(0),
+                      m_steps(steps) {
     m_name = "StepMotor";
     setSpeed(60);
-    setStep(0);
+    setPosition(0);
 
     if (m_dirPinCtx.dir(mraa::DIR_OUT) != mraa::SUCCESS) {
         throw std::runtime_error(string(__FUNCTION__) +
 mraa::Result
 StepMotor::step (int ticks) {
     if (ticks < 0) {
-        return stepBackwards(abs(ticks));
+        return stepBackward(abs(ticks));
     } else {
         return stepForward(ticks);
     }
     dirForward();
     for (int i = 0; i < ticks; i++) {
         move();
-        if (++m_position >= m_steps) {
-            m_position = 0;
-        }
+        m_position++;
         delayus(m_delay - MINPULSE_US - OVERHEAD_US);
     }
     return mraa::SUCCESS;
 }
 
 mraa::Result
-StepMotor::stepBackwards (int ticks) {
-    dirBackwards();
+StepMotor::stepBackward (int ticks) {
+    dirBackward();
     for (int i = 0; i < ticks; i++) {
         move();
-        if (--m_position < 0) {
-            m_position = m_steps - 1;
-        }
+        m_position--;
         delayus(m_delay - MINPULSE_US - OVERHEAD_US);
     }
     return mraa::SUCCESS;
 }
 
 void
-StepMotor::setStep (int step) {
-    if (step <= m_steps) {
-        m_position = step;
-    }
+StepMotor::setPosition (int pos) {
+    m_position = pos;
 }
 
 int
-StepMotor::getStep () {
+StepMotor::getPosition () {
     return m_position;
 }
 
+int
+StepMotor::getStep () {
+    return m_position < 0 ? m_steps + m_position % m_steps :
+                            m_position % m_steps;
+}
+
 void
 StepMotor::move () {
     m_stePinCtx.write(1);
 }
 
 mraa::Result
-StepMotor::dirBackwards () {
+StepMotor::dirBackward () {
     mraa::Result error = m_dirPinCtx.write(LOW);
     if (error != mraa::SUCCESS) {
         throw std::runtime_error(string(__FUNCTION__) +

src/stepmotor/stepmotor.h

  * and/or microstepping on stepper drivers that support such features.
  *
  * @image html stepmotor.jpg
- * <br><em>ECS1030 Sensor image provided by SparkFun* under
+ * <br><em>EasyDriver Sensor image provided by SparkFun* under
  * <a href=https://creativecommons.org/licenses/by-nc-sa/3.0/>
  * CC BY-NC-SA-3.0</a>.</em>
  *
          *
          * @param ticks Number of steps the motor moves
          */
-        mraa::Result stepBackwards (int ticks);
+        mraa::Result stepBackward (int ticks);
 
         /**
-         * Sets the current step. Useful if the motor is not at 0 when the
+         * Sets the current position. Useful if the motor is not at 0 when the
          * driver is initialized.
          *
-         * @param step Current shaft position
+         * @param step Current position
          */
-        void setStep (int step);
+        void setPosition (int pos);
 
         /**
-         * Gets the current step.
+         * Gets the current position. This is cumulative and the result of all
+         * the step commands sent to the motor.
          *
-         * @return Current shaft position.
+         * @return Stepper's position.
+         */
+        int getPosition ();
+
+        /**
+         * Gets the current step. This is relative to one revolution.
+         *
+         * @return Current step, ranges from 0 to number of steps per revolution.
          */
         int getStep ();
 
         int                 m_position;
 
         mraa::Result dirForward ();
-        mraa::Result dirBackwards ();
+        mraa::Result dirBackward ();
         void move ();
         void delayus (int us);
     };