add const qualifier to input argument to cartesian_to_actuator and actuator_to_cartes...

diff --git a/src/modules/robot/arm_solutions/BaseSolution.h b/src/modules/robot/arm_solutions/BaseSolution.h
index eecdd13..29d2c75 100644 (file)
--- a/src/modules/robot/arm_solutions/BaseSolution.h
+++ b/src/modules/robot/arm_solutions/BaseSolution.h
@@ -10,8 +10,8 @@ class BaseSolution {
         BaseSolution(){};
         BaseSolution(Config*){};
         virtual ~BaseSolution() {};
-        virtual void cartesian_to_actuator( float[], float[] ) = 0;
-        virtual void actuator_to_cartesian( float[], float[] ) = 0;
+        virtual void cartesian_to_actuator(const float[], float[] ) = 0;
+        virtual void actuator_to_cartesian(const float[], float[] ) = 0;
         typedef std::map<char, float> arm_options_t;
         virtual bool set_optional(const arm_options_t& options) { return false; };
         virtual bool get_optional(arm_options_t& options) { return false; };

diff --git a/src/modules/robot/arm_solutions/CartesianSolution.cpp b/src/modules/robot/arm_solutions/CartesianSolution.cpp
index 5308700..cef25d4 100644 (file)
--- a/src/modules/robot/arm_solutions/CartesianSolution.cpp
+++ b/src/modules/robot/arm_solutions/CartesianSolution.cpp
@@ -1,13 +1,13 @@
 #include "CartesianSolution.h"
 #include <math.h>
 
-void CartesianSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] ){
+void CartesianSolution::cartesian_to_actuator( const float cartesian_mm[], float actuator_mm[] ){
     actuator_mm[ALPHA_STEPPER] = cartesian_mm[X_AXIS];
     actuator_mm[BETA_STEPPER ] = cartesian_mm[Y_AXIS];
     actuator_mm[GAMMA_STEPPER] = cartesian_mm[Z_AXIS];
 }
 
-void CartesianSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] ){
+void CartesianSolution::actuator_to_cartesian( const float actuator_mm[], float cartesian_mm[] ){
     cartesian_mm[ALPHA_STEPPER] = actuator_mm[X_AXIS];
     cartesian_mm[BETA_STEPPER ] = actuator_mm[Y_AXIS];
     cartesian_mm[GAMMA_STEPPER] = actuator_mm[Z_AXIS];

diff --git a/src/modules/robot/arm_solutions/CartesianSolution.h b/src/modules/robot/arm_solutions/CartesianSolution.h
index c2d04cb..2f82c7e 100644 (file)
--- a/src/modules/robot/arm_solutions/CartesianSolution.h
+++ b/src/modules/robot/arm_solutions/CartesianSolution.h
@@ -11,8 +11,8 @@ class CartesianSolution : public BaseSolution {
     public:
         CartesianSolution(){};
         CartesianSolution(Config*){};
-        void cartesian_to_actuator( float millimeters[], float steps[] );
-        void actuator_to_cartesian( float steps[], float millimeters[] );
+        void cartesian_to_actuator( const float millimeters[], float steps[] );
+        void actuator_to_cartesian( const float steps[], float millimeters[] );
 };
 
 

diff --git a/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.cpp b/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.cpp
index b7d72dc..c995d1c 100644 (file)
--- a/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.cpp
+++ b/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.cpp
@@ -37,7 +37,7 @@ ExperimentalDeltaSolution::ExperimentalDeltaSolution(Config* config)
     arm_length_squared = powf(arm_length, 2);
 }
 
-void ExperimentalDeltaSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] ){
+void ExperimentalDeltaSolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] ){
     float alpha_rotated[3], rotated[3];
 
     if( sin_alpha == 0 && cos_alpha == 1){
@@ -56,7 +56,7 @@ void ExperimentalDeltaSolution::cartesian_to_actuator( float cartesian_mm[], flo
     actuator_mm[GAMMA_STEPPER] = solve_arm( rotated );
 }
 
-void ExperimentalDeltaSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] ){
+void ExperimentalDeltaSolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] ){
     // unimplemented
 }
 
