SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Add/correct time units on planner vars / M205 B

Browse source
This commit is contained in:
Scott Lahteine 2017-10-29 18:21:15 -05:00
parent b2a48f1a04
commit 3e8754a38a
4 changed files with 39 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Marlin/src/gcode/config/M200-M205.cpp
View file

@ -121,7 +121,7 @@ void GcodeSuite::M204() {
void GcodeSuite::M205() { void GcodeSuite::M205() {
if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units(); if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units();
if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units(); if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units();
if (parser.seen('B')) planner.min_segment_time = parser.value_millis(); if (parser.seen('B')) planner.min_segment_time_us = parser.value_ulong();
if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units(); if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units();
if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units(); if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units();
if (parser.seen('Z')) planner.max_jerk[Z_AXIS] = parser.value_linear_units(); if (parser.seen('Z')) planner.max_jerk[Z_AXIS] = parser.value_linear_units();

14
Marlin/src/module/configuration_store.cpp
View file

@ -56,7 +56,7 @@
* 163 M204 T planner.travel_acceleration (float) * 163 M204 T planner.travel_acceleration (float)
* 167 M205 S planner.min_feedrate_mm_s (float) * 167 M205 S planner.min_feedrate_mm_s (float)
* 171 M205 T planner.min_travel_feedrate_mm_s (float) * 171 M205 T planner.min_travel_feedrate_mm_s (float)
* 175 M205 B planner.min_segment_time (ulong) * 175 M205 B planner.min_segment_time_us (ulong)
* 179 M205 X planner.max_jerk[X_AXIS] (float) * 179 M205 X planner.max_jerk[X_AXIS] (float)
* 183 M205 Y planner.max_jerk[Y_AXIS] (float) * 183 M205 Y planner.max_jerk[Y_AXIS] (float)
* 187 M205 Z planner.max_jerk[Z_AXIS] (float) * 187 M205 Z planner.max_jerk[Z_AXIS] (float)
@ -68,7 +68,7 @@
* 219 z_fade_height (float) * 219 z_fade_height (float)
* *
* MESH_BED_LEVELING: 43 bytes * MESH_BED_LEVELING: 43 bytes
* 223 M420 S planner.leveling_active (bool) * 223 M420 S planner.leveling_active (bool)
* 224 mbl.z_offset (float) * 224 mbl.z_offset (float)
* 228 GRID_MAX_POINTS_X (uint8_t) * 228 GRID_MAX_POINTS_X (uint8_t)
* 229 GRID_MAX_POINTS_Y (uint8_t) * 229 GRID_MAX_POINTS_Y (uint8_t)
@ -305,7 +305,7 @@ void MarlinSettings::postprocess() {
EEPROM_WRITE(planner.travel_acceleration); EEPROM_WRITE(planner.travel_acceleration);
EEPROM_WRITE(planner.min_feedrate_mm_s); EEPROM_WRITE(planner.min_feedrate_mm_s);
EEPROM_WRITE(planner.min_travel_feedrate_mm_s); EEPROM_WRITE(planner.min_travel_feedrate_mm_s);
EEPROM_WRITE(planner.min_segment_time); EEPROM_WRITE(planner.min_segment_time_us);
EEPROM_WRITE(planner.max_jerk); EEPROM_WRITE(planner.max_jerk);
#if !HAS_HOME_OFFSET #if !HAS_HOME_OFFSET
const float home_offset[XYZ] = { 0 }; const float home_offset[XYZ] = { 0 };
@ -699,7 +699,7 @@ void MarlinSettings::postprocess() {
EEPROM_READ(planner.travel_acceleration); EEPROM_READ(planner.travel_acceleration);
EEPROM_READ(planner.min_feedrate_mm_s); EEPROM_READ(planner.min_feedrate_mm_s);
EEPROM_READ(planner.min_travel_feedrate_mm_s); EEPROM_READ(planner.min_travel_feedrate_mm_s);
EEPROM_READ(planner.min_segment_time); EEPROM_READ(planner.min_segment_time_us);
EEPROM_READ(planner.max_jerk); EEPROM_READ(planner.max_jerk);
#if !HAS_HOME_OFFSET #if !HAS_HOME_OFFSET
@ -1166,7 +1166,7 @@ void MarlinSettings::reset() {
planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION; planner.retract_acceleration = DEFAULT_RETRACT_ACCELERATION;
planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION; planner.travel_acceleration = DEFAULT_TRAVEL_ACCELERATION;
planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE; planner.min_feedrate_mm_s = DEFAULT_MINIMUMFEEDRATE;
planner.min_segment_time = DEFAULT_MINSEGMENTTIME; planner.min_segment_time_us = DEFAULT_MINSEGMENTTIME;
planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE; planner.min_travel_feedrate_mm_s = DEFAULT_MINTRAVELFEEDRATE;
planner.max_jerk[X_AXIS] = DEFAULT_XJERK; planner.max_jerk[X_AXIS] = DEFAULT_XJERK;
planner.max_jerk[Y_AXIS] = DEFAULT_YJERK; planner.max_jerk[Y_AXIS] = DEFAULT_YJERK;
@ -1504,12 +1504,12 @@ void MarlinSettings::reset() {
if (!forReplay) { if (!forReplay) {
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOLNPGM("Advanced: S<min_feedrate> T<min_travel_feedrate> B<min_segment_time_ms> X<max_xy_jerk> Z<max_z_jerk> E<max_e_jerk>"); SERIAL_ECHOLNPGM("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>");
} }
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s)); SERIAL_ECHOPAIR(" M205 S", LINEAR_UNIT(planner.min_feedrate_mm_s));
SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s)); SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s));
SERIAL_ECHOPAIR(" B", planner.min_segment_time); SERIAL_ECHOPAIR(" B", planner.min_segment_time_us);
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS])); SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS]));
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS])); SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS]));
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS])); SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS]));

