Add G68/G51 rotate/scale workspace (LinuxCNC)

Marlin/Configuration_adv.h

@@ -2289,22 +2289,6 @@
 
 //#define FAST_BUTTON_POLLING           // Poll buttons at ~1kHz on 8-bit AVR. Set to 'false' for slow polling on 32-bit.
 
-// @section safety
-
-/**
- * The watchdog hardware timer will do a reset and disable all outputs
- * if the firmware gets too overloaded to read the temperature sensors.
- *
- * If you find that watchdog reboot causes your AVR board to hang forever,
- * enable WATCHDOG_RESET_MANUAL to use a custom timer instead of WDTO.
- * NOTE: This method is less reliable as it can only catch hangups while
- * interrupts are enabled.
- */
-#define USE_WATCHDOG
-#if ENABLED(USE_WATCHDOG)
-  //#define WATCHDOG_RESET_MANUAL
-#endif
-
 // @section lcd
 
 /**
@@ -3644,6 +3628,21 @@
 
 // @section cnc
 
+/**
+ * CNC Coordinate Systems
+ *
+ * Enables G53 and G54-G59.3 commands to select coordinate systems
+ * and G92.1 to reset the workspace to native machine space.
+ */
+//#define CNC_COORDINATE_SYSTEMS
+
+/**
+ * Rotate Workspace
+ *
+ * Enables G68 command to rotate the workspace.
+ */
+//#define ROTATE_WORKSPACE
+
 /**
  * Spindle & Laser control
  *
@@ -3911,6 +3910,20 @@
 
 // @section safety
 
+/**
+ * The watchdog hardware timer will do a reset and disable all outputs
+ * if the firmware gets too overloaded to read the temperature sensors.
+ *
+ * If you find that watchdog reboot causes your AVR board to hang forever,
+ * enable WATCHDOG_RESET_MANUAL to use a custom timer instead of WDTO.
+ * NOTE: This method is less reliable as it can only catch hangups while
+ * interrupts are enabled.
+ */
+#define USE_WATCHDOG
+#if ENABLED(USE_WATCHDOG)
+  //#define WATCHDOG_RESET_MANUAL
+#endif
+
 /**
  * Stepper Driver Anti-SNAFU Protection
  *
@@ -3920,16 +3933,6 @@
  */
 //#define DISABLE_DRIVER_SAFE_POWER_PROTECT
 
