Code editting : motor.h in snake case

motor.cpp

+#include "motor.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

motor.h

@@ -41,80 +41,80 @@ public:
     //CONSTRUCTORS
     Motor (MotorHardware_t& stepper): stepper(stepper)
     {
-        setSpeedMmPerSec(1);
-        setAccelMmPerSecPerSec(0.5); //  <----- this is not yet configured by user
+        set_speed_mm_per_sec(1);
+        set_accel_mm_per_sec_per_sec(0.5); //  <----- this is not yet configured by user
     }
 
-    void setMmPerRev (float mmPerRevolution)
+    void set_mm_per_rev (float mm_per_revolution)
     {
-        _mmPerRevolution = mmPerRevolution;
+        _mm_per_revolution = mm_per_revolution;
     }
 
-    float getMmPerRev () const
+    float get_mm_per_rev () const
     {
-        return _mmPerRevolution;
+        return _mm_per_revolution;
     }
 
-    void setPhysical (int stepsPerRevolution, float mmPerRevolution, bool forwardClockwise)
+    void set_physical (int steps_per_revolution, float mm_per_revolution, bool forward_clockwise)
     {
-        _stepsPerRevolution = stepsPerRevolution;
-        setMmPerRev(mmPerRevolution);
-        setForwardClockwise(forwardClockwise);
+        _steps_per_revolution = steps_per_revolution;
+        set_mm_per_rev(mm_per_revolution);
+        set_forward_clockwise(forward_clockwise);
     }
 
-    void setForwardClockwise (bool clockwise)
+    void set_forward_clockwise (bool forward_clockwise)
     {
-        _forwardClockwise = clockwise;
+        _forward_clockwise = forward_clockwise;
     }
 
-    bool getForwardClockwise ()
+    bool get_forward_clockwise ()
     {
-        return _forwardClockwise;
+        return _forward_clockwise;
     }
 
-    void setSpeedMmPerSec (float mmPerSec)
+    void set_speed_mm_per_sec (float mm_per_sec)
     {
 #if !CORE_MOCK
-        stepper.setMaxSpeed(mmToStep(mmPerSec));
+        stepper.setMaxSpeed(mm_to_step(mm_per_sec));
 #endif
     }
 
-    bool motorIsRunning ()  //return true if the motor is currently running
+    bool motor_is_running ()  //return true if the motor is currently running
     {
         return (stepper.speed() != 0);
     }
 
-    void setAccelMmPerSecPerSec (float mmPerSecPerSec)
+    void set_accel_mm_per_sec_per_sec (float mm_per_sec_per_sec)
     {
-        if (mmPerSecPerSec == 0)
-            mmPerSecPerSec = 1000;
-        _retainAccel = mmPerSecPerSec;
+        if (mm_per_sec_per_sec == 0)
+            mm_per_sec_per_sec = 1000;
+        _retain_accel = mm_per_sec_per_sec;
 #if !CORE_MOCK
-        stepper.setAcceleration(mmToStep(mmPerSecPerSec));
+        stepper.setAcceleration(mm_to_step(mm_per_sec_per_sec));
 #endif
     }
 
-    float getAccelMmPerSecPerSec () const
+    float get_accel_mm_per_sec_per_sec () const
     {
-        return _retainAccel;
+        return _retain_accel;
     }
 
-    float mmToStep (float mm) const
+    float mm_to_step (float mm) const
     {
-        return mm * _stepsPerRevolution / _mmPerRevolution;
+        return mm * _steps_per_revolution / _mm_per_revolution;
     }
 
-    float stepToMm (int step) const
+    float step_to_mm (int step) const
     {
-        return step * _mmPerRevolution / _stepsPerRevolution;
+        return step * _mm_per_revolution / _steps_per_revolution;
     }
 
-    int whereStep ()
+    int where_step ()
     {
 #if CORE_MOCK
         return 0;
 #else
-        return stepper.currentPosition() * (_forwardClockwise? 1: -1);
+        return stepper.currentPosition() * (_forward_clockwise? 1: -1);
 #endif
     }
 
@@ -122,20 +122,20 @@ public:
     {
         Serial.printf("# moving to %g mm / %g steps\n",
             mm,
-            mmToStep(mm));
-        moveToStep(mmToStep(mm));
+            mm_to_step(mm));
+        move_to_step(mm_to_step(mm));
     }
 
-    void moveToStep (int step)
+    void move_to_step (int step)
     {
 #if !CORE_MOCK
         cli();
-        setAccelMmPerSecPerSec(_retainAccel);
-        if (_mmPerRevolution > 0 && _stepsPerRevolution > 0)
-            stepper.moveTo(_forwardClockwise? step: -step);
+        set_accel_mm_per_sec_per_sec(_retain_accel);
+        if (_mm_per_revolution > 0 && _steps_per_revolution > 0)
+            stepper.moveTo(_forward_clockwise? step: -step);
         sei();
 #endif
-        Serial.printf("#     move to: %d step    %g mm\n", step, stepToMm(step));
+        Serial.printf("#     move to: %d step    %g mm\n", step, step_to_mm(step));
     }
 
     void stop ()
@@ -147,7 +147,7 @@ public:
 #endif
     }
 
-	void resetPosition()
+	void reset_position()
 	{
 #if !CORE_MOCK
         stop();
@@ -157,40 +157,40 @@ public:
 #endif
 	}
 
-	void stayHere ()
+	void stay_here ()
 	{
 #if !CORE_MOCK
         cli();
         stepper.setAcceleration(1e20);
 	      stepper.moveTo(stepper.currentPosition()); // change target to here
-        setAccelMmPerSecPerSec(_retainAccel);
+        set_accel_mm_per_sec_per_sec(_retain_accel);
 	    sei();
 #endif
 	}
 
-    void showConfiguration ()
+    void show_configuration ()
     {
         Serial.printf("#     %g mm/rev\n"
                       "#     %d steps/rev\n"
                       "#     %g steps/mm\n"
                       "#     max speed: %g steps/s   %g mm/s\n"
                       "#     accel: %g steps/s/s   %g mm/s/s\n",
-                      _mmPerRevolution,
-                      _stepsPerRevolution,
-                      _stepsPerRevolution / _mmPerRevolution,
+                      _mm_per_revolution,
+                      _steps_per_revolution,
+                      _steps_per_revolution / _mm_per_revolution,
                       stepper.maxSpeed(),
-                      stepToMm(stepper.maxSpeed()),
+                      step_to_mm(stepper.maxSpeed()),
                       stepper.acceleration(),
-                      stepToMm(stepper.acceleration())
+                      step_to_mm(stepper.acceleration())
                   );
     }
 
 protected:
 
-    int _stepsPerRevolution = -1;
-    float _mmPerRevolution = -1;
-    float _retainAccel = -1;
-    bool _forwardClockwise;
+    int _steps_per_revolution = -1;
+    float _mm_per_revolution = -1;
+    float _retain_accel = -1;
+    bool _forward_clockwise;
 
     MotorHardware_t& stepper;
 };