Polargraph / Makelangelo kinematics (#22790)

Marlin/Configuration.h

 // Enable for a belt style printer with endless "Z" motion
 //#define BELTPRINTER
 
+// Enable for Polargraph Kinematics
+//#define POLARGRAPH
+#if ENABLED(POLARGRAPH)
+  #define POLARGRAPH_MAX_BELT_LEN 1035.0
+  #define POLAR_SEGMENTS_PER_SECOND 5
+#endif
+
 //===========================================================================
 //============================== Endstop Settings ===========================
 //===========================================================================

Marlin/src/MarlinCore.cpp

 
 #if ENABLED(DELTA)
   #include "module/delta.h"
+#elif ENABLED(POLARGRAPH)
+  #include "module/polargraph.h"
 #elif IS_SCARA
   #include "module/scara.h"
 #endif

Marlin/src/core/language.h

 // Settings Report Strings
 #define STR_Z_AUTO_ALIGN                    "Z Auto-Align"
 #define STR_BACKLASH_COMPENSATION           "Backlash compensation"
-#define STR_DELTA_SETTINGS                  "Delta settings (L<diagonal-rod> R<radius> H<height> S<segments-per-sec> XYZ<tower-angle-trim> ABC<rod-trim>)"
-#define STR_SCARA_SETTINGS                  "SCARA settings"
-#define STR_SCARA_S                         "S<seg-per-sec>"
+#define STR_S_SEG_PER_SEC                   "S<seg-per-sec>"
+#define STR_DELTA_SETTINGS                  "Delta (L<diagonal-rod> R<radius> H<height> S<seg-per-sec> XYZ<tower-angle-trim> ABC<rod-trim>)"
+#define STR_SCARA_SETTINGS                  "SCARA"
+#define STR_POLARGRAPH_SETTINGS             "Polargraph"
 #define STR_SCARA_P_T_Z                     "P<theta-psi-offset> T<theta-offset> Z<home-offset>"
 #define STR_ENDSTOP_ADJUSTMENT              "Endstop adjustment"
 #define STR_SKEW_FACTOR                     "Skew Factor"

Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

     #define DELTA_SEGMENT_MIN_LENGTH 0.25 // SCARA minimum segment size is 0.25mm
   #elif ENABLED(DELTA)
     #define DELTA_SEGMENT_MIN_LENGTH 0.10 // mm (still subject to DELTA_SEGMENTS_PER_SECOND)
+  #elif ENABLED(POLARGRAPH)
+    #define DELTA_SEGMENT_MIN_LENGTH 0.10 // mm (still subject to DELTA_SEGMENTS_PER_SECOND)
   #else // CARTESIAN
     #ifdef LEVELED_SEGMENT_LENGTH
       #define DELTA_SEGMENT_MIN_LENGTH LEVELED_SEGMENT_LENGTH

Marlin/src/gcode/calibrate/M665.cpp

   }
 
   void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
-    report_heading_etc(forReplay, PSTR(STR_SCARA_SETTINGS " (" STR_SCARA_S TERN_(HAS_SCARA_OFFSET, " " STR_SCARA_P_T_Z) ")"));
+    report_heading_etc(forReplay, PSTR(STR_SCARA_SETTINGS " (" STR_S_SEG_PER_SEC TERN_(HAS_SCARA_OFFSET, " " STR_SCARA_P_T_Z) ")"));
     SERIAL_ECHOLNPGM_P(
       PSTR("  M665 S"), segments_per_second
       #if HAS_SCARA_OFFSET
     );
   }
 
+#elif ENABLED(POLARGRAPH)
+
+  #include "../../module/polargraph.h"
+
+  /**
+   * M665: Set POLARGRAPH settings
+   *
+   * Parameters:
+   *
+   *   S[segments-per-second] - Segments-per-second
+   */
+  void GcodeSuite::M665() {
+    if (parser.seenval('S'))
+      segments_per_second = parser.value_float();
+    else
+      M665_report();
+  }
+
+  void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
+    report_heading_etc(forReplay, PSTR(STR_POLARGRAPH_SETTINGS " (" STR_S_SEG_PER_SEC ")"));
+    SERIAL_ECHOLNPGM("  M665 S", segments_per_second);
+  }
+
 #endif
 
 #endif // IS_KINEMATIC