-// @section cnc
-
-/**
- * CNC Coordinate Systems
- *
- * Enables G53 and G54-G59.3 commands to select coordinate systems
- * and G92.1 to reset the workspace to native machine space.
- */
-//#define CNC_COORDINATE_SYSTEMS
-
 // @section security
 
 /**

Marlin/src/gcode/gcode.cpp

@@ -100,6 +100,21 @@ relative_t GcodeSuite::axis_relative; // Init in constructor
   xyz_pos_t GcodeSuite::coordinate_system[MAX_COORDINATE_SYSTEMS];
 #endif
 
+#if ENABLED(SCALE_WORKSPACE)
+  float GcodeSuite::scaling_center_x = 0.0f;
+  float GcodeSuite::scaling_center_y = 0.0f;
+  float GcodeSuite::scaling_center_z = 0.0f;
+  float GcodeSuite::scaling_factor_x = 1.0f;
+  float GcodeSuite::scaling_factor_y = 1.0f;
+  float GcodeSuite::scaling_factor_z = 1.0f;
+#endif
+
+#if ENABLED(ROTATE_WORKSPACE)
+  float GcodeSuite::rotation_center_x = 0.0f;
+  float GcodeSuite::rotation_center_y = 0.0f;
+  float GcodeSuite::rotation_angle = 0.0f;
+#endif
+
 void GcodeSuite::report_echo_start(const bool forReplay) { if (!forReplay) SERIAL_ECHO_START(); }
 void GcodeSuite::report_heading(const bool forReplay, FSTR_P const fstr, const bool eol/*=true*/) {
   if (forReplay) return;
@@ -175,15 +190,54 @@ void GcodeSuite::get_destination_from_command() {
   LOOP_NUM_AXES(i) {
     if ( (seen[i] = parser.seenval(AXIS_CHAR(i))) ) {
       const float v = parser.value_axis_units((AxisEnum)i);
-      if (skip_move)
+      if (skip_move) {
+        #if ANY(SCALE_WORKSPACE, ROTATE_WORKSPACE)
+          raw_destination[i] = current_position[i];
+        #else
+          destination[i] = current_position[i];
+        #endif
+      }
+      else {
+        #if ANY(SCALE_WORKSPACE, ROTATE_WORKSPACE)
+          raw_destination[i] = axis_is_relative(AxisEnum(i)) ? raw_destination[i] + v : LOGICAL_TO_NATIVE(v, i);
+        #else
+          destination[i] = axis_is_relative(AxisEnum(i)) ? current_position[i] + v : LOGICAL_TO_NATIVE(v, i);
+        #endif
+      }
+    }
+    else {
+      #if NONE(SCALE_WORKSPACE, ROTATE_WORKSPACE)
         destination[i] = current_position[i];
-      else
-        destination[i] = axis_is_relative(AxisEnum(i)) ? current_position[i] + v : LOGICAL_TO_NATIVE(v, i);
+      #endif
     }
-    else
-      destination[i] = current_position[i];
   }
 
+  #if ANY(SCALE_WORKSPACE, ROTATE_WORKSPACE)
+    destination = raw_destination;
+  #endif
+
+  #if ENABLED(SCALE_WORKSPACE)
+    if (!(NEAR(scaling_factor_x, 1.0f) || NEAR(scaling_factor_y, 1.0f) || NEAR(scaling_factor_z, 1.0f))) {
+      destination.x = (raw_destination.x - scaling_center_x) * scaling_factor_x + scaling_center_x;
+      TERN_(HAS_Y_AXIS, destination.y = (raw_destination.y - scaling_center_y) * scaling_factor_y + scaling_center_y);
+      TERN_(HAS_Z_AXIS, destination.z = (raw_destination.z - scaling_center_z) * scaling_factor_z + scaling_center_z);
+    }
+  #endif
+
+  #if ENABLED(ROTATE_WORKSPACE)
+    if (!NEAR_ZERO(rotation_angle)) {
+      const float angle_rad = RADIANS(rotation_angle);
+      const float cos_angle = cos(angle_rad);
+      const float sin_angle = sin(angle_rad);
+
+      // Apply rotation
+      const float temp_x = destination.x - rotation_center_x;
+      const float temp_y = destination.y - rotation_center_y;
+      destination.x = temp_x * cos_angle - temp_y * sin_angle + rotation_center_x;
+      destination.y = temp_x * sin_angle + temp_y * cos_angle + rotation_center_y;
+    }
+  #endif
+
   #if HAS_EXTRUDERS
     // Get new E position, whether absolute or relative
     if ( (seen.e = parser.seenval('E')) ) {
@@ -435,6 +489,11 @@ void GcodeSuite::process_parsed_command(bool no_ok/*=false*/) {
         case 42: G42(); break;                                    // G42: Coordinated move to a mesh point
       #endif
 
+      #if ENABLED(SCALE_WORKSPACE)
+        case 50: G50(); break;                                    // G50: Cancel Workspace Scaling
+        case 51: G51(); break;                                    // G51: Set Workspace Scaling
+      #endif
+
       #if ENABLED(CNC_COORDINATE_SYSTEMS)
         case 53: G53(); break;                                    // G53: (prefix) Apply native workspace
         case 54: G54(); break;                                    // G54: Switch to Workspace 1
@@ -450,6 +509,11 @@ void GcodeSuite::process_parsed_command(bool no_ok/*=false*/) {
         case 61: G61(); break;                                    // G61:  Apply/restore saved coordinates.
       #endif
 
+      #if ENABLED(ROTATE_WORKSPACE)
+        case 68: G68(); break;                                    // G68: Set Workspace Rotation
+        case 69: G69(); break;                                    // G69: Cancel Workspace Rotation
+      #endif
+
       #if ALL(PTC_PROBE, PTC_BED)
         case 76: G76(); break;                                    // G76: Calibrate first layer compensation values
       #endif

Marlin/src/gcode/gcode.h

@@ -64,8 +64,12 @@
  * G35  - Read bed corners to help adjust bed screws: T<screw_thread> (Requires ASSISTED_TRAMMING)
  * G38  - Probe in any direction using the Z_MIN_PROBE (Requires G38_PROBE_TARGET)
  * G42  - Coordinated move to a mesh point (Requires MESH_BED_LEVELING, AUTO_BED_LEVELING_BLINEAR, or AUTO_BED_LEVELING_UBL)
+ * G50  - Set Workspace Scaling (Requires SCALE_WORKSPACE)
+ * G51  - Cancel Workspace Scaling (Requires SCALE_WORKSPACE)
  * G60  - Save current position. (Requires SAVED_POSITIONS)
  * G61  - Apply/Restore saved coordinates. (Requires SAVED_POSITIONS)
+ * G68  - Set Workspace Rotation (Requires ROTATE_WORKSPACE)
+ * G69  - Cancel Workspace Rotation (Requires ROTATE_WORKSPACE)
  * G76  - Calibrate first layer temperature offsets. (Requires PTC_PROBE and PTC_BED)
  * G80  - Cancel current motion mode (Requires GCODE_MOTION_MODES)
  * G90  - Use Absolute Coordinates
@@ -431,6 +435,21 @@ class GcodeSuite {
     static bool select_coordinate_system(const int8_t _new);
   #endif
 
+  #if ENABLED(SCALE_WORKSPACE)
+    static float scaling_center_x;
+    static float scaling_center_y;
+    static float scaling_center_z;
+    static float scaling_factor_x;
+    static float scaling_factor_y;
+    static float scaling_factor_z;
+  #endif
+
+  #if ENABLED(ROTATE_WORKSPACE)
+    static float rotation_angle;
+    static float rotation_center_x;
+    static float rotation_center_y;
+  #endif
+
   static millis_t previous_move_ms, max_inactive_time;
   FORCE_INLINE static bool stepper_max_timed_out(const millis_t ms=millis()) {
     return max_inactive_time && ELAPSED(ms, previous_move_ms, max_inactive_time);
@@ -609,6 +628,11 @@ class GcodeSuite {
     static void G42();
   #endif
 
+  #if ENABLED(SCALE_WORKSPACE)
+    static void G50();
+    static void G51();
+  #endif
+
   #if ENABLED(CNC_COORDINATE_SYSTEMS)
     static void G53();
     static void G54();
@@ -628,6 +652,11 @@ class GcodeSuite {
     static void G61(int8_t slot=-1);
   #endif
 
+  #if ENABLED(ROTATE_WORKSPACE)
+    static void G68();
+    static void G69();
+  #endif
+
   #if ENABLED(GCODE_MOTION_MODES)
     static void G80();
   #endif

Marlin/src/gcode/geometry/G17-G19.cpp

@@ -37,8 +37,13 @@ inline void report_workspace_plane() {
 }
 
 inline void set_workspace_plane(const GcodeSuite::WorkspacePlane plane) {
-  gcode.workspace_plane = plane;
-  if (DEBUGGING(INFO)) report_workspace_plane();
+  if (TERN0(ROTATE_WORKSPACE, !NEAR_ZERO(gcode.rotation_angle))) {
+    SERIAL_ECHOLNPGM("Error: Workspace plane cannnot change while using workspace rotation.");
+  }
+  else {
+    gcode.workspace_plane = plane;
+    if (DEBUGGING(INFO)) report_workspace_plane();
+  }
 }
 
 /**

Marlin/src/gcode/geometry/G50_G51.cpp

@@ -0,0 +1,86 @@
+/**
+ * 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/>.
+ *
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(SCALE_WORKSPACE)
+
+  #include "../gcode.h"
+  #include "../../module/motion.h"
+
+  /**
+   * G50: Set Workspace Scaling
+   *
+   * Scale the current workspace coordinate system.
+   *
+   * Parameters:
+   *   X<linear>  X coordinate of the scaling center
+   *   Y<linear>  Y coordinate of the scaling center
+   *   Z<linear>  Z coordinate of the scaling center
+   *   I<float>   scaling factor for X axis
+   *   J<float>   scaling factor for Y axis
+   *   K<float>   scaling factor for Z axis
+   *   P<float>   scaling factor
+   */
+  void GcodeSuite::G50() {
+    if (parser.seenval('P')) {
+      const float scaling_factor = parser.value_float();
+      scaling_factor_x = scaling_factor;
+      TERN_(HAS_Y_AXIS, scaling_factor_y = scaling_factor);
+      TERN_(HAS_Z_AXIS, scaling_factor_z = scaling_factor);
+    }
+    else {
+      if (parser.seenval('I'))
+        scaling_factor_x = parser.value_float();
+      #if HAS_Y_AXIS
+        if (parser.seenval('J'))
+          scaling_factor_y = parser.value_float();
+      #endif
+      #if HAS_Z_AXIS
+        if (parser.seenval('K'))
+          scaling_factor_z = parser.value_float();
+      #endif
+    }
+
+    scaling_center_x = parser.seenval('X') ? LOGICAL_TO_NATIVE(parser.value_axis_units(X_AXIS), X_AXIS) : current_position.x;
+    TERN_(HAS_Y_AXIS, scaling_center_y = parser.seenval('Y') ? LOGICAL_TO_NATIVE(parser.value_axis_units(Y_AXIS), Y_AXIS) : current_position.y);
+    TERN_(HAS_Z_AXIS, scaling_center_z = parser.seenval('Z') ? LOGICAL_TO_NATIVE(parser.value_axis_units(Z_AXIS), Z_AXIS) : current_position.z);
+
+    SERIAL_ECHOLNPGM("Workspace scaling set");
+  }
+
+  /**
+   * G51: Cancel Workspace Scaling
+   */
+  void GcodeSuite::G51() {
+    scaling_factor_x = 1.0f;
+    scaling_center_x = 0.0f;
+    scaling_factor_y = 1.0f;
+    scaling_center_y = 0.0f;
+    #if HAS_Z_AXIS
+      scaling_factor_z = 1.0f;
+      scaling_center_z = 0.0f;
+    #endif
+    SERIAL_ECHOLNPGM("Workspace scaling canceled");
+  }
+
+#endif // SCALE_WORKSPACE

Marlin/src/gcode/geometry/G53-G59.cpp

@@ -33,6 +33,10 @@
  */
 bool GcodeSuite::select_coordinate_system(const int8_t _new) {
   if (active_coordinate_system == _new) return false;
+  if (TERN0(ROTATE_WORKSPACE, !NEAR_ZERO(gcode.rotation_angle))) {
+    SERIAL_ECHOLNPGM("Cannot change workspace while workspace rotation is active");
+    return false;
+  }
   active_coordinate_system = _new;
   xyz_float_t new_offset{0};
   if (WITHIN(_new, 0, MAX_COORDINATE_SYSTEMS - 1))