Merge pull request #994 from bdring/PDeltaUpdate

P delta update
bdring · Aug 14, 2023 · d63a827 · d63a827
2 parents d700350 + b8fa5c2
commit d63a827
Show file tree

Hide file tree

Showing 15 changed files with 637 additions and 29 deletions.
diff --git a/FluidNC/src/Kinematics/Cartesian.cpp b/FluidNC/src/Kinematics/Cartesian.cpp
@@ -259,9 +259,10 @@ namespace Kinematics {
         copyAxes(cartesian, motors);
     }
 
-    void Cartesian::transform_cartesian_to_motors(float* motors, float* cartesian) {
+    bool Cartesian::transform_cartesian_to_motors(float* motors, float* cartesian) {
         // Motor space is cartesian space, so we do no transform.
         copyAxes(motors, cartesian);
+        return true;
     }
 
     bool Cartesian::canHome(AxisMask axisMask) {
@@ -304,6 +305,10 @@ namespace Kinematics {
         }
     }
 
+    bool Cartesian::kinematics_homing(AxisMask& axisMask) {
+        return false;  // kinematics does not do the homing for catesian systems
+    }
+
     // Configuration registration
     namespace {
         KinematicsFactory::InstanceBuilder<Cartesian> registration("Cartesian");

diff --git a/FluidNC/src/Kinematics/Cartesian.h b/FluidNC/src/Kinematics/Cartesian.h
@@ -37,11 +37,12 @@ namespace Kinematics {
         virtual void init() override;
         virtual void init_position() override;
         void         motors_to_cartesian(float* cartesian, float* motors, int n_axis) override;
-        void         transform_cartesian_to_motors(float* cartesian, float* motors) override;
+        bool         transform_cartesian_to_motors(float* cartesian, float* motors) override;
 
         bool canHome(AxisMask axisMask) override;
         void releaseMotors(AxisMask axisMask, MotorMask motors) override;
         bool limitReached(AxisMask& axisMask, MotorMask& motors, MotorMask limited) override;
+        virtual bool kinematics_homing(AxisMask& axisMask) override;
 
         // Configuration handlers:
         void afterParse() override {}

diff --git a/FluidNC/src/Kinematics/CoreXY.cpp b/FluidNC/src/Kinematics/CoreXY.cpp
@@ -132,14 +132,15 @@ namespace Kinematics {
     /*
       Kinematic equations
     */
-    void CoreXY::transform_cartesian_to_motors(float* motors, float* cartesian) {
+    bool CoreXY::transform_cartesian_to_motors(float* motors, float* cartesian) {
         motors[X_AXIS] = (_x_scaler * cartesian[X_AXIS]) + cartesian[Y_AXIS];
         motors[Y_AXIS] = (_x_scaler * cartesian[X_AXIS]) - cartesian[Y_AXIS];
 
         auto n_axis = config->_axes->_numberAxis;
         for (size_t axis = Z_AXIS; axis < n_axis; axis++) {
             motors[axis] = cartesian[axis];
         }
+        return true;
     }
 
     // Configuration registration

diff --git a/FluidNC/src/Kinematics/CoreXY.h b/FluidNC/src/Kinematics/CoreXY.h
@@ -40,7 +40,7 @@ namespace Kinematics {
         virtual void group(Configuration::HandlerBase& handler) override;
         void         afterParse() override {}
 
-        void transform_cartesian_to_motors(float* motors, float* cartesian) override;
+        bool transform_cartesian_to_motors(float* motors, float* cartesian) override;
 
         // Name of the configurable. Must match the name registered in the cpp file.
         virtual const char* name() const override { return "CoreXY"; }

diff --git a/FluidNC/src/Kinematics/Kinematics.cpp b/FluidNC/src/Kinematics/Kinematics.cpp
@@ -39,6 +39,11 @@ namespace Kinematics {
         return _system->canHome(axisMask);
     }
 
+    bool Kinematics::kinematics_homing(AxisMask axisMask) {
+        Assert(_system != nullptr, "No kinematic system");
+        return _system->kinematics_homing(axisMask);
+    }
+
     void Kinematics::releaseMotors(AxisMask axisMask, MotorMask motors) {
         Assert(_system != nullptr, "No kinematic system");
         _system->releaseMotors(axisMask, motors);
@@ -49,7 +54,7 @@ namespace Kinematics {
         return _system->limitReached(axisMask, motors, limited);
     }
 
-    void Kinematics::transform_cartesian_to_motors(float* motors, float* cartesian) {
+    bool Kinematics::transform_cartesian_to_motors(float* motors, float* cartesian) {
         Assert(_system != nullptr, "No kinematics system.");
         return _system->transform_cartesian_to_motors(motors, cartesian);
     }

diff --git a/FluidNC/src/Kinematics/Kinematics.h b/FluidNC/src/Kinematics/Kinematics.h
@@ -46,14 +46,15 @@ namespace Kinematics {
 
         bool cartesian_to_motors(float* target, plan_line_data_t* pl_data, float* position);
         void motors_to_cartesian(float* cartesian, float* motors, int n_axis);
-        void transform_cartesian_to_motors(float* motors, float* cartesian);
+        bool transform_cartesian_to_motors(float* motors, float* cartesian);
 
         void constrain_jog(float* target, plan_line_data_t* pl_data, float* position);
         bool invalid_line(float* target);
         bool invalid_arc(
             float* target, plan_line_data_t* pl_data, float* position, float center[3], float radius, size_t caxes[3], bool is_clockwise_arc);
 
         bool canHome(AxisMask axisMask);
+        bool kinematics_homing(AxisMask axisMask);
         void releaseMotors(AxisMask axisMask, MotorMask motors);
         bool limitReached(AxisMask& axisMask, MotorMask& motors, MotorMask limited);
 
@@ -65,10 +66,10 @@ namespace Kinematics {
     public:
         KinematicSystem() = default;
 
-        KinematicSystem(const KinematicSystem&) = delete;
-        KinematicSystem(KinematicSystem&&)      = delete;
+        KinematicSystem(const KinematicSystem&)            = delete;
+        KinematicSystem(KinematicSystem&&)                 = delete;
         KinematicSystem& operator=(const KinematicSystem&) = delete;
-        KinematicSystem& operator=(KinematicSystem&&) = delete;
+        KinematicSystem& operator=(KinematicSystem&&)      = delete;
 
         // Kinematic system interface.
         virtual bool cartesian_to_motors(float* target, plan_line_data_t* pl_data, float* position) = 0;
@@ -84,11 +85,12 @@ namespace Kinematics {
 
         virtual void motors_to_cartesian(float* cartesian, float* motors, int n_axis) = 0;
 
-        virtual void transform_cartesian_to_motors(float* motors, float* cartesian) = 0;
+        virtual bool transform_cartesian_to_motors(float* motors, float* cartesian) = 0;
 
         virtual bool canHome(AxisMask axisMask) { return false; }
         virtual void releaseMotors(AxisMask axisMask, MotorMask motors) {}
         virtual bool limitReached(AxisMask& axisMask, MotorMask& motors, MotorMask limited) { return false; }
+        virtual bool kinematics_homing(AxisMask& axisMask) { return false; }
 
         // Configuration interface.
         void afterParse() override {}