Marlin/src/gcode/control/M280.cpp

 
 #include "../gcode.h"
 #include "../../module/servo.h"
+#include "../../module/planner.h"
 
 /**
- * M280: Get or set servo position. P<index> [S<angle>]
+ * M280: Get or set servo position.
+ *  P<index> - Servo index
+ *  S<angle> - Angle to set, omit to read current angle, or use -1 to detach
+ *
+ * With POLARGRAPH:
+ *  T<ms>    - Duration of servo move
  */
 void GcodeSuite::M280() {
 
-  if (!parser.seen('P')) return;
+  if (!parser.seenval('P')) return;
+
+  TERN_(POLARGRAPH, planner.synchronize());
 
   const int servo_index = parser.value_int();
   if (WITHIN(servo_index, 0, NUM_SERVOS - 1)) {
-    if (parser.seen('S')) {
-      const int a = parser.value_int();
-      if (a == -1)
-        DETACH_SERVO(servo_index);
+    if (parser.seenval('S')) {
+      const int anew = parser.value_int();
+      if (anew >= 0) {
+        #if ENABLED(POLARGRAPH)
+          if (parser.seen('T')) { // (ms) Total duration of servo move
+            const int16_t t = constrain(parser.value_int(), 0, 10000);
+            const int aold = servo[servo_index].read();
+            millis_t now = millis();
+            const millis_t start = now, end = start + t;
+            while (PENDING(now, end)) {
+              safe_delay(50);
+              now = _MIN(millis(), end);
+              MOVE_SERVO(servo_index, LROUND(aold + (anew - aold) * (float(now - start) / t)));
+            }
+          }
+        #endif // POLARGRAPH
+        MOVE_SERVO(servo_index, anew);
+      }
       else
-        MOVE_SERVO(servo_index, a);
+        DETACH_SERVO(servo_index);
     }
     else
       SERIAL_ECHO_MSG(" Servo ", servo_index, ": ", servo[servo_index].read());

Marlin/src/gcode/control/M282.cpp

  */
 void GcodeSuite::M282() {
 
-  if (!parser.seen('P')) return;
+  if (!parser.seenval('P')) return;
 
   const int servo_index = parser.value_int();
   if (WITHIN(servo_index, 0, NUM_SERVOS - 1))

Marlin/src/gcode/gcode.cpp

         case 605: M605(); break;                                  // M605: Set Dual X Carriage movement mode
       #endif
 
-      #if ENABLED(DELTA)
-        case 665: M665(); break;                                  // M665: Set delta configurations
+      #if IS_KINEMATIC
+        case 665: M665(); break;                                  // M665: Set Delta/SCARA parameters
       #endif
 
       #if ENABLED(DELTA) || HAS_EXTRA_ENDSTOPS

Marlin/src/gcode/gcode.h

  * M603 - Configure filament change: "M603 T<tool> U<unload_length> L<load_length>". (Requires ADVANCED_PAUSE_FEATURE)
  * M605 - Set Dual X-Carriage movement mode: "M605 S<mode> [X<x_offset>] [R<temp_offset>]". (Requires DUAL_X_CARRIAGE)
  * M665 - Set delta configurations: "M665 H<delta height> L<diagonal rod> R<delta radius> S<segments/s> B<calibration radius> X<Alpha angle trim> Y<Beta angle trim> Z<Gamma angle trim> (Requires DELTA)
+ *        Set SCARA configurations: "M665 S<segments-per-second> P<theta-psi-offset> T<theta-offset> Z<z-offset> (Requires MORGAN_SCARA or MP_SCARA)
  * M666 - Set/get offsets for delta (Requires DELTA) or dual endstops. (Requires [XYZ]_DUAL_ENDSTOPS)
  * M672 - Set/Reset Duet Smart Effector's sensitivity. (Requires DUET_SMART_EFFECTOR and SMART_EFFECTOR_MOD_PIN)
  * M701 - Load filament (Requires FILAMENT_LOAD_UNLOAD_GCODES)

Marlin/src/inc/Conditionals_LCD.h

 #if ANY(MORGAN_SCARA, MP_SCARA, AXEL_TPARA)
   #define IS_SCARA 1
   #define IS_KINEMATIC 1
-#elif ENABLED(DELTA)
+#elif EITHER(DELTA, POLARGRAPH)
   #define IS_KINEMATIC 1
 #else
   #define IS_CARTESIAN 1

Marlin/src/inc/SanityCheck.h

 /**
  * Servo deactivation depends on servo endstops, switching nozzle, or switching extruder
  */
-#if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE) && !HAS_Z_SERVO_PROBE && !defined(SWITCHING_NOZZLE_SERVO_NR) && !defined(SWITCHING_EXTRUDER_SERVO_NR) && !defined(SWITCHING_TOOLHEAD_SERVO_NR)
-  #error "Z_PROBE_SERVO_NR, switching nozzle, switching toolhead or switching extruder is required for DEACTIVATE_SERVOS_AFTER_MOVE."
+#if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE) && NONE(HAS_Z_SERVO_PROBE, POLARGRAPH) && !defined(SWITCHING_NOZZLE_SERVO_NR) && !defined(SWITCHING_EXTRUDER_SERVO_NR) && !defined(SWITCHING_TOOLHEAD_SERVO_NR)
+  #error "Z_PROBE_SERVO_NR, switching nozzle, switching toolhead, switching extruder, or POLARGRAPH is required for DEACTIVATE_SERVOS_AFTER_MOVE."
 #endif
 
 /**

Marlin/src/lcd/menu/menu_advanced.cpp

         #ifdef MAX_JERK_EDIT_VALUES
           MAX_JERK_EDIT_VALUES
         #elif ENABLED(LIMITED_JERK_EDITING)
-          { (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2, (DEFAULT_ZJERK) * 2, (DEFAULT_EJERK) * 2 }
+          { LOGICAL_AXIS_LIST((DEFAULT_EJERK) * 2,
+                              (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2, (DEFAULT_ZJERK) * 2,
+                              (DEFAULT_IJERK) * 2, (DEFAULT_JJERK) * 2, (DEFAULT_KJERK) * 2) }
         #else
-          { 990, 990, 990, 990 }
+          { LOGICAL_AXIS_LIST(990, 990, 990, 990, 990, 990, 990) }
         #endif
       ;
       #define EDIT_JERK(N) EDIT_ITEM_FAST(float3, MSG_V##N##_JERK, &planner.max_jerk[_AXIS(N)], 1, max_jerk_edit[_AXIS(N)])

Marlin/src/module/motion.cpp

     const feedRate_t z_feedrate = fr_mm_s ?: homing_feedrate(Z_AXIS);
   #endif
 
-  #if EITHER(DELTA, IS_SCARA)
+  #if IS_KINEMATIC
     if (!position_is_reachable(x, y)) return;
     destination = current_position;          // sync destination at the start
   #endif

Marlin/src/module/motion.h

 
       return HYPOT2(rx, ry) <= sq(DELTA_PRINTABLE_RADIUS - inset + fslop);
 
+    #elif ENABLED(POLARGRAPH)
+
+      const float x1 = rx - (X_MIN_POS), x2 = (X_MAX_POS) - rx, y = ry - (Y_MAX_POS),
+                  a = HYPOT(x1, y), b = HYPOT(x2, y);
+      return a < (POLARGRAPH_MAX_BELT_LEN) + 1
+          && b < (POLARGRAPH_MAX_BELT_LEN) + 1
+          && (a + b) > _MIN(X_BED_SIZE, Y_BED_SIZE);
+
     #elif ENABLED(AXEL_TPARA)
 
       const float R2 = HYPOT2(rx - TPARA_OFFSET_X, ry - TPARA_OFFSET_Y);

Marlin/src/module/planner.cpp

     #else
       const feedRate_t feedrate = fr_mm_s;
     #endif
-    delta.e = machine.e;
+    TERN_(HAS_EXTRUDERS, delta.e = machine.e);
     if (buffer_segment(delta OPTARG(HAS_DIST_MM_ARG, cart_dist_mm), feedrate, extruder, mm)) {
       position_cart = cart;
       return true;
   #if IS_KINEMATIC
     position_cart = xyze;
     inverse_kinematics(machine);
-    delta.e = machine.e;
+    TERN_(HAS_EXTRUDERS, delta.e = machine.e);
     set_machine_position_mm(delta);
   #else
     set_machine_position_mm(machine);

Marlin/src/module/planner.h

 
 #if ENABLED(DELTA)
   #include "delta.h"
+#elif ENABLED(POLARGRAPH)
+  #include "polargraph.h"
 #endif
 
 #if ABL_PLANAR

Marlin/src/module/polargraph.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * polargraph.cpp
+ */
+
+#include "../inc/MarlinConfig.h"
+
+#if ENABLED(POLARGRAPH)
+
+#include "polargraph.h"
+#include "motion.h"
+
+// For homing:
+#include "planner.h"
+#include "endstops.h"
+#include "../lcd/marlinui.h"
+#include "../MarlinCore.h"
+
+float segments_per_second; // Initialized by settings.load()
+
+void inverse_kinematics(const xyz_pos_t &raw) {
+  const float x1 = raw.x - (X_MIN_POS), x2 = (X_MAX_POS) - raw.x, y = raw.y - (Y_MAX_POS);
+  delta.set(HYPOT(x1, y), HYPOT(x2, y), raw.z);
+}
+
+#endif // POLARGRAPH

Marlin/src/module/polargraph.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+/**
+ * polargraph.h - Polargraph-specific functions
+ */
+
+#include "../core/types.h"
+#include "../core/macros.h"
+
+extern float segments_per_second;
+
+void inverse_kinematics(const xyz_pos_t &raw);

Marlin/src/module/settings.cpp

  */
 
 // Change EEPROM version if the structure changes
-#define EEPROM_VERSION "V84"
+#define EEPROM_VERSION "V85"
 #define EEPROM_OFFSET 100
 
 // Check the integrity of data offsets.
   bool bltouch_last_written_mode;
 
   //
-  // DELTA / [XYZ]_DUAL_ENDSTOPS
+  // Kinematic Settings
   //
-  #if ENABLED(DELTA)
-    float delta_height;                                 // M666 H
-    abc_float_t delta_endstop_adj;                      // M666 X Y Z
-    float delta_radius,                                 // M665 R
-          delta_diagonal_rod,                           // M665 L
-          segments_per_second;                          // M665 S
-    abc_float_t delta_tower_angle_trim,                 // M665 X Y Z
-                delta_diagonal_rod_trim;                // M665 A B C
-  #elif HAS_EXTRA_ENDSTOPS
+  #if IS_KINEMATIC
+    float segments_per_second;                          // M665 S
+    #if ENABLED(DELTA)
+      float delta_height;                               // M666 H
+      abc_float_t delta_endstop_adj;                    // M666 X Y Z
+      float delta_radius,                               // M665 R
+            delta_diagonal_rod;                         // M665 L
+      abc_float_t delta_tower_angle_trim,               // M665 X Y Z
+                  delta_diagonal_rod_trim;              // M665 A B C
+    #endif
+  #endif
+
+  //
+  // Extra Endstops offsets
+  //
+  #if HAS_EXTRA_ENDSTOPS
     float x2_endstop_adj,                               // M666 X
           y2_endstop_adj,                               // M666 Y
           z2_endstop_adj,                               // M666 (S2) Z
     }
 
     //
-    // DELTA Geometry or Dual Endstops offsets
+    // Kinematic Settings
     //
+    #if IS_KINEMATIC
     {
+      EEPROM_WRITE(segments_per_second);
       #if ENABLED(DELTA)
-
         _FIELD_TEST(delta_height);
-
         EEPROM_WRITE(delta_height);              // 1 float
         EEPROM_WRITE(delta_endstop_adj);         // 3 floats
         EEPROM_WRITE(delta_radius);              // 1 float
         EEPROM_WRITE(delta_diagonal_rod);        // 1 float
-        EEPROM_WRITE(segments_per_second);       // 1 float
         EEPROM_WRITE(delta_tower_angle_trim);    // 3 floats
         EEPROM_WRITE(delta_diagonal_rod_trim);   // 3 floats
+      #endif
+    }
+    #endif
 
-      #elif HAS_EXTRA_ENDSTOPS
-
-        _FIELD_TEST(x2_endstop_adj);
-
-        // Write dual endstops in X, Y, Z order. Unused = 0.0
-        dummyf = 0;
-        EEPROM_WRITE(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf));   // 1 float
-        EEPROM_WRITE(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf));   // 1 float
-        EEPROM_WRITE(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf));  // 1 float
+    //
+    // Extra Endstops offsets
+    //
+    #if HAS_EXTRA_ENDSTOPS
+    {
+      _FIELD_TEST(x2_endstop_adj);
 
-        #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
-          EEPROM_WRITE(endstops.z3_endstop_adj);   // 1 float
-        #else
-          EEPROM_WRITE(dummyf);
-        #endif
+      // Write dual endstops in X, Y, Z order. Unused = 0.0
+      dummyf = 0;
+      EEPROM_WRITE(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf));   // 1 float
+      EEPROM_WRITE(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf));   // 1 float
+      EEPROM_WRITE(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf));  // 1 float
 
