Sfoglia il codice sorgente

Add Junction Deviation mm runtime setting (#10990)

Scott Lahteine 7 anni fa
parent
commit
a2f521d34b
Nessun account collegato all'indirizzo email del committer

+ 19
- 12
Marlin/src/gcode/config/M200-M205.cpp Vedi File

@@ -118,26 +118,33 @@ void GcodeSuite::M204() {
118 118
 /**
119 119
  * M205: Set Advanced Settings
120 120
  *
121
+ *    B = Min Segment Time (µs)
121 122
  *    S = Min Feed Rate (units/s)
122 123
  *    T = Min Travel Feed Rate (units/s)
123
- *    B = Min Segment Time (µs)
124 124
  *    X = Max X Jerk (units/sec^2)
125 125
  *    Y = Max Y Jerk (units/sec^2)
126 126
  *    Z = Max Z Jerk (units/sec^2)
127 127
  *    E = Max E Jerk (units/sec^2)
128
+ *    J = Junction Deviation (mm) (Requires JUNCTION_DEVIATION)
128 129
  */
129 130
 void GcodeSuite::M205() {
131
+  if (parser.seen('B')) planner.min_segment_time_us = parser.value_ulong();
130 132
   if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units();
131 133
   if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units();
132
-  if (parser.seen('B')) planner.min_segment_time_us = parser.value_ulong();
133
-  if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units();
134
-  if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units();
135
-  if (parser.seen('Z')) {
136
-    planner.max_jerk[Z_AXIS] = parser.value_linear_units();
137
-    #if HAS_MESH
138
-      if (planner.max_jerk[Z_AXIS] <= 0.1)
139
-        SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses.");
140
-    #endif
141
-  }
142
-  if (parser.seen('E')) planner.max_jerk[E_AXIS] = parser.value_linear_units();
134
+  #if ENABLED(JUNCTION_DEVIATION)
135
+    if (parser.seen('J')) planner.junction_deviation_mm = parser.value_linear_units();
136
+  #else
137
+    if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units();
138
+    if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units();
139
+    if (parser.seen('Z')) {
140
+      planner.max_jerk[Z_AXIS] = parser.value_linear_units();
141
+      #if HAS_MESH
142
+        if (planner.max_jerk[Z_AXIS] <= 0.1)
143
+          SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses.");
144
+      #endif
145
+    }
146
+  #endif
147
+  #if DISABLED(JUNCTION_DEVIATION) || ENABLED(LIN_ADVANCE)
148
+    if (parser.seen('E')) planner.max_jerk[E_AXIS] = parser.value_linear_units();
149
+  #endif
143 150
 }

+ 5
- 2
Marlin/src/lcd/language/language_en.h Vedi File

@@ -371,7 +371,7 @@
371 371
 #ifndef MSG_LED_CONTROL
372 372
   #define MSG_LED_CONTROL                     _UxGT("LED Control")
373 373
 #endif
374
-#ifndef MSG_LEDS   
374
+#ifndef MSG_LEDS
375 375
   #define MSG_LEDS                            _UxGT("Lights")
376 376
 #endif
377 377
 #ifndef MSG_LED_PRESETS
@@ -537,6 +537,9 @@
537 537
 #ifndef MSG_VE_JERK
538 538
   #define MSG_VE_JERK                         _UxGT("Ve-jerk")
539 539
 #endif
540
+#ifndef MSG_JUNCTION_DEVIATION
541
+  #define MSG_JUNCTION_DEVIATION              _UxGT("Junction Dev")
542
+#endif
540 543
 #ifndef MSG_VELOCITY
541 544
   #define MSG_VELOCITY                        _UxGT("Velocity")
542 545
 #endif
@@ -739,7 +742,7 @@
739 742
   #define MSG_CNG_SDCARD                      _UxGT("Change SD card")
740 743
 #endif
741 744
 #ifndef MSG_ZPROBE_OUT
742
-  #define MSG_ZPROBE_OUT                      _UxGT("Z probe out. bed")
745
+  #define MSG_ZPROBE_OUT                      _UxGT("Z Probe past bed")
743 746
 #endif
744 747
 #ifndef MSG_SKEW_FACTOR
745 748
   #define MSG_SKEW_FACTOR                     _UxGT("Skew Factor")

+ 9
- 5
Marlin/src/lcd/ultralcd.cpp Vedi File

@@ -3753,12 +3753,16 @@ void lcd_quick_feedback(const bool clear_buttons) {
3753 3753
       START_MENU();
3754 3754
       MENU_BACK(MSG_MOTION);
3755 3755
 
3756
-      MENU_ITEM_EDIT(float3, MSG_VA_JERK, &planner.max_jerk[A_AXIS], 1, 990);
3757
-      MENU_ITEM_EDIT(float3, MSG_VB_JERK, &planner.max_jerk[B_AXIS], 1, 990);
3758
-      #if ENABLED(DELTA)
3759
-        MENU_ITEM_EDIT(float3, MSG_VC_JERK, &planner.max_jerk[C_AXIS], 1, 990);
3756
+      #if ENABLED(JUNCTION_DEVIATION)
3757
+        MENU_ITEM_EDIT(float3, MSG_JUNCTION_DEVIATION, &planner.junction_deviation_mm, 0, 5);
3760 3758
       #else
3761
-        MENU_ITEM_EDIT(float52sign, MSG_VC_JERK, &planner.max_jerk[C_AXIS], 0.1, 990);
3759
+        MENU_ITEM_EDIT(float3, MSG_VA_JERK, &planner.max_jerk[A_AXIS], 1, 990);
3760
+        MENU_ITEM_EDIT(float3, MSG_VB_JERK, &planner.max_jerk[B_AXIS], 1, 990);
3761
+        #if ENABLED(DELTA)
3762
+          MENU_ITEM_EDIT(float3, MSG_VC_JERK, &planner.max_jerk[C_AXIS], 1, 990);
3763
+        #else
3764
+          MENU_ITEM_EDIT(float52sign, MSG_VC_JERK, &planner.max_jerk[C_AXIS], 0.1, 990);
3765
+        #endif
3762 3766
       #endif
3763 3767
       MENU_ITEM_EDIT(float3, MSG_VE_JERK, &planner.max_jerk[E_AXIS], 1, 990);
3764 3768
 

+ 68
- 31
Marlin/src/module/configuration_store.cpp Vedi File

@@ -37,7 +37,7 @@
37 37
  */
38 38
 
39 39
 // Change EEPROM version if the structure changes
40
-#define EEPROM_VERSION "V54"
40
+#define EEPROM_VERSION "V55"
41 41
 #define EEPROM_OFFSET 100
42 42
 
43 43
 // Check the integrity of data offsets.
@@ -112,16 +112,17 @@ typedef struct SettingsDataStruct {
112 112
   //
113 113
   uint8_t   esteppers;                                  // XYZE_N - XYZ
114 114
 
115
+  uint32_t  planner_max_acceleration_mm_per_s2[XYZE_N], // M201 XYZE  planner.max_acceleration_mm_per_s2[XYZE_N]
116
+            planner_min_segment_time_us;                // M205 B     planner.min_segment_time_us
115 117
   float     planner_axis_steps_per_mm[XYZE_N],          // M92 XYZE   planner.axis_steps_per_mm[XYZE_N]
116
-            planner_max_feedrate_mm_s[XYZE_N];          // M203 XYZE  planner.max_feedrate_mm_s[XYZE_N]
117
-  uint32_t  planner_max_acceleration_mm_per_s2[XYZE_N]; // M201 XYZE  planner.max_acceleration_mm_per_s2[XYZE_N]
118
-  float     planner_acceleration,                       // M204 P     planner.acceleration
118
+            planner_max_feedrate_mm_s[XYZE_N],          // M203 XYZE  planner.max_feedrate_mm_s[XYZE_N]
119
+            planner_acceleration,                       // M204 P     planner.acceleration
119 120
             planner_retract_acceleration,               // M204 R     planner.retract_acceleration
120 121
             planner_travel_acceleration,                // M204 T     planner.travel_acceleration
121 122
             planner_min_feedrate_mm_s,                  // M205 S     planner.min_feedrate_mm_s
122
-            planner_min_travel_feedrate_mm_s;           // M205 T     planner.min_travel_feedrate_mm_s
123
-  uint32_t  planner_min_segment_time_us;                // M205 B     planner.min_segment_time_us
124
-  float     planner_max_jerk[XYZE];                     // M205 XYZE  planner.max_jerk[XYZE]
123
+            planner_min_travel_feedrate_mm_s,           // M205 T     planner.min_travel_feedrate_mm_s
124
+            planner_max_jerk[XYZE],                     // M205 XYZE  planner.max_jerk[XYZE]
125
+            planner_junction_deviation_mm;              // M205 J     planner.junction_deviation_mm
125 126
 
126 127
   float home_offset[XYZ];                               // M206 XYZ
127 128
 
@@ -401,18 +402,24 @@ void MarlinSettings::postprocess() {
401 402
     const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ;
402 403
     EEPROM_WRITE(esteppers);
403 404
 
405
+    EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
406
+    EEPROM_WRITE(planner.min_segment_time_us);
404 407
     EEPROM_WRITE(planner.axis_steps_per_mm);
405 408
     EEPROM_WRITE(planner.max_feedrate_mm_s);
406
-    EEPROM_WRITE(planner.max_acceleration_mm_per_s2);
407
-
408 409
     EEPROM_WRITE(planner.acceleration);
409 410
     EEPROM_WRITE(planner.retract_acceleration);
410 411
     EEPROM_WRITE(planner.travel_acceleration);
411 412
     EEPROM_WRITE(planner.min_feedrate_mm_s);
412 413
     EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
413
-    EEPROM_WRITE(planner.min_segment_time_us);
414 414
     EEPROM_WRITE(planner.max_jerk);
415 415
 
416
+    #if ENABLED(JUNCTION_DEVIATION)
417
+      EEPROM_WRITE(planner.junction_deviation_mm);
418
+    #else
419
+      dummy = 0.02;
420
+      EEPROM_WRITE(dummy);
421
+    #endif
422
+
416 423
     _FIELD_TEST(home_offset);
417 424
 
418 425
     #if !HAS_HOME_OFFSET
@@ -980,17 +987,20 @@ void MarlinSettings::postprocess() {
980 987
 
981 988
       // Get only the number of E stepper parameters previously stored
982 989
       // Any steppers added later are set to their defaults
983
-      const float def1[] = DEFAULT_AXIS_STEPS_PER_UNIT, def2[] = DEFAULT_MAX_FEEDRATE;
984
-      const uint32_t def3[] = DEFAULT_MAX_ACCELERATION;
985
-      float tmp1[XYZ + esteppers], tmp2[XYZ + esteppers];
986
-      uint32_t tmp3[XYZ + esteppers];
987
-      EEPROM_READ(tmp1);
988
-      EEPROM_READ(tmp2);
989
-      EEPROM_READ(tmp3);
990
+      const uint32_t def1[] = DEFAULT_MAX_ACCELERATION;
991
+      const float def2[] = DEFAULT_AXIS_STEPS_PER_UNIT, def3[] = DEFAULT_MAX_FEEDRATE;
992
+
993
+      uint32_t tmp1[XYZ + esteppers];
994
+      EEPROM_READ(tmp1);                         // max_acceleration_mm_per_s2
995
+      EEPROM_READ(planner.min_segment_time_us);
996
+
997
+      float tmp2[XYZ + esteppers], tmp3[XYZ + esteppers];
998
+      EEPROM_READ(tmp2);                         // axis_steps_per_mm
999
+      EEPROM_READ(tmp3);                         // max_feedrate_mm_s
990 1000
       if (!validating) LOOP_XYZE_N(i) {
991
-        planner.axis_steps_per_mm[i]          = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1];
992
-        planner.max_feedrate_mm_s[i]          = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1];
993
-        planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1];
1001
+        planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1];
1002
+        planner.axis_steps_per_mm[i]          = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1];
1003
+        planner.max_feedrate_mm_s[i]          = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1];
994 1004
       }