50
Marlin/src/module/planner.cpp
View file

@ -112,7 +112,7 @@ float Planner::filament_size[EXTRUDERS], // As a baseline for the multip
uint32_t Planner::max_acceleration_steps_per_s2[XYZE_N], uint32_t Planner::max_acceleration_steps_per_s2[XYZE_N],
Planner::max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override by software Planner::max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override by software
millis_t Planner::min_segment_time; uint32_t Planner::min_segment_time_us;
// Initialized by settings.load() // Initialized by settings.load()
float Planner::min_feedrate_mm_s, float Planner::min_feedrate_mm_s,
@ -159,7 +159,7 @@ float Planner::previous_speed[NUM_AXIS],
// Old direction bits. Used for speed calculations // Old direction bits. Used for speed calculations
unsigned char Planner::old_direction_bits = 0; unsigned char Planner::old_direction_bits = 0;
// Segment times (in µs). Used for speed calculations // Segment times (in µs). Used for speed calculations
long Planner::axis_segment_time[2][3] = { {MAX_FREQ_TIME + 1, 0, 0}, {MAX_FREQ_TIME + 1, 0, 0} }; uint32_t Planner::axis_segment_time_us[2][3] = { { MAX_FREQ_TIME_US + 1, 0, 0 }, { MAX_FREQ_TIME_US + 1, 0, 0 } };
#endif #endif
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
@ -1057,15 +1057,15 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
// Slow down when the buffer starts to empty, rather than wait at the corner for a buffer refill // Slow down when the buffer starts to empty, rather than wait at the corner for a buffer refill
#if ENABLED(SLOWDOWN) || ENABLED(ULTRA_LCD) || defined(XY_FREQUENCY_LIMIT) #if ENABLED(SLOWDOWN) || ENABLED(ULTRA_LCD) || defined(XY_FREQUENCY_LIMIT)
// Segment time im micro seconds // Segment time im micro seconds
unsigned long segment_time = LROUND(1000000.0 / inverse_mm_s); uint32_t segment_time_us = LROUND(1000000.0 / inverse_mm_s);
#endif #endif
#if ENABLED(SLOWDOWN) #if ENABLED(SLOWDOWN)
if (WITHIN(moves_queued, 2, (BLOCK_BUFFER_SIZE) / 2 - 1)) { if (WITHIN(moves_queued, 2, (BLOCK_BUFFER_SIZE) / 2 - 1)) {
if (segment_time < min_segment_time) { if (segment_time_us < min_segment_time_us) {
// buffer is draining, add extra time. The amount of time added increases if the buffer is still emptied more. // buffer is draining, add extra time. The amount of time added increases if the buffer is still emptied more.
inverse_mm_s = 1000000.0 / (segment_time + LROUND(2 * (min_segment_time - segment_time) / moves_queued)); inverse_mm_s = 1000000.0 / (segment_time_us + LROUND(2 * (min_segment_time_us - segment_time_us) / moves_queued));
#if defined(XY_FREQUENCY_LIMIT) || ENABLED(ULTRA_LCD) #if defined(XY_FREQUENCY_LIMIT) || ENABLED(ULTRA_LCD)
segment_time = LROUND(1000000.0 / inverse_mm_s); segment_time_us = LROUND(1000000.0 / inverse_mm_s);
#endif #endif
} }
} }
@ -1073,7 +1073,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
CRITICAL_SECTION_START CRITICAL_SECTION_START
block_buffer_runtime_us += segment_time; block_buffer_runtime_us += segment_time_us;
CRITICAL_SECTION_END CRITICAL_SECTION_END
#endif #endif
@ -1130,34 +1130,34 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
// Check and limit the xy direction change frequency // Check and limit the xy direction change frequency
const unsigned char direction_change = block->direction_bits ^ old_direction_bits; const unsigned char direction_change = block->direction_bits ^ old_direction_bits;
old_direction_bits = block->direction_bits; old_direction_bits = block->direction_bits;
segment_time = LROUND((float)segment_time / speed_factor); segment_time_us = LROUND((float)segment_time_us / speed_factor);
long xs0 = axis_segment_time[X_AXIS][0], uint32_t xs0 = axis_segment_time_us[X_AXIS][0],
xs1 = axis_segment_time[X_AXIS][1], xs1 = axis_segment_time_us[X_AXIS][1],
xs2 = axis_segment_time[X_AXIS][2], xs2 = axis_segment_time_us[X_AXIS][2],
ys0 = axis_segment_time[Y_AXIS][0], ys0 = axis_segment_time_us[Y_AXIS][0],
ys1 = axis_segment_time[Y_AXIS][1], ys1 = axis_segment_time_us[Y_AXIS][1],
ys2 = axis_segment_time[Y_AXIS][2]; ys2 = axis_segment_time_us[Y_AXIS][2];
if (TEST(direction_change, X_AXIS)) { if (TEST(direction_change, X_AXIS)) {
xs2 = axis_segment_time[X_AXIS][2] = xs1; xs2 = axis_segment_time_us[X_AXIS][2] = xs1;
xs1 = axis_segment_time[X_AXIS][1] = xs0; xs1 = axis_segment_time_us[X_AXIS][1] = xs0;
xs0 = 0; xs0 = 0;
} }
xs0 = axis_segment_time[X_AXIS][0] = xs0 + segment_time; xs0 = axis_segment_time_us[X_AXIS][0] = xs0 + segment_time_us;
if (TEST(direction_change, Y_AXIS)) { if (TEST(direction_change, Y_AXIS)) {
ys2 = axis_segment_time[Y_AXIS][2] = axis_segment_time[Y_AXIS][1]; ys2 = axis_segment_time_us[Y_AXIS][2] = axis_segment_time_us[Y_AXIS][1];
ys1 = axis_segment_time[Y_AXIS][1] = axis_segment_time[Y_AXIS][0]; ys1 = axis_segment_time_us[Y_AXIS][1] = axis_segment_time_us[Y_AXIS][0];
ys0 = 0; ys0 = 0;
} }
ys0 = axis_segment_time[Y_AXIS][0] = ys0 + segment_time; ys0 = axis_segment_time_us[Y_AXIS][0] = ys0 + segment_time_us;
const long max_x_segment_time = MAX3(xs0, xs1, xs2), const uint32_t max_x_segment_time = MAX3(xs0, xs1, xs2),
max_y_segment_time = MAX3(ys0, ys1, ys2), max_y_segment_time = MAX3(ys0, ys1, ys2),
min_xy_segment_time = min(max_x_segment_time, max_y_segment_time); min_xy_segment_time = min(max_x_segment_time, max_y_segment_time);
if (min_xy_segment_time < MAX_FREQ_TIME) { if (min_xy_segment_time < MAX_FREQ_TIME_US) {
const float low_sf = speed_factor * min_xy_segment_time / (MAX_FREQ_TIME); const float low_sf = speed_factor * min_xy_segment_time / (MAX_FREQ_TIME_US);
NOMORE(speed_factor, low_sf); NOMORE(speed_factor, low_sf);
} }
#endif // XY_FREQUENCY_LIMIT #endif // XY_FREQUENCY_LIMIT