-        #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
-          EEPROM_WRITE(endstops.z4_endstop_adj);   // 1 float
-        #else
-          EEPROM_WRITE(dummyf);
-        #endif
+      #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
+        EEPROM_WRITE(endstops.z3_endstop_adj);   // 1 float
+      #else
+        EEPROM_WRITE(dummyf);
+      #endif
 
+      #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
+        EEPROM_WRITE(endstops.z4_endstop_adj);   // 1 float
+      #else
+        EEPROM_WRITE(dummyf);
       #endif
     }
+    #endif
 
     #if ENABLED(Z_STEPPER_AUTO_ALIGN)
       EEPROM_WRITE(z_stepper_align.xy);
       }
 
       //
-      // DELTA Geometry or Dual Endstops offsets
+      // Kinematic Segments-per-second
       //
+      #if IS_KINEMATIC
       {
+        EEPROM_READ(segments_per_second);
         #if ENABLED(DELTA)
-
           _FIELD_TEST(delta_height);
-
           EEPROM_READ(delta_height);              // 1 float
           EEPROM_READ(delta_endstop_adj);         // 3 floats
           EEPROM_READ(delta_radius);              // 1 float
           EEPROM_READ(delta_diagonal_rod);        // 1 float
-          EEPROM_READ(segments_per_second);       // 1 float
           EEPROM_READ(delta_tower_angle_trim);    // 3 floats
           EEPROM_READ(delta_diagonal_rod_trim);   // 3 floats
+        #endif
+      }
+      #endif
 