995 1005
 
996 1006
       EEPROM_READ(planner.acceleration);
@@ -998,9 +1008,14 @@ void MarlinSettings::postprocess() {
998 1008
       EEPROM_READ(planner.travel_acceleration);
999 1009
       EEPROM_READ(planner.min_feedrate_mm_s);
1000 1010
       EEPROM_READ(planner.min_travel_feedrate_mm_s);
1001
-      EEPROM_READ(planner.min_segment_time_us);
1002 1011
       EEPROM_READ(planner.max_jerk);
1003 1012
 
1013
+      #if ENABLED(JUNCTION_DEVIATION)
1014
+        EEPROM_READ(planner.junction_deviation_mm);
1015
+      #else
1016
+        EEPROM_READ(dummy);
1017
+      #endif
1018
+
1004 1019
       //
1005 1020
       // Home Offset (M206)
1006 1021
       //
@@ -1518,9 +1533,9 @@ void MarlinSettings::postprocess() {
1518 1533
 
1519 1534
       #if ENABLED(AUTO_BED_LEVELING_UBL)
1520 1535
         if (!validating) {
1521
-            ubl.report_state();
1536
+          ubl.report_state();
1522 1537
 
1523
-            if (!ubl.sanity_check()) {
1538
+          if (!ubl.sanity_check()) {
1524 1539
             SERIAL_EOL_P(port);
1525 1540
             #if ENABLED(EEPROM_CHITCHAT)
1526 1541
               ubl.echo_name();
@@ -1703,17 +1718,21 @@ void MarlinSettings::reset(PORTARG_SOLO) {
1703 1718
     planner.max_acceleration_mm_per_s2[i] = pgm_read_dword_near(&tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1]);
1704 1719
   }
1705 1720
 
1721
+  planner.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
1706 1722
   planner.acceleration = DEFAULT_ACCELERATION;
1707 1723
   planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
1708 1724
   planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
1709 1725
   planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
1710 1726
   planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
1711
-  planner.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
1712 1727
   planner.max_jerk[X_AXIS] = DEFAULT_XJERK;
1713 1728
   planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
1714 1729
   planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK;
1715 1730
   planner.max_jerk[E_AXIS] = DEFAULT_EJERK;
1716 1731
 
1732
+  #if ENABLED(JUNCTION_DEVIATION)
1733
+    planner.junction_deviation_mm = JUNCTION_DEVIATION_MM;
1734
+  #endif
1735
+
1717 1736
   #if HAS_HOME_OFFSET
1718 1737
     ZERO(home_offset);
1719 1738
   #endif
@@ -2094,16 +2113,34 @@ void MarlinSettings::reset(PORTARG_SOLO) {
2094 2113
 
2095 2114
     if (!forReplay) {
2096 2115
       CONFIG_ECHO_START;
2097
-      SERIAL_ECHOLNPGM_P(port, "Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_us> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>");
2116
+      SERIAL_ECHOPGM_P(port, "Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate>");
2117
+      #if ENABLED(JUNCTION_DEVIATION)
2118
+        SERIAL_ECHOPGM_P(port, " J<junc_dev>");
2119
+      #else
2120
+        SERIAL_ECHOPGM_P(port, " X<max_x_jerk> Y<max_y_jerk> Z<max_z_jerk>");
2121
+      #endif
2122
+      #if DISABLED(JUNCTION_DEVIATION) || ENABLED(LIN_ADVANCE)
2123
+        SERIAL_ECHOPGM_P(port, " E<max_e_jerk>");
2124
+      #endif
2125
+      SERIAL_EOL_P(port);
2098 2126
     }
2099 2127
     CONFIG_ECHO_START;
2100
-    SERIAL_ECHOPAIR_P(port, "  M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s));
2128
+    SERIAL_ECHOPAIR_P(port, "  M205 B", LINEAR_UNIT(planner.min_segment_time_us));
2129
+    SERIAL_ECHOPAIR_P(port, " S", LINEAR_UNIT(planner.min_feedrate_mm_s));
2101 2130
     SERIAL_ECHOPAIR_P(port, " T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s));
2102
-    SERIAL_ECHOPAIR_P(port, " B", planner.min_segment_time_us);
2103
-    SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
2104
-    SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
2105
-    SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));
2106
-    SERIAL_ECHOLNPAIR_P(port, " E", LINEAR_UNIT(planner.max_jerk[E_AXIS]));
2131
+
2132
+    #if ENABLED(JUNCTION_DEVIATION)
2133
+      SERIAL_ECHOPAIR_P(port, " J", LINEAR_UNIT(planner.junction_deviation_mm));
2134
+    #else
2135
+      SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
2136
+      SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
2137
+      SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));
2138
+    #endif
2139
+    #if DISABLED(JUNCTION_DEVIATION) || ENABLED(LIN_ADVANCE)
2140
+      SERIAL_ECHOPAIR_P(port, " E", LINEAR_UNIT(planner.max_jerk[E_AXIS]));
2141
+    #endif
2142
+
2143
+    SERIAL_EOL_P(port);
2107 2144
 
2108 2145
     #if HAS_M206_COMMAND
2109 2146
       if (!forReplay) {

+ 18
- 17
Marlin/src/module/planner.cpp Vedi File

@@ -110,9 +110,23 @@ uint16_t Planner::cleaning_buffer_counter;    // A counter to disable queuing of
110 110
 uint8_t Planner::delay_before_delivering,     // This counter delays delivery of blocks when queue becomes empty to allow the opportunity of merging blocks
111 111
         Planner::block_buffer_planned;        // Index of the optimally planned block
112 112
 
113
-float Planner::max_feedrate_mm_s[XYZE_N],   // Max speeds in mm per second
114
-      Planner::axis_steps_per_mm[XYZE_N],
115
-      Planner::steps_to_mm[XYZE_N];
113
+uint32_t Planner::max_acceleration_mm_per_s2[XYZE_N],    // (mm/s^2) M201 XYZE
114
+         Planner::max_acceleration_steps_per_s2[XYZE_N], // (steps/s^2) Derived from mm_per_s2
115
+         Planner::min_segment_time_us;                   // (µs) M205 B
116
+
117
+float Planner::max_feedrate_mm_s[XYZE_N],     // (mm/s) M203 XYZE - Max speeds
118
+      Planner::axis_steps_per_mm[XYZE_N],     // (steps) M92 XYZE - Steps per millimeter
119
+      Planner::steps_to_mm[XYZE_N],           // (mm) Millimeters per step
120
+      Planner::min_feedrate_mm_s,             // (mm/s) M205 S - Minimum linear feedrate
121
+      Planner::acceleration,                  // (mm/s^2) M204 S - Normal acceleration. DEFAULT ACCELERATION for all printing moves.
122
+      Planner::retract_acceleration,          // (mm/s^2) M204 R - Retract acceleration. Filament pull-back and push-forward while standing still in the other axes
123
+      Planner::travel_acceleration,           // (mm/s^2) M204 T - Travel acceleration. DEFAULT ACCELERATION for all NON printing moves.
124
+      Planner::max_jerk[XYZE],                // (mm/s^2) M205 XYZE - The largest speed change requiring no acceleration.
125
+      Planner::min_travel_feedrate_mm_s;      // (mm/s) M205 T - Minimum travel feedrate
126
+
127
+#if ENABLED(JUNCTION_DEVIATION)
128
+  float Planner::junction_deviation_mm;       // (mm) M205 J
129
+#endif
116 130
 
117 131
 #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
118 132
   bool Planner::abort_on_endstop_hit = false;
@@ -132,19 +146,6 @@ float Planner::e_factor[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(1.0); // The flow perce
132 146
         Planner::volumetric_multiplier[EXTRUDERS];  // Reciprocal of cross-sectional area of filament (in mm^2). Pre-calculated to reduce computation in the planner
133 147
 #endif
134 148
 
135
-uint32_t Planner::max_acceleration_steps_per_s2[XYZE_N],
136
-         Planner::max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override by software
137
-
138
-uint32_t Planner::min_segment_time_us;
139
-
140
-// Initialized by settings.load()
141
-float Planner::min_feedrate_mm_s,
142
-      Planner::acceleration,         // Normal acceleration mm/s^2  DEFAULT ACCELERATION for all printing moves. M204 SXXXX
143
-      Planner::retract_acceleration, // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX
144
-      Planner::travel_acceleration,  // Travel acceleration mm/s^2  DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX
145
-      Planner::max_jerk[XYZE],       // The largest speed change requiring no acceleration
146
-      Planner::min_travel_feedrate_mm_s;
147
-
148 149
 #if HAS_LEVELING
149 150
   bool Planner::leveling_active = false; // Flag that auto bed leveling is enabled
150 151
   #if ABL_PLANAR
@@ -2187,7 +2188,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move,
2187 2188
         const float junction_acceleration = limit_value_by_axis_maximum(block->acceleration, junction_unit_vec),
2188 2189
                     sin_theta_d2 = SQRT(0.5 * (1.0 - junction_cos_theta)); // Trig half angle identity. Always positive.
2189 2190
 
2190
-        vmax_junction_sqr = (junction_acceleration * JUNCTION_DEVIATION_MM * sin_theta_d2) / (1.0 - sin_theta_d2);
2191
+        vmax_junction_sqr = (junction_acceleration * junction_deviation_mm * sin_theta_d2) / (1.0 - sin_theta_d2);
2191 2192
         if (block->millimeters < 1.0) {
2192 2193
 
2193 2194
           // Fast acos approximation, minus the error bar to be safe

+ 13
- 10
Marlin/src/module/planner.h Vedi File

@@ -116,10 +116,10 @@ typedef struct {
116 116
            decelerate_after;                // The index of the step event on which to start decelerating
117 117
 
118 118
   #if ENABLED(S_CURVE_ACCELERATION)
119
-    uint32_t cruise_rate;                   // The actual cruise rate to use, between end of the acceleration phase and start of deceleration phase
120
-    uint32_t acceleration_time,             // Acceleration time and deceleration time in STEP timer counts
121
-             deceleration_time;
122
-    uint32_t acceleration_time_inverse,     // Inverse of acceleration and deceleration periods, expressed as integer. Scale depends on CPU being used
119
+    uint32_t cruise_rate,                   // The actual cruise rate to use, between end of the acceleration phase and start of deceleration phase
120
+             acceleration_time,             // Acceleration time and deceleration time in STEP timer counts
121
+             deceleration_time,
122
+             acceleration_time_inverse,     // Inverse of acceleration and deceleration periods, expressed as integer. Scale depends on CPU being used
123 123
              deceleration_time_inverse;
124 124
   #else
125 125
     uint32_t acceleration_rate;             // The acceleration rate used for acceleration calculation
@@ -195,20 +195,23 @@ class Planner {
195 195
                                                       // May be auto-adjusted by a filament width sensor
196 196
     #endif
197 197
 
198
+    static uint32_t max_acceleration_steps_per_s2[XYZE_N],
199
+                    max_acceleration_mm_per_s2[XYZE_N], // Use M201 to override
200
+                    min_segment_time_us; // Use 'M205 B<µs>' to override
198 201
     static float max_feedrate_mm_s[XYZE_N],         // Max speeds in mm per second
199 202
                  axis_steps_per_mm[XYZE_N],
200
-                 steps_to_mm[XYZE_N];
201
-    static uint32_t max_acceleration_steps_per_s2[XYZE_N],
202
-                    max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override
203
-
204
-    static uint32_t min_segment_time_us; // Use 'M205 B<µs>' to override
205
-    static float min_feedrate_mm_s,
203
+                 steps_to_mm[XYZE_N],
204
+                 min_feedrate_mm_s,
206 205
                  acceleration,         // Normal acceleration mm/s^2  DEFAULT ACCELERATION for all printing moves. M204 SXXXX
207 206
                  retract_acceleration, // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX
208 207
                  travel_acceleration,  // Travel acceleration mm/s^2  DEFAULT ACCELERATION for all NON printing moves. M204 MXXXX
209 208
                  max_jerk[XYZE],       // The largest speed change requiring no acceleration
210 209
                  min_travel_feedrate_mm_s;
211 210
 
211
+    #if ENABLED(JUNCTION_DEVIATION)
212
+      static float junction_deviation_mm; // Initialized by EEPROM
213
+    #endif
214
+
212 215
     #if HAS_LEVELING
213 216
       static bool leveling_active;          // Flag that bed leveling is enabled
214 217
       #if ABL_PLANAR

Loading…
Annulla
Salva