@@ -64,7 +64,7 @@ float ExperimentalDeltaSolution::solve_arm( float cartesian_mm[]) {
     return sqrtf(arm_length_squared - powf(cartesian_mm[X_AXIS] - arm_radius, 2) - powf(cartesian_mm[Y_AXIS], 2)) + cartesian_mm[Z_AXIS];
 }
 
-void ExperimentalDeltaSolution::rotate(float in[], float out[], float sin, float cos ){
+void ExperimentalDeltaSolution::rotate(const float in[], float out[], float sin, float cos ){
     out[X_AXIS] = cos * in[X_AXIS] - sin * in[Y_AXIS];
     out[Y_AXIS] = sin * in[X_AXIS] + cos * in[Y_AXIS];
     out[Z_AXIS] = in[Z_AXIS];

diff --git a/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.h b/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.h
index 5479997..595c124 100644 (file)
--- a/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.h
+++ b/src/modules/robot/arm_solutions/ExperimentalDeltaSolution.h
@@ -8,11 +8,11 @@ class Config;
 class ExperimentalDeltaSolution : public BaseSolution {
     public:
         ExperimentalDeltaSolution(Config*);
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 
         float solve_arm( float millimeters[] );
-        void rotate( float in[], float out[], float sin, float cos );
+        void rotate(const float in[], float out[], float sin, float cos );
 
     private:
         float arm_length;

diff --git a/src/modules/robot/arm_solutions/HBotSolution.cpp b/src/modules/robot/arm_solutions/HBotSolution.cpp
index b22cf4e..106e6d1 100644 (file)
--- a/src/modules/robot/arm_solutions/HBotSolution.cpp
+++ b/src/modules/robot/arm_solutions/HBotSolution.cpp
@@ -1,13 +1,13 @@
 #include "HBotSolution.h"
 #include <math.h>
 
-void HBotSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] ){
+void HBotSolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] ){
     actuator_mm[ALPHA_STEPPER] = cartesian_mm[X_AXIS] + cartesian_mm[Y_AXIS];
     actuator_mm[BETA_STEPPER ] = cartesian_mm[X_AXIS] - cartesian_mm[Y_AXIS];
     actuator_mm[GAMMA_STEPPER] = cartesian_mm[Z_AXIS];
 }
 