-        #elif HAS_EXTRA_ENDSTOPS
-
-          _FIELD_TEST(x2_endstop_adj);
+      //
+      // Extra Endstops offsets
+      //
+      #if HAS_EXTRA_ENDSTOPS
+      {
+        _FIELD_TEST(x2_endstop_adj);
 
-          EEPROM_READ(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf));  // 1 float
-          EEPROM_READ(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf));  // 1 float
-          EEPROM_READ(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf)); // 1 float
-
-          #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
-            EEPROM_READ(endstops.z3_endstop_adj); // 1 float
-          #else
-            EEPROM_READ(dummyf);
-          #endif
-          #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
-            EEPROM_READ(endstops.z4_endstop_adj); // 1 float
-          #else
-            EEPROM_READ(dummyf);
-          #endif
+        EEPROM_READ(TERN(X_DUAL_ENDSTOPS, endstops.x2_endstop_adj, dummyf));  // 1 float
+        EEPROM_READ(TERN(Y_DUAL_ENDSTOPS, endstops.y2_endstop_adj, dummyf));  // 1 float
+        EEPROM_READ(TERN(Z_MULTI_ENDSTOPS, endstops.z2_endstop_adj, dummyf)); // 1 float
 
+        #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 3
+          EEPROM_READ(endstops.z3_endstop_adj); // 1 float
+        #else
+          EEPROM_READ(dummyf);
+        #endif
+        #if ENABLED(Z_MULTI_ENDSTOPS) && NUM_Z_STEPPER_DRIVERS >= 4
+          EEPROM_READ(endstops.z4_endstop_adj); // 1 float
+        #else
+          EEPROM_READ(dummyf);
         #endif
       }