12
Marlin/src/module/planner.h
View file

@ -123,7 +123,7 @@ typedef struct {
uint8_t valve_pressure, e_to_p_pressure; uint8_t valve_pressure, e_to_p_pressure;
#endif #endif
uint32_t segment_time; uint32_t segment_time_us;
} block_t; } block_t;
@ -154,9 +154,9 @@ class Planner {
axis_steps_per_mm[XYZE_N], axis_steps_per_mm[XYZE_N],
steps_to_mm[XYZE_N]; steps_to_mm[XYZE_N];
static uint32_t max_acceleration_steps_per_s2[XYZE_N], static uint32_t max_acceleration_steps_per_s2[XYZE_N],
max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override by software max_acceleration_mm_per_s2[XYZE_N]; // Use M201 to override
static millis_t min_segment_time; static uint32_t min_segment_time_us; // Use 'M205 B<µs>' to override
static float min_feedrate_mm_s, static float min_feedrate_mm_s,
acceleration, // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX acceleration, // Normal acceleration mm/s^2 DEFAULT ACCELERATION for all printing moves. M204 SXXXX
retract_acceleration, // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX retract_acceleration, // Retract acceleration mm/s^2 filament pull-back and push-forward while standing still in the other axes M204 TXXXX
@ -214,11 +214,11 @@ class Planner {
#ifdef XY_FREQUENCY_LIMIT #ifdef XY_FREQUENCY_LIMIT
// Used for the frequency limit // Used for the frequency limit
#define MAX_FREQ_TIME long(1000000.0/XY_FREQUENCY_LIMIT) #define MAX_FREQ_TIME_US (uint32_t)(1000000.0 / XY_FREQUENCY_LIMIT)
// Old direction bits. Used for speed calculations // Old direction bits. Used for speed calculations
static unsigned char old_direction_bits; static unsigned char old_direction_bits;
// Segment times (in µs). Used for speed calculations // Segment times (in µs). Used for speed calculations
static long axis_segment_time[2][3]; static long axis_segment_time_us[2][3];
#endif #endif
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
@ -439,7 +439,7 @@ class Planner {
if (blocks_queued()) { if (blocks_queued()) {
block_t* block = &block_buffer[block_buffer_tail]; block_t* block = &block_buffer[block_buffer_tail];
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
block_buffer_runtime_us -= block->segment_time; //We can't be sure how long an active block will take, so don't count it. block_buffer_runtime_us -= block->segment_time_us; //We can't be sure how long an active block will take, so don't count it.
#endif #endif
SBI(block->flag, BLOCK_BIT_BUSY); SBI(block->flag, BLOCK_BIT_BUSY);
return block; return block;