-void HBotSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] ){
+void HBotSolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] ){
     cartesian_mm[X_AXIS] = 0.5F * (actuator_mm[ALPHA_STEPPER] + actuator_mm[BETA_STEPPER]);
     cartesian_mm[Y_AXIS] = 0.5F * (actuator_mm[ALPHA_STEPPER] - actuator_mm[BETA_STEPPER]);
     cartesian_mm[Z_AXIS] = actuator_mm[GAMMA_STEPPER];

diff --git a/src/modules/robot/arm_solutions/HBotSolution.h b/src/modules/robot/arm_solutions/HBotSolution.h
index 24771bb..c35eca2 100644 (file)
--- a/src/modules/robot/arm_solutions/HBotSolution.h
+++ b/src/modules/robot/arm_solutions/HBotSolution.h
@@ -11,8 +11,8 @@ class HBotSolution : public BaseSolution {
     public:
         HBotSolution();
         HBotSolution(Config*){};
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 };
 
 

diff --git a/src/modules/robot/arm_solutions/LinearDeltaSolution.cpp b/src/modules/robot/arm_solutions/LinearDeltaSolution.cpp
index 81ab15d..1513aaf 100644 (file)
--- a/src/modules/robot/arm_solutions/LinearDeltaSolution.cpp
+++ b/src/modules/robot/arm_solutions/LinearDeltaSolution.cpp
@@ -54,7 +54,7 @@ void LinearDeltaSolution::init() {
     delta_tower3_y = (delta_radius + tower3_offset) * sinf((90.0F  + tower3_angle) * PIOVER180);
 }
 
-void LinearDeltaSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] )
+void LinearDeltaSolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] )
 {
 
     actuator_mm[ALPHA_STEPPER] = sqrtf(this->arm_length_squared
@@ -71,7 +71,7 @@ void LinearDeltaSolution::cartesian_to_actuator( float cartesian_mm[], float act
                                       ) + cartesian_mm[Z_AXIS];
 }
 
-void LinearDeltaSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] )
+void LinearDeltaSolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] )
 {
     // from http://en.wikipedia.org/wiki/Circumscribed_circle#Barycentric_coordinates_from_cross-_and_dot-products
     // based on https://github.com/ambrop72/aprinter/blob/2de69a/aprinter/printer/DeltaTransform.h#L81

diff --git a/src/modules/robot/arm_solutions/LinearDeltaSolution.h b/src/modules/robot/arm_solutions/LinearDeltaSolution.h
index fd2458a..54da7f8 100644 (file)
--- a/src/modules/robot/arm_solutions/LinearDeltaSolution.h
+++ b/src/modules/robot/arm_solutions/LinearDeltaSolution.h
@@ -8,8 +8,8 @@ class Config;
 class LinearDeltaSolution : public BaseSolution {
     public:
         LinearDeltaSolution(Config*);
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 
         bool set_optional(const arm_options_t& options);
         bool get_optional(arm_options_t& options);

diff --git a/src/modules/robot/arm_solutions/MorganSCARASolution.cpp b/src/modules/robot/arm_solutions/MorganSCARASolution.cpp
index 99cb7c9..2205637 100644 (file)
--- a/src/modules/robot/arm_solutions/MorganSCARASolution.cpp
+++ b/src/modules/robot/arm_solutions/MorganSCARASolution.cpp
@@ -58,7 +58,7 @@ float MorganSCARASolution::to_degrees(float radians) {
     return radians*(180.0F/3.14159265359f);
 }
 
-void MorganSCARASolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] )
+void MorganSCARASolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] )
 {
 
     float SCARA_pos[2],
@@ -103,7 +103,7 @@ void MorganSCARASolution::cartesian_to_actuator( float cartesian_mm[], float act
 
 }
 
-void MorganSCARASolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] ) {
+void MorganSCARASolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] ) {
     // Perform forward kinematics, and place results in cartesian_mm[]
 
     float y1, y2,

diff --git a/src/modules/robot/arm_solutions/MorganSCARASolution.h b/src/modules/robot/arm_solutions/MorganSCARASolution.h
index 867c57f..5d85e4d 100644 (file)
--- a/src/modules/robot/arm_solutions/MorganSCARASolution.h
+++ b/src/modules/robot/arm_solutions/MorganSCARASolution.h
@@ -8,8 +8,8 @@ class Config;
 class MorganSCARASolution : public BaseSolution {
     public:
         MorganSCARASolution(Config*);
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 
         bool set_optional(const arm_options_t& options);
         bool get_optional(arm_options_t& options);

diff --git a/src/modules/robot/arm_solutions/RotatableCartesianSolution.cpp b/src/modules/robot/arm_solutions/RotatableCartesianSolution.cpp
index e877a4e..beb3ade 100644 (file)
--- a/src/modules/robot/arm_solutions/RotatableCartesianSolution.cpp
+++ b/src/modules/robot/arm_solutions/RotatableCartesianSolution.cpp
@@ -12,15 +12,15 @@ RotatableCartesianSolution::RotatableCartesianSolution(Config* config) {
     cos_alpha          = cosf(alpha_angle);
 }
 
-void RotatableCartesianSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] ){
+void RotatableCartesianSolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] ){
     rotate( cartesian_mm, actuator_mm, sin_alpha, cos_alpha );
 }
 