+      #endif
 
       #if ENABLED(Z_STEPPER_AUTO_ALIGN)
         EEPROM_READ(z_stepper_align.xy);
   //#endif
 
   //
-  // Endstop Adjustments
+  // Kinematic settings
   //
 
-  #if ENABLED(DELTA)
-    const abc_float_t adj = DELTA_ENDSTOP_ADJ, dta = DELTA_TOWER_ANGLE_TRIM, ddr = DELTA_DIAGONAL_ROD_TRIM_TOWER;
-    delta_height = DELTA_HEIGHT;
-    delta_endstop_adj = adj;
-    delta_radius = DELTA_RADIUS;
-    delta_diagonal_rod = DELTA_DIAGONAL_ROD;
-    segments_per_second = DELTA_SEGMENTS_PER_SECOND;
-    delta_tower_angle_trim = dta;
-    delta_diagonal_rod_trim = ddr;
+  #if IS_KINEMATIC
+    segments_per_second = (
+      TERN_(DELTA, DELTA_SEGMENTS_PER_SECOND)
+      TERN_(IS_SCARA, SCARA_SEGMENTS_PER_SECOND)
+      TERN_(POLARGRAPH, POLAR_SEGMENTS_PER_SECOND)
+    );
+    #if ENABLED(DELTA)
+      const abc_float_t adj = DELTA_ENDSTOP_ADJ, dta = DELTA_TOWER_ANGLE_TRIM, ddr = DELTA_DIAGONAL_ROD_TRIM_TOWER;
+      delta_height = DELTA_HEIGHT;
+      delta_endstop_adj = adj;
+      delta_radius = DELTA_RADIUS;
+      delta_diagonal_rod = DELTA_DIAGONAL_ROD;
+      delta_tower_angle_trim = dta;
+      delta_diagonal_rod_trim = ddr;
+    #endif
   #endif
 
+  //
+  // Endstop Adjustments
+  //
+
   #if ENABLED(X_DUAL_ENDSTOPS)
     #ifndef X2_ENDSTOP_ADJUSTMENT
       #define X2_ENDSTOP_ADJUSTMENT 0
     TERN_(EDITABLE_SERVO_ANGLES, gcode.M281_report(forReplay));
 
     //
-    // Delta / SCARA Kinematics
+    // Kinematic Settings
     //
     TERN_(IS_KINEMATIC, gcode.M665_report(forReplay));
 

Marlin/src/pins/ramps/pins_RUMBA.h

 //
 // Limit Switches
 //
-#define X_MIN_PIN                             37
-#define X_MAX_PIN                             36
-#define Y_MIN_PIN                             35
-#define Y_MAX_PIN                             34
-#define Z_MIN_PIN                             33
-#define Z_MAX_PIN                             32
+#ifndef X_MIN_PIN
+  #define X_MIN_PIN                           37
+#endif
+#ifndef X_MIN_PIN
+  #define X_MIN_PIN                           37
+#endif
+#ifndef X_MAX_PIN
+  #define X_MAX_PIN                           36
+#endif
+#ifndef Y_MIN_PIN
+  #define Y_MIN_PIN                           35
+#endif
+#ifndef Y_MAX_PIN
+  #define Y_MAX_PIN                           34
+#endif
+#ifndef Z_MIN_PIN
+  #define Z_MIN_PIN                           33
+#endif
+#ifndef Z_MAX_PIN
+  #define Z_MAX_PIN                           32
+#endif
 
 //
 // Z Probe (when not Z_MIN_PIN)

buildroot/tests/mega1280

 
 #
 # Delta Config (generic) + ABL bilinear + BLTOUCH
+#
 use_example_configs delta/generic
 opt_set LCD_LANGUAGE cz \
         Z_MIN_PROBE_ENDSTOP_INVERTING false \

buildroot/tests/mega2560

 opt_enable REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER SDSUPPORT EEPROM_SETTINGS EEPROM_BOOT_SILENT EEPROM_AUTO_INIT \
            LASER_FEATURE AIR_EVACUATION AIR_EVACUATION_PIN AIR_ASSIST AIR_ASSIST_PIN LASER_COOLANT_FLOW_METER MEATPACK_ON_SERIAL_PORT_1
 
-exec_test $1 $2 "REPRAP MEGA2560 RAMPS | Laser Feature | Air Evacuation | Air Assist | Cooler | Flowmeter | 12864 LCD | meatpack | SERIAL_PORT_2 " "$3"
+exec_test $1 $2 "MEGA2560 RAMPS | Laser Feature | Air Evacuation | Air Assist | Cooler | Flowmeter | 12864 LCD | meatpack | SERIAL_PORT_2 " "$3"
 
 #
 # Test Laser features with 44780 LCD
 opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER SDSUPPORT EEPROM_SETTINGS EEPROM_BOOT_SILENT EEPROM_AUTO_INIT \
            LASER_FEATURE AIR_EVACUATION AIR_EVACUATION_PIN AIR_ASSIST AIR_ASSIST_PIN LASER_COOLANT_FLOW_METER I2C_AMMETER
 
-exec_test $1 $2 "REPRAP MEGA2560 RAMPS | Laser Feature | Air Evacuation | Air Assist | Cooler | Flowmeter | 44780 LCD " "$3"
+exec_test $1 $2 "MEGA2560 RAMPS | Laser Feature | Air Evacuation | Air Assist | Cooler | Flowmeter | 44780 LCD " "$3"
 
 #
 # Test redundant temperature sensors + MAX TC
 exec_test $1 $2 "MEGA2560 RAMPS | Redundant temperature sensor | 2x MAX6675" "$3"
 
 #
+# Polargraph Config
+#
+use_example_configs Polargraph
+exec_test $1 $2 "RUMBA | POLARGRAPH | RRD LCD" "$3"
+
+#
 # Language files test with REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
 #
 #restore_configs

ini/features.ini

 NOZZLE_PARK_FEATURE                    = src_filter=+<src/libs/nozzle.cpp> +<src/gcode/feature/pause/G27.cpp>
 NOZZLE_CLEAN_FEATURE                   = src_filter=+<src/libs/nozzle.cpp> +<src/gcode/feature/clean>
 DELTA                                  = src_filter=+<src/module/delta.cpp> +<src/gcode/calibrate/M666.cpp>
+POLARGRAPH                             = src_filter=+<src/module/polargraph.cpp>
 BEZIER_CURVE_SUPPORT                   = src_filter=+<src/module/planner_bezier.cpp> +<src/gcode/motion/G5.cpp>
 PRINTCOUNTER                           = src_filter=+<src/module/printcounter.cpp>
 HAS_BED_PROBE                          = src_filter=+<src/module/probe.cpp> +<src/gcode/probe/G30.cpp> +<src/gcode/probe/M401_M402.cpp> +<src/gcode/probe/M851.cpp>

platformio.ini

   -<src/gcode/calibrate/M48.cpp>
   -<src/gcode/calibrate/M100.cpp>
   -<src/gcode/calibrate/M425.cpp>
+  -<src/gcode/calibrate/M665.cpp>
   -<src/gcode/calibrate/M666.cpp>
   -<src/gcode/calibrate/M852.cpp>
   -<src/gcode/control/M10-M11.cpp>
   -<src/libs/nozzle.cpp> -<src/gcode/feature/clean>
   -<src/module/delta.cpp>
   -<src/module/planner_bezier.cpp>
+  -<src/module/polargraph.cpp>
   -<src/module/printcounter.cpp>
   -<src/module/probe.cpp>
-  -<src/module/scara.cpp> -<src/gcode/calibrate/M665.cpp>
+  -<src/module/scara.cpp>
   -<src/module/servo.cpp> -<src/gcode/control/M280.cpp> -<src/gcode/config/M281.cpp> -<src/gcode/control/M282.cpp>
   -<src/module/stepper/TMC26X.cpp>