-void RotatableCartesianSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] ){
+void RotatableCartesianSolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] ){
     rotate( actuator_mm, cartesian_mm, - sin_alpha, cos_alpha );
 }
 
-void RotatableCartesianSolution::rotate(float in[], float out[], float sin, float cos ){
+void RotatableCartesianSolution::rotate(const float in[], float out[], float sin, float cos ){
     out[ALPHA_STEPPER] = cos * in[X_AXIS] - sin * in[Y_AXIS];
     out[BETA_STEPPER ] = sin * in[X_AXIS] + cos * in[Y_AXIS];
     out[GAMMA_STEPPER] =       in[Z_AXIS];

diff --git a/src/modules/robot/arm_solutions/RotatableCartesianSolution.h b/src/modules/robot/arm_solutions/RotatableCartesianSolution.h
index bbd443a..83d04ce 100644 (file)
--- a/src/modules/robot/arm_solutions/RotatableCartesianSolution.h
+++ b/src/modules/robot/arm_solutions/RotatableCartesianSolution.h
@@ -12,10 +12,10 @@
 class RotatableCartesianSolution : public BaseSolution {
     public:
         RotatableCartesianSolution(Config*);
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 
-        void rotate( float in[], float out[], float sin, float cos );
+        void rotate(const float in[], float out[], float sin, float cos );
 
         float sin_alpha;
         float cos_alpha;

diff --git a/src/modules/robot/arm_solutions/RotatableDeltaSolution.cpp b/src/modules/robot/arm_solutions/RotatableDeltaSolution.cpp
index 4b219db..798992f 100644 (file)
--- a/src/modules/robot/arm_solutions/RotatableDeltaSolution.cpp
+++ b/src/modules/robot/arm_solutions/RotatableDeltaSolution.cpp
@@ -133,7 +133,7 @@ void RotatableDeltaSolution::init() {
        z_calc_offset  = (delta_z_offset - tool_offset - delta_ee_offs)*-1.0F;
 }
 
-void RotatableDeltaSolution::cartesian_to_actuator( float cartesian_mm[], float actuator_mm[] )
+void RotatableDeltaSolution::cartesian_to_actuator(const float cartesian_mm[], float actuator_mm[] )
 {
        //We need to translate the Cartesian coordinates in mm to the actuator position required in mm so the stepper motor  functions
        float alpha_theta = 0.0F;
@@ -182,7 +182,7 @@ void RotatableDeltaSolution::cartesian_to_actuator( float cartesian_mm[], float
 
 }
 
-void RotatableDeltaSolution::actuator_to_cartesian( float actuator_mm[], float cartesian_mm[] )
+void RotatableDeltaSolution::actuator_to_cartesian(const float actuator_mm[], float cartesian_mm[] )
 {
     //Use forward kinematics
     delta_calcForward(actuator_mm[ALPHA_STEPPER], actuator_mm[BETA_STEPPER ], actuator_mm[GAMMA_STEPPER], cartesian_mm[X_AXIS], cartesian_mm[Y_AXIS], cartesian_mm[Z_AXIS]);

diff --git a/src/modules/robot/arm_solutions/RotatableDeltaSolution.h b/src/modules/robot/arm_solutions/RotatableDeltaSolution.h
index a7cd15f..03e150d 100644 (file)
--- a/src/modules/robot/arm_solutions/RotatableDeltaSolution.h
+++ b/src/modules/robot/arm_solutions/RotatableDeltaSolution.h
@@ -8,8 +8,8 @@ class Config;
 class RotatableDeltaSolution : public BaseSolution {
     public:
         RotatableDeltaSolution(Config*);
-        void cartesian_to_actuator( float[], float[] );
-        void actuator_to_cartesian( float[], float[] );
+        void cartesian_to_actuator(const float[], float[] );
+        void actuator_to_cartesian(const float[], float[] );
 
         bool set_optional(const arm_options_t& options);
         bool get_optional(arm_options_t& options);