2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2016-03-24 18:01:20 +00:00
|
|
|
* Marlin 3D Printer Firmware
|
|
|
|
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
2015-05-17 08:44:53 +00:00
|
|
|
*
|
|
|
|
* 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 <http://www.gnu.org/licenses/>.
|
2016-03-24 18:01:20 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2015-05-17 08:44:53 +00:00
|
|
|
* About Marlin
|
|
|
|
*
|
|
|
|
* This firmware is a mashup between Sprinter and grbl.
|
|
|
|
* - https://github.com/kliment/Sprinter
|
|
|
|
* - https://github.com/simen/grbl/tree
|
|
|
|
*
|
|
|
|
* It has preliminary support for Matthew Roberts advance algorithm
|
|
|
|
* - http://reprap.org/pipermail/reprap-dev/2011-May/003323.html
|
2012-11-06 11:06:41 +00:00
|
|
|
*/
|
2012-11-21 19:53:56 +00:00
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
2016-11-19 03:54:38 +00:00
|
|
|
* -----------------
|
|
|
|
* G-Codes in Marlin
|
|
|
|
* -----------------
|
|
|
|
*
|
|
|
|
* Helpful G-code references:
|
2015-04-14 00:17:36 +00:00
|
|
|
* - http://linuxcnc.org/handbook/gcode/g-code.html
|
|
|
|
* - http://objects.reprap.org/wiki/Mendel_User_Manual:_RepRapGCodes
|
|
|
|
*
|
2016-11-19 03:54:38 +00:00
|
|
|
* Help to document Marlin's G-codes online:
|
2015-04-14 00:17:36 +00:00
|
|
|
* - http://reprap.org/wiki/G-code
|
2016-11-19 03:54:38 +00:00
|
|
|
* - https://github.com/MarlinFirmware/MarlinDocumentation
|
2015-05-17 08:44:53 +00:00
|
|
|
*
|
|
|
|
* -----------------
|
2015-04-14 00:17:36 +00:00
|
|
|
*
|
|
|
|
* "G" Codes
|
|
|
|
*
|
|
|
|
* G0 -> G1
|
|
|
|
* G1 - Coordinated Movement X Y Z E
|
|
|
|
* G2 - CW ARC
|
|
|
|
* G3 - CCW ARC
|
|
|
|
* G4 - Dwell S<seconds> or P<milliseconds>
|
2016-05-19 19:00:12 +00:00
|
|
|
* G5 - Cubic B-spline with XYZE destination and IJPQ offsets
|
2016-06-16 04:18:44 +00:00
|
|
|
* G10 - Retract filament according to settings of M207
|
|
|
|
* G11 - Retract recover filament according to settings of M208
|
|
|
|
* G12 - Clean tool
|
2016-05-31 15:26:08 +00:00
|
|
|
* G20 - Set input units to inches
|
|
|
|
* G21 - Set input units to millimeters
|
2015-04-14 00:17:36 +00:00
|
|
|
* G28 - Home one or more axes
|
2015-08-20 14:07:55 +00:00
|
|
|
* G29 - Detailed Z probe, probes the bed at 3 or more points. Will fail if you haven't homed yet.
|
2016-11-05 10:08:41 +00:00
|
|
|
* G30 - Single Z probe, probes bed at X Y location (defaults to current XY location)
|
2015-04-14 00:17:36 +00:00
|
|
|
* G31 - Dock sled (Z_PROBE_SLED only)
|
|
|
|
* G32 - Undock sled (Z_PROBE_SLED only)
|
2016-09-26 06:30:34 +00:00
|
|
|
* G38 - Probe target - similar to G28 except it uses the Z_MIN endstop for all three axes
|
2015-04-14 00:17:36 +00:00
|
|
|
* G90 - Use Absolute Coordinates
|
|
|
|
* G91 - Use Relative Coordinates
|
|
|
|
* G92 - Set current position to coordinates given
|
|
|
|
*
|
|
|
|
* "M" Codes
|
|
|
|
*
|
|
|
|
* M0 - Unconditional stop - Wait for user to press a button on the LCD (Only if ULTRA_LCD is enabled)
|
|
|
|
* M1 - Same as M0
|
|
|
|
* M17 - Enable/Power all stepper motors
|
|
|
|
* M18 - Disable all stepper motors; same as M84
|
2016-09-25 12:50:11 +00:00
|
|
|
* M20 - List SD card. (Requires SDSUPPORT)
|
|
|
|
* M21 - Init SD card. (Requires SDSUPPORT)
|
|
|
|
* M22 - Release SD card. (Requires SDSUPPORT)
|
|
|
|
* M23 - Select SD file: "M23 /path/file.gco". (Requires SDSUPPORT)
|
|
|
|
* M24 - Start/resume SD print. (Requires SDSUPPORT)
|
|
|
|
* M25 - Pause SD print. (Requires SDSUPPORT)
|
|
|
|
* M26 - Set SD position in bytes: "M26 S12345". (Requires SDSUPPORT)
|
|
|
|
* M27 - Report SD print status. (Requires SDSUPPORT)
|
|
|
|
* M28 - Start SD write: "M28 /path/file.gco". (Requires SDSUPPORT)
|
|
|
|
* M29 - Stop SD write. (Requires SDSUPPORT)
|
|
|
|
* M30 - Delete file from SD: "M30 /path/file.gco"
|
|
|
|
* M31 - Report time since last M109 or SD card start to serial.
|
|
|
|
* M32 - Select file and start SD print: "M32 [S<bytepos>] !/path/file.gco#". (Requires SDSUPPORT)
|
|
|
|
* Use P to run other files as sub-programs: "M32 P !filename#"
|
2015-04-14 00:17:36 +00:00
|
|
|
* The '#' is necessary when calling from within sd files, as it stops buffer prereading
|
2016-09-25 12:50:11 +00:00
|
|
|
* M33 - Get the longname version of a path. (Requires LONG_FILENAME_HOST_SUPPORT)
|
|
|
|
* M42 - Change pin status via gcode: M42 P<pin> S<value>. LED pin assumed if P is omitted.
|
2016-10-29 18:42:43 +00:00
|
|
|
* M43 - Monitor pins & report changes - report active pins
|
2016-09-25 12:50:11 +00:00
|
|
|
* M48 - Measure Z Probe repeatability: M48 P<points> X<pos> Y<pos> V<level> E<engage> L<legs>. (Requires Z_MIN_PROBE_REPEATABILITY_TEST)
|
|
|
|
* M75 - Start the print job timer.
|
|
|
|
* M76 - Pause the print job timer.
|
|
|
|
* M77 - Stop the print job timer.
|
|
|
|
* M78 - Show statistical information about the print jobs. (Requires PRINTCOUNTER)
|
|
|
|
* M80 - Turn on Power Supply. (Requires POWER_SUPPLY)
|
|
|
|
* M81 - Turn off Power Supply. (Requires POWER_SUPPLY)
|
|
|
|
* M82 - Set E codes absolute (default).
|
|
|
|
* M83 - Set E codes relative while in Absolute (G90) mode.
|
|
|
|
* M84 - Disable steppers until next move, or use S<seconds> to specify an idle
|
|
|
|
* duration after which steppers should turn off. S0 disables the timeout.
|
2015-04-14 00:17:36 +00:00
|
|
|
* M85 - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M92 - Set planner.axis_steps_per_mm for one or more axes.
|
|
|
|
* M104 - Set extruder target temp.
|
|
|
|
* M105 - Report current temperatures.
|
|
|
|
* M106 - Fan on.
|
|
|
|
* M107 - Fan off.
|
|
|
|
* M108 - Break out of heating loops (M109, M190, M303). With no controller, breaks out of M0/M1. (Requires EMERGENCY_PARSER)
|
2015-04-14 00:17:36 +00:00
|
|
|
* M109 - Sxxx Wait for extruder current temp to reach target temp. Waits only when heating
|
|
|
|
* Rxxx Wait for extruder current temp to reach target temp. Waits when heating and cooling
|
2016-11-30 01:51:13 +00:00
|
|
|
* If AUTOTEMP is enabled, S<mintemp> B<maxtemp> F<factor>. Exit autotemp by any M109 without F
|
2016-09-25 12:50:11 +00:00
|
|
|
* M110 - Set the current line number. (Used by host printing)
|
|
|
|
* M111 - Set debug flags: "M111 S<flagbits>". See flag bits defined in enum.h.
|
|
|
|
* M112 - Emergency stop.
|
|
|
|
* M113 - Get or set the timeout interval for Host Keepalive "busy" messages. (Requires HOST_KEEPALIVE_FEATURE)
|
|
|
|
* M114 - Report current position.
|
2016-11-09 00:05:59 +00:00
|
|
|
* M115 - Report capabilities. (Extended capabilities requires EXTENDED_CAPABILITIES_REPORT)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M117 - Display a message on the controller screen. (Requires an LCD)
|
|
|
|
* M119 - Report endstops status.
|
|
|
|
* M120 - Enable endstops detection.
|
|
|
|
* M121 - Disable endstops detection.
|
|
|
|
* M126 - Solenoid Air Valve Open. (Requires BARICUDA)
|
|
|
|
* M127 - Solenoid Air Valve Closed. (Requires BARICUDA)
|
|
|
|
* M128 - EtoP Open. (Requires BARICUDA)
|
|
|
|
* M129 - EtoP Closed. (Requires BARICUDA)
|
|
|
|
* M140 - Set bed target temp. S<temp>
|
|
|
|
* M145 - Set heatup values for materials on the LCD. H<hotend> B<bed> F<fan speed> for S<material> (0=PLA, 1=ABS)
|
|
|
|
* M149 - Set temperature units. (Requires TEMPERATURE_UNITS_SUPPORT)
|
2016-11-30 01:51:13 +00:00
|
|
|
* M150 - Set Status LED Color as R<red> U<green> B<blue>. Values 0-255. (Requires BLINKM or RGB_LED)
|
2016-11-09 00:03:40 +00:00
|
|
|
* M155 - Auto-report temperatures with interval of S<seconds>. (Requires AUTO_REPORT_TEMPERATURES)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M163 - Set a single proportion for a mixing extruder. (Requires MIXING_EXTRUDER)
|
|
|
|
* M164 - Save the mix as a virtual extruder. (Requires MIXING_EXTRUDER and MIXING_VIRTUAL_TOOLS)
|
|
|
|
* M165 - Set the proportions for a mixing extruder. Use parameters ABCDHI to set the mixing factors. (Requires MIXING_EXTRUDER)
|
|
|
|
* M190 - Sxxx Wait for bed current temp to reach target temp. ** Waits only when heating! **
|
|
|
|
* Rxxx Wait for bed current temp to reach target temp. ** Waits for heating or cooling. **
|
2016-07-04 03:08:22 +00:00
|
|
|
* M200 - Set filament diameter, D<diameter>, setting E axis units to cubic. (Use S0 to revert to linear units.)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M201 - Set max acceleration in units/s^2 for print moves: "M201 X<accel> Y<accel> Z<accel> E<accel>"
|
|
|
|
* M202 - Set max acceleration in units/s^2 for travel moves: "M202 X<accel> Y<accel> Z<accel> E<accel>" ** UNUSED IN MARLIN! **
|
|
|
|
* M203 - Set maximum feedrate: "M203 X<fr> Y<fr> Z<fr> E<fr>" in units/sec.
|
|
|
|
* M204 - Set default acceleration in units/sec^2: P<printing> R<extruder_only> T<travel>
|
2016-07-04 03:08:22 +00:00
|
|
|
* M205 - Set advanced settings. Current units apply:
|
|
|
|
S<print> T<travel> minimum speeds
|
|
|
|
B<minimum segment time>
|
2016-10-03 06:54:15 +00:00
|
|
|
X<max X jerk>, Y<max Y jerk>, Z<max Z jerk>, E<max E jerk>
|
2016-09-25 12:50:11 +00:00
|
|
|
* M206 - Set additional homing offset.
|
|
|
|
* M207 - Set Retract Length: S<length>, Feedrate: F<units/min>, and Z lift: Z<distance>. (Requires FWRETRACT)
|
|
|
|
* M208 - Set Recover (unretract) Additional (!) Length: S<length> and Feedrate: F<units/min>. (Requires FWRETRACT)
|
|
|
|
* M209 - Turn Automatic Retract Detection on/off: S<0|1> (For slicers that don't support G10/11). (Requires FWRETRACT)
|
2016-07-04 03:08:22 +00:00
|
|
|
Every normal extrude-only move will be classified as retract depending on the direction.
|
2016-09-25 12:50:11 +00:00
|
|
|
* M211 - Enable, Disable, and/or Report software endstops: S<0|1>
|
|
|
|
* M218 - Set a tool offset: "M218 T<index> X<offset> Y<offset>". (Requires 2 or more extruders)
|
|
|
|
* M220 - Set Feedrate Percentage: "M220 S<percent>" (i.e., "FR" on the LCD)
|
|
|
|
* M221 - Set Flow Percentage: "M221 S<percent>"
|
|
|
|
* M226 - Wait until a pin is in a given state: "M226 P<pin> S<state>"
|
|
|
|
* M240 - Trigger a camera to take a photograph. (Requires CHDK or PHOTOGRAPH_PIN)
|
|
|
|
* M250 - Set LCD contrast: "M250 C<contrast>" (0-63). (Requires LCD support)
|
2016-11-08 22:28:42 +00:00
|
|
|
* M260 - i2c Send Data (Requires EXPERIMENTAL_I2CBUS)
|
|
|
|
* M261 - i2c Request Data (Requires EXPERIMENTAL_I2CBUS)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M280 - Set servo position absolute: "M280 P<index> S<angle|µs>". (Requires servos)
|
2015-04-14 00:17:36 +00:00
|
|
|
* M300 - Play beep sound S<frequency Hz> P<duration ms>
|
2016-09-25 12:50:11 +00:00
|
|
|
* M301 - Set PID parameters P I and D. (Requires PIDTEMP)
|
|
|
|
* M302 - Allow cold extrudes, or set the minimum extrude S<temperature>. (Requires PREVENT_COLD_EXTRUSION)
|
|
|
|
* M303 - PID relay autotune S<temperature> sets the target temperature. Default 150C. (Requires PIDTEMP)
|
|
|
|
* M304 - Set bed PID parameters P I and D. (Requires PIDTEMPBED)
|
2016-11-02 21:43:52 +00:00
|
|
|
* M355 - Turn the Case Light on/off and set its brightness. (Requires CASE_LIGHT_PIN)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M380 - Activate solenoid on active extruder. (Requires EXT_SOLENOID)
|
|
|
|
* M381 - Disable all solenoids. (Requires EXT_SOLENOID)
|
|
|
|
* M400 - Finish all moves.
|
|
|
|
* M401 - Lower Z probe. (Requires a probe)
|
|
|
|
* M402 - Raise Z probe. (Requires a probe)
|
|
|
|
* M404 - Display or set the Nominal Filament Width: "W<diameter>". (Requires FILAMENT_WIDTH_SENSOR)
|
|
|
|
* M405 - Enable Filament Sensor flow control. "M405 D<delay_cm>". (Requires FILAMENT_WIDTH_SENSOR)
|
|
|
|
* M406 - Disable Filament Sensor flow control. (Requires FILAMENT_WIDTH_SENSOR)
|
|
|
|
* M407 - Display measured filament diameter in millimeters. (Requires FILAMENT_WIDTH_SENSOR)
|
|
|
|
* M410 - Quickstop. Abort all planned moves.
|
2016-09-29 06:03:28 +00:00
|
|
|
* M420 - Enable/Disable Leveling (with current values) S1=enable S0=disable (Requires MESH_BED_LEVELING or ABL)
|
2016-09-25 12:50:11 +00:00
|
|
|
* M421 - Set a single Z coordinate in the Mesh Leveling grid. X<units> Y<units> Z<units> (Requires MESH_BED_LEVELING)
|
|
|
|
* M428 - Set the home_offset based on the current_position. Nearest edge applies.
|
|
|
|
* M500 - Store parameters in EEPROM. (Requires EEPROM_SETTINGS)
|
|
|
|
* M501 - Restore parameters from EEPROM. (Requires EEPROM_SETTINGS)
|
|
|
|
* M502 - Revert to the default "factory settings". ** Does not write them to EEPROM! **
|
|
|
|
* M503 - Print the current settings (in memory): "M503 S<verbose>". S0 specifies compact output.
|
|
|
|
* M540 - Enable/disable SD card abort on endstop hit: "M540 S<state>". (Requires ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
|
|
|
|
* M600 - Pause for filament change: "M600 X<pos> Y<pos> Z<raise> E<first_retract> L<later_retract>". (Requires FILAMENT_CHANGE_FEATURE)
|
|
|
|
* M665 - Set delta configurations: "M665 L<diagonal rod> R<delta radius> S<segments/s>" (Requires DELTA)
|
|
|
|
* M666 - Set delta endstop adjustment. (Requires DELTA)
|
|
|
|
* M605 - Set dual x-carriage movement mode: "M605 S<mode> [X<x_offset>] [R<temp_offset>]". (Requires DUAL_X_CARRIAGE)
|
|
|
|
* M851 - Set Z probe's Z offset in current units. (Negative = below the nozzle.)
|
|
|
|
* M907 - Set digital trimpot motor current using axis codes. (Requires a board with digital trimpots)
|
|
|
|
* M908 - Control digital trimpot directly. (Requires DAC_STEPPER_CURRENT or DIGIPOTSS_PIN)
|
|
|
|
* M909 - Print digipot/DAC current value. (Requires DAC_STEPPER_CURRENT)
|
|
|
|
* M910 - Commit digipot/DAC value to external EEPROM via I2C. (Requires DAC_STEPPER_CURRENT)
|
|
|
|
* M350 - Set microstepping mode. (Requires digital microstepping pins.)
|
|
|
|
* M351 - Toggle MS1 MS2 pins directly. (Requires digital microstepping pins.)
|
2015-04-14 00:17:36 +00:00
|
|
|
*
|
|
|
|
* ************ SCARA Specific - This can change to suit future G-code regulations
|
|
|
|
* M360 - SCARA calibration: Move to cal-position ThetaA (0 deg calibration)
|
|
|
|
* M361 - SCARA calibration: Move to cal-position ThetaB (90 deg calibration - steps per degree)
|
|
|
|
* M362 - SCARA calibration: Move to cal-position PsiA (0 deg calibration)
|
|
|
|
* M363 - SCARA calibration: Move to cal-position PsiB (90 deg calibration - steps per degree)
|
|
|
|
* M364 - SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
|
|
|
|
* ************* SCARA End ***************
|
|
|
|
*
|
2015-05-19 11:25:15 +00:00
|
|
|
* ************ Custom codes - This can change to suit future G-code regulations
|
2016-09-25 12:50:11 +00:00
|
|
|
* M100 - Watch Free Memory (For Debugging). (Requires M100_FREE_MEMORY_WATCHER)
|
|
|
|
* M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT)
|
2015-04-14 00:17:36 +00:00
|
|
|
* M999 - Restart after being stopped by error
|
2015-05-17 08:44:53 +00:00
|
|
|
*
|
|
|
|
* "T" Codes
|
|
|
|
*
|
2016-09-25 12:50:11 +00:00
|
|
|
* T0-T3 - Select an extruder (tool) by index: "T<n> F<units/min>"
|
2015-05-17 08:44:53 +00:00
|
|
|
*
|
2015-04-14 00:17:36 +00:00
|
|
|
*/
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-11-19 03:54:38 +00:00
|
|
|
#include "Marlin.h"
|
|
|
|
|
|
|
|
#include "ultralcd.h"
|
|
|
|
#include "planner.h"
|
|
|
|
#include "stepper.h"
|
|
|
|
#include "endstops.h"
|
|
|
|
#include "temperature.h"
|
|
|
|
#include "cardreader.h"
|
|
|
|
#include "configuration_store.h"
|
|
|
|
#include "language.h"
|
|
|
|
#include "pins_arduino.h"
|
|
|
|
#include "math.h"
|
|
|
|
#include "nozzle.h"
|
|
|
|
#include "duration_t.h"
|
|
|
|
#include "types.h"
|
|
|
|
|
|
|
|
#if HAS_ABL
|
|
|
|
#include "vector_3.h"
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_LINEAR)
|
|
|
|
#include "qr_solve.h"
|
|
|
|
#endif
|
|
|
|
#elif ENABLED(MESH_BED_LEVELING)
|
|
|
|
#include "mesh_bed_leveling.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
|
|
|
#include "planner_bezier.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
|
|
|
|
#include "buzzer.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(USE_WATCHDOG)
|
|
|
|
#include "watchdog.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(BLINKM)
|
|
|
|
#include "blinkm.h"
|
|
|
|
#include "Wire.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_SERVOS
|
|
|
|
#include "servo.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_DIGIPOTSS
|
|
|
|
#include <SPI.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(DAC_STEPPER_CURRENT)
|
|
|
|
#include "stepper_dac.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS)
|
|
|
|
#include "twibus.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
|
|
|
|
#include "endstop_interrupts.h"
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(M100_FREE_MEMORY_WATCHER)
|
2015-07-18 23:59:12 +00:00
|
|
|
void gcode_M100();
|
2015-07-06 00:42:13 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2015-01-30 02:52:21 +00:00
|
|
|
CardReader card;
|
2012-11-06 11:06:41 +00:00
|
|
|
#endif
|
2015-01-30 02:52:21 +00:00
|
|
|
|
2016-03-26 23:25:28 +00:00
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS)
|
|
|
|
TWIBus i2c;
|
|
|
|
#endif
|
|
|
|
|
2016-09-29 20:06:01 +00:00
|
|
|
#if ENABLED(G38_PROBE_TARGET)
|
2016-09-26 06:30:34 +00:00
|
|
|
bool G38_move = false,
|
|
|
|
G38_endstop_hit = false;
|
2016-09-19 19:17:10 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-08 07:56:19 +00:00
|
|
|
bool Running = true;
|
|
|
|
|
2016-03-30 02:18:45 +00:00
|
|
|
uint8_t marlin_debug_flags = DEBUG_NONE;
|
2015-04-27 03:08:45 +00:00
|
|
|
|
2016-10-05 02:32:37 +00:00
|
|
|
/**
|
|
|
|
* Cartesian Current Position
|
|
|
|
* Used to track the logical position as moves are queued.
|
|
|
|
* Used by 'line_to_current_position' to do a move after changing it.
|
|
|
|
* Used by 'SYNC_PLAN_POSITION_KINEMATIC' to update 'planner.position'.
|
|
|
|
*/
|
|
|
|
float current_position[XYZE] = { 0.0 };
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Cartesian Destination
|
|
|
|
* A temporary position, usually applied to 'current_position'.
|
|
|
|
* Set with 'gcode_get_destination' or 'set_destination_to_current'.
|
|
|
|
* 'line_to_destination' sets 'current_position' to 'destination'.
|
|
|
|
*/
|
|
|
|
static float destination[XYZE] = { 0.0 };
|
|
|
|
|
|
|
|
/**
|
|
|
|
* axis_homed
|
|
|
|
* Flags that each linear axis was homed.
|
|
|
|
* XYZ on cartesian, ABC on delta, ABZ on SCARA.
|
|
|
|
*
|
|
|
|
* axis_known_position
|
|
|
|
* Flags that the position is known in each linear axis. Set when homed.
|
|
|
|
* Cleared whenever a stepper powers off, potentially losing its position.
|
|
|
|
*/
|
|
|
|
bool axis_homed[XYZ] = { false }, axis_known_position[XYZ] = { false };
|
2015-04-08 07:56:19 +00:00
|
|
|
|
2016-10-05 02:32:37 +00:00
|
|
|
/**
|
|
|
|
* GCode line number handling. Hosts may opt to include line numbers when
|
|
|
|
* sending commands to Marlin, and lines will be checked for sequentiality.
|
|
|
|
* M110 S<int> sets the current line number.
|
|
|
|
*/
|
2015-04-08 07:56:19 +00:00
|
|
|
static long gcode_N, gcode_LastN, Stopped_gcode_LastN = 0;
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2016-10-05 02:32:37 +00:00
|
|
|
/**
|
|
|
|
* GCode Command Queue
|
|
|
|
* A simple ring buffer of BUFSIZE command strings.
|
|
|
|
*
|
|
|
|
* Commands are copied into this buffer by the command injectors
|
|
|
|
* (immediate, serial, sd card) and they are processed sequentially by
|
|
|
|
* the main loop. The process_next_command function parses the next
|
|
|
|
* command and hands off execution to individual handler functions.
|
|
|
|
*/
|
2015-04-14 00:17:36 +00:00
|
|
|
static char command_queue[BUFSIZE][MAX_CMD_SIZE];
|
2016-10-05 02:32:37 +00:00
|
|
|
static uint8_t cmd_queue_index_r = 0, // Ring buffer read position
|
|
|
|
cmd_queue_index_w = 0, // Ring buffer write position
|
|
|
|
commands_in_queue = 0; // Count of commands in the queue
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Current GCode Command
|
|
|
|
* When a GCode handler is running, these will be set
|
|
|
|
*/
|
|
|
|
static char *current_command, // The command currently being executed
|
|
|
|
*current_command_args, // The address where arguments begin
|
|
|
|
*seen_pointer; // Set by code_seen(), used by the code_value functions
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Next Injected Command pointer. NULL if no commands are being injected.
|
|
|
|
* Used by Marlin internally to ensure that commands initiated from within
|
|
|
|
* are enqueued ahead of any pending serial or sd card commands.
|
|
|
|
*/
|
|
|
|
static const char *injected_commands_P = NULL;
|
2015-04-08 07:56:19 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
2016-10-05 02:32:37 +00:00
|
|
|
float linear_unit_factor = 1.0, volumetric_unit_factor = 1.0;
|
2016-05-31 15:26:08 +00:00
|
|
|
#endif
|
2016-10-05 02:32:37 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
|
|
|
TempUnit input_temp_units = TEMPUNIT_C;
|
|
|
|
#endif
|
|
|
|
|
2016-07-16 01:49:34 +00:00
|
|
|
/**
|
|
|
|
* Feed rates are often configured with mm/m
|
|
|
|
* but the planner and stepper like mm/s units.
|
|
|
|
*/
|
2016-09-21 21:47:12 +00:00
|
|
|
float constexpr homing_feedrate_mm_s[] = {
|
2016-07-20 00:11:57 +00:00
|
|
|
#if ENABLED(DELTA)
|
2016-08-07 07:20:25 +00:00
|
|
|
MMM_TO_MMS(HOMING_FEEDRATE_Z), MMM_TO_MMS(HOMING_FEEDRATE_Z),
|
2016-07-20 00:11:57 +00:00
|
|
|
#else
|
2016-08-07 07:20:25 +00:00
|
|
|
MMM_TO_MMS(HOMING_FEEDRATE_XY), MMM_TO_MMS(HOMING_FEEDRATE_XY),
|
2016-07-20 00:11:57 +00:00
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
MMM_TO_MMS(HOMING_FEEDRATE_Z), 0
|
2016-07-20 00:11:57 +00:00
|
|
|
};
|
2016-08-07 07:20:25 +00:00
|
|
|
static float feedrate_mm_s = MMM_TO_MMS(1500.0), saved_feedrate_mm_s;
|
2016-10-05 02:32:37 +00:00
|
|
|
int feedrate_percentage = 100, saved_feedrate_percentage,
|
|
|
|
flow_percentage[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(100);
|
2016-04-28 16:57:21 +00:00
|
|
|
|
2016-10-05 02:32:37 +00:00
|
|
|
bool axis_relative_modes[] = AXIS_RELATIVE_MODES,
|
|
|
|
volumetric_enabled = false;
|
|
|
|
float filament_size[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_NOMINAL_FILAMENT_DIA),
|
|
|
|
volumetric_multiplier[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(1.0);
|
2016-03-24 10:55:18 +00:00
|
|
|
|
2016-04-18 06:13:07 +00:00
|
|
|
// The distance that XYZ has been offset by G92. Reset by G28.
|
2016-08-21 03:38:32 +00:00
|
|
|
float position_shift[XYZ] = { 0 };
|
2016-04-18 06:13:07 +00:00
|
|
|
|
|
|
|
// This offset is added to the configured home position.
|
|
|
|
// Set by M206, M428, or menu item. Saved to EEPROM.
|
2016-08-21 03:38:32 +00:00
|
|
|
float home_offset[XYZ] = { 0 };
|
2016-04-18 06:11:35 +00:00
|
|
|
|
2016-08-21 01:07:42 +00:00
|
|
|
// Software Endstops are based on the configured limits.
|
|
|
|
#if ENABLED(min_software_endstops) || ENABLED(max_software_endstops)
|
|
|
|
bool soft_endstops_enabled = true;
|
|
|
|
#endif
|
|
|
|
float soft_endstop_min[XYZ] = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS },
|
|
|
|
soft_endstop_max[XYZ] = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
|
2015-04-08 07:56:19 +00:00
|
|
|
|
2016-03-06 02:27:45 +00:00
|
|
|
#if FAN_COUNT > 0
|
|
|
|
int fanSpeeds[FAN_COUNT] = { 0 };
|
|
|
|
#endif
|
|
|
|
|
2016-04-18 06:13:07 +00:00
|
|
|
// The active extruder (tool). Set with T<extruder> command.
|
2015-04-03 22:45:41 +00:00
|
|
|
uint8_t active_extruder = 0;
|
2016-04-18 06:13:07 +00:00
|
|
|
|
|
|
|
// Relative Mode. Enable with G91, disable with G90.
|
|
|
|
static bool relative_mode = false;
|
|
|
|
|
2016-10-07 03:06:33 +00:00
|
|
|
// For M109 and M190, this flag may be cleared (by M108) to exit the wait loop
|
2016-07-07 02:59:19 +00:00
|
|
|
volatile bool wait_for_heatup = true;
|
2015-04-08 07:56:19 +00:00
|
|
|
|
2016-10-07 03:06:33 +00:00
|
|
|
// For M0/M1, this flag may be cleared (by M108) to exit the wait-for-user loop
|
2016-10-26 22:21:46 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER) || ENABLED(ULTIPANEL)
|
2016-09-15 07:53:46 +00:00
|
|
|
volatile bool wait_for_user = false;
|
2016-09-12 01:51:53 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-03 22:45:41 +00:00
|
|
|
const char errormagic[] PROGMEM = "Error:";
|
|
|
|
const char echomagic[] PROGMEM = "echo:";
|
|
|
|
const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'};
|
2015-04-08 07:56:19 +00:00
|
|
|
|
2016-10-07 03:06:33 +00:00
|
|
|
// Number of characters read in the current line of serial input
|
2015-04-03 22:45:41 +00:00
|
|
|
static int serial_count = 0;
|
2016-04-18 06:13:07 +00:00
|
|
|
|
2015-04-03 22:45:41 +00:00
|
|
|
// Inactivity shutdown
|
2015-04-13 01:07:08 +00:00
|
|
|
millis_t previous_cmd_ms = 0;
|
|
|
|
static millis_t max_inactive_time = 0;
|
2016-04-10 22:55:12 +00:00
|
|
|
static millis_t stepper_inactive_time = (DEFAULT_STEPPER_DEACTIVE_TIME) * 1000UL;
|
2016-04-18 06:13:07 +00:00
|
|
|
|
|
|
|
// Print Job Timer
|
2016-04-27 01:13:27 +00:00
|
|
|
#if ENABLED(PRINTCOUNTER)
|
|
|
|
PrintCounter print_job_timer = PrintCounter();
|
|
|
|
#else
|
|
|
|
Stopwatch print_job_timer = Stopwatch();
|
|
|
|
#endif
|
2016-04-18 06:13:07 +00:00
|
|
|
|
2016-08-02 04:10:53 +00:00
|
|
|
// Buzzer - I2C on the LCD or a BEEPER_PIN
|
|
|
|
#if ENABLED(LCD_USE_I2C_BUZZER)
|
|
|
|
#define BUZZ(d,f) lcd_buzz(d, f)
|
2016-10-05 02:31:50 +00:00
|
|
|
#elif PIN_EXISTS(BEEPER)
|
2016-08-02 04:10:53 +00:00
|
|
|
Buzzer buzzer;
|
|
|
|
#define BUZZ(d,f) buzzer.tone(d, f)
|
|
|
|
#else
|
|
|
|
#define BUZZ(d,f) NOOP
|
2016-06-04 19:29:01 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-04 04:43:30 +00:00
|
|
|
static uint8_t target_extruder;
|
2015-04-03 22:45:41 +00:00
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
float zprobe_zoffset = Z_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
#endif
|
|
|
|
|
2016-07-16 01:49:34 +00:00
|
|
|
#define PLANNER_XY_FEEDRATE() (min(planner.max_feedrate_mm_s[X_AXIS], planner.max_feedrate_mm_s[Y_AXIS]))
|
2016-06-22 22:49:05 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if HAS_ABL
|
2016-08-07 07:20:25 +00:00
|
|
|
float xy_probe_feedrate_mm_s = MMM_TO_MMS(XY_PROBE_SPEED);
|
|
|
|
#define XY_PROBE_FEEDRATE_MM_S xy_probe_feedrate_mm_s
|
2016-06-22 09:44:55 +00:00
|
|
|
#elif defined(XY_PROBE_SPEED)
|
2016-08-07 07:20:25 +00:00
|
|
|
#define XY_PROBE_FEEDRATE_MM_S MMM_TO_MMS(XY_PROBE_SPEED)
|
2016-06-22 09:22:43 +00:00
|
|
|
#else
|
2016-08-07 07:20:25 +00:00
|
|
|
#define XY_PROBE_FEEDRATE_MM_S PLANNER_XY_FEEDRATE()
|
2015-04-03 22:45:41 +00:00
|
|
|
#endif
|
|
|
|
|
2016-10-09 20:19:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-10-10 22:05:11 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
#define ADJUST_DELTA(V) \
|
|
|
|
if (planner.abl_enabled) { \
|
|
|
|
const float zadj = bilinear_z_offset(V); \
|
|
|
|
delta[A_AXIS] += zadj; \
|
|
|
|
delta[B_AXIS] += zadj; \
|
|
|
|
delta[C_AXIS] += zadj; \
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ADJUST_DELTA(V) if (planner.abl_enabled) { delta[Z_AXIS] += bilinear_z_offset(V); }
|
|
|
|
#endif
|
2016-10-09 20:19:39 +00:00
|
|
|
#elif IS_KINEMATIC
|
|
|
|
#define ADJUST_DELTA(V) NOOP
|
|
|
|
#endif
|
|
|
|
|
2016-08-07 23:54:56 +00:00
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
2015-04-03 22:45:41 +00:00
|
|
|
float z_endstop_adj = 0;
|
|
|
|
#endif
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2015-03-31 09:49:47 +00:00
|
|
|
// Extruder offsets
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2016-10-28 23:39:23 +00:00
|
|
|
float hotend_offset[XYZ][HOTENDS];
|
2013-02-27 11:32:07 +00:00
|
|
|
#endif
|
2015-01-30 02:52:21 +00:00
|
|
|
|
2016-06-17 01:15:48 +00:00
|
|
|
#if HAS_Z_SERVO_ENDSTOP
|
2016-06-14 03:18:24 +00:00
|
|
|
const int z_servo_angle[2] = Z_SERVO_ANGLES;
|
2013-06-06 16:18:03 +00:00
|
|
|
#endif
|
2015-01-30 02:52:21 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(BARICUDA)
|
2016-04-18 06:12:15 +00:00
|
|
|
int baricuda_valve_pressure = 0;
|
|
|
|
int baricuda_e_to_p_pressure = 0;
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-01-30 02:52:21 +00:00
|
|
|
|
|
|
|
bool autoretract_enabled = false;
|
2015-03-29 03:33:21 +00:00
|
|
|
bool retracted[EXTRUDERS] = { false };
|
|
|
|
bool retracted_swap[EXTRUDERS] = { false };
|
2014-06-02 15:02:10 +00:00
|
|
|
|
2014-02-17 03:00:28 +00:00
|
|
|
float retract_length = RETRACT_LENGTH;
|
2014-06-02 15:02:10 +00:00
|
|
|
float retract_length_swap = RETRACT_LENGTH_SWAP;
|
2016-06-22 10:27:31 +00:00
|
|
|
float retract_feedrate_mm_s = RETRACT_FEEDRATE;
|
2014-02-17 03:00:28 +00:00
|
|
|
float retract_zlift = RETRACT_ZLIFT;
|
|
|
|
float retract_recover_length = RETRACT_RECOVER_LENGTH;
|
2014-06-02 15:02:10 +00:00
|
|
|
float retract_recover_length_swap = RETRACT_RECOVER_LENGTH_SWAP;
|
2016-07-16 01:49:34 +00:00
|
|
|
float retract_recover_feedrate_mm_s = RETRACT_RECOVER_FEEDRATE;
|
2015-01-30 02:52:21 +00:00
|
|
|
|
2015-01-23 22:13:06 +00:00
|
|
|
#endif // FWRETRACT
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTIPANEL) && HAS_POWER_SWITCH
|
2015-08-05 11:40:36 +00:00
|
|
|
bool powersupply =
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PS_DEFAULT_OFF)
|
2015-01-30 02:52:21 +00:00
|
|
|
false
|
|
|
|
#else
|
2015-03-05 12:27:24 +00:00
|
|
|
true
|
2015-01-30 02:52:21 +00:00
|
|
|
#endif
|
|
|
|
;
|
2013-03-05 13:52:51 +00:00
|
|
|
#endif
|
|
|
|
|
2016-11-19 10:17:39 +00:00
|
|
|
#if ENABLED(ULTIPANEL) && HAS_CASE_LIGHT
|
|
|
|
bool case_light_on =
|
|
|
|
#if ENABLED(CASE_LIGHT_DEFAULT_ON)
|
|
|
|
true
|
|
|
|
#else
|
|
|
|
false
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-09-03 05:38:47 +00:00
|
|
|
|
2015-04-03 23:46:56 +00:00
|
|
|
#define SIN_60 0.8660254037844386
|
|
|
|
#define COS_60 0.5
|
2016-08-21 08:10:55 +00:00
|
|
|
|
|
|
|
float delta[ABC],
|
|
|
|
endstop_adj[ABC] = { 0 };
|
|
|
|
|
2015-04-03 23:46:56 +00:00
|
|
|
// these are the default values, can be overriden with M665
|
2016-08-21 08:10:55 +00:00
|
|
|
float delta_radius = DELTA_RADIUS,
|
|
|
|
delta_tower1_x = -SIN_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1), // front left tower
|
|
|
|
delta_tower1_y = -COS_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_1),
|
|
|
|
delta_tower2_x = SIN_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2), // front right tower
|
|
|
|
delta_tower2_y = -COS_60 * (delta_radius + DELTA_RADIUS_TRIM_TOWER_2),
|
|
|
|
delta_tower3_x = 0, // back middle tower
|
|
|
|
delta_tower3_y = (delta_radius + DELTA_RADIUS_TRIM_TOWER_3),
|
|
|
|
delta_diagonal_rod = DELTA_DIAGONAL_ROD,
|
|
|
|
delta_diagonal_rod_trim_tower_1 = DELTA_DIAGONAL_ROD_TRIM_TOWER_1,
|
|
|
|
delta_diagonal_rod_trim_tower_2 = DELTA_DIAGONAL_ROD_TRIM_TOWER_2,
|
|
|
|
delta_diagonal_rod_trim_tower_3 = DELTA_DIAGONAL_ROD_TRIM_TOWER_3,
|
|
|
|
delta_diagonal_rod_2_tower_1 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_1),
|
|
|
|
delta_diagonal_rod_2_tower_2 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_2),
|
|
|
|
delta_diagonal_rod_2_tower_3 = sq(delta_diagonal_rod + delta_diagonal_rod_trim_tower_3),
|
|
|
|
delta_segments_per_second = DELTA_SEGMENTS_PER_SECOND,
|
|
|
|
delta_clip_start_height = Z_MAX_POS;
|
|
|
|
|
2016-07-21 21:37:10 +00:00
|
|
|
float delta_safe_distance_from_top();
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2015-04-03 23:46:56 +00:00
|
|
|
#else
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2015-04-03 22:45:41 +00:00
|
|
|
static bool home_all_axis = true;
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2015-04-03 22:45:41 +00:00
|
|
|
#endif
|
2014-07-01 14:45:03 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-12-10 07:54:09 +00:00
|
|
|
int bilinear_grid_spacing[2], bilinear_start[2];
|
2016-12-10 05:38:28 +00:00
|
|
|
float bed_level_grid[ABL_GRID_MAX_POINTS_X][ABL_GRID_MAX_POINTS_Y];
|
2016-09-12 01:56:16 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
// Float constants for SCARA calculations
|
|
|
|
const float L1 = SCARA_LINKAGE_1, L2 = SCARA_LINKAGE_2,
|
|
|
|
L1_2 = sq(float(L1)), L1_2_2 = 2.0 * L1_2,
|
|
|
|
L2_2 = sq(float(L2));
|
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
float delta_segments_per_second = SCARA_SEGMENTS_PER_SECOND,
|
2016-09-16 19:31:53 +00:00
|
|
|
delta[ABC];
|
2015-04-03 23:46:56 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
float cartes[XYZ] = { 0 };
|
|
|
|
|
2016-03-30 03:28:23 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2015-03-30 23:39:47 +00:00
|
|
|
bool filament_sensor = false; //M405 turns on filament_sensor control, M406 turns it off
|
2016-09-06 04:57:12 +00:00
|
|
|
float filament_width_nominal = DEFAULT_NOMINAL_FILAMENT_DIA, // Nominal filament width. Change with M404
|
|
|
|
filament_width_meas = DEFAULT_MEASURED_FILAMENT_DIA; // Measured filament diameter
|
|
|
|
int8_t measurement_delay[MAX_MEASUREMENT_DELAY + 1]; // Ring buffer to delayed measurement. Store extruder factor after subtracting 100
|
|
|
|
int filwidth_delay_index[2] = { 0, -1 }; // Indexes into ring buffer
|
2014-08-07 00:30:57 +00:00
|
|
|
int meas_delay_cm = MEASUREMENT_DELAY_CM; //distance delay setting
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
2016-04-18 06:16:49 +00:00
|
|
|
static bool filament_ran_out = false;
|
2015-03-07 20:43:15 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
#if ENABLED(FILAMENT_CHANGE_FEATURE)
|
|
|
|
FilamentChangeMenuResponse filament_change_menu_response;
|
|
|
|
#endif
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MIXING_EXTRUDER)
|
2016-11-12 20:33:07 +00:00
|
|
|
float mixing_factor[MIXING_STEPPERS]; // Reciprocal of mix proportion. 0.0 = off, otherwise >= 1.0.
|
2016-06-28 22:06:56 +00:00
|
|
|
#if MIXING_VIRTUAL_TOOLS > 1
|
|
|
|
float mixing_virtual_tool_mix[MIXING_VIRTUAL_TOOLS][MIXING_STEPPERS];
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
static bool send_ok[BUFSIZE];
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if HAS_SERVOS
|
2015-04-14 10:13:25 +00:00
|
|
|
Servo servo[NUM_SERVOS];
|
2016-06-12 22:35:01 +00:00
|
|
|
#define MOVE_SERVO(I, P) servo[I].move(P)
|
2016-06-22 21:04:23 +00:00
|
|
|
#if HAS_Z_SERVO_ENDSTOP
|
|
|
|
#define DEPLOY_Z_SERVO() MOVE_SERVO(Z_ENDSTOP_SERVO_NR, z_servo_angle[0])
|
|
|
|
#define STOW_Z_SERVO() MOVE_SERVO(Z_ENDSTOP_SERVO_NR, z_servo_angle[1])
|
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
|
|
|
|
2014-03-10 20:57:08 +00:00
|
|
|
#ifdef CHDK
|
2016-04-10 22:55:12 +00:00
|
|
|
millis_t chdkHigh = 0;
|
2015-01-30 02:52:21 +00:00
|
|
|
boolean chdkActive = false;
|
2014-03-10 20:57:08 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-08-31 02:04:30 +00:00
|
|
|
int lpq_len = 20;
|
|
|
|
#endif
|
|
|
|
|
2016-03-07 11:48:14 +00:00
|
|
|
#if ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
static MarlinBusyState busy_state = NOT_BUSY;
|
2016-04-10 22:55:12 +00:00
|
|
|
static millis_t next_busy_signal_ms = 0;
|
2016-04-07 00:31:18 +00:00
|
|
|
uint8_t host_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL;
|
2016-03-07 11:48:14 +00:00
|
|
|
#define KEEPALIVE_STATE(n) do{ busy_state = n; }while(0)
|
|
|
|
#else
|
|
|
|
#define host_keepalive() ;
|
|
|
|
#define KEEPALIVE_STATE(n) ;
|
|
|
|
#endif // HOST_KEEPALIVE_FEATURE
|
|
|
|
|
2016-09-06 00:56:03 +00:00
|
|
|
#define DEFINE_PGM_READ_ANY(type, reader) \
|
|
|
|
static inline type pgm_read_any(const type *p) \
|
|
|
|
{ return pgm_read_##reader##_near(p); }
|
|
|
|
|
2016-10-13 15:51:44 +00:00
|
|
|
DEFINE_PGM_READ_ANY(float, float)
|
|
|
|
DEFINE_PGM_READ_ANY(signed char, byte)
|
2016-09-06 00:56:03 +00:00
|
|
|
|
|
|
|
#define XYZ_CONSTS_FROM_CONFIG(type, array, CONFIG) \
|
|
|
|
static const PROGMEM type array##_P[XYZ] = \
|
|
|
|
{ X_##CONFIG, Y_##CONFIG, Z_##CONFIG }; \
|
|
|
|
static inline type array(int axis) \
|
|
|
|
{ return pgm_read_any(&array##_P[axis]); }
|
|
|
|
|
2016-10-13 15:51:44 +00:00
|
|
|
XYZ_CONSTS_FROM_CONFIG(float, base_min_pos, MIN_POS)
|
|
|
|
XYZ_CONSTS_FROM_CONFIG(float, base_max_pos, MAX_POS)
|
|
|
|
XYZ_CONSTS_FROM_CONFIG(float, base_home_pos, HOME_POS)
|
|
|
|
XYZ_CONSTS_FROM_CONFIG(float, max_length, MAX_LENGTH)
|
|
|
|
XYZ_CONSTS_FROM_CONFIG(float, home_bump_mm, HOME_BUMP_MM)
|
|
|
|
XYZ_CONSTS_FROM_CONFIG(signed char, home_dir, HOME_DIR)
|
2016-09-06 00:56:03 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* ***************************************************************************
|
|
|
|
* ******************************** FUNCTIONS ********************************
|
|
|
|
* ***************************************************************************
|
|
|
|
*/
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-04-18 07:05:22 +00:00
|
|
|
void stop();
|
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
void get_available_commands();
|
2015-05-17 03:47:40 +00:00
|
|
|
void process_next_command();
|
2016-06-11 02:23:41 +00:00
|
|
|
void prepare_move_to_destination();
|
2016-09-12 08:48:29 +00:00
|
|
|
|
|
|
|
void get_cartesian_from_steppers();
|
2016-09-15 04:50:17 +00:00
|
|
|
void set_current_from_steppers_for_axis(const AxisEnum axis);
|
2015-05-17 03:47:40 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
#if ENABLED(ARC_SUPPORT)
|
|
|
|
void plan_arc(float target[NUM_AXIS], float* offset, uint8_t clockwise);
|
|
|
|
#endif
|
2015-07-19 17:48:20 +00:00
|
|
|
|
2016-05-12 20:33:47 +00:00
|
|
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
|
|
|
void plan_cubic_move(const float offset[4]);
|
|
|
|
#endif
|
|
|
|
|
2016-08-05 15:17:06 +00:00
|
|
|
void serial_echopair_P(const char* s_P, const char *v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
2016-07-15 08:57:02 +00:00
|
|
|
void serial_echopair_P(const char* s_P, char v) { serialprintPGM(s_P); SERIAL_CHAR(v); }
|
2015-10-03 06:08:58 +00:00
|
|
|
void serial_echopair_P(const char* s_P, int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
|
|
|
void serial_echopair_P(const char* s_P, long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
|
|
|
void serial_echopair_P(const char* s_P, float v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
|
|
|
void serial_echopair_P(const char* s_P, double v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
|
|
|
void serial_echopair_P(const char* s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
2015-04-09 08:40:48 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
void tool_change(const uint8_t tmp_extruder, const float fr_mm_s=0.0, bool no_move=false);
|
2016-04-26 01:23:09 +00:00
|
|
|
static void report_current_position();
|
2016-03-23 12:30:50 +00:00
|
|
|
|
2016-04-13 03:58:27 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-13 01:14:59 +00:00
|
|
|
void print_xyz(const char* prefix, const char* suffix, const float x, const float y, const float z) {
|
|
|
|
serialprintPGM(prefix);
|
2016-07-07 18:42:19 +00:00
|
|
|
SERIAL_ECHOPAIR("(", x);
|
2016-04-13 03:58:27 +00:00
|
|
|
SERIAL_ECHOPAIR(", ", y);
|
|
|
|
SERIAL_ECHOPAIR(", ", z);
|
2016-07-13 01:14:59 +00:00
|
|
|
SERIAL_ECHOPGM(")");
|
2016-07-15 10:25:34 +00:00
|
|
|
|
|
|
|
if (suffix) serialprintPGM(suffix);
|
|
|
|
else SERIAL_EOL;
|
2016-04-13 03:58:27 +00:00
|
|
|
}
|
2016-07-15 10:25:34 +00:00
|
|
|
|
|
|
|
void print_xyz(const char* prefix, const char* suffix, const float xyz[]) {
|
2016-07-13 01:14:59 +00:00
|
|
|
print_xyz(prefix, suffix, xyz[X_AXIS], xyz[Y_AXIS], xyz[Z_AXIS]);
|
2016-04-13 03:58:27 +00:00
|
|
|
}
|
2016-07-15 10:25:34 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if HAS_ABL
|
2016-07-15 10:25:34 +00:00
|
|
|
void print_xyz(const char* prefix, const char* suffix, const vector_3 &xyz) {
|
2016-07-13 01:14:59 +00:00
|
|
|
print_xyz(prefix, suffix, xyz.x, xyz.y, xyz.z);
|
2016-04-14 07:00:21 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-07-15 10:25:34 +00:00
|
|
|
|
|
|
|
#define DEBUG_POS(SUFFIX,VAR) do { \
|
2016-10-02 06:48:17 +00:00
|
|
|
print_xyz(PSTR(" " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); } while(0)
|
2016-04-13 03:58:27 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-24 20:27:09 +00:00
|
|
|
/**
|
|
|
|
* sync_plan_position
|
2016-09-15 05:38:02 +00:00
|
|
|
*
|
|
|
|
* Set the planner/stepper positions directly from current_position with
|
|
|
|
* no kinematic translation. Used for homing axes and cartesian/core syncing.
|
2016-07-24 20:27:09 +00:00
|
|
|
*/
|
|
|
|
inline void sync_plan_position() {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position);
|
|
|
|
#endif
|
|
|
|
planner.set_position_mm(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
|
|
|
}
|
|
|
|
inline void sync_plan_position_e() { planner.set_e_position_mm(current_position[E_AXIS]); }
|
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_KINEMATIC
|
2016-09-15 06:21:31 +00:00
|
|
|
|
2016-09-12 02:30:59 +00:00
|
|
|
inline void sync_plan_position_kinematic() {
|
2016-04-12 01:25:39 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-12 02:30:59 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position_kinematic", current_position);
|
2016-04-12 01:25:39 +00:00
|
|
|
#endif
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.set_position_mm_kinematic(current_position);
|
2016-04-12 01:25:39 +00:00
|
|
|
}
|
2016-09-12 02:30:59 +00:00
|
|
|
#define SYNC_PLAN_POSITION_KINEMATIC() sync_plan_position_kinematic()
|
2016-09-15 06:21:31 +00:00
|
|
|
|
2016-06-22 01:56:25 +00:00
|
|
|
#else
|
2016-09-15 06:21:31 +00:00
|
|
|
|
2016-06-22 01:56:25 +00:00
|
|
|
#define SYNC_PLAN_POSITION_KINEMATIC() sync_plan_position()
|
2016-09-15 06:21:31 +00:00
|
|
|
|
2016-04-12 01:25:39 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2014-12-03 13:19:42 +00:00
|
|
|
#include "SdFatUtil.h"
|
|
|
|
int freeMemory() { return SdFatUtil::FreeRam(); }
|
|
|
|
#else
|
2015-10-03 06:08:58 +00:00
|
|
|
extern "C" {
|
2016-12-12 13:35:02 +00:00
|
|
|
extern char __bss_end;
|
|
|
|
extern char __heap_start;
|
2015-10-03 06:08:58 +00:00
|
|
|
extern void* __brkval;
|
|
|
|
|
|
|
|
int freeMemory() {
|
|
|
|
int free_memory;
|
|
|
|
if ((int)__brkval == 0)
|
|
|
|
free_memory = ((int)&free_memory) - ((int)&__bss_end);
|
|
|
|
else
|
|
|
|
free_memory = ((int)&free_memory) - ((int)__brkval);
|
|
|
|
return free_memory;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
}
|
2014-12-03 13:19:42 +00:00
|
|
|
#endif //!SDSUPPORT
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-05-18 01:22:41 +00:00
|
|
|
#if ENABLED(DIGIPOT_I2C)
|
|
|
|
extern void digipot_i2c_set_current(int channel, float current);
|
|
|
|
extern void digipot_i2c_init();
|
|
|
|
#endif
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
2016-03-19 00:37:31 +00:00
|
|
|
* Inject the next "immediate" command, when possible.
|
|
|
|
* Return true if any immediate commands remain to inject.
|
2015-04-14 00:17:36 +00:00
|
|
|
*/
|
2016-10-05 02:32:37 +00:00
|
|
|
static bool drain_injected_commands_P() {
|
|
|
|
if (injected_commands_P != NULL) {
|
2016-03-19 00:37:31 +00:00
|
|
|
size_t i = 0;
|
2016-03-20 03:05:23 +00:00
|
|
|
char c, cmd[30];
|
2016-10-05 02:32:37 +00:00
|
|
|
strncpy_P(cmd, injected_commands_P, sizeof(cmd) - 1);
|
2016-03-20 03:05:23 +00:00
|
|
|
cmd[sizeof(cmd) - 1] = '\0';
|
|
|
|
while ((c = cmd[i]) && c != '\n') i++; // find the end of this gcode command
|
|
|
|
cmd[i] = '\0';
|
|
|
|
if (enqueue_and_echo_command(cmd)) { // success?
|
|
|
|
if (c) // newline char?
|
2016-10-05 02:32:37 +00:00
|
|
|
injected_commands_P += i + 1; // advance to the next command
|
2016-03-20 03:05:23 +00:00
|
|
|
else
|
2016-10-05 02:32:37 +00:00
|
|
|
injected_commands_P = NULL; // nul char? no more commands
|
2016-03-19 00:37:31 +00:00
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-10-05 02:32:37 +00:00
|
|
|
return (injected_commands_P != NULL); // return whether any more remain
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
|
|
|
* Record one or many commands to run from program memory.
|
|
|
|
* Aborts the current queue, if any.
|
2016-10-05 02:32:37 +00:00
|
|
|
* Note: drain_injected_commands_P() must be called repeatedly to drain the commands afterwards
|
2015-04-14 00:17:36 +00:00
|
|
|
*/
|
2016-02-21 01:35:35 +00:00
|
|
|
void enqueue_and_echo_commands_P(const char* pgcode) {
|
2016-10-05 02:32:37 +00:00
|
|
|
injected_commands_P = pgcode;
|
|
|
|
drain_injected_commands_P(); // first command executed asap (when possible)
|
2012-11-28 09:30:34 +00:00
|
|
|
}
|
|
|
|
|
2016-06-01 00:41:32 +00:00
|
|
|
void clear_command_queue() {
|
|
|
|
cmd_queue_index_r = cmd_queue_index_w;
|
|
|
|
commands_in_queue = 0;
|
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
/**
|
2016-02-21 01:35:35 +00:00
|
|
|
* Once a new command is in the ring buffer, call this to commit it
|
2015-04-14 00:17:36 +00:00
|
|
|
*/
|
2016-02-21 01:35:35 +00:00
|
|
|
inline void _commit_command(bool say_ok) {
|
|
|
|
send_ok[cmd_queue_index_w] = say_ok;
|
2015-04-14 00:17:36 +00:00
|
|
|
cmd_queue_index_w = (cmd_queue_index_w + 1) % BUFSIZE;
|
|
|
|
commands_in_queue++;
|
2016-02-21 01:35:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy a command directly into the main command buffer, from RAM.
|
|
|
|
* Returns true if successfully adds the command
|
|
|
|
*/
|
|
|
|
inline bool _enqueuecommand(const char* cmd, bool say_ok=false) {
|
|
|
|
if (*cmd == ';' || commands_in_queue >= BUFSIZE) return false;
|
|
|
|
strcpy(command_queue[cmd_queue_index_w], cmd);
|
|
|
|
_commit_command(say_ok);
|
2015-02-07 22:24:20 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-03-22 01:10:08 +00:00
|
|
|
void enqueue_and_echo_command_now(const char* cmd) {
|
|
|
|
while (!enqueue_and_echo_command(cmd)) idle();
|
|
|
|
}
|
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
/**
|
|
|
|
* Enqueue with Serial Echo
|
|
|
|
*/
|
|
|
|
bool enqueue_and_echo_command(const char* cmd, bool say_ok/*=false*/) {
|
|
|
|
if (_enqueuecommand(cmd, say_ok)) {
|
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(MSG_Enqueueing, cmd);
|
2016-10-03 21:23:41 +00:00
|
|
|
SERIAL_CHAR('"');
|
|
|
|
SERIAL_EOL;
|
2016-02-21 01:35:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
void setup_killpin() {
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_KILL
|
2014-12-28 18:54:06 +00:00
|
|
|
SET_INPUT(KILL_PIN);
|
2015-04-03 22:31:35 +00:00
|
|
|
WRITE(KILL_PIN, HIGH);
|
2012-11-06 11:06:41 +00:00
|
|
|
#endif
|
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-06-20 01:05:57 +00:00
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
|
|
|
|
|
|
|
void setup_filrunoutpin() {
|
2016-09-25 10:52:10 +00:00
|
|
|
SET_INPUT(FIL_RUNOUT_PIN);
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ENDSTOPPULLUP_FIL_RUNOUT)
|
2016-06-20 02:25:09 +00:00
|
|
|
WRITE(FIL_RUNOUT_PIN, HIGH);
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif
|
2016-06-20 01:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2015-03-07 20:43:15 +00:00
|
|
|
|
2014-12-28 18:54:06 +00:00
|
|
|
// Set home pin
|
2015-04-14 00:17:36 +00:00
|
|
|
void setup_homepin(void) {
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HOME
|
|
|
|
SET_INPUT(HOME_PIN);
|
|
|
|
WRITE(HOME_PIN, HIGH);
|
|
|
|
#endif
|
2014-12-28 18:54:06 +00:00
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
void setup_powerhold() {
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SUICIDE
|
2015-03-03 08:48:20 +00:00
|
|
|
OUT_WRITE(SUICIDE_PIN, HIGH);
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2015-03-30 23:39:47 +00:00
|
|
|
#if HAS_POWER_SWITCH
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PS_DEFAULT_OFF)
|
2015-03-03 08:48:20 +00:00
|
|
|
OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP);
|
2015-03-05 12:27:24 +00:00
|
|
|
#else
|
2015-03-03 08:48:20 +00:00
|
|
|
OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE);
|
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
void suicide() {
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SUICIDE
|
2015-03-03 08:48:20 +00:00
|
|
|
OUT_WRITE(SUICIDE_PIN, LOW);
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
void servo_init() {
|
2015-04-03 22:31:35 +00:00
|
|
|
#if NUM_SERVOS >= 1 && HAS_SERVO_0
|
2015-04-14 10:13:25 +00:00
|
|
|
servo[0].attach(SERVO0_PIN);
|
2015-07-24 09:38:15 +00:00
|
|
|
servo[0].detach(); // Just set up the pin. We don't have a position yet. Don't move to a random position.
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if NUM_SERVOS >= 2 && HAS_SERVO_1
|
2015-04-14 10:13:25 +00:00
|
|
|
servo[1].attach(SERVO1_PIN);
|
2015-07-24 09:38:15 +00:00
|
|
|
servo[1].detach();
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if NUM_SERVOS >= 3 && HAS_SERVO_2
|
2015-04-14 10:13:25 +00:00
|
|
|
servo[2].attach(SERVO2_PIN);
|
2015-07-24 09:38:15 +00:00
|
|
|
servo[2].detach();
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if NUM_SERVOS >= 4 && HAS_SERVO_3
|
2015-04-14 10:13:25 +00:00
|
|
|
servo[3].attach(SERVO3_PIN);
|
2015-07-24 09:38:15 +00:00
|
|
|
servo[3].detach();
|
2013-06-06 22:49:25 +00:00
|
|
|
#endif
|
2013-06-06 14:36:52 +00:00
|
|
|
|
2016-06-17 01:15:48 +00:00
|
|
|
#if HAS_Z_SERVO_ENDSTOP
|
2015-12-03 13:19:29 +00:00
|
|
|
/**
|
2016-06-14 03:18:24 +00:00
|
|
|
* Set position of Z Servo Endstop
|
2015-12-03 13:19:29 +00:00
|
|
|
*
|
|
|
|
* The servo might be deployed and positioned too low to stow
|
|
|
|
* when starting up the machine or rebooting the board.
|
|
|
|
* There's no way to know where the nozzle is positioned until
|
|
|
|
* homing has been done - no homing with z-probe without init!
|
|
|
|
*
|
|
|
|
*/
|
2016-06-14 03:18:24 +00:00
|
|
|
STOW_Z_SERVO();
|
2016-06-12 22:15:37 +00:00
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 01:15:24 +00:00
|
|
|
/**
|
|
|
|
* Stepper Reset (RigidBoard, et.al.)
|
|
|
|
*/
|
|
|
|
#if HAS_STEPPER_RESET
|
|
|
|
void disableStepperDrivers() {
|
2016-09-25 10:52:10 +00:00
|
|
|
OUT_WRITE(STEPPER_RESET_PIN, LOW); // drive it down to hold in reset motor driver chips
|
2015-07-11 01:15:24 +00:00
|
|
|
}
|
2016-09-25 10:52:10 +00:00
|
|
|
void enableStepperDrivers() { SET_INPUT(STEPPER_RESET_PIN); } // set to input, which allows it to be pulled high by pullups
|
2015-07-11 01:15:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-11 06:04:18 +00:00
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS) && I2C_SLAVE_ADDRESS > 0
|
|
|
|
|
2016-08-12 00:57:22 +00:00
|
|
|
void i2c_on_receive(int bytes) { // just echo all bytes received to serial
|
|
|
|
i2c.receive(bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
void i2c_on_request() { // just send dummy data for now
|
2016-08-14 01:06:10 +00:00
|
|
|
i2c.reply("Hello World!\n");
|
2016-08-11 06:04:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
void gcode_line_error(const char* err, bool doFlush = true) {
|
2015-05-17 03:54:58 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
serialprintPGM(err);
|
|
|
|
SERIAL_ERRORLN(gcode_LastN);
|
|
|
|
//Serial.println(gcode_N);
|
|
|
|
if (doFlush) FlushSerialRequestResend();
|
|
|
|
serial_count = 0;
|
|
|
|
}
|
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
inline void get_serial_commands() {
|
2016-02-21 01:35:35 +00:00
|
|
|
static char serial_line_buffer[MAX_CMD_SIZE];
|
|
|
|
static boolean serial_comment_mode = false;
|
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
// If the command buffer is empty for too long,
|
|
|
|
// send "wait" to indicate Marlin is still waiting.
|
2016-02-21 01:35:35 +00:00
|
|
|
#if defined(NO_TIMEOUTS) && NO_TIMEOUTS > 0
|
2015-04-16 19:42:54 +00:00
|
|
|
static millis_t last_command_time = 0;
|
|
|
|
millis_t ms = millis();
|
2016-04-10 22:55:12 +00:00
|
|
|
if (commands_in_queue == 0 && !MYSERIAL.available() && ELAPSED(ms, last_command_time + NO_TIMEOUTS)) {
|
2015-04-16 19:42:54 +00:00
|
|
|
SERIAL_ECHOLNPGM(MSG_WAIT);
|
|
|
|
last_command_time = ms;
|
|
|
|
}
|
|
|
|
#endif
|
2015-05-17 03:59:04 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* Loop while serial characters are incoming and the queue is not full
|
|
|
|
*/
|
2015-05-17 03:59:04 +00:00
|
|
|
while (commands_in_queue < BUFSIZE && MYSERIAL.available() > 0) {
|
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
char serial_char = MYSERIAL.read();
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* If the character ends the line
|
|
|
|
*/
|
2016-02-21 01:35:35 +00:00
|
|
|
if (serial_char == '\n' || serial_char == '\r') {
|
2015-05-17 03:59:04 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
serial_comment_mode = false; // end of line == end of comment
|
2015-03-05 22:30:34 +00:00
|
|
|
|
2016-03-28 11:42:51 +00:00
|
|
|
if (!serial_count) continue; // skip empty lines
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
serial_line_buffer[serial_count] = 0; // terminate string
|
|
|
|
serial_count = 0; //reset buffer
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
char* command = serial_line_buffer;
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2015-10-13 10:58:11 +00:00
|
|
|
while (*command == ' ') command++; // skip any leading spaces
|
|
|
|
char* npos = (*command == 'N') ? command : NULL; // Require the N parameter to start the line
|
|
|
|
char* apos = strchr(command, '*');
|
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
if (npos) {
|
2015-06-24 00:50:09 +00:00
|
|
|
|
|
|
|
boolean M110 = strstr_P(command, PSTR("M110")) != NULL;
|
|
|
|
|
|
|
|
if (M110) {
|
2015-10-03 06:08:58 +00:00
|
|
|
char* n2pos = strchr(command + 4, 'N');
|
2015-06-24 00:50:09 +00:00
|
|
|
if (n2pos) npos = n2pos;
|
|
|
|
}
|
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
gcode_N = strtol(npos + 1, NULL, 10);
|
2015-06-24 00:50:09 +00:00
|
|
|
|
2015-06-24 00:57:38 +00:00
|
|
|
if (gcode_N != gcode_LastN + 1 && !M110) {
|
2015-05-17 03:54:58 +00:00
|
|
|
gcode_line_error(PSTR(MSG_ERR_LINE_NO));
|
2015-03-05 22:30:34 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
if (apos) {
|
|
|
|
byte checksum = 0, count = 0;
|
2015-04-14 00:17:36 +00:00
|
|
|
while (command[count] != '*') checksum ^= command[count++];
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
if (strtol(apos + 1, NULL, 10) != checksum) {
|
2015-05-17 03:54:58 +00:00
|
|
|
gcode_line_error(PSTR(MSG_ERR_CHECKSUM_MISMATCH));
|
2012-11-06 11:06:41 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-05-17 03:54:58 +00:00
|
|
|
// if no errors, continue parsing
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-03-08 10:25:11 +00:00
|
|
|
else {
|
2015-05-17 03:54:58 +00:00
|
|
|
gcode_line_error(PSTR(MSG_ERR_NO_CHECKSUM));
|
2015-03-05 22:30:34 +00:00
|
|
|
return;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2015-03-05 22:30:34 +00:00
|
|
|
gcode_LastN = gcode_N;
|
2015-05-17 03:54:58 +00:00
|
|
|
// if no errors, continue parsing
|
2015-03-05 22:30:34 +00:00
|
|
|
}
|
2015-05-17 12:00:09 +00:00
|
|
|
else if (apos) { // No '*' without 'N'
|
|
|
|
gcode_line_error(PSTR(MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM), false);
|
|
|
|
return;
|
2015-03-05 22:30:34 +00:00
|
|
|
}
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
// Movement commands alert when stopped
|
|
|
|
if (IsStopped()) {
|
2015-10-03 06:08:58 +00:00
|
|
|
char* gpos = strchr(command, 'G');
|
2015-05-17 12:00:09 +00:00
|
|
|
if (gpos) {
|
|
|
|
int codenum = strtol(gpos + 1, NULL, 10);
|
|
|
|
switch (codenum) {
|
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 3:
|
2015-04-13 01:07:08 +00:00
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
|
|
|
|
LCD_MESSAGEPGM(MSG_STOPPED);
|
2015-05-17 12:00:09 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-03-05 22:30:34 +00:00
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#if DISABLED(EMERGENCY_PARSER)
|
|
|
|
// If command was e-stop process now
|
2016-10-26 06:42:52 +00:00
|
|
|
if (strcmp(command, "M108") == 0) {
|
|
|
|
wait_for_heatup = false;
|
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
wait_for_user = false;
|
|
|
|
#endif
|
|
|
|
}
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
if (strcmp(command, "M112") == 0) kill(PSTR(MSG_KILLED));
|
2016-07-06 19:00:28 +00:00
|
|
|
if (strcmp(command, "M410") == 0) { quickstop_stepper(); }
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#endif
|
2015-03-05 22:30:34 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
#if defined(NO_TIMEOUTS) && NO_TIMEOUTS > 0
|
|
|
|
last_command_time = ms;
|
|
|
|
#endif
|
2015-03-05 22:30:34 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
// Add the command to the queue
|
|
|
|
_enqueuecommand(serial_line_buffer, true);
|
|
|
|
}
|
|
|
|
else if (serial_count >= MAX_CMD_SIZE - 1) {
|
|
|
|
// Keep fetching, but ignore normal characters beyond the max length
|
|
|
|
// The command will be injected when EOL is reached
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-04-13 01:07:08 +00:00
|
|
|
else if (serial_char == '\\') { // Handle escapes
|
2016-02-21 01:35:35 +00:00
|
|
|
if (MYSERIAL.available() > 0) {
|
2015-04-13 01:07:08 +00:00
|
|
|
// if we have one more character, copy it over
|
|
|
|
serial_char = MYSERIAL.read();
|
2016-03-28 11:36:14 +00:00
|
|
|
if (!serial_comment_mode) serial_line_buffer[serial_count++] = serial_char;
|
2015-04-13 01:07:08 +00:00
|
|
|
}
|
|
|
|
// otherwise do nothing
|
2015-03-05 20:22:37 +00:00
|
|
|
}
|
2016-02-21 01:35:35 +00:00
|
|
|
else { // it's not a newline, carriage return or escape char
|
|
|
|
if (serial_char == ';') serial_comment_mode = true;
|
|
|
|
if (!serial_comment_mode) serial_line_buffer[serial_count++] = serial_char;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-02-21 01:35:35 +00:00
|
|
|
|
|
|
|
} // queue has space, serial has data
|
2016-03-28 12:25:27 +00:00
|
|
|
}
|
2013-12-08 20:35:57 +00:00
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
inline void get_sdcard_commands() {
|
2016-02-21 01:35:35 +00:00
|
|
|
static bool stop_buffering = false,
|
|
|
|
sd_comment_mode = false;
|
|
|
|
|
|
|
|
if (!card.sdprinting) return;
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* '#' stops reading from SD to the buffer prematurely, so procedural
|
|
|
|
* macro calls are possible. If it occurs, stop_buffering is triggered
|
|
|
|
* and the buffer is run dry; this character _can_ occur in serial com
|
|
|
|
* due to checksums, however, no checksums are used in SD printing.
|
|
|
|
*/
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2015-04-14 00:17:36 +00:00
|
|
|
if (commands_in_queue == 0) stop_buffering = false;
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
uint16_t sd_count = 0;
|
|
|
|
bool card_eof = card.eof();
|
|
|
|
while (commands_in_queue < BUFSIZE && !card_eof && !stop_buffering) {
|
2015-04-13 01:07:08 +00:00
|
|
|
int16_t n = card.get();
|
2016-02-21 01:35:35 +00:00
|
|
|
char sd_char = (char)n;
|
|
|
|
card_eof = card.eof();
|
|
|
|
if (card_eof || n == -1
|
|
|
|
|| sd_char == '\n' || sd_char == '\r'
|
|
|
|
|| ((sd_char == '#' || sd_char == ':') && !sd_comment_mode)
|
2015-04-13 01:07:08 +00:00
|
|
|
) {
|
2016-02-21 01:35:35 +00:00
|
|
|
if (card_eof) {
|
2015-04-13 01:07:08 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_FILE_PRINTED);
|
|
|
|
card.printingHasFinished();
|
|
|
|
card.checkautostart(true);
|
|
|
|
}
|
2016-06-20 00:14:56 +00:00
|
|
|
else if (n == -1) {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_SD_ERR_READ);
|
|
|
|
}
|
2016-02-21 01:35:35 +00:00
|
|
|
if (sd_char == '#') stop_buffering = true;
|
2013-12-08 20:35:57 +00:00
|
|
|
|
2016-02-21 01:35:35 +00:00
|
|
|
sd_comment_mode = false; //for new command
|
|
|
|
|
|
|
|
if (!sd_count) continue; //skip empty lines
|
|
|
|
|
|
|
|
command_queue[cmd_queue_index_w][sd_count] = '\0'; //terminate string
|
|
|
|
sd_count = 0; //clear buffer
|
|
|
|
|
|
|
|
_commit_command(false);
|
|
|
|
}
|
|
|
|
else if (sd_count >= MAX_CMD_SIZE - 1) {
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* Keep fetching, but ignore normal characters beyond the max length
|
|
|
|
* The command will be injected when EOL is reached
|
|
|
|
*/
|
2015-04-13 01:07:08 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-02-21 01:35:35 +00:00
|
|
|
if (sd_char == ';') sd_comment_mode = true;
|
|
|
|
if (!sd_comment_mode) command_queue[cmd_queue_index_w][sd_count++] = sd_char;
|
2015-04-13 01:07:08 +00:00
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-03-28 12:25:27 +00:00
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
#endif // SDSUPPORT
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add to the circular command queue the next command from:
|
2016-10-05 02:32:37 +00:00
|
|
|
* - The command-injection queue (injected_commands_P)
|
2016-03-28 12:25:27 +00:00
|
|
|
* - The active serial input (usually USB)
|
|
|
|
* - The SD card file being actively printed
|
|
|
|
*/
|
|
|
|
void get_available_commands() {
|
|
|
|
|
|
|
|
// if any immediate commands remain, don't get other commands yet
|
2016-10-05 02:32:37 +00:00
|
|
|
if (drain_injected_commands_P()) return;
|
2016-03-28 12:25:27 +00:00
|
|
|
|
|
|
|
get_serial_commands();
|
|
|
|
|
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
get_sdcard_commands();
|
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline bool code_has_value() {
|
2015-04-25 03:43:16 +00:00
|
|
|
int i = 1;
|
2015-05-17 12:00:09 +00:00
|
|
|
char c = seen_pointer[i];
|
2016-02-10 02:03:13 +00:00
|
|
|
while (c == ' ') c = seen_pointer[++i];
|
2015-05-17 12:00:09 +00:00
|
|
|
if (c == '-' || c == '+') c = seen_pointer[++i];
|
|
|
|
if (c == '.') c = seen_pointer[++i];
|
2016-03-28 10:52:49 +00:00
|
|
|
return NUMERIC(c);
|
2015-04-12 03:06:48 +00:00
|
|
|
}
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline float code_value_float() {
|
2015-03-28 03:29:05 +00:00
|
|
|
float ret;
|
2015-10-03 06:08:58 +00:00
|
|
|
char* e = strchr(seen_pointer, 'E');
|
2015-03-28 03:29:05 +00:00
|
|
|
if (e) {
|
|
|
|
*e = 0;
|
2015-10-03 06:08:58 +00:00
|
|
|
ret = strtod(seen_pointer + 1, NULL);
|
2015-03-28 03:29:05 +00:00
|
|
|
*e = 'E';
|
|
|
|
}
|
|
|
|
else
|
2015-10-03 06:08:58 +00:00
|
|
|
ret = strtod(seen_pointer + 1, NULL);
|
2015-03-28 03:29:05 +00:00
|
|
|
return ret;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline unsigned long code_value_ulong() { return strtoul(seen_pointer + 1, NULL, 10); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline long code_value_long() { return strtol(seen_pointer + 1, NULL, 10); }
|
2015-04-04 04:43:30 +00:00
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline int code_value_int() { return (int)strtol(seen_pointer + 1, NULL, 10); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline uint16_t code_value_ushort() { return (uint16_t)strtoul(seen_pointer + 1, NULL, 10); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline uint8_t code_value_byte() { return (uint8_t)(constrain(strtol(seen_pointer + 1, NULL, 10), 0, 255)); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
2016-09-15 08:09:42 +00:00
|
|
|
inline bool code_value_bool() { return !code_has_value() || code_value_byte() > 0; }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
2016-06-09 00:03:28 +00:00
|
|
|
inline void set_input_linear_units(LinearUnit units) {
|
2016-05-31 15:26:08 +00:00
|
|
|
switch (units) {
|
|
|
|
case LINEARUNIT_INCH:
|
|
|
|
linear_unit_factor = 25.4;
|
|
|
|
break;
|
|
|
|
case LINEARUNIT_MM:
|
|
|
|
default:
|
|
|
|
linear_unit_factor = 1.0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
volumetric_unit_factor = pow(linear_unit_factor, 3.0);
|
|
|
|
}
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline float axis_unit_factor(int axis) {
|
2016-12-04 04:02:27 +00:00
|
|
|
return (axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor);
|
2016-05-31 15:26:08 +00:00
|
|
|
}
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline float code_value_linear_units() { return code_value_float() * linear_unit_factor; }
|
|
|
|
inline float code_value_axis_units(int axis) { return code_value_float() * axis_unit_factor(axis); }
|
2016-06-16 18:24:11 +00:00
|
|
|
inline float code_value_per_axis_unit(int axis) { return code_value_float() / axis_unit_factor(axis); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
2016-06-09 00:03:28 +00:00
|
|
|
inline float code_value_linear_units() { return code_value_float(); }
|
2016-06-16 18:24:11 +00:00
|
|
|
inline float code_value_axis_units(int axis) { UNUSED(axis); return code_value_float(); }
|
|
|
|
inline float code_value_per_axis_unit(int axis) { UNUSED(axis); return code_value_float(); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
2016-06-09 00:03:28 +00:00
|
|
|
inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
|
2016-06-04 19:29:01 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
float code_value_temp_abs() {
|
|
|
|
switch (input_temp_units) {
|
|
|
|
case TEMPUNIT_C:
|
|
|
|
return code_value_float();
|
|
|
|
case TEMPUNIT_F:
|
2016-07-24 18:50:54 +00:00
|
|
|
return (code_value_float() - 32) * 0.5555555556;
|
2016-05-31 15:26:08 +00:00
|
|
|
case TEMPUNIT_K:
|
|
|
|
return code_value_float() - 272.15;
|
|
|
|
default:
|
|
|
|
return code_value_float();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float code_value_temp_diff() {
|
|
|
|
switch (input_temp_units) {
|
|
|
|
case TEMPUNIT_C:
|
|
|
|
case TEMPUNIT_K:
|
|
|
|
return code_value_float();
|
|
|
|
case TEMPUNIT_F:
|
2016-07-24 18:50:54 +00:00
|
|
|
return code_value_float() * 0.5555555556;
|
2016-05-31 15:26:08 +00:00
|
|
|
default:
|
|
|
|
return code_value_float();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
float code_value_temp_abs() { return code_value_float(); }
|
|
|
|
float code_value_temp_diff() { return code_value_float(); }
|
|
|
|
#endif
|
|
|
|
|
2016-07-10 00:53:49 +00:00
|
|
|
FORCE_INLINE millis_t code_value_millis() { return code_value_ulong(); }
|
2016-06-09 00:03:28 +00:00
|
|
|
inline millis_t code_value_millis_from_seconds() { return code_value_float() * 1000; }
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-03-28 03:29:05 +00:00
|
|
|
bool code_seen(char code) {
|
2015-07-07 06:09:14 +00:00
|
|
|
seen_pointer = strchr(current_command_args, code);
|
|
|
|
return (seen_pointer != NULL); // Return TRUE if the code-letter was found
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-03-30 23:39:47 +00:00
|
|
|
|
2016-04-18 07:01:28 +00:00
|
|
|
/**
|
|
|
|
* Set target_extruder from the T parameter or the active_extruder
|
|
|
|
*
|
|
|
|
* Returns TRUE if the target is invalid
|
|
|
|
*/
|
|
|
|
bool get_target_extruder_from_command(int code) {
|
|
|
|
if (code_seen('T')) {
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_value_byte() >= EXTRUDERS) {
|
2016-04-18 07:01:28 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_CHAR('M');
|
|
|
|
SERIAL_ECHO(code);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" " MSG_INVALID_EXTRUDER " ", code_value_byte());
|
2016-04-18 07:01:28 +00:00
|
|
|
return true;
|
|
|
|
}
|
2016-07-09 23:25:48 +00:00
|
|
|
target_extruder = code_value_byte();
|
2016-04-18 07:01:28 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
target_extruder = active_extruder;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-07-20 17:30:10 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(DUAL_NOZZLE_DUPLICATION_MODE)
|
|
|
|
bool extruder_duplication_enabled = false; // Used in Dual X mode 2
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2013-08-01 13:06:39 +00:00
|
|
|
|
2016-11-03 02:37:46 +00:00
|
|
|
static DualXMode dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE;
|
2015-03-20 05:22:23 +00:00
|
|
|
|
2016-11-07 06:20:59 +00:00
|
|
|
static float x_home_pos(const int extruder) {
|
2015-03-20 05:22:23 +00:00
|
|
|
if (extruder == 0)
|
2016-07-24 23:34:01 +00:00
|
|
|
return LOGICAL_X_POSITION(base_home_pos(X_AXIS));
|
2015-03-20 05:22:23 +00:00
|
|
|
else
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* In dual carriage mode the extruder offset provides an override of the
|
2016-11-07 06:20:19 +00:00
|
|
|
* second X-carriage position when homed - otherwise X2_HOME_POS is used.
|
|
|
|
* This allows soft recalibration of the second extruder home position
|
2016-03-27 03:36:36 +00:00
|
|
|
* without firmware reflash (through the M218 command).
|
|
|
|
*/
|
2016-11-07 06:20:19 +00:00
|
|
|
return LOGICAL_X_POSITION(hotend_offset[X_AXIS][1] > 0 ? hotend_offset[X_AXIS][1] : X2_HOME_POS);
|
2015-03-20 05:22:23 +00:00
|
|
|
}
|
|
|
|
|
2016-11-07 06:20:59 +00:00
|
|
|
static int x_home_dir(const int extruder) { return extruder ? X2_HOME_DIR : X_HOME_DIR; }
|
2015-03-20 05:22:23 +00:00
|
|
|
|
|
|
|
static float inactive_extruder_x_pos = X2_MAX_POS; // used in mode 0 & 1
|
2016-07-24 23:34:31 +00:00
|
|
|
static bool active_extruder_parked = false; // used in mode 1 & 2
|
|
|
|
static float raised_parked_position[NUM_AXIS]; // used in mode 1
|
|
|
|
static millis_t delayed_move_time = 0; // used in mode 1
|
2015-03-20 05:22:23 +00:00
|
|
|
static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2
|
2016-07-24 23:34:31 +00:00
|
|
|
static float duplicate_extruder_temp_offset = 0; // used in mode 2
|
2013-07-17 12:44:45 +00:00
|
|
|
|
2016-10-05 10:50:22 +00:00
|
|
|
#endif // DUAL_X_CARRIAGE
|
2013-07-17 12:44:45 +00:00
|
|
|
|
2016-03-24 10:55:18 +00:00
|
|
|
/**
|
|
|
|
* Software endstops can be used to monitor the open end of
|
|
|
|
* an axis that has a hardware endstop on the other end. Or
|
|
|
|
* they can prevent axes from moving past endstops and grinding.
|
|
|
|
*
|
|
|
|
* To keep doing their job as the coordinate system changes,
|
|
|
|
* the software endstop positions must be refreshed to remain
|
|
|
|
* at the same positions relative to the machine.
|
|
|
|
*/
|
2016-08-19 06:00:46 +00:00
|
|
|
void update_software_endstops(AxisEnum axis) {
|
2016-07-23 00:46:05 +00:00
|
|
|
float offs = LOGICAL_POSITION(0, axis);
|
2016-05-23 21:46:29 +00:00
|
|
|
|
2016-03-24 10:55:18 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
|
|
|
if (axis == X_AXIS) {
|
2016-12-03 06:27:10 +00:00
|
|
|
|
|
|
|
// In Dual X mode hotend_offset[X] is T1's home position
|
2016-05-27 00:43:20 +00:00
|
|
|
float dual_max_x = max(hotend_offset[X_AXIS][1], X2_MAX_POS);
|
2016-12-03 06:27:10 +00:00
|
|
|
|
2016-03-24 10:55:18 +00:00
|
|
|
if (active_extruder != 0) {
|
2016-12-03 06:27:10 +00:00
|
|
|
// T1 can move from X2_MIN_POS to X2_MAX_POS or X2 home position (whichever is larger)
|
2016-08-21 01:07:42 +00:00
|
|
|
soft_endstop_min[X_AXIS] = X2_MIN_POS + offs;
|
|
|
|
soft_endstop_max[X_AXIS] = dual_max_x + offs;
|
2016-03-24 10:55:18 +00:00
|
|
|
}
|
|
|
|
else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE) {
|
2016-12-03 06:27:10 +00:00
|
|
|
// In Duplication Mode, T0 can move as far left as X_MIN_POS
|
|
|
|
// but not so far to the right that T1 would move past the end
|
2016-08-21 01:07:42 +00:00
|
|
|
soft_endstop_min[X_AXIS] = base_min_pos(X_AXIS) + offs;
|
|
|
|
soft_endstop_max[X_AXIS] = min(base_max_pos(X_AXIS), dual_max_x - duplicate_extruder_x_offset) + offs;
|
2016-12-03 06:27:10 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// In other modes, T0 can move from X_MIN_POS to X_MAX_POS
|
|
|
|
soft_endstop_min[axis] = base_min_pos(axis) + offs;
|
|
|
|
soft_endstop_max[axis] = base_max_pos(axis) + offs;
|
2016-03-24 10:55:18 +00:00
|
|
|
}
|
|
|
|
}
|
2016-12-03 06:27:10 +00:00
|
|
|
#else
|
2016-08-21 01:07:42 +00:00
|
|
|
soft_endstop_min[axis] = base_min_pos(axis) + offs;
|
|
|
|
soft_endstop_max[axis] = base_max_pos(axis) + offs;
|
2016-12-03 06:27:10 +00:00
|
|
|
#endif
|
2016-07-15 13:20:54 +00:00
|
|
|
|
2016-07-15 01:34:08 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("For ", axis_codes[axis]);
|
|
|
|
SERIAL_ECHOPAIR(" axis:\n home_offset = ", home_offset[axis]);
|
|
|
|
SERIAL_ECHOPAIR("\n position_shift = ", position_shift[axis]);
|
2016-08-21 01:07:42 +00:00
|
|
|
SERIAL_ECHOPAIR("\n soft_endstop_min = ", soft_endstop_min[axis]);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("\n soft_endstop_max = ", soft_endstop_max[axis]);
|
2016-07-15 01:34:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-07-15 13:20:54 +00:00
|
|
|
|
|
|
|
#if ENABLED(DELTA)
|
2016-08-21 01:07:42 +00:00
|
|
|
if (axis == Z_AXIS)
|
|
|
|
delta_clip_start_height = soft_endstop_max[axis] - delta_safe_distance_from_top();
|
2016-07-15 13:20:54 +00:00
|
|
|
#endif
|
|
|
|
|
2016-03-24 10:55:18 +00:00
|
|
|
}
|
|
|
|
|
2016-04-18 06:11:35 +00:00
|
|
|
/**
|
|
|
|
* Change the home offset for an axis, update the current
|
|
|
|
* position and the software endstops to retain the same
|
|
|
|
* relative distance to the new home.
|
|
|
|
*
|
|
|
|
* Since this changes the current_position, code should
|
|
|
|
* call sync_plan_position soon after this.
|
|
|
|
*/
|
2016-03-24 10:55:18 +00:00
|
|
|
static void set_home_offset(AxisEnum axis, float v) {
|
|
|
|
current_position[axis] += v - home_offset[axis];
|
|
|
|
home_offset[axis] = v;
|
|
|
|
update_software_endstops(axis);
|
|
|
|
}
|
|
|
|
|
2016-09-15 07:47:32 +00:00
|
|
|
/**
|
|
|
|
* Set an axis' current position to its home position (after homing).
|
|
|
|
*
|
|
|
|
* For Core and Cartesian robots this applies one-to-one when an
|
|
|
|
* individual axis has been homed.
|
|
|
|
*
|
|
|
|
* DELTA should wait until all homing is done before setting the XYZ
|
|
|
|
* current_position to home, because homing is a single operation.
|
|
|
|
* In the case where the axis positions are already known and previously
|
|
|
|
* homed, DELTA could home to X or Y individually by moving either one
|
|
|
|
* to the center. However, homing Z always homes XY and Z.
|
|
|
|
*
|
|
|
|
* SCARA should wait until all XY homing is done before setting the XY
|
|
|
|
* current_position to home, because neither X nor Y is at home until
|
|
|
|
* both are at home. Z can however be homed individually.
|
2016-09-26 06:30:34 +00:00
|
|
|
*
|
2016-11-07 06:21:45 +00:00
|
|
|
* Callers must sync the planner position after calling this!
|
2016-09-15 07:47:32 +00:00
|
|
|
*/
|
2015-07-18 14:05:43 +00:00
|
|
|
static void set_axis_is_at_home(AxisEnum axis) {
|
2016-04-06 01:30:53 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-08-19 06:09:03 +00:00
|
|
|
SERIAL_ECHOPAIR(">>> set_axis_is_at_home(", axis_codes[axis]);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2016-04-06 01:30:53 +00:00
|
|
|
}
|
|
|
|
#endif
|
2015-03-28 03:29:05 +00:00
|
|
|
|
2016-09-15 08:10:33 +00:00
|
|
|
axis_known_position[axis] = axis_homed[axis] = true;
|
|
|
|
|
2016-03-24 10:55:18 +00:00
|
|
|
position_shift[axis] = 0;
|
2016-09-15 08:10:33 +00:00
|
|
|
update_software_endstops(axis);
|
2016-03-24 10:55:18 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2016-11-07 06:23:39 +00:00
|
|
|
if (axis == X_AXIS && (active_extruder == 1 || dual_x_carriage_mode == DXC_DUPLICATION_MODE)) {
|
|
|
|
current_position[X_AXIS] = x_home_pos(active_extruder);
|
2016-03-24 10:55:18 +00:00
|
|
|
return;
|
2013-08-07 14:10:26 +00:00
|
|
|
}
|
2015-03-28 03:29:05 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
#if ENABLED(MORGAN_SCARA)
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-21 21:47:12 +00:00
|
|
|
/**
|
|
|
|
* Morgan SCARA homes XY at the same time
|
|
|
|
*/
|
2015-04-24 01:16:44 +00:00
|
|
|
if (axis == X_AXIS || axis == Y_AXIS) {
|
2015-03-28 03:29:05 +00:00
|
|
|
|
2016-08-21 03:38:32 +00:00
|
|
|
float homeposition[XYZ];
|
2016-11-02 22:42:24 +00:00
|
|
|
LOOP_XYZ(i) homeposition[i] = LOGICAL_POSITION(base_home_pos((AxisEnum)i), i);
|
2015-03-28 03:29:05 +00:00
|
|
|
|
2016-09-12 22:49:35 +00:00
|
|
|
// SERIAL_ECHOPAIR("homeposition X:", homeposition[X_AXIS]);
|
|
|
|
// SERIAL_ECHOLNPAIR(" Y:", homeposition[Y_AXIS]);
|
2016-03-27 03:36:36 +00:00
|
|
|
|
|
|
|
/**
|
2016-09-15 18:34:24 +00:00
|
|
|
* Get Home position SCARA arm angles using inverse kinematics,
|
|
|
|
* and calculate homing offset using forward kinematics
|
2016-03-27 03:36:36 +00:00
|
|
|
*/
|
2016-07-21 22:46:22 +00:00
|
|
|
inverse_kinematics(homeposition);
|
2016-09-12 08:48:29 +00:00
|
|
|
forward_kinematics_SCARA(delta[A_AXIS], delta[B_AXIS]);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-12 22:49:35 +00:00
|
|
|
// SERIAL_ECHOPAIR("Cartesian X:", cartes[X_AXIS]);
|
|
|
|
// SERIAL_ECHOLNPAIR(" Y:", cartes[Y_AXIS]);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
current_position[axis] = LOGICAL_POSITION(cartes[axis], axis);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* SCARA home positions are based on configuration since the actual
|
|
|
|
* limits are determined by the inverse kinematic transform.
|
|
|
|
*/
|
2016-09-12 08:48:29 +00:00
|
|
|
soft_endstop_min[axis] = base_min_pos(axis); // + (cartes[axis] - base_home_pos(axis));
|
|
|
|
soft_endstop_max[axis] = base_max_pos(axis); // + (cartes[axis] - base_home_pos(axis));
|
2015-03-28 03:29:05 +00:00
|
|
|
}
|
2015-04-24 01:16:44 +00:00
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
2016-07-23 00:46:05 +00:00
|
|
|
current_position[axis] = LOGICAL_POSITION(base_home_pos(axis), axis);
|
2016-09-21 21:47:12 +00:00
|
|
|
}
|
2015-04-16 14:41:19 +00:00
|
|
|
|
2016-09-21 21:47:12 +00:00
|
|
|
/**
|
|
|
|
* Z Probe Z Homing? Account for the probe's Z offset.
|
|
|
|
*/
|
|
|
|
#if HAS_BED_PROBE && Z_HOME_DIR < 0
|
2016-08-26 20:42:16 +00:00
|
|
|
if (axis == Z_AXIS) {
|
2016-09-21 21:47:12 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE
|
|
|
|
|
|
|
|
current_position[Z_AXIS] -= zprobe_zoffset;
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOLNPGM("*** Z HOMED WITH PROBE (Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) ***");
|
|
|
|
SERIAL_ECHOLNPAIR("> zprobe_zoffset = ", zprobe_zoffset);
|
|
|
|
}
|
2016-08-26 20:42:16 +00:00
|
|
|
#endif
|
2016-09-21 21:47:12 +00:00
|
|
|
|
|
|
|
#elif ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("*** Z HOMED TO ENDSTOP (Z_MIN_PROBE_ENDSTOP) ***");
|
|
|
|
|
2016-08-26 20:42:16 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-09-21 21:47:12 +00:00
|
|
|
#endif
|
2016-08-26 20:42:16 +00:00
|
|
|
|
2016-04-06 01:30:53 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-09-21 21:47:12 +00:00
|
|
|
SERIAL_ECHOPAIR("> home_offset[", axis_codes[axis]);
|
|
|
|
SERIAL_ECHOLNPAIR("] = ", home_offset[axis]);
|
|
|
|
DEBUG_POS("", current_position);
|
2016-08-19 06:09:03 +00:00
|
|
|
SERIAL_ECHOPAIR("<<< set_axis_is_at_home(", axis_codes[axis]);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2016-04-06 01:30:53 +00:00
|
|
|
}
|
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2015-03-29 03:33:21 +00:00
|
|
|
/**
|
2015-03-30 06:16:12 +00:00
|
|
|
* Some planner shorthand inline functions
|
2015-03-29 03:33:21 +00:00
|
|
|
*/
|
2016-07-18 13:52:41 +00:00
|
|
|
inline float get_homing_bump_feedrate(AxisEnum axis) {
|
2016-09-21 21:47:12 +00:00
|
|
|
int constexpr homing_bump_divisor[] = HOMING_BUMP_DIVISOR;
|
2015-07-24 20:43:03 +00:00
|
|
|
int hbd = homing_bump_divisor[axis];
|
|
|
|
if (hbd < 1) {
|
|
|
|
hbd = 10;
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM("Warning: Homing Bump Divisor < 1");
|
2015-04-07 06:21:33 +00:00
|
|
|
}
|
2016-08-07 07:20:25 +00:00
|
|
|
return homing_feedrate_mm_s[axis] / hbd;
|
2015-04-07 06:21:33 +00:00
|
|
|
}
|
2016-07-19 15:24:44 +00:00
|
|
|
|
2016-09-22 12:49:49 +00:00
|
|
|
//
|
|
|
|
// line_to_current_position
|
|
|
|
// Move the planner to the current position from wherever it last moved
|
|
|
|
// (or from wherever it has been told it is located).
|
|
|
|
//
|
|
|
|
inline void line_to_current_position() {
|
|
|
|
planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate_mm_s, active_extruder);
|
|
|
|
}
|
2016-09-15 08:02:42 +00:00
|
|
|
|
2016-09-22 12:49:49 +00:00
|
|
|
//
|
|
|
|
// line_to_destination
|
|
|
|
// Move the planner, not necessarily synced with current_position
|
|
|
|
//
|
|
|
|
inline void line_to_destination(float fr_mm_s) {
|
|
|
|
planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], fr_mm_s, active_extruder);
|
|
|
|
}
|
|
|
|
inline void line_to_destination() { line_to_destination(feedrate_mm_s); }
|
2016-04-28 16:57:21 +00:00
|
|
|
|
2015-04-04 06:42:50 +00:00
|
|
|
inline void set_current_to_destination() { memcpy(current_position, destination, sizeof(current_position)); }
|
|
|
|
inline void set_destination_to_current() { memcpy(destination, current_position, sizeof(destination)); }
|
2015-03-29 03:33:21 +00:00
|
|
|
|
2016-09-15 18:21:59 +00:00
|
|
|
#if IS_KINEMATIC
|
2016-06-15 01:03:17 +00:00
|
|
|
/**
|
2016-07-14 23:26:37 +00:00
|
|
|
* Calculate delta, start a line, and set current_position to destination
|
2016-06-15 01:03:17 +00:00
|
|
|
*/
|
2016-09-21 21:47:12 +00:00
|
|
|
void prepare_uninterpolated_move_to_destination(const float fr_mm_s=0.0) {
|
2016-06-15 01:03:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-15 07:55:23 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("prepare_uninterpolated_move_to_destination", destination);
|
2016-06-15 01:03:17 +00:00
|
|
|
#endif
|
2016-09-21 23:47:11 +00:00
|
|
|
|
|
|
|
if ( current_position[X_AXIS] == destination[X_AXIS]
|
|
|
|
&& current_position[Y_AXIS] == destination[Y_AXIS]
|
|
|
|
&& current_position[Z_AXIS] == destination[Z_AXIS]
|
|
|
|
&& current_position[E_AXIS] == destination[E_AXIS]
|
|
|
|
) return;
|
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
refresh_cmd_timeout();
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.buffer_line_kinematic(destination, MMS_SCALED(fr_mm_s ? fr_mm_s : feedrate_mm_s), active_extruder);
|
2016-07-14 23:26:37 +00:00
|
|
|
set_current_to_destination();
|
|
|
|
}
|
2016-09-21 22:27:37 +00:00
|
|
|
#endif // IS_KINEMATIC
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
/**
|
|
|
|
* Plan a move to (X, Y, Z) and set the current_position
|
|
|
|
* The final current_position may not be the one that was requested
|
|
|
|
*/
|
2016-08-10 07:03:04 +00:00
|
|
|
void do_blocking_move_to(const float &x, const float &y, const float &z, const float &fr_mm_s /*=0.0*/) {
|
2016-08-07 07:20:25 +00:00
|
|
|
float old_feedrate_mm_s = feedrate_mm_s;
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 06:52:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) print_xyz(PSTR(">>> do_blocking_move_to"), NULL, x, y, z);
|
2016-07-14 23:26:37 +00:00
|
|
|
#endif
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
#if ENABLED(DELTA)
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-09-21 21:47:12 +00:00
|
|
|
feedrate_mm_s = fr_mm_s ? fr_mm_s : XY_PROBE_FEEDRATE_MM_S;
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-22 21:18:08 +00:00
|
|
|
set_destination_to_current(); // sync destination at the start
|
|
|
|
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("set_destination_to_current", destination);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-22 01:12:46 +00:00
|
|
|
// when in the danger zone
|
|
|
|
if (current_position[Z_AXIS] > delta_clip_start_height) {
|
2016-07-22 21:18:08 +00:00
|
|
|
if (z > delta_clip_start_height) { // staying in the danger zone
|
|
|
|
destination[X_AXIS] = x; // move directly (uninterpolated)
|
2016-07-22 01:12:46 +00:00
|
|
|
destination[Y_AXIS] = y;
|
|
|
|
destination[Z_AXIS] = z;
|
2016-09-15 07:55:23 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_to_destination
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("danger zone move", current_position);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
2016-07-22 01:12:46 +00:00
|
|
|
return;
|
2016-07-22 21:18:08 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-07-22 01:12:46 +00:00
|
|
|
destination[Z_AXIS] = delta_clip_start_height;
|
2016-09-15 07:55:23 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_to_destination
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("zone border move", current_position);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
2016-07-22 01:12:46 +00:00
|
|
|
}
|
|
|
|
}
|
2016-07-22 21:18:08 +00:00
|
|
|
|
|
|
|
if (z > current_position[Z_AXIS]) { // raising?
|
2016-07-22 01:12:46 +00:00
|
|
|
destination[Z_AXIS] = z;
|
2016-09-15 07:55:23 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_to_destination
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("z raise move", current_position);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
2016-07-22 01:12:46 +00:00
|
|
|
}
|
2016-07-22 21:18:08 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
destination[X_AXIS] = x;
|
|
|
|
destination[Y_AXIS] = y;
|
2016-07-22 21:18:08 +00:00
|
|
|
prepare_move_to_destination(); // set_current_to_destination
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("xy move", current_position);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-22 21:18:08 +00:00
|
|
|
if (z < current_position[Z_AXIS]) { // lowering?
|
2016-07-22 01:12:46 +00:00
|
|
|
destination[Z_AXIS] = z;
|
2016-09-15 07:55:23 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(); // set_current_to_destination
|
2016-07-23 06:52:42 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-23 07:37:46 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("z lower move", current_position);
|
2016-07-23 06:52:42 +00:00
|
|
|
#endif
|
2016-07-22 01:12:46 +00:00
|
|
|
}
|
2016-07-14 23:26:37 +00:00
|
|
|
|
2016-09-15 18:21:59 +00:00
|
|
|
#elif IS_SCARA
|
|
|
|
|
|
|
|
set_destination_to_current();
|
|
|
|
|
|
|
|
// If Z needs to raise, do it before moving XY
|
2016-09-21 22:27:37 +00:00
|
|
|
if (destination[Z_AXIS] < z) {
|
2016-09-15 18:21:59 +00:00
|
|
|
destination[Z_AXIS] = z;
|
2016-09-21 21:47:12 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[Z_AXIS]);
|
2016-09-15 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
destination[X_AXIS] = x;
|
|
|
|
destination[Y_AXIS] = y;
|
2016-09-21 21:47:12 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(fr_mm_s ? fr_mm_s : XY_PROBE_FEEDRATE_MM_S);
|
2016-09-15 18:21:59 +00:00
|
|
|
|
|
|
|
// If Z needs to lower, do it after moving XY
|
2016-09-21 22:27:37 +00:00
|
|
|
if (destination[Z_AXIS] > z) {
|
2016-09-15 18:21:59 +00:00
|
|
|
destination[Z_AXIS] = z;
|
2016-09-21 21:47:12 +00:00
|
|
|
prepare_uninterpolated_move_to_destination(fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[Z_AXIS]);
|
2016-09-15 18:21:59 +00:00
|
|
|
}
|
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
#else
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
// If Z needs to raise, do it before moving XY
|
|
|
|
if (current_position[Z_AXIS] < z) {
|
2016-09-21 21:47:12 +00:00
|
|
|
feedrate_mm_s = fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[Z_AXIS];
|
2016-07-14 23:26:37 +00:00
|
|
|
current_position[Z_AXIS] = z;
|
2016-06-15 01:03:17 +00:00
|
|
|
line_to_current_position();
|
2016-07-14 23:26:37 +00:00
|
|
|
}
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-09-21 21:47:12 +00:00
|
|
|
feedrate_mm_s = fr_mm_s ? fr_mm_s : XY_PROBE_FEEDRATE_MM_S;
|
2016-07-14 23:26:37 +00:00
|
|
|
current_position[X_AXIS] = x;
|
|
|
|
current_position[Y_AXIS] = y;
|
|
|
|
line_to_current_position();
|
2016-06-23 22:50:13 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
// If Z needs to lower, do it after moving XY
|
|
|
|
if (current_position[Z_AXIS] > z) {
|
2016-09-21 21:47:12 +00:00
|
|
|
feedrate_mm_s = fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[Z_AXIS];
|
2016-07-14 23:26:37 +00:00
|
|
|
current_position[Z_AXIS] = z;
|
|
|
|
line_to_current_position();
|
|
|
|
}
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
#endif
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
stepper.synchronize();
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = old_feedrate_mm_s;
|
2016-09-21 22:27:37 +00:00
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< do_blocking_move_to");
|
|
|
|
#endif
|
2016-07-14 23:26:37 +00:00
|
|
|
}
|
2016-08-10 07:03:04 +00:00
|
|
|
void do_blocking_move_to_x(const float &x, const float &fr_mm_s/*=0.0*/) {
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(x, current_position[Y_AXIS], current_position[Z_AXIS], fr_mm_s);
|
2016-07-23 07:58:53 +00:00
|
|
|
}
|
2016-08-10 07:03:04 +00:00
|
|
|
void do_blocking_move_to_z(const float &z, const float &fr_mm_s/*=0.0*/) {
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z, fr_mm_s);
|
2016-07-23 07:58:53 +00:00
|
|
|
}
|
2016-08-10 07:03:04 +00:00
|
|
|
void do_blocking_move_to_xy(const float &x, const float &y, const float &fr_mm_s/*=0.0*/) {
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(x, y, current_position[Z_AXIS], fr_mm_s);
|
2016-07-14 23:26:37 +00:00
|
|
|
}
|
2016-06-15 01:03:17 +00:00
|
|
|
|
2016-07-16 02:13:02 +00:00
|
|
|
//
|
|
|
|
// Prepare to do endstop or probe moves
|
|
|
|
// with custom feedrates.
|
|
|
|
//
|
|
|
|
// - Save current feedrates
|
|
|
|
// - Reset the rate multiplier
|
|
|
|
// - Reset the command timeout
|
|
|
|
// - Enable the endstops (for endstop moves)
|
|
|
|
//
|
|
|
|
static void setup_for_endstop_or_probe_move() {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("setup_for_endstop_or_probe_move", current_position);
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
saved_feedrate_mm_s = feedrate_mm_s;
|
2016-07-16 01:49:34 +00:00
|
|
|
saved_feedrate_percentage = feedrate_percentage;
|
|
|
|
feedrate_percentage = 100;
|
2016-07-16 02:13:02 +00:00
|
|
|
refresh_cmd_timeout();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clean_up_after_endstop_or_probe_move() {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("clean_up_after_endstop_or_probe_move", current_position);
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = saved_feedrate_mm_s;
|
2016-07-16 01:49:34 +00:00
|
|
|
feedrate_percentage = saved_feedrate_percentage;
|
2016-07-16 02:13:02 +00:00
|
|
|
refresh_cmd_timeout();
|
|
|
|
}
|
|
|
|
|
2016-07-14 23:26:37 +00:00
|
|
|
#if HAS_BED_PROBE
|
2016-06-12 22:15:37 +00:00
|
|
|
/**
|
2016-06-22 21:40:15 +00:00
|
|
|
* Raise Z to a minimum height to make room for a probe to move
|
2016-06-12 22:15:37 +00:00
|
|
|
*/
|
2016-06-22 21:40:15 +00:00
|
|
|
inline void do_probe_raise(float z_raise) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("do_probe_raise(", z_raise);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2016-06-22 21:40:15 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-09-14 01:25:12 +00:00
|
|
|
|
2016-07-24 23:34:01 +00:00
|
|
|
float z_dest = LOGICAL_Z_POSITION(z_raise);
|
2016-09-14 01:25:12 +00:00
|
|
|
if (zprobe_zoffset < 0) z_dest -= zprobe_zoffset;
|
|
|
|
|
2016-07-06 01:32:24 +00:00
|
|
|
if (z_dest > current_position[Z_AXIS])
|
2016-06-22 21:40:15 +00:00
|
|
|
do_blocking_move_to_z(z_dest);
|
2016-06-12 22:15:37 +00:00
|
|
|
}
|
|
|
|
|
2016-06-22 21:40:15 +00:00
|
|
|
#endif //HAS_BED_PROBE
|
2016-06-12 22:15:37 +00:00
|
|
|
|
2016-09-24 01:02:51 +00:00
|
|
|
#if ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) || HAS_PROBING_PROCEDURE || HOTENDS > 1 || ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE)
|
2016-07-16 10:57:35 +00:00
|
|
|
static bool axis_unhomed_error(const bool x, const bool y, const bool z) {
|
|
|
|
const bool xx = x && !axis_homed[X_AXIS],
|
|
|
|
yy = y && !axis_homed[Y_AXIS],
|
|
|
|
zz = z && !axis_homed[Z_AXIS];
|
|
|
|
if (xx || yy || zz) {
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_HOME " ");
|
|
|
|
if (xx) SERIAL_ECHOPGM(MSG_X);
|
|
|
|
if (yy) SERIAL_ECHOPGM(MSG_Y);
|
|
|
|
if (zz) SERIAL_ECHOPGM(MSG_Z);
|
|
|
|
SERIAL_ECHOLNPGM(" " MSG_FIRST);
|
|
|
|
|
|
|
|
#if ENABLED(ULTRA_LCD)
|
|
|
|
char message[3 * (LCD_WIDTH) + 1] = ""; // worst case is kana.utf with up to 3*LCD_WIDTH+1
|
|
|
|
strcat_P(message, PSTR(MSG_HOME " "));
|
|
|
|
if (xx) strcat_P(message, PSTR(MSG_X));
|
|
|
|
if (yy) strcat_P(message, PSTR(MSG_Y));
|
|
|
|
if (zz) strcat_P(message, PSTR(MSG_Z));
|
|
|
|
strcat_P(message, PSTR(" " MSG_FIRST));
|
|
|
|
lcd_setstatus(message);
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2016-06-22 21:03:22 +00:00
|
|
|
}
|
2016-07-16 10:57:35 +00:00
|
|
|
#endif
|
2016-06-22 21:03:22 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
#if ENABLED(Z_PROBE_SLED)
|
|
|
|
|
|
|
|
#ifndef SLED_DOCKING_OFFSET
|
|
|
|
#define SLED_DOCKING_OFFSET 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method to dock/undock a sled designed by Charles Bell.
|
|
|
|
*
|
2016-06-27 16:09:22 +00:00
|
|
|
* stow[in] If false, move to MAX_X and engage the solenoid
|
|
|
|
* If true, move to MAX_X and release the solenoid
|
2016-06-20 22:50:51 +00:00
|
|
|
*/
|
2016-06-27 16:09:22 +00:00
|
|
|
static void dock_sled(bool stow) {
|
2016-06-20 22:50:51 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-06-27 16:09:22 +00:00
|
|
|
SERIAL_ECHOPAIR("dock_sled(", stow);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2016-06-20 22:50:51 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-06-27 16:09:22 +00:00
|
|
|
// Dock sled a bit closer to ensure proper capturing
|
|
|
|
do_blocking_move_to_x(X_MAX_POS + SLED_DOCKING_OFFSET - ((stow) ? 1 : 0));
|
|
|
|
|
2016-07-30 09:01:46 +00:00
|
|
|
#if PIN_EXISTS(SLED)
|
|
|
|
digitalWrite(SLED_PIN, !stow); // switch solenoid
|
|
|
|
#endif
|
2016-06-20 22:50:51 +00:00
|
|
|
}
|
|
|
|
|
2016-10-02 23:18:05 +00:00
|
|
|
#elif ENABLED(Z_PROBE_ALLEN_KEY)
|
|
|
|
|
2016-07-04 07:46:22 +00:00
|
|
|
void run_deploy_moves_script() {
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_DEPLOY_1_X, Z_PROBE_ALLEN_KEY_DEPLOY_1_Y, Z_PROBE_ALLEN_KEY_DEPLOY_1_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_DEPLOY_2_X, Z_PROBE_ALLEN_KEY_DEPLOY_2_Y, Z_PROBE_ALLEN_KEY_DEPLOY_2_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_DEPLOY_3_X, Z_PROBE_ALLEN_KEY_DEPLOY_3_Y, Z_PROBE_ALLEN_KEY_DEPLOY_3_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_DEPLOY_4_X, Z_PROBE_ALLEN_KEY_DEPLOY_4_Y, Z_PROBE_ALLEN_KEY_DEPLOY_4_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_DEPLOY_5_X, Z_PROBE_ALLEN_KEY_DEPLOY_5_Y, Z_PROBE_ALLEN_KEY_DEPLOY_5_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-10-02 23:18:05 +00:00
|
|
|
|
2016-07-04 07:46:22 +00:00
|
|
|
void run_stow_moves_script() {
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_STOW_1_X) || defined(Z_PROBE_ALLEN_KEY_STOW_1_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_1_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_1_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_1_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_1_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_STOW_1_X, Z_PROBE_ALLEN_KEY_STOW_1_Y, Z_PROBE_ALLEN_KEY_STOW_1_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_STOW_2_X) || defined(Z_PROBE_ALLEN_KEY_STOW_2_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_2_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_2_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_2_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_2_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_STOW_2_X, Z_PROBE_ALLEN_KEY_STOW_2_Y, Z_PROBE_ALLEN_KEY_STOW_2_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_STOW_3_X) || defined(Z_PROBE_ALLEN_KEY_STOW_3_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_3_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_3_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_3_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_3_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_STOW_3_X, Z_PROBE_ALLEN_KEY_STOW_3_Y, Z_PROBE_ALLEN_KEY_STOW_3_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_STOW_4_X) || defined(Z_PROBE_ALLEN_KEY_STOW_4_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_4_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_4_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_4_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_4_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_STOW_4_X, Z_PROBE_ALLEN_KEY_STOW_4_Y, Z_PROBE_ALLEN_KEY_STOW_4_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
#if defined(Z_PROBE_ALLEN_KEY_STOW_5_X) || defined(Z_PROBE_ALLEN_KEY_STOW_5_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_5_Z)
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_X
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_5_X current_position[X_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_Y
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_5_Y current_position[Y_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_Z
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_5_Z current_position[Z_AXIS]
|
|
|
|
#endif
|
|
|
|
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE
|
|
|
|
#define Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE 0.0
|
|
|
|
#endif
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to(Z_PROBE_ALLEN_KEY_STOW_5_X, Z_PROBE_ALLEN_KEY_STOW_5_Y, Z_PROBE_ALLEN_KEY_STOW_5_Z, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE));
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-10-02 23:18:05 +00:00
|
|
|
|
2016-07-04 07:46:22 +00:00
|
|
|
#endif
|
2016-06-20 22:50:51 +00:00
|
|
|
|
2016-06-20 21:31:01 +00:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
// TRIGGERED_WHEN_STOWED_TEST can easily be extended to servo probes, ... if needed.
|
|
|
|
#if ENABLED(PROBE_IS_TRIGGERED_WHEN_STOWED_TEST)
|
|
|
|
#if ENABLED(Z_MIN_PROBE_ENDSTOP)
|
|
|
|
#define _TRIGGERED_WHEN_STOWED_TEST (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING)
|
|
|
|
#else
|
|
|
|
#define _TRIGGERED_WHEN_STOWED_TEST (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-08-30 06:40:29 +00:00
|
|
|
#define DEPLOY_PROBE() set_probe_deployed(true)
|
|
|
|
#define STOW_PROBE() set_probe_deployed(false)
|
2016-07-06 01:40:21 +00:00
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
#if ENABLED(BLTOUCH)
|
|
|
|
FORCE_INLINE void set_bltouch_deployed(const bool &deploy) {
|
|
|
|
servo[Z_ENDSTOP_SERVO_NR].move(deploy ? BLTOUCH_DEPLOY : BLTOUCH_STOW);
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("set_bltouch_deployed(", deploy);
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#endif
|
2016-09-20 19:37:18 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
// returns false for ok and true for failure
|
|
|
|
static bool set_probe_deployed(bool deploy) {
|
2016-06-20 21:31:01 +00:00
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-07-06 01:40:21 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
DEBUG_POS("set_probe_deployed", current_position);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("deploy: ", deploy);
|
2016-07-06 01:40:21 +00:00
|
|
|
}
|
2016-06-20 21:31:01 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
if (endstops.z_probe_enabled == deploy) return false;
|
2016-06-20 21:31:01 +00:00
|
|
|
|
2016-06-24 01:00:20 +00:00
|
|
|
// Make room for probe
|
2016-09-20 08:49:42 +00:00
|
|
|
do_probe_raise(_Z_CLEARANCE_DEPLOY_PROBE);
|
2016-06-24 01:00:20 +00:00
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
// When deploying make sure BLTOUCH is not already triggered
|
2016-09-18 23:02:53 +00:00
|
|
|
#if ENABLED(BLTOUCH)
|
2016-09-20 19:37:18 +00:00
|
|
|
if (deploy && TEST_BLTOUCH()) { stop(); return true; }
|
2016-11-18 05:42:41 +00:00
|
|
|
#elif ENABLED(Z_PROBE_SLED)
|
2016-07-06 01:40:21 +00:00
|
|
|
if (axis_unhomed_error(true, false, false)) { stop(); return true; }
|
2016-06-20 21:31:01 +00:00
|
|
|
#elif ENABLED(Z_PROBE_ALLEN_KEY)
|
2016-07-06 01:40:21 +00:00
|
|
|
if (axis_unhomed_error(true, true, true )) { stop(); return true; }
|
2016-06-20 21:31:01 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-30 06:40:29 +00:00
|
|
|
float oldXpos = current_position[X_AXIS],
|
|
|
|
oldYpos = current_position[Y_AXIS];
|
2016-06-24 01:00:20 +00:00
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
#ifdef _TRIGGERED_WHEN_STOWED_TEST
|
2016-08-06 21:24:05 +00:00
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
// If endstop is already false, the Z probe is deployed
|
2016-08-06 21:24:05 +00:00
|
|
|
if (_TRIGGERED_WHEN_STOWED_TEST == deploy) { // closed after the probe specific actions.
|
|
|
|
// Would a goto be less ugly?
|
|
|
|
//while (!_TRIGGERED_WHEN_STOWED_TEST) idle(); // would offer the opportunity
|
|
|
|
// for a triggered when stowed manual probe.
|
2016-07-06 01:56:17 +00:00
|
|
|
|
2016-08-06 21:24:05 +00:00
|
|
|
if (!deploy) endstops.enable_z_probe(false); // Switch off triggered when stowed probes early
|
|
|
|
// otherwise an Allen-Key probe can't be stowed.
|
2016-06-20 21:31:01 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-06 21:24:05 +00:00
|
|
|
#if ENABLED(Z_PROBE_SLED)
|
|
|
|
|
|
|
|
dock_sled(!deploy);
|
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
#elif HAS_Z_SERVO_ENDSTOP && DISABLED(BLTOUCH)
|
2016-08-06 21:24:05 +00:00
|
|
|
|
|
|
|
servo[Z_ENDSTOP_SERVO_NR].move(z_servo_angle[deploy ? 0 : 1]);
|
|
|
|
|
|
|
|
#elif ENABLED(Z_PROBE_ALLEN_KEY)
|
|
|
|
|
|
|
|
deploy ? run_deploy_moves_script() : run_stow_moves_script();
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
#ifdef _TRIGGERED_WHEN_STOWED_TEST
|
2016-08-06 21:24:05 +00:00
|
|
|
} // _TRIGGERED_WHEN_STOWED_TEST == deploy
|
|
|
|
|
|
|
|
if (_TRIGGERED_WHEN_STOWED_TEST == deploy) { // State hasn't changed?
|
2016-07-06 01:40:21 +00:00
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
if (IsRunning()) {
|
|
|
|
SERIAL_ERROR_START;
|
2016-07-06 01:40:21 +00:00
|
|
|
SERIAL_ERRORLNPGM("Z-Probe failed");
|
2016-07-06 01:56:17 +00:00
|
|
|
LCD_ALERTMESSAGEPGM("Err: ZPROBE");
|
|
|
|
}
|
|
|
|
stop();
|
|
|
|
return true;
|
2016-08-06 21:24:05 +00:00
|
|
|
|
|
|
|
} // _TRIGGERED_WHEN_STOWED_TEST == deploy
|
|
|
|
|
2016-07-06 01:56:17 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
do_blocking_move_to(oldXpos, oldYpos, current_position[Z_AXIS]); // return to position before deploy
|
2016-08-28 00:53:02 +00:00
|
|
|
endstops.enable_z_probe(deploy);
|
2016-07-06 01:40:21 +00:00
|
|
|
return false;
|
2016-06-20 21:31:01 +00:00
|
|
|
}
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
static void do_probe_move(float z, float fr_mm_m) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS(">>> do_probe_move", current_position);
|
|
|
|
#endif
|
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
// Deploy BLTouch at the start of any probe
|
|
|
|
#if ENABLED(BLTOUCH)
|
|
|
|
set_bltouch_deployed(true);
|
|
|
|
#endif
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
// Move down until probe triggered
|
|
|
|
do_blocking_move_to_z(LOGICAL_Z_POSITION(z), MMM_TO_MMS(fr_mm_m));
|
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
// Retract BLTouch immediately after a probe
|
|
|
|
#if ENABLED(BLTOUCH)
|
|
|
|
set_bltouch_deployed(false);
|
|
|
|
#endif
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
// Clear endstop flags
|
|
|
|
endstops.hit_on_purpose();
|
|
|
|
|
|
|
|
// Get Z where the steppers were interrupted
|
|
|
|
set_current_from_steppers_for_axis(Z_AXIS);
|
|
|
|
|
2016-10-23 00:45:13 +00:00
|
|
|
// Tell the planner where we actually are
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("<<< do_probe_move", current_position);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-06-21 22:14:04 +00:00
|
|
|
// Do a single Z probe and return with current_position[Z_AXIS]
|
|
|
|
// at the height where the probe triggered.
|
2016-06-22 23:52:32 +00:00
|
|
|
static float run_z_probe() {
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-08-19 06:09:03 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS(">>> run_z_probe", current_position);
|
|
|
|
#endif
|
|
|
|
|
2016-06-21 22:14:04 +00:00
|
|
|
// Prevent stepper_inactive_time from running out and EXTRUDER_RUNOUT_PREVENT from extruding
|
2016-03-27 03:36:36 +00:00
|
|
|
refresh_cmd_timeout();
|
2015-11-03 19:14:15 +00:00
|
|
|
|
double bump probing as a feature
Why double touch probing is not a good thing.
It's widely believed we can get better __probing__ results when using a double touch when probing.
Let's compare to double touch __homing__.
Or better let's begin with single touch __homing__.
We home to find out out position, so our position is unknown.
To find the endstop we have to move into the direction of the endstop.
The maximum way we have to move is a bit longer than the axis length.
When we arrive at the endstop - when it triggers, the stepper pulses are stopped immediately.
It's a sudden stop. No smooth deacceleration is possible.
Depending on the speed and the moving mass we lose steps here.
Only if we approached slow enough (below jerk speed?) we will not lose steps.
Moving a complete axis length, that slow, takes for ever.
To speed up homing, we now make the first approach faster, get a guess about our position,
back up a bit and make a second slower approach to get a exact result without losing steps.
What we do in double touch probing is the same. But the difference here is:
a. we already know where we are
b. if the first approach is to fast we will lose steps here to.
But this time there is no second approach to set the position to 0. We are measuring only.
The lost steps are permanent until we home the next time.
So if you experienced permanently rising values in M48 you now know why. (Too fast, suddenly stopped, first approach)
What can we do to improve probing?
We can use the information about our current position.
We can make a really fast, but deaccelerated, move to a place we know it is a bit before the trigger point.
And then move the rest of the way really slow.
2016-07-30 01:00:49 +00:00
|
|
|
#if ENABLED(PROBE_DOUBLE_TOUCH)
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
// Do a first probe at the fast speed
|
|
|
|
do_probe_move(-(Z_MAX_LENGTH) - 10, Z_PROBE_SPEED_FAST);
|
|
|
|
|
2016-09-28 19:01:59 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
float first_probe_z = current_position[Z_AXIS];
|
2016-10-02 22:35:40 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPAIR("1st Probe Z:", first_probe_z);
|
2016-09-28 19:01:59 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-19 06:10:41 +00:00
|
|
|
// move up by the bump distance
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to_z(current_position[Z_AXIS] + home_bump_mm(Z_AXIS), MMM_TO_MMS(Z_PROBE_SPEED_FAST));
|
2016-08-19 06:17:56 +00:00
|
|
|
|
double bump probing as a feature
Why double touch probing is not a good thing.
It's widely believed we can get better __probing__ results when using a double touch when probing.
Let's compare to double touch __homing__.
Or better let's begin with single touch __homing__.
We home to find out out position, so our position is unknown.
To find the endstop we have to move into the direction of the endstop.
The maximum way we have to move is a bit longer than the axis length.
When we arrive at the endstop - when it triggers, the stepper pulses are stopped immediately.
It's a sudden stop. No smooth deacceleration is possible.
Depending on the speed and the moving mass we lose steps here.
Only if we approached slow enough (below jerk speed?) we will not lose steps.
Moving a complete axis length, that slow, takes for ever.
To speed up homing, we now make the first approach faster, get a guess about our position,
back up a bit and make a second slower approach to get a exact result without losing steps.
What we do in double touch probing is the same. But the difference here is:
a. we already know where we are
b. if the first approach is to fast we will lose steps here to.
But this time there is no second approach to set the position to 0. We are measuring only.
The lost steps are permanent until we home the next time.
So if you experienced permanently rising values in M48 you now know why. (Too fast, suddenly stopped, first approach)
What can we do to improve probing?
We can use the information about our current position.
We can make a really fast, but deaccelerated, move to a place we know it is a bit before the trigger point.
And then move the rest of the way really slow.
2016-07-30 01:00:49 +00:00
|
|
|
#else
|
2016-08-19 06:17:56 +00:00
|
|
|
|
2016-08-29 00:13:08 +00:00
|
|
|
// If the nozzle is above the travel height then
|
|
|
|
// move down quickly before doing the slow probe
|
2016-09-20 08:49:42 +00:00
|
|
|
float z = LOGICAL_Z_POSITION(Z_CLEARANCE_BETWEEN_PROBES);
|
2016-10-03 21:18:04 +00:00
|
|
|
if (zprobe_zoffset < 0) z -= zprobe_zoffset;
|
2016-08-29 00:13:08 +00:00
|
|
|
if (z < current_position[Z_AXIS])
|
|
|
|
do_blocking_move_to_z(z, MMM_TO_MMS(Z_PROBE_SPEED_FAST));
|
2016-08-19 06:17:56 +00:00
|
|
|
|
double bump probing as a feature
Why double touch probing is not a good thing.
It's widely believed we can get better __probing__ results when using a double touch when probing.
Let's compare to double touch __homing__.
Or better let's begin with single touch __homing__.
We home to find out out position, so our position is unknown.
To find the endstop we have to move into the direction of the endstop.
The maximum way we have to move is a bit longer than the axis length.
When we arrive at the endstop - when it triggers, the stepper pulses are stopped immediately.
It's a sudden stop. No smooth deacceleration is possible.
Depending on the speed and the moving mass we lose steps here.
Only if we approached slow enough (below jerk speed?) we will not lose steps.
Moving a complete axis length, that slow, takes for ever.
To speed up homing, we now make the first approach faster, get a guess about our position,
back up a bit and make a second slower approach to get a exact result without losing steps.
What we do in double touch probing is the same. But the difference here is:
a. we already know where we are
b. if the first approach is to fast we will lose steps here to.
But this time there is no second approach to set the position to 0. We are measuring only.
The lost steps are permanent until we home the next time.
So if you experienced permanently rising values in M48 you now know why. (Too fast, suddenly stopped, first approach)
What can we do to improve probing?
We can use the information about our current position.
We can make a really fast, but deaccelerated, move to a place we know it is a bit before the trigger point.
And then move the rest of the way really slow.
2016-07-30 01:00:49 +00:00
|
|
|
#endif
|
2016-07-18 13:52:41 +00:00
|
|
|
|
double bump probing as a feature
Why double touch probing is not a good thing.
It's widely believed we can get better __probing__ results when using a double touch when probing.
Let's compare to double touch __homing__.
Or better let's begin with single touch __homing__.
We home to find out out position, so our position is unknown.
To find the endstop we have to move into the direction of the endstop.
The maximum way we have to move is a bit longer than the axis length.
When we arrive at the endstop - when it triggers, the stepper pulses are stopped immediately.
It's a sudden stop. No smooth deacceleration is possible.
Depending on the speed and the moving mass we lose steps here.
Only if we approached slow enough (below jerk speed?) we will not lose steps.
Moving a complete axis length, that slow, takes for ever.
To speed up homing, we now make the first approach faster, get a guess about our position,
back up a bit and make a second slower approach to get a exact result without losing steps.
What we do in double touch probing is the same. But the difference here is:
a. we already know where we are
b. if the first approach is to fast we will lose steps here to.
But this time there is no second approach to set the position to 0. We are measuring only.
The lost steps are permanent until we home the next time.
So if you experienced permanently rising values in M48 you now know why. (Too fast, suddenly stopped, first approach)
What can we do to improve probing?
We can use the information about our current position.
We can make a really fast, but deaccelerated, move to a place we know it is a bit before the trigger point.
And then move the rest of the way really slow.
2016-07-30 01:00:49 +00:00
|
|
|
// move down slowly to find bed
|
2016-08-29 00:00:25 +00:00
|
|
|
do_probe_move(-(Z_MAX_LENGTH) - 10, Z_PROBE_SPEED_SLOW);
|
2016-06-28 02:33:37 +00:00
|
|
|
|
2016-07-18 13:52:41 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-19 06:09:03 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("<<< run_z_probe", current_position);
|
2016-07-18 13:52:41 +00:00
|
|
|
#endif
|
2016-06-22 23:52:32 +00:00
|
|
|
|
2016-09-28 19:01:59 +00:00
|
|
|
// Debug: compare probe heights
|
|
|
|
#if ENABLED(PROBE_DOUBLE_TOUCH) && ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("2nd Probe Z:", current_position[Z_AXIS]);
|
|
|
|
SERIAL_ECHOLNPAIR(" Discrepancy:", first_probe_z - current_position[Z_AXIS]);
|
|
|
|
}
|
|
|
|
#endif
|
2016-06-22 23:52:32 +00:00
|
|
|
return current_position[Z_AXIS];
|
2015-03-30 06:16:12 +00:00
|
|
|
}
|
2013-09-29 16:20:06 +00:00
|
|
|
|
2016-06-24 02:00:29 +00:00
|
|
|
//
|
|
|
|
// - Move to the given XY
|
|
|
|
// - Deploy the probe, if not already deployed
|
|
|
|
// - Probe the bed, get the Z position
|
|
|
|
// - Depending on the 'stow' flag
|
|
|
|
// - Stow the probe, or
|
|
|
|
// - Raise to the BETWEEN height
|
|
|
|
// - Return the probed Z position
|
|
|
|
//
|
2016-09-17 21:21:08 +00:00
|
|
|
static float probe_pt(const float &x, const float &y, bool stow = true, int verbose_level = 1) {
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-06-28 02:33:37 +00:00
|
|
|
SERIAL_ECHOPAIR(">>> probe_pt(", x);
|
|
|
|
SERIAL_ECHOPAIR(", ", y);
|
2016-10-02 23:18:05 +00:00
|
|
|
SERIAL_ECHOPAIR(", ", stow ? "" : "no ");
|
|
|
|
SERIAL_ECHOLNPGM("stow)");
|
2016-04-06 02:04:42 +00:00
|
|
|
DEBUG_POS("", current_position);
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
float old_feedrate_mm_s = feedrate_mm_s;
|
2016-06-22 23:39:51 +00:00
|
|
|
|
2016-12-10 12:49:46 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
if (current_position[Z_AXIS] > delta_clip_start_height)
|
|
|
|
do_blocking_move_to_z(delta_clip_start_height);
|
|
|
|
#endif
|
|
|
|
|
2016-06-26 02:19:31 +00:00
|
|
|
// Ensure a minimum height before moving the probe
|
2016-09-20 08:49:42 +00:00
|
|
|
do_probe_raise(Z_CLEARANCE_BETWEEN_PROBES);
|
2016-06-26 02:19:31 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = XY_PROBE_FEEDRATE_MM_S;
|
2016-09-15 18:34:24 +00:00
|
|
|
|
|
|
|
// Move the probe to the given XY
|
2016-03-27 03:36:36 +00:00
|
|
|
do_blocking_move_to_xy(x - (X_PROBE_OFFSET_FROM_EXTRUDER), y - (Y_PROBE_OFFSET_FROM_EXTRUDER));
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
if (DEPLOY_PROBE()) return NAN;
|
2016-06-21 22:15:59 +00:00
|
|
|
|
2016-06-22 23:52:32 +00:00
|
|
|
float measured_z = run_z_probe();
|
2014-02-16 18:38:29 +00:00
|
|
|
|
2016-09-14 01:25:12 +00:00
|
|
|
if (!stow)
|
2016-09-20 08:49:42 +00:00
|
|
|
do_probe_raise(Z_CLEARANCE_BETWEEN_PROBES);
|
2016-09-14 01:25:12 +00:00
|
|
|
else
|
2016-07-06 01:40:21 +00:00
|
|
|
if (STOW_PROBE()) return NAN;
|
2014-02-16 18:38:29 +00:00
|
|
|
|
2015-03-30 06:16:12 +00:00
|
|
|
if (verbose_level > 2) {
|
2015-05-17 08:49:52 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Bed X: ");
|
2015-03-30 06:16:12 +00:00
|
|
|
SERIAL_PROTOCOL_F(x, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" Y: ");
|
|
|
|
SERIAL_PROTOCOL_F(y, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" Z: ");
|
|
|
|
SERIAL_PROTOCOL_F(measured_z, 3);
|
|
|
|
SERIAL_EOL;
|
2015-03-07 18:36:21 +00:00
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-06 02:04:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< probe_pt");
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = old_feedrate_mm_s;
|
2016-06-22 22:49:05 +00:00
|
|
|
|
2015-03-30 06:16:12 +00:00
|
|
|
return measured_z;
|
2015-03-07 18:36:21 +00:00
|
|
|
}
|
|
|
|
|
2016-06-24 02:00:29 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2016-06-22 21:03:22 +00:00
|
|
|
|
2016-09-29 05:59:06 +00:00
|
|
|
#if PLANNER_LEVELING
|
|
|
|
/**
|
|
|
|
* Turn bed leveling on or off, fixing the current
|
|
|
|
* position as-needed.
|
|
|
|
*
|
|
|
|
* Disable: Current position = physical position
|
|
|
|
* Enable: Current position = "unleveled" physical position
|
|
|
|
*/
|
|
|
|
void set_bed_leveling_enabled(bool enable=true) {
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
|
2016-12-05 07:53:36 +00:00
|
|
|
if (enable != mbl.active()) {
|
2016-09-29 05:59:06 +00:00
|
|
|
|
2016-12-05 07:53:36 +00:00
|
|
|
if (!enable)
|
|
|
|
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
|
|
|
|
|
|
|
|
mbl.set_active(enable && mbl.has_mesh());
|
|
|
|
|
|
|
|
if (enable) planner.unapply_leveling(current_position);
|
|
|
|
}
|
2016-09-29 05:59:06 +00:00
|
|
|
|
|
|
|
#elif HAS_ABL
|
|
|
|
|
|
|
|
if (enable != planner.abl_enabled) {
|
2016-10-10 22:05:40 +00:00
|
|
|
planner.abl_enabled = enable;
|
|
|
|
if (!enable)
|
2016-09-29 05:59:06 +00:00
|
|
|
set_current_from_steppers_for_axis(
|
|
|
|
#if ABL_PLANAR
|
|
|
|
ALL_AXES
|
|
|
|
#else
|
|
|
|
Z_AXIS
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
else
|
|
|
|
planner.unapply_leveling(current_position);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-11-26 05:32:47 +00:00
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
|
|
|
|
void set_z_fade_height(const float zfh) {
|
|
|
|
planner.z_fade_height = zfh;
|
|
|
|
planner.inverse_z_fade_height = RECIPROCAL(zfh);
|
|
|
|
|
|
|
|
if (
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
mbl.active()
|
|
|
|
#else
|
|
|
|
planner.abl_enabled
|
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
set_current_from_steppers_for_axis(
|
|
|
|
#if ABL_PLANAR
|
|
|
|
ALL_AXES
|
|
|
|
#else
|
|
|
|
Z_AXIS
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // LEVELING_FADE_HEIGHT
|
2016-06-22 21:03:22 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Reset calibration results to zero.
|
|
|
|
*/
|
|
|
|
void reset_bed_level() {
|
2016-12-10 07:54:09 +00:00
|
|
|
set_bed_leveling_enabled(false);
|
2016-09-29 05:59:06 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
if (mbl.has_mesh()) {
|
|
|
|
mbl.reset();
|
|
|
|
mbl.set_has_mesh(false);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("reset_bed_level");
|
|
|
|
#endif
|
|
|
|
#if ABL_PLANAR
|
|
|
|
planner.bed_level_matrix.set_to_identity();
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-12-10 07:54:09 +00:00
|
|
|
bilinear_start[X_AXIS] = bilinear_start[Y_AXIS] =
|
|
|
|
bilinear_grid_spacing[X_AXIS] = bilinear_grid_spacing[Y_AXIS] = 0;
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X; x++)
|
|
|
|
for (uint8_t y = 0; y < ABL_GRID_MAX_POINTS_Y; y++)
|
2016-09-29 05:59:06 +00:00
|
|
|
bed_level_grid[x][y] = 1000.0;
|
|
|
|
#endif
|
2016-09-13 07:11:45 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-06-22 21:03:22 +00:00
|
|
|
|
2016-09-29 05:59:06 +00:00
|
|
|
#endif // PLANNER_LEVELING
|
2016-09-12 07:52:52 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
2016-09-15 08:40:34 +00:00
|
|
|
* Extrapolate a single point from its neighbors
|
2016-09-13 07:11:45 +00:00
|
|
|
*/
|
2016-09-15 08:40:34 +00:00
|
|
|
static void extrapolate_one_point(uint8_t x, uint8_t y, int8_t xdir, int8_t ydir) {
|
2016-09-27 04:38:03 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPGM("Extrapolate [");
|
|
|
|
if (x < 10) SERIAL_CHAR(' ');
|
|
|
|
SERIAL_ECHO((int)x);
|
|
|
|
SERIAL_CHAR(xdir ? (xdir > 0 ? '+' : '-') : ' ');
|
|
|
|
SERIAL_CHAR(' ');
|
|
|
|
if (y < 10) SERIAL_CHAR(' ');
|
|
|
|
SERIAL_ECHO((int)y);
|
|
|
|
SERIAL_CHAR(ydir ? (ydir > 0 ? '+' : '-') : ' ');
|
2016-10-06 22:04:22 +00:00
|
|
|
SERIAL_CHAR(']');
|
2016-09-27 04:38:03 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (bed_level_grid[x][y] < 999.0) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM(" (done)");
|
|
|
|
#endif
|
|
|
|
return; // Don't overwrite good values.
|
|
|
|
}
|
2016-10-06 22:04:22 +00:00
|
|
|
SERIAL_EOL;
|
2016-09-27 04:38:03 +00:00
|
|
|
|
|
|
|
// Get X neighbors, Y neighbors, and XY neighbors
|
|
|
|
float a1 = bed_level_grid[x + xdir][y], a2 = bed_level_grid[x + xdir * 2][y],
|
|
|
|
b1 = bed_level_grid[x][y + ydir], b2 = bed_level_grid[x][y + ydir * 2],
|
|
|
|
c1 = bed_level_grid[x + xdir][y + ydir], c2 = bed_level_grid[x + xdir * 2][y + ydir * 2];
|
|
|
|
|
|
|
|
// Treat far unprobed points as zero, near as equal to far
|
|
|
|
if (a2 > 999.0) a2 = 0.0; if (a1 > 999.0) a1 = a2;
|
|
|
|
if (b2 > 999.0) b2 = 0.0; if (b1 > 999.0) b1 = b2;
|
|
|
|
if (c2 > 999.0) c2 = 0.0; if (c1 > 999.0) c1 = c2;
|
|
|
|
|
|
|
|
float a = 2 * a1 - a2, b = 2 * b1 - b2, c = 2 * c1 - c2;
|
|
|
|
|
|
|
|
// Take the average intstead of the median
|
|
|
|
bed_level_grid[x][y] = (a + b + c) / 3.0;
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Median is robust (ignores outliers).
|
2016-09-27 04:38:03 +00:00
|
|
|
// bed_level_grid[x][y] = (a < b) ? ((b < c) ? b : (c < a) ? a : c)
|
|
|
|
// : ((c < b) ? b : (a < c) ? a : c);
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
|
|
|
|
2016-10-14 19:44:28 +00:00
|
|
|
//Enable this if your SCARA uses 180° of total area
|
|
|
|
//#define EXTRAPOLATE_FROM_EDGE
|
2016-09-27 04:38:03 +00:00
|
|
|
|
|
|
|
#if ENABLED(EXTRAPOLATE_FROM_EDGE)
|
2016-12-10 05:38:28 +00:00
|
|
|
#if ABL_GRID_MAX_POINTS_X < ABL_GRID_MAX_POINTS_Y
|
2016-09-27 04:38:03 +00:00
|
|
|
#define HALF_IN_X
|
2016-12-10 05:38:28 +00:00
|
|
|
#elif ABL_GRID_MAX_POINTS_Y < ABL_GRID_MAX_POINTS_X
|
2016-09-27 04:38:03 +00:00
|
|
|
#define HALF_IN_Y
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Fill in the unprobed points (corners of circular print surface)
|
|
|
|
* using linear extrapolation, away from the center.
|
|
|
|
*/
|
|
|
|
static void extrapolate_unprobed_bed_level() {
|
2016-09-27 04:38:03 +00:00
|
|
|
#ifdef HALF_IN_X
|
2016-12-10 05:38:28 +00:00
|
|
|
const uint8_t ctrx2 = 0, xlen = ABL_GRID_MAX_POINTS_X - 1;
|
2016-09-27 04:38:03 +00:00
|
|
|
#else
|
2016-12-10 05:38:28 +00:00
|
|
|
const uint8_t ctrx1 = (ABL_GRID_MAX_POINTS_X - 1) / 2, // left-of-center
|
|
|
|
ctrx2 = ABL_GRID_MAX_POINTS_X / 2, // right-of-center
|
2016-09-27 04:38:03 +00:00
|
|
|
xlen = ctrx1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HALF_IN_Y
|
2016-12-10 05:38:28 +00:00
|
|
|
const uint8_t ctry2 = 0, ylen = ABL_GRID_MAX_POINTS_Y - 1;
|
2016-09-27 04:38:03 +00:00
|
|
|
#else
|
2016-12-10 05:38:28 +00:00
|
|
|
const uint8_t ctry1 = (ABL_GRID_MAX_POINTS_Y - 1) / 2, // top-of-center
|
|
|
|
ctry2 = ABL_GRID_MAX_POINTS_Y / 2, // bottom-of-center
|
2016-09-27 04:38:03 +00:00
|
|
|
ylen = ctry1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (uint8_t xo = 0; xo <= xlen; xo++)
|
|
|
|
for (uint8_t yo = 0; yo <= ylen; yo++) {
|
|
|
|
uint8_t x2 = ctrx2 + xo, y2 = ctry2 + yo;
|
|
|
|
#ifndef HALF_IN_X
|
|
|
|
uint8_t x1 = ctrx1 - xo;
|
|
|
|
#endif
|
|
|
|
#ifndef HALF_IN_Y
|
|
|
|
uint8_t y1 = ctry1 - yo;
|
|
|
|
#ifndef HALF_IN_X
|
|
|
|
extrapolate_one_point(x1, y1, +1, +1); // left-below + +
|
|
|
|
#endif
|
|
|
|
extrapolate_one_point(x2, y1, -1, +1); // right-below - +
|
|
|
|
#endif
|
|
|
|
#ifndef HALF_IN_X
|
|
|
|
extrapolate_one_point(x1, y2, +1, -1); // left-above + -
|
|
|
|
#endif
|
|
|
|
extrapolate_one_point(x2, y2, -1, -1); // right-above - -
|
2015-03-30 06:16:12 +00:00
|
|
|
}
|
2016-09-27 04:38:03 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-12 08:58:40 +00:00
|
|
|
/**
|
2016-09-13 07:11:45 +00:00
|
|
|
* Print calibration results for plotting or manual frame adjustment.
|
2016-09-12 08:58:40 +00:00
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
static void print_bed_level() {
|
2016-09-27 04:38:03 +00:00
|
|
|
SERIAL_ECHOPGM("Bilinear Leveling Grid:\n ");
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X; x++) {
|
2016-09-27 04:38:03 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" ");
|
|
|
|
if (x < 10) SERIAL_PROTOCOLCHAR(' ');
|
|
|
|
SERIAL_PROTOCOL((int)x);
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t y = 0; y < ABL_GRID_MAX_POINTS_Y; y++) {
|
2016-11-07 10:08:25 +00:00
|
|
|
if (y < 10) SERIAL_PROTOCOLCHAR(' ');
|
2016-10-06 21:46:54 +00:00
|
|
|
SERIAL_PROTOCOL((int)y);
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X; x++) {
|
2016-09-13 07:11:45 +00:00
|
|
|
SERIAL_PROTOCOLCHAR(' ');
|
2016-09-27 04:38:03 +00:00
|
|
|
float offset = bed_level_grid[x][y];
|
|
|
|
if (offset < 999.0) {
|
|
|
|
if (offset > 0) SERIAL_CHAR('+');
|
|
|
|
SERIAL_PROTOCOL_F(offset, 2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
SERIAL_PROTOCOLPGM(" ====");
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
2016-09-27 04:38:03 +00:00
|
|
|
SERIAL_EOL;
|
2016-09-12 08:58:40 +00:00
|
|
|
}
|
|
|
|
|
2016-11-05 16:01:26 +00:00
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
2016-12-10 05:38:28 +00:00
|
|
|
#define ABL_GRID_POINTS_VIRT_X (ABL_GRID_MAX_POINTS_X - 1) * (BILINEAR_SUBDIVISIONS) + 1
|
|
|
|
#define ABL_GRID_POINTS_VIRT_Y (ABL_GRID_MAX_POINTS_Y - 1) * (BILINEAR_SUBDIVISIONS) + 1
|
2016-11-05 16:01:26 +00:00
|
|
|
float bed_level_grid_virt[ABL_GRID_POINTS_VIRT_X][ABL_GRID_POINTS_VIRT_Y];
|
2016-12-10 05:38:28 +00:00
|
|
|
float bed_level_grid_virt_temp[ABL_GRID_MAX_POINTS_X + 2][ABL_GRID_MAX_POINTS_Y + 2]; //temporary for calculation (maybe dynamical?)
|
2016-11-05 16:01:26 +00:00
|
|
|
int bilinear_grid_spacing_virt[2] = { 0 };
|
|
|
|
|
|
|
|
static void bed_level_virt_print() {
|
|
|
|
SERIAL_ECHOLNPGM("Subdivided with CATMULL ROM Leveling Grid:");
|
|
|
|
for (uint8_t x = 0; x < ABL_GRID_POINTS_VIRT_X; x++) {
|
|
|
|
SERIAL_PROTOCOLPGM(" ");
|
|
|
|
if (x < 10) SERIAL_PROTOCOLCHAR(' ');
|
|
|
|
SERIAL_PROTOCOL((int)x);
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
for (uint8_t y = 0; y < ABL_GRID_POINTS_VIRT_Y; y++) {
|
|
|
|
if (y < 10) SERIAL_PROTOCOLCHAR(' ');
|
|
|
|
SERIAL_PROTOCOL((int)y);
|
|
|
|
for (uint8_t x = 0; x < ABL_GRID_POINTS_VIRT_X; x++) {
|
|
|
|
SERIAL_PROTOCOLCHAR(' ');
|
|
|
|
float offset = bed_level_grid_virt[x][y];
|
|
|
|
if (offset < 999.0) {
|
|
|
|
if (offset > 0) SERIAL_CHAR('+');
|
|
|
|
SERIAL_PROTOCOL_F(offset, 5);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
SERIAL_PROTOCOLPGM(" ====");
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#define LINEAR_EXTRAPOLATION(E, I) (E * 2 - I)
|
|
|
|
static void bed_level_virt_prepare() {
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t y = 1; y <= ABL_GRID_MAX_POINTS_Y; y++) {
|
2016-11-05 16:01:26 +00:00
|
|
|
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t x = 1; x <= ABL_GRID_MAX_POINTS_X; x++)
|
2016-11-05 16:01:26 +00:00
|
|
|
bed_level_grid_virt_temp[x][y] = bed_level_grid[x - 1][y - 1];
|
|
|
|
|
|
|
|
bed_level_grid_virt_temp[0][y] = LINEAR_EXTRAPOLATION(
|
|
|
|
bed_level_grid_virt_temp[1][y],
|
|
|
|
bed_level_grid_virt_temp[2][y]
|
|
|
|
);
|
|
|
|
|
2016-12-10 05:38:28 +00:00
|
|
|
bed_level_grid_virt_temp[(ABL_GRID_MAX_POINTS_X + 2) - 1][y] =
|
2016-11-05 16:01:26 +00:00
|
|
|
LINEAR_EXTRAPOLATION(
|
2016-12-10 05:38:28 +00:00
|
|
|
bed_level_grid_virt_temp[(ABL_GRID_MAX_POINTS_X + 2) - 2][y],
|
|
|
|
bed_level_grid_virt_temp[(ABL_GRID_MAX_POINTS_X + 2) - 3][y]
|
2016-11-05 16:01:26 +00:00
|
|
|
);
|
|
|
|
}
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X + 2; x++) {
|
2016-11-05 16:01:26 +00:00
|
|
|
bed_level_grid_virt_temp[x][0] = LINEAR_EXTRAPOLATION(
|
|
|
|
bed_level_grid_virt_temp[x][1],
|
|
|
|
bed_level_grid_virt_temp[x][2]
|
|
|
|
);
|
2016-12-10 05:38:28 +00:00
|
|
|
bed_level_grid_virt_temp[x][(ABL_GRID_MAX_POINTS_Y + 2) - 1] =
|
2016-11-05 16:01:26 +00:00
|
|
|
LINEAR_EXTRAPOLATION(
|
2016-12-10 05:38:28 +00:00
|
|
|
bed_level_grid_virt_temp[x][(ABL_GRID_MAX_POINTS_Y + 2) - 2],
|
|
|
|
bed_level_grid_virt_temp[x][(ABL_GRID_MAX_POINTS_Y + 2) - 3]
|
2016-11-05 16:01:26 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static float bed_level_virt_cmr(const float p[4], const uint8_t i, const float t) {
|
|
|
|
return (
|
|
|
|
p[i-1] * -t * sq(1 - t)
|
|
|
|
+ p[i] * (2 - 5 * sq(t) + 3 * t * sq(t))
|
|
|
|
+ p[i+1] * t * (1 + 4 * t - 3 * sq(t))
|
|
|
|
- p[i+2] * sq(t) * (1 - t)
|
|
|
|
) * 0.5;
|
|
|
|
}
|
|
|
|
static float bed_level_virt_2cmr(const uint8_t x, const uint8_t y, const float &tx, const float &ty) {
|
|
|
|
float row[4], column[4];
|
|
|
|
for (uint8_t i = 0; i < 4; i++) {
|
|
|
|
for (uint8_t j = 0; j < 4; j++) // can be memcopy or through memory access
|
|
|
|
column[j] = bed_level_grid_virt_temp[i + x - 1][j + y - 1];
|
|
|
|
row[i] = bed_level_virt_cmr(column, 1, ty);
|
|
|
|
}
|
|
|
|
return bed_level_virt_cmr(row, 1, tx);
|
|
|
|
}
|
|
|
|
static void bed_level_virt_interpolate() {
|
2016-12-10 05:38:28 +00:00
|
|
|
for (uint8_t y = 0; y < ABL_GRID_MAX_POINTS_Y; y++)
|
|
|
|
for (uint8_t x = 0; x < ABL_GRID_MAX_POINTS_X; x++)
|
2016-11-05 16:01:26 +00:00
|
|
|
for (uint8_t ty = 0; ty < BILINEAR_SUBDIVISIONS; ty++)
|
|
|
|
for (uint8_t tx = 0; tx < BILINEAR_SUBDIVISIONS; tx++) {
|
2016-12-10 05:38:28 +00:00
|
|
|
if ((ty && y == ABL_GRID_MAX_POINTS_Y - 1) || (tx && x == ABL_GRID_MAX_POINTS_X - 1))
|
2016-11-05 16:01:26 +00:00
|
|
|
continue;
|
|
|
|
bed_level_grid_virt[x * (BILINEAR_SUBDIVISIONS) + tx][y * (BILINEAR_SUBDIVISIONS) + ty] =
|
|
|
|
bed_level_virt_2cmr(
|
|
|
|
x + 1,
|
|
|
|
y + 1,
|
|
|
|
(float)tx / (BILINEAR_SUBDIVISIONS),
|
|
|
|
(float)ty / (BILINEAR_SUBDIVISIONS)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // ABL_BILINEAR_SUBDIVISION
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
2015-08-11 23:04:40 +00:00
|
|
|
|
2016-09-29 20:06:01 +00:00
|
|
|
|
2015-04-01 08:44:13 +00:00
|
|
|
/**
|
2016-09-15 18:34:24 +00:00
|
|
|
* Home an individual linear axis
|
2015-04-01 08:44:13 +00:00
|
|
|
*/
|
2016-09-21 22:37:36 +00:00
|
|
|
static void do_homing_move(const AxisEnum axis, float distance, float fr_mm_s=0.0) {
|
2016-09-20 19:37:18 +00:00
|
|
|
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR(">>> do_homing_move(", axis_codes[axis]);
|
|
|
|
SERIAL_ECHOPAIR(", ", distance);
|
|
|
|
SERIAL_ECHOPAIR(", ", fr_mm_s);
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-09-20 19:37:18 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
|
2016-09-25 04:58:08 +00:00
|
|
|
bool deploy_bltouch = (axis == Z_AXIS && distance < 0);
|
2016-09-22 19:27:22 +00:00
|
|
|
if (deploy_bltouch) set_bltouch_deployed(true);
|
2016-09-20 19:37:18 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-21 23:35:40 +00:00
|
|
|
// Tell the planner we're at Z=0
|
2016-08-28 00:53:02 +00:00
|
|
|
current_position[axis] = 0;
|
2016-09-21 23:35:40 +00:00
|
|
|
|
|
|
|
#if IS_SCARA
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
current_position[axis] = distance;
|
|
|
|
inverse_kinematics(current_position);
|
|
|
|
planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], current_position[E_AXIS], fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[axis], active_extruder);
|
|
|
|
#else
|
|
|
|
sync_plan_position();
|
|
|
|
current_position[axis] = distance;
|
|
|
|
planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], fr_mm_s ? fr_mm_s : homing_feedrate_mm_s[axis], active_extruder);
|
|
|
|
#endif
|
|
|
|
|
2016-08-19 06:11:41 +00:00
|
|
|
stepper.synchronize();
|
2016-09-20 19:37:18 +00:00
|
|
|
|
|
|
|
#if HOMING_Z_WITH_PROBE && ENABLED(BLTOUCH)
|
2016-09-22 19:27:22 +00:00
|
|
|
if (deploy_bltouch) set_bltouch_deployed(false);
|
2016-09-20 19:37:18 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-28 00:53:02 +00:00
|
|
|
endstops.hit_on_purpose();
|
2016-10-02 06:48:17 +00:00
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("<<< do_homing_move(", axis_codes[axis]);
|
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
#endif
|
2016-08-19 06:11:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-15 18:22:23 +00:00
|
|
|
/**
|
|
|
|
* Home an individual "raw axis" to its endstop.
|
|
|
|
* This applies to XYZ on Cartesian and Core robots, and
|
|
|
|
* to the individual ABC steppers on DELTA and SCARA.
|
|
|
|
*
|
|
|
|
* At the end of the procedure the axis is marked as
|
|
|
|
* homed and the current position of that axis is updated.
|
|
|
|
* Kinematic robots should wait till all axes are homed
|
|
|
|
* before updating the current position.
|
|
|
|
*/
|
|
|
|
|
2015-04-01 08:44:13 +00:00
|
|
|
#define HOMEAXIS(LETTER) homeaxis(LETTER##_AXIS)
|
|
|
|
|
2015-04-07 06:21:33 +00:00
|
|
|
static void homeaxis(AxisEnum axis) {
|
2016-07-08 13:59:33 +00:00
|
|
|
|
2016-09-15 20:43:06 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
// Only Z homing (with probe) is permitted
|
|
|
|
if (axis != Z_AXIS) { BUZZ(100, 880); return; }
|
|
|
|
#else
|
|
|
|
#define CAN_HOME(A) \
|
|
|
|
(axis == A##_AXIS && ((A##_MIN_PIN > -1 && A##_HOME_DIR < 0) || (A##_MAX_PIN > -1 && A##_HOME_DIR > 0)))
|
|
|
|
if (!CAN_HOME(X) && !CAN_HOME(Y) && !CAN_HOME(Z)) return;
|
|
|
|
#endif
|
2016-07-08 13:59:33 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-08-19 06:09:03 +00:00
|
|
|
SERIAL_ECHOPAIR(">>> homeaxis(", axis_codes[axis]);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2013-06-06 14:36:52 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
int axis_home_dir =
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
|
|
|
(axis == X_AXIS) ? x_home_dir(active_extruder) :
|
2016-06-02 02:48:17 +00:00
|
|
|
#endif
|
2016-07-08 13:59:33 +00:00
|
|
|
home_dir(axis);
|
2016-03-31 00:19:54 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
// Homing Z towards the bed? Deploy the Z probe or endstop.
|
2016-08-30 18:29:13 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE
|
2016-09-12 22:49:35 +00:00
|
|
|
if (axis == Z_AXIS && DEPLOY_PROBE()) return;
|
2016-07-08 13:59:33 +00:00
|
|
|
#endif
|
2016-07-05 08:42:33 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
// Set a flag for Z motor locking
|
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
if (axis == Z_AXIS) stepper.set_homing_flag(true);
|
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-09-22 11:23:46 +00:00
|
|
|
// Fast move towards endstop until triggered
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("Home 1 Fast:");
|
|
|
|
#endif
|
2016-09-22 11:23:46 +00:00
|
|
|
do_homing_move(axis, 1.5 * max_length(axis) * axis_home_dir);
|
|
|
|
|
2016-09-22 20:21:53 +00:00
|
|
|
// When homing Z with probe respect probe clearance
|
|
|
|
const float bump = axis_home_dir * (
|
|
|
|
#if HOMING_Z_WITH_PROBE
|
|
|
|
(axis == Z_AXIS) ? max(Z_CLEARANCE_BETWEEN_PROBES, home_bump_mm(Z_AXIS)) :
|
|
|
|
#endif
|
|
|
|
home_bump_mm(axis)
|
|
|
|
);
|
|
|
|
|
2016-09-22 11:23:46 +00:00
|
|
|
// If a second homing move is configured...
|
|
|
|
if (bump) {
|
|
|
|
// Move away from the endstop by the axis HOME_BUMP_MM
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("Move Away:");
|
|
|
|
#endif
|
2016-09-22 11:23:46 +00:00
|
|
|
do_homing_move(axis, -bump);
|
2016-10-02 06:48:17 +00:00
|
|
|
|
2016-09-22 11:23:46 +00:00
|
|
|
// Slow move towards endstop until triggered
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("Home 2 Slow:");
|
|
|
|
#endif
|
2016-09-22 11:23:46 +00:00
|
|
|
do_homing_move(axis, 2 * bump, get_homing_bump_feedrate(axis));
|
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
#if ENABLED(Z_DUAL_ENDSTOPS)
|
|
|
|
if (axis == Z_AXIS) {
|
|
|
|
float adj = fabs(z_endstop_adj);
|
|
|
|
bool lockZ1;
|
|
|
|
if (axis_home_dir > 0) {
|
|
|
|
adj = -adj;
|
|
|
|
lockZ1 = (z_endstop_adj > 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
lockZ1 = (z_endstop_adj < 0);
|
2015-04-01 08:44:13 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
if (lockZ1) stepper.set_z_lock(true); else stepper.set_z2_lock(true);
|
2015-04-01 08:44:13 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
// Move to the adjusted endstop height
|
2016-08-19 06:11:41 +00:00
|
|
|
do_homing_move(axis, adj);
|
2015-04-01 08:44:13 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
if (lockZ1) stepper.set_z_lock(false); else stepper.set_z2_lock(false);
|
|
|
|
stepper.set_homing_flag(false);
|
|
|
|
} // Z_AXIS
|
|
|
|
#endif
|
2015-03-24 17:06:44 +00:00
|
|
|
|
2016-09-15 20:43:06 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
|
|
|
|
set_axis_is_at_home(axis);
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
|
|
|
#elif ENABLED(DELTA)
|
|
|
|
|
|
|
|
// Delta has already moved all three towers up in G28
|
|
|
|
// so here it re-homes each tower in turn.
|
|
|
|
// Delta homing treats the axes as normal linear axes.
|
2016-08-28 00:53:02 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
// retrace by the amount specified in endstop_adj
|
2016-08-19 06:16:49 +00:00
|
|
|
if (endstop_adj[axis] * Z_HOME_DIR < 0) {
|
2016-07-08 13:59:33 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-10-02 06:48:17 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("endstop_adj:");
|
2016-07-08 13:59:33 +00:00
|
|
|
#endif
|
2016-08-19 06:11:41 +00:00
|
|
|
do_homing_move(axis, endstop_adj[axis]);
|
2016-07-08 13:59:33 +00:00
|
|
|
}
|
2016-06-21 23:17:48 +00:00
|
|
|
|
2016-08-28 00:53:02 +00:00
|
|
|
#else
|
2015-04-01 08:44:13 +00:00
|
|
|
|
2016-09-21 21:47:12 +00:00
|
|
|
// For cartesian/core machines,
|
|
|
|
// set the axis to its home position
|
2016-08-28 00:53:02 +00:00
|
|
|
set_axis_is_at_home(axis);
|
|
|
|
sync_plan_position();
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2016-08-28 00:53:02 +00:00
|
|
|
destination[axis] = current_position[axis];
|
2013-06-06 14:36:52 +00:00
|
|
|
|
2016-08-28 00:53:02 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> AFTER set_axis_is_at_home", current_position);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
2015-04-29 02:10:07 +00:00
|
|
|
|
2016-07-08 13:59:33 +00:00
|
|
|
// Put away the Z probe
|
2016-08-30 06:40:29 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE
|
2016-09-12 22:49:35 +00:00
|
|
|
if (axis == Z_AXIS && STOW_PROBE()) return;
|
2016-07-08 13:59:33 +00:00
|
|
|
#endif
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-08-19 06:09:03 +00:00
|
|
|
SERIAL_ECHOPAIR("<<< homeaxis(", axis_codes[axis]);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2016-08-19 06:12:41 +00:00
|
|
|
} // homeaxis()
|
2014-06-23 15:09:57 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
void retract(bool retracting, bool swapping = false) {
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2016-12-13 16:23:43 +00:00
|
|
|
static float hop_height;
|
|
|
|
|
2015-04-01 01:52:19 +00:00
|
|
|
if (retracting == retracted[active_extruder]) return;
|
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
float old_feedrate_mm_s = feedrate_mm_s;
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2015-04-04 06:42:50 +00:00
|
|
|
set_destination_to_current();
|
2015-04-01 01:52:19 +00:00
|
|
|
|
|
|
|
if (retracting) {
|
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = retract_feedrate_mm_s;
|
2015-05-12 09:08:20 +00:00
|
|
|
current_position[E_AXIS] += (swapping ? retract_length_swap : retract_length) / volumetric_multiplier[active_extruder];
|
2016-04-20 20:02:19 +00:00
|
|
|
sync_plan_position_e();
|
2016-06-11 02:23:41 +00:00
|
|
|
prepare_move_to_destination();
|
2015-04-01 01:52:19 +00:00
|
|
|
|
|
|
|
if (retract_zlift > 0.01) {
|
2016-12-13 16:23:43 +00:00
|
|
|
hop_height = current_position[Z_AXIS];
|
|
|
|
// Pretend current position is lower
|
2015-04-01 01:52:19 +00:00
|
|
|
current_position[Z_AXIS] -= retract_zlift;
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-12-13 16:23:43 +00:00
|
|
|
// Raise up to the old current_position
|
2016-06-11 02:23:41 +00:00
|
|
|
prepare_move_to_destination();
|
2015-01-09 20:33:02 +00:00
|
|
|
}
|
2015-04-01 01:52:19 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
2016-12-13 16:23:43 +00:00
|
|
|
// If the height hasn't been altered, undo the Z hop
|
|
|
|
if (retract_zlift > 0.01 && hop_height == current_position[Z_AXIS]) {
|
|
|
|
// Pretend current position is higher. Z will lower on the next move
|
2015-04-02 12:50:31 +00:00
|
|
|
current_position[Z_AXIS] += retract_zlift;
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2014-06-02 15:02:10 +00:00
|
|
|
}
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = retract_recover_feedrate_mm_s;
|
2015-05-12 09:08:20 +00:00
|
|
|
float move_e = swapping ? retract_length_swap + retract_recover_length_swap : retract_length + retract_recover_length;
|
2015-04-01 01:52:19 +00:00
|
|
|
current_position[E_AXIS] -= move_e / volumetric_multiplier[active_extruder];
|
2016-04-20 20:02:19 +00:00
|
|
|
sync_plan_position_e();
|
2016-12-13 16:23:43 +00:00
|
|
|
|
|
|
|
// Lower Z and recover E
|
2016-06-11 02:23:41 +00:00
|
|
|
prepare_move_to_destination();
|
2014-02-17 02:59:04 +00:00
|
|
|
}
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = old_feedrate_mm_s;
|
2015-04-07 00:04:22 +00:00
|
|
|
retracted[active_extruder] = retracting;
|
2015-04-01 01:52:19 +00:00
|
|
|
|
|
|
|
} // retract()
|
|
|
|
|
|
|
|
#endif // FWRETRACT
|
2014-02-17 03:00:28 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MIXING_EXTRUDER)
|
|
|
|
|
|
|
|
void normalize_mix() {
|
|
|
|
float mix_total = 0.0;
|
2016-11-12 20:33:07 +00:00
|
|
|
for (int i = 0; i < MIXING_STEPPERS; i++) mix_total += RECIPROCAL(mixing_factor[i]);
|
2016-06-28 22:06:56 +00:00
|
|
|
// Scale all values if they don't add up to ~1.0
|
2016-11-12 20:33:07 +00:00
|
|
|
if (!NEAR(mix_total, 1.0)) {
|
2016-06-28 22:06:56 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Warning: Mix factors must add up to 1.0. Scaling.");
|
2016-11-12 20:33:07 +00:00
|
|
|
for (int i = 0; i < MIXING_STEPPERS; i++) mixing_factor[i] *= mix_total;
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(DIRECT_MIXING_IN_G1)
|
|
|
|
// Get mixing parameters from the GCode
|
|
|
|
// The total "must" be 1.0 (but it will be normalized)
|
2016-11-15 21:50:54 +00:00
|
|
|
// If no mix factors are given, the old mix is preserved
|
2016-06-28 22:06:56 +00:00
|
|
|
void gcode_get_mix() {
|
|
|
|
const char* mixing_codes = "ABCDHI";
|
2016-11-15 21:50:54 +00:00
|
|
|
byte mix_bits = 0;
|
|
|
|
for (uint8_t i = 0; i < MIXING_STEPPERS; i++) {
|
|
|
|
if (code_seen(mixing_codes[i])) {
|
|
|
|
SBI(mix_bits, i);
|
|
|
|
float v = code_value_float();
|
|
|
|
NOLESS(v, 0.0);
|
|
|
|
mixing_factor[i] = RECIPROCAL(v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If any mixing factors were included, clear the rest
|
|
|
|
// If none were included, preserve the last mix
|
|
|
|
if (mix_bits) {
|
|
|
|
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
|
|
|
|
if (!TEST(mix_bits, i)) mixing_factor[i] = 0.0;
|
|
|
|
normalize_mix();
|
2016-11-12 20:33:07 +00:00
|
|
|
}
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2016-03-27 03:36:36 +00:00
|
|
|
* ***************************************************************************
|
|
|
|
* ***************************** G-CODE HANDLING *****************************
|
|
|
|
* ***************************************************************************
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-05-14 01:52:41 +00:00
|
|
|
/**
|
|
|
|
* Set XYZE destination and feedrate from the current GCode command
|
|
|
|
*
|
|
|
|
* - Set destination from included axis codes
|
|
|
|
* - Set to current for missing axis codes
|
|
|
|
* - Set the feedrate, if included
|
|
|
|
*/
|
|
|
|
void gcode_get_destination() {
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) {
|
2015-05-14 01:52:41 +00:00
|
|
|
if (code_seen(axis_codes[i]))
|
2016-05-31 15:26:08 +00:00
|
|
|
destination[i] = code_value_axis_units(i) + (axis_relative_modes[i] || relative_mode ? current_position[i] : 0);
|
2015-05-14 01:52:41 +00:00
|
|
|
else
|
|
|
|
destination[i] = current_position[i];
|
|
|
|
}
|
2016-07-14 01:18:59 +00:00
|
|
|
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_seen('F') && code_value_linear_units() > 0.0)
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = MMM_TO_MMS(code_value_linear_units());
|
2016-07-14 01:18:59 +00:00
|
|
|
|
|
|
|
#if ENABLED(PRINTCOUNTER)
|
2016-07-16 01:49:34 +00:00
|
|
|
if (!DEBUGGING(DRYRUN))
|
2016-07-14 01:18:59 +00:00
|
|
|
print_job_timer.incFilamentUsed(destination[E_AXIS] - current_position[E_AXIS]);
|
|
|
|
#endif
|
2016-06-28 22:06:56 +00:00
|
|
|
|
|
|
|
// Get ABCDHI mixing factors
|
|
|
|
#if ENABLED(MIXING_EXTRUDER) && ENABLED(DIRECT_MIXING_IN_G1)
|
|
|
|
gcode_get_mix();
|
|
|
|
#endif
|
2015-05-14 01:52:41 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
void unknown_command_error() {
|
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, current_command);
|
2016-10-03 21:23:41 +00:00
|
|
|
SERIAL_CHAR('"');
|
|
|
|
SERIAL_EOL;
|
2015-05-17 12:00:09 +00:00
|
|
|
}
|
|
|
|
|
2016-03-07 11:48:14 +00:00
|
|
|
#if ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
|
2016-03-26 01:36:21 +00:00
|
|
|
/**
|
|
|
|
* Output a "busy" message at regular intervals
|
|
|
|
* while the machine is not accepting commands.
|
|
|
|
*/
|
2016-03-07 11:48:14 +00:00
|
|
|
void host_keepalive() {
|
|
|
|
millis_t ms = millis();
|
2016-04-09 23:58:17 +00:00
|
|
|
if (host_keepalive_interval && busy_state != NOT_BUSY) {
|
2016-04-10 22:55:12 +00:00
|
|
|
if (PENDING(ms, next_busy_signal_ms)) return;
|
2016-03-07 11:48:14 +00:00
|
|
|
switch (busy_state) {
|
|
|
|
case IN_HANDLER:
|
|
|
|
case IN_PROCESS:
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_BUSY_PROCESSING);
|
|
|
|
break;
|
|
|
|
case PAUSED_FOR_USER:
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_USER);
|
|
|
|
break;
|
|
|
|
case PAUSED_FOR_INPUT:
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_INPUT);
|
|
|
|
break;
|
2016-04-02 21:28:17 +00:00
|
|
|
default:
|
|
|
|
break;
|
2016-03-07 11:48:14 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-10 22:55:12 +00:00
|
|
|
next_busy_signal_ms = ms + host_keepalive_interval * 1000UL;
|
2016-03-07 11:48:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif //HOST_KEEPALIVE_FEATURE
|
|
|
|
|
2016-09-22 00:16:01 +00:00
|
|
|
bool position_is_reachable(float target[XYZ]
|
|
|
|
#if HAS_BED_PROBE
|
|
|
|
, bool by_probe=false
|
|
|
|
#endif
|
|
|
|
) {
|
2016-09-12 03:21:32 +00:00
|
|
|
float dx = RAW_X_POSITION(target[X_AXIS]),
|
2016-09-24 01:02:51 +00:00
|
|
|
dy = RAW_Y_POSITION(target[Y_AXIS]);
|
2016-09-12 03:21:32 +00:00
|
|
|
|
2016-09-22 00:16:01 +00:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
if (by_probe) {
|
|
|
|
dx -= X_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
dy -= Y_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-09-15 20:43:59 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
#if MIDDLE_DEAD_ZONE_R > 0
|
|
|
|
const float R2 = HYPOT2(dx - SCARA_OFFSET_X, dy - SCARA_OFFSET_Y);
|
2016-09-22 00:16:01 +00:00
|
|
|
return R2 >= sq(float(MIDDLE_DEAD_ZONE_R)) && R2 <= sq(L1 + L2);
|
2016-09-15 20:43:59 +00:00
|
|
|
#else
|
2016-09-22 00:16:01 +00:00
|
|
|
return HYPOT2(dx - SCARA_OFFSET_X, dy - SCARA_OFFSET_Y) <= sq(L1 + L2);
|
2016-09-15 20:43:59 +00:00
|
|
|
#endif
|
|
|
|
#elif ENABLED(DELTA)
|
2016-09-22 00:16:01 +00:00
|
|
|
return HYPOT2(dx, dy) <= sq(DELTA_PRINTABLE_RADIUS);
|
2016-09-12 03:21:32 +00:00
|
|
|
#else
|
2016-09-24 01:02:51 +00:00
|
|
|
const float dz = RAW_Z_POSITION(target[Z_AXIS]);
|
2016-09-22 00:16:01 +00:00
|
|
|
return dx >= X_MIN_POS - 0.0001 && dx <= X_MAX_POS + 0.0001
|
|
|
|
&& dy >= Y_MIN_POS - 0.0001 && dy <= Y_MAX_POS + 0.0001
|
|
|
|
&& dz >= Z_MIN_POS - 0.0001 && dz <= Z_MAX_POS + 0.0001;
|
2016-09-12 03:21:32 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**************************************************
|
|
|
|
***************** GCode Handlers *****************
|
|
|
|
**************************************************/
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* G0, G1: Coordinated movement of X Y Z E axes
|
|
|
|
*/
|
2016-09-15 19:15:08 +00:00
|
|
|
inline void gcode_G0_G1(
|
|
|
|
#if IS_SCARA
|
|
|
|
bool fast_move=false
|
|
|
|
#endif
|
|
|
|
) {
|
2015-04-08 07:56:19 +00:00
|
|
|
if (IsRunning()) {
|
2015-05-14 01:52:41 +00:00
|
|
|
gcode_get_destination(); // For X Y Z E F
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-04-14 00:17:36 +00:00
|
|
|
|
|
|
|
if (autoretract_enabled && !(code_seen('X') || code_seen('Y') || code_seen('Z')) && code_seen('E')) {
|
2015-03-05 12:27:24 +00:00
|
|
|
float echange = destination[E_AXIS] - current_position[E_AXIS];
|
|
|
|
// Is this move an attempt to retract or recover?
|
|
|
|
if ((echange < -MIN_RETRACT && !retracted[active_extruder]) || (echange > MIN_RETRACT && retracted[active_extruder])) {
|
|
|
|
current_position[E_AXIS] = destination[E_AXIS]; // hide the slicer-generated retract/recover from calculations
|
2016-04-20 20:02:19 +00:00
|
|
|
sync_plan_position_e(); // AND from the planner
|
2015-03-05 12:27:24 +00:00
|
|
|
retract(!retracted[active_extruder]);
|
|
|
|
return;
|
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif //FWRETRACT
|
2015-04-14 00:17:36 +00:00
|
|
|
|
2016-09-15 19:15:08 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
fast_move ? prepare_uninterpolated_move_to_destination() : prepare_move_to_destination();
|
|
|
|
#else
|
|
|
|
prepare_move_to_destination();
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* G2: Clockwise Arc
|
|
|
|
* G3: Counterclockwise Arc
|
2016-09-19 01:23:01 +00:00
|
|
|
*
|
|
|
|
* This command has two forms: IJ-form and R-form.
|
|
|
|
*
|
|
|
|
* - I specifies an X offset. J specifies a Y offset.
|
|
|
|
* At least one of the IJ parameters is required.
|
|
|
|
* X and Y can be omitted to do a complete circle.
|
|
|
|
* The given XY is not error-checked. The arc ends
|
|
|
|
* based on the angle of the destination.
|
|
|
|
* Mixing I or J with R will throw an error.
|
|
|
|
*
|
|
|
|
* - R specifies the radius. X or Y is required.
|
|
|
|
* Omitting both X and Y will throw an error.
|
|
|
|
* X or Y must differ from the current XY.
|
|
|
|
* Mixing R with I or J will throw an error.
|
|
|
|
*
|
|
|
|
* Examples:
|
|
|
|
*
|
|
|
|
* G2 I10 ; CW circle centered at X+10
|
|
|
|
* G3 X20 Y12 R14 ; CCW circle with r=14 ending at X20 Y12
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-05-13 11:27:45 +00:00
|
|
|
#if ENABLED(ARC_SUPPORT)
|
|
|
|
inline void gcode_G2_G3(bool clockwise) {
|
|
|
|
if (IsRunning()) {
|
2015-05-14 01:52:41 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
#if ENABLED(SF_ARC_FIX)
|
|
|
|
bool relative_mode_backup = relative_mode;
|
|
|
|
relative_mode = true;
|
|
|
|
#endif
|
2015-05-14 01:52:41 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
gcode_get_destination();
|
2015-05-14 01:52:41 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
#if ENABLED(SF_ARC_FIX)
|
|
|
|
relative_mode = relative_mode_backup;
|
|
|
|
#endif
|
2015-05-14 01:52:41 +00:00
|
|
|
|
2016-09-19 01:23:01 +00:00
|
|
|
float arc_offset[2] = { 0.0, 0.0 };
|
|
|
|
if (code_seen('R')) {
|
|
|
|
const float r = code_value_axis_units(X_AXIS),
|
|
|
|
x1 = current_position[X_AXIS], y1 = current_position[Y_AXIS],
|
|
|
|
x2 = destination[X_AXIS], y2 = destination[Y_AXIS];
|
|
|
|
if (r && (x2 != x1 || y2 != y1)) {
|
2016-10-03 19:48:44 +00:00
|
|
|
const float e = clockwise ^ (r < 0) ? -1 : 1, // clockwise -1/1, counterclockwise 1/-1
|
2016-09-19 01:23:01 +00:00
|
|
|
dx = x2 - x1, dy = y2 - y1, // X and Y differences
|
|
|
|
d = HYPOT(dx, dy), // Linear distance between the points
|
|
|
|
h = sqrt(sq(r) - sq(d * 0.5)), // Distance to the arc pivot-point
|
|
|
|
mx = (x1 + x2) * 0.5, my = (y1 + y2) * 0.5, // Point between the two points
|
|
|
|
sx = -dy / d, sy = dx / d, // Slope of the perpendicular bisector
|
|
|
|
cx = mx + e * h * sx, cy = my + e * h * sy; // Pivot-point of the arc
|
|
|
|
arc_offset[X_AXIS] = cx - x1;
|
|
|
|
arc_offset[Y_AXIS] = cy - y1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (code_seen('I')) arc_offset[X_AXIS] = code_value_axis_units(X_AXIS);
|
|
|
|
if (code_seen('J')) arc_offset[Y_AXIS] = code_value_axis_units(Y_AXIS);
|
|
|
|
}
|
2015-05-14 01:52:41 +00:00
|
|
|
|
2016-09-19 01:23:01 +00:00
|
|
|
if (arc_offset[0] || arc_offset[1]) {
|
|
|
|
// Send an arc to the planner
|
|
|
|
plan_arc(destination, arc_offset, clockwise);
|
|
|
|
refresh_cmd_timeout();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Bad arguments
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_ARC_ARGS);
|
|
|
|
}
|
2016-05-13 11:27:45 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2016-05-13 11:27:45 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* G4: Dwell S<seconds> or P<milliseconds>
|
|
|
|
*/
|
|
|
|
inline void gcode_G4() {
|
2016-07-14 23:39:49 +00:00
|
|
|
millis_t dwell_ms = 0;
|
2013-09-29 16:20:06 +00:00
|
|
|
|
2016-07-14 23:39:49 +00:00
|
|
|
if (code_seen('P')) dwell_ms = code_value_millis(); // milliseconds to wait
|
|
|
|
if (code_seen('S')) dwell_ms = code_value_millis_from_seconds(); // seconds to wait
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-04-03 22:31:35 +00:00
|
|
|
refresh_cmd_timeout();
|
2016-07-14 23:39:49 +00:00
|
|
|
dwell_ms += previous_cmd_ms; // keep track of when we started waiting
|
2015-04-25 03:13:01 +00:00
|
|
|
|
|
|
|
if (!lcd_hasstatus()) LCD_MESSAGEPGM(MSG_DWELL);
|
|
|
|
|
2016-07-14 23:39:49 +00:00
|
|
|
while (PENDING(millis(), dwell_ms)) idle();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-05-12 20:33:47 +00:00
|
|
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Parameters interpreted according to:
|
|
|
|
* http://linuxcnc.org/docs/2.6/html/gcode/gcode.html#sec:G5-Cubic-Spline
|
|
|
|
* However I, J omission is not supported at this point; all
|
|
|
|
* parameters can be omitted and default to zero.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* G5: Cubic B-spline
|
|
|
|
*/
|
|
|
|
inline void gcode_G5() {
|
|
|
|
if (IsRunning()) {
|
|
|
|
|
|
|
|
gcode_get_destination();
|
|
|
|
|
|
|
|
float offset[] = {
|
2016-05-31 15:26:08 +00:00
|
|
|
code_seen('I') ? code_value_axis_units(X_AXIS) : 0.0,
|
|
|
|
code_seen('J') ? code_value_axis_units(Y_AXIS) : 0.0,
|
|
|
|
code_seen('P') ? code_value_axis_units(X_AXIS) : 0.0,
|
|
|
|
code_seen('Q') ? code_value_axis_units(Y_AXIS) : 0.0
|
2016-05-12 20:33:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
plan_cubic_move(offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // BEZIER_CURVE_SUPPORT
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* G10 - Retract filament according to settings of M207
|
|
|
|
* G11 - Recover filament according to settings of M208
|
|
|
|
*/
|
|
|
|
inline void gcode_G10_G11(bool doRetract=false) {
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
if (doRetract) {
|
2016-05-31 15:26:08 +00:00
|
|
|
retracted_swap[active_extruder] = (code_seen('S') && code_value_bool()); // checks for swap retract argument
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
retract(doRetract
|
|
|
|
#if EXTRUDERS > 1
|
|
|
|
, retracted_swap[active_extruder]
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
}
|
2013-06-10 04:10:00 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif //FWRETRACT
|
2013-06-10 04:10:00 +00:00
|
|
|
|
2016-07-19 00:56:14 +00:00
|
|
|
#if ENABLED(NOZZLE_CLEAN_FEATURE)
|
2016-07-14 15:29:04 +00:00
|
|
|
/**
|
|
|
|
* G12: Clean the nozzle
|
|
|
|
*/
|
2016-06-16 04:18:44 +00:00
|
|
|
inline void gcode_G12() {
|
|
|
|
// Don't allow nozzle cleaning without homing first
|
2016-07-13 23:07:36 +00:00
|
|
|
if (axis_unhomed_error(true, true, true)) { return; }
|
2016-06-16 04:18:44 +00:00
|
|
|
|
|
|
|
uint8_t const pattern = code_seen('P') ? code_value_ushort() : 0;
|
2016-07-13 23:07:36 +00:00
|
|
|
uint8_t const strokes = code_seen('S') ? code_value_ushort() : NOZZLE_CLEAN_STROKES;
|
2016-06-22 23:23:55 +00:00
|
|
|
uint8_t const objects = code_seen('T') ? code_value_ushort() : 3;
|
2016-06-16 04:18:44 +00:00
|
|
|
|
2016-06-22 23:23:55 +00:00
|
|
|
Nozzle::clean(pattern, strokes, objects);
|
2016-06-16 04:18:44 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
|
|
|
/**
|
|
|
|
* G20: Set input mode to inches
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_G20() { set_input_linear_units(LINEARUNIT_INCH); }
|
2016-05-31 15:26:08 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* G21: Set input mode to millimeters
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_G21() { set_input_linear_units(LINEARUNIT_MM); }
|
2016-05-31 15:26:08 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-19 15:24:44 +00:00
|
|
|
#if ENABLED(NOZZLE_PARK_FEATURE)
|
|
|
|
/**
|
|
|
|
* G27: Park the nozzle
|
|
|
|
*/
|
|
|
|
inline void gcode_G27() {
|
|
|
|
// Don't allow nozzle parking without homing first
|
|
|
|
if (axis_unhomed_error(true, true, true)) { return; }
|
|
|
|
uint8_t const z_action = code_seen('P') ? code_value_ushort() : 0;
|
|
|
|
Nozzle::park(z_action);
|
|
|
|
}
|
|
|
|
#endif // NOZZLE_PARK_FEATURE
|
|
|
|
|
2016-07-06 03:10:15 +00:00
|
|
|
#if ENABLED(QUICK_HOME)
|
|
|
|
|
|
|
|
static void quick_home_xy() {
|
|
|
|
|
2016-07-19 15:24:44 +00:00
|
|
|
// Pretend the current position is 0,0
|
|
|
|
current_position[X_AXIS] = current_position[Y_AXIS] = 0.0;
|
|
|
|
sync_plan_position();
|
|
|
|
|
2016-07-20 17:30:10 +00:00
|
|
|
int x_axis_home_dir =
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
|
|
|
x_home_dir(active_extruder)
|
|
|
|
#else
|
|
|
|
home_dir(X_AXIS)
|
|
|
|
#endif
|
|
|
|
;
|
2016-07-06 03:10:15 +00:00
|
|
|
|
2016-07-17 23:30:28 +00:00
|
|
|
float mlx = max_length(X_AXIS),
|
|
|
|
mly = max_length(Y_AXIS),
|
|
|
|
mlratio = mlx > mly ? mly / mlx : mlx / mly,
|
2016-08-07 07:20:25 +00:00
|
|
|
fr_mm_s = min(homing_feedrate_mm_s[X_AXIS], homing_feedrate_mm_s[Y_AXIS]) * sqrt(sq(mlratio) + 1.0);
|
2016-07-06 03:10:15 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
do_blocking_move_to_xy(1.5 * mlx * x_axis_home_dir, 1.5 * mly * home_dir(Y_AXIS), fr_mm_s);
|
2016-07-06 03:10:15 +00:00
|
|
|
endstops.hit_on_purpose(); // clear endstop hit flags
|
2016-07-19 15:24:44 +00:00
|
|
|
current_position[X_AXIS] = current_position[Y_AXIS] = 0.0;
|
2016-07-06 03:10:15 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // QUICK_HOME
|
|
|
|
|
2016-08-29 01:45:18 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
|
|
|
|
void log_machine_info() {
|
|
|
|
SERIAL_ECHOPGM("Machine Type: ");
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
SERIAL_ECHOLNPGM("Delta");
|
2016-09-12 01:11:30 +00:00
|
|
|
#elif IS_SCARA
|
2016-08-29 01:45:18 +00:00
|
|
|
SERIAL_ECHOLNPGM("SCARA");
|
2016-11-06 04:47:38 +00:00
|
|
|
#elif IS_CORE
|
2016-08-29 01:45:18 +00:00
|
|
|
SERIAL_ECHOLNPGM("Core");
|
|
|
|
#else
|
|
|
|
SERIAL_ECHOLNPGM("Cartesian");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
SERIAL_ECHOPGM("Probe: ");
|
|
|
|
#if ENABLED(FIX_MOUNTED_PROBE)
|
|
|
|
SERIAL_ECHOLNPGM("FIX_MOUNTED_PROBE");
|
|
|
|
#elif ENABLED(BLTOUCH)
|
|
|
|
SERIAL_ECHOLNPGM("BLTOUCH");
|
2016-09-30 02:28:23 +00:00
|
|
|
#elif HAS_Z_SERVO_ENDSTOP
|
|
|
|
SERIAL_ECHOLNPGM("SERVO PROBE");
|
2016-08-29 01:45:18 +00:00
|
|
|
#elif ENABLED(Z_PROBE_SLED)
|
|
|
|
SERIAL_ECHOLNPGM("Z_PROBE_SLED");
|
|
|
|
#elif ENABLED(Z_PROBE_ALLEN_KEY)
|
|
|
|
SERIAL_ECHOLNPGM("Z_PROBE_ALLEN_KEY");
|
|
|
|
#else
|
|
|
|
SERIAL_ECHOLNPGM("NONE");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_BED_PROBE
|
|
|
|
SERIAL_ECHOPAIR("Probe Offset X:", X_PROBE_OFFSET_FROM_EXTRUDER);
|
|
|
|
SERIAL_ECHOPAIR(" Y:", Y_PROBE_OFFSET_FROM_EXTRUDER);
|
|
|
|
SERIAL_ECHOPAIR(" Z:", zprobe_zoffset);
|
|
|
|
#if (X_PROBE_OFFSET_FROM_EXTRUDER > 0)
|
|
|
|
SERIAL_ECHOPGM(" (Right");
|
|
|
|
#elif (X_PROBE_OFFSET_FROM_EXTRUDER < 0)
|
|
|
|
SERIAL_ECHOPGM(" (Left");
|
2016-09-15 18:06:00 +00:00
|
|
|
#elif (Y_PROBE_OFFSET_FROM_EXTRUDER != 0)
|
|
|
|
SERIAL_ECHOPGM(" (Middle");
|
|
|
|
#else
|
|
|
|
SERIAL_ECHOPGM(" (Aligned With");
|
2016-08-29 01:45:18 +00:00
|
|
|
#endif
|
|
|
|
#if (Y_PROBE_OFFSET_FROM_EXTRUDER > 0)
|
|
|
|
SERIAL_ECHOPGM("-Back");
|
|
|
|
#elif (Y_PROBE_OFFSET_FROM_EXTRUDER < 0)
|
|
|
|
SERIAL_ECHOPGM("-Front");
|
2016-09-15 18:06:00 +00:00
|
|
|
#elif (X_PROBE_OFFSET_FROM_EXTRUDER != 0)
|
|
|
|
SERIAL_ECHOPGM("-Center");
|
2016-08-29 01:45:18 +00:00
|
|
|
#endif
|
|
|
|
if (zprobe_zoffset < 0)
|
|
|
|
SERIAL_ECHOPGM(" & Below");
|
|
|
|
else if (zprobe_zoffset > 0)
|
|
|
|
SERIAL_ECHOPGM(" & Above");
|
|
|
|
else
|
|
|
|
SERIAL_ECHOPGM(" & Same Z as");
|
|
|
|
SERIAL_ECHOLNPGM(" Nozzle)");
|
|
|
|
#endif
|
2016-09-27 04:38:52 +00:00
|
|
|
|
|
|
|
#if HAS_ABL
|
|
|
|
SERIAL_ECHOPGM("Auto Bed Leveling: ");
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_LINEAR)
|
|
|
|
SERIAL_ECHOPGM("LINEAR");
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
SERIAL_ECHOPGM("BILINEAR");
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_3POINT)
|
|
|
|
SERIAL_ECHOPGM("3POINT");
|
|
|
|
#endif
|
|
|
|
if (planner.abl_enabled) {
|
|
|
|
SERIAL_ECHOLNPGM(" (enabled)");
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)
|
|
|
|
float diff[XYZ] = {
|
|
|
|
stepper.get_axis_position_mm(X_AXIS) - current_position[X_AXIS],
|
|
|
|
stepper.get_axis_position_mm(Y_AXIS) - current_position[Y_AXIS],
|
|
|
|
stepper.get_axis_position_mm(Z_AXIS) - current_position[Z_AXIS]
|
|
|
|
};
|
|
|
|
SERIAL_ECHOPGM("ABL Adjustment X");
|
|
|
|
if (diff[X_AXIS] > 0) SERIAL_CHAR('+');
|
|
|
|
SERIAL_ECHO(diff[X_AXIS]);
|
|
|
|
SERIAL_ECHOPGM(" Y");
|
|
|
|
if (diff[Y_AXIS] > 0) SERIAL_CHAR('+');
|
|
|
|
SERIAL_ECHO(diff[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPGM(" Z");
|
|
|
|
if (diff[Z_AXIS] > 0) SERIAL_CHAR('+');
|
|
|
|
SERIAL_ECHO(diff[Z_AXIS]);
|
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
SERIAL_ECHOPAIR("ABL Adjustment Z", bilinear_z_offset(current_position));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
#elif ENABLED(MESH_BED_LEVELING)
|
|
|
|
SERIAL_ECHOPGM("Mesh Bed Leveling");
|
|
|
|
if (mbl.active()) {
|
2016-12-05 07:53:36 +00:00
|
|
|
float lz = current_position[Z_AXIS];
|
|
|
|
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], lz);
|
2016-09-27 04:38:52 +00:00
|
|
|
SERIAL_ECHOLNPGM(" (enabled)");
|
2016-12-05 07:53:36 +00:00
|
|
|
SERIAL_ECHOPAIR("MBL Adjustment Z", lz);
|
2016-09-27 04:38:52 +00:00
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
|
|
|
|
2016-08-29 01:45:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // DEBUG_LEVELING_FEATURE
|
|
|
|
|
2016-09-12 01:25:44 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A delta can only safely home all axes at the same time
|
|
|
|
* This is like quick_home_xy() but for 3 towers.
|
|
|
|
*/
|
|
|
|
inline void home_delta() {
|
2016-10-02 06:48:17 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS(">>> home_delta", current_position);
|
|
|
|
#endif
|
2016-09-12 01:25:44 +00:00
|
|
|
// Init the current position of all carriages to 0,0,0
|
2016-10-22 15:07:18 +00:00
|
|
|
ZERO(current_position);
|
2016-09-12 01:25:44 +00:00
|
|
|
sync_plan_position();
|
|
|
|
|
|
|
|
// Move all carriages together linearly until an endstop is hit.
|
|
|
|
current_position[X_AXIS] = current_position[Y_AXIS] = current_position[Z_AXIS] = (Z_MAX_LENGTH + 10);
|
2016-09-21 22:27:37 +00:00
|
|
|
feedrate_mm_s = homing_feedrate_mm_s[X_AXIS];
|
|
|
|
line_to_current_position();
|
2016-09-12 01:25:44 +00:00
|
|
|
stepper.synchronize();
|
|
|
|
endstops.hit_on_purpose(); // clear endstop hit flags
|
|
|
|
|
|
|
|
// At least one carriage has reached the top.
|
2016-10-02 06:48:17 +00:00
|
|
|
// Now re-home each carriage separately.
|
2016-09-12 01:25:44 +00:00
|
|
|
HOMEAXIS(A);
|
|
|
|
HOMEAXIS(B);
|
|
|
|
HOMEAXIS(C);
|
|
|
|
|
|
|
|
// Set all carriages to their home positions
|
|
|
|
// Do this here all at once for Delta, because
|
|
|
|
// XYZ isn't ABC. Applying this per-tower would
|
|
|
|
// give the impression that they are the same.
|
|
|
|
LOOP_XYZ(i) set_axis_is_at_home((AxisEnum)i);
|
|
|
|
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-10-02 06:48:17 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("<<< home_delta", current_position);
|
2016-09-12 01:25:44 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // DELTA
|
|
|
|
|
2016-09-12 01:39:39 +00:00
|
|
|
#if ENABLED(Z_SAFE_HOMING)
|
|
|
|
|
|
|
|
inline void home_z_safely() {
|
|
|
|
|
|
|
|
// Disallow Z homing if X or Y are unknown
|
|
|
|
if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) {
|
|
|
|
LCD_MESSAGEPGM(MSG_ERR_Z_HOMING);
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_Z_HOMING);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("Z_SAFE_HOMING >>>");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Move the Z probe (or just the nozzle) to the safe homing point
|
|
|
|
*/
|
2016-09-12 03:21:32 +00:00
|
|
|
destination[X_AXIS] = LOGICAL_X_POSITION(Z_SAFE_HOMING_X_POINT);
|
|
|
|
destination[Y_AXIS] = LOGICAL_Y_POSITION(Z_SAFE_HOMING_Y_POINT);
|
|
|
|
destination[Z_AXIS] = current_position[Z_AXIS]; // Z is already at the right height
|
|
|
|
|
2016-09-22 00:16:01 +00:00
|
|
|
if (position_is_reachable(
|
|
|
|
destination
|
2016-09-21 23:38:47 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE
|
2016-09-22 00:16:01 +00:00
|
|
|
, true
|
|
|
|
#endif
|
|
|
|
)
|
|
|
|
) {
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2016-09-21 23:38:47 +00:00
|
|
|
#if HOMING_Z_WITH_PROBE
|
|
|
|
destination[X_AXIS] -= X_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
destination[Y_AXIS] -= Y_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
#endif
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2016-09-21 23:38:47 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("Z_SAFE_HOMING", destination);
|
|
|
|
#endif
|
2016-11-07 06:24:39 +00:00
|
|
|
|
|
|
|
// This causes the carriage on Dual X to unpark
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
|
|
|
active_extruder_parked = false;
|
|
|
|
#endif
|
|
|
|
|
2016-09-12 03:21:32 +00:00
|
|
|
do_blocking_move_to_xy(destination[X_AXIS], destination[Y_AXIS]);
|
2016-09-12 01:39:39 +00:00
|
|
|
HOMEAXIS(Z);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< Z_SAFE_HOMING");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // Z_SAFE_HOMING
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-03-30 01:06:59 +00:00
|
|
|
* G28: Home all axes according to settings
|
|
|
|
*
|
|
|
|
* Parameters
|
|
|
|
*
|
|
|
|
* None Home to all axes with no parameters.
|
|
|
|
* With QUICK_HOME enabled XY will home together, then Z.
|
|
|
|
*
|
|
|
|
* Cartesian parameters
|
|
|
|
*
|
|
|
|
* X Home to the X endstop
|
|
|
|
* Y Home to the Y endstop
|
|
|
|
* Z Home to the Z endstop
|
|
|
|
*
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_G28() {
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-29 01:45:18 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOLNPGM(">>> gcode_G28");
|
|
|
|
log_machine_info();
|
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2015-05-12 07:31:51 +00:00
|
|
|
// Wait for planner moves to finish!
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-05-12 07:31:51 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
// For auto bed leveling, clear the level matrix
|
2016-09-26 04:17:39 +00:00
|
|
|
#if HAS_ABL
|
2016-09-12 01:11:30 +00:00
|
|
|
reset_bed_level();
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2013-06-10 04:10:00 +00:00
|
|
|
|
2016-07-20 02:37:31 +00:00
|
|
|
// Always home with tool 0 active
|
|
|
|
#if HOTENDS > 1
|
|
|
|
uint8_t old_tool_index = active_extruder;
|
|
|
|
tool_change(0, 0, true);
|
|
|
|
#endif
|
|
|
|
|
2016-07-20 17:30:10 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(DUAL_NOZZLE_DUPLICATION_MODE)
|
|
|
|
extruder_duplication_enabled = false;
|
|
|
|
#endif
|
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* For mesh bed leveling deactivate the mesh calculations, will be turned
|
|
|
|
* on again when homing all axis
|
|
|
|
*/
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-05-24 20:53:15 +00:00
|
|
|
float pre_home_z = MESH_HOME_SEARCH_Z;
|
2016-06-04 04:31:38 +00:00
|
|
|
if (mbl.active()) {
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("MBL was active");
|
|
|
|
#endif
|
2016-12-05 07:53:36 +00:00
|
|
|
// Use known Z position if already homed
|
2016-05-24 20:53:15 +00:00
|
|
|
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS]) {
|
2016-12-05 07:53:36 +00:00
|
|
|
set_bed_leveling_enabled(false);
|
2016-05-24 20:53:15 +00:00
|
|
|
pre_home_z = current_position[Z_AXIS];
|
|
|
|
}
|
2016-12-05 07:53:36 +00:00
|
|
|
else {
|
|
|
|
mbl.set_active(false);
|
|
|
|
current_position[Z_AXIS] = pre_home_z;
|
|
|
|
}
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("Set Z to pre_home_z", current_position);
|
|
|
|
#endif
|
2016-05-24 20:53:15 +00:00
|
|
|
}
|
2015-03-30 06:16:12 +00:00
|
|
|
#endif
|
2015-03-15 22:18:11 +00:00
|
|
|
|
2016-07-08 13:23:20 +00:00
|
|
|
setup_for_endstop_or_probe_move();
|
2016-07-08 13:49:10 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> endstops.enable(true)");
|
|
|
|
#endif
|
|
|
|
endstops.enable(true); // Enable endstops for next homing move
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
2016-08-28 00:53:02 +00:00
|
|
|
|
2016-09-12 01:25:44 +00:00
|
|
|
home_delta();
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
#else // NOT DELTA
|
2014-10-05 20:20:53 +00:00
|
|
|
|
2016-07-07 01:37:21 +00:00
|
|
|
bool homeX = code_seen('X'), homeY = code_seen('Y'), homeZ = code_seen('Z');
|
2015-03-30 01:06:59 +00:00
|
|
|
|
2015-04-25 02:23:12 +00:00
|
|
|
home_all_axis = (!homeX && !homeY && !homeZ) || (homeX && homeY && homeZ);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-06 01:32:24 +00:00
|
|
|
set_destination_to_current();
|
|
|
|
|
2016-03-08 16:50:23 +00:00
|
|
|
#if Z_HOME_DIR > 0 // If homing away from BED do Z first
|
2015-03-31 03:22:21 +00:00
|
|
|
|
2016-03-08 16:50:23 +00:00
|
|
|
if (home_all_axis || homeZ) {
|
2015-04-12 03:06:48 +00:00
|
|
|
HOMEAXIS(Z);
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-06 02:04:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> HOMEAXIS(Z)", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2016-03-08 16:50:23 +00:00
|
|
|
}
|
2015-03-31 03:22:21 +00:00
|
|
|
|
2016-07-08 13:08:32 +00:00
|
|
|
#else
|
2016-03-07 03:49:11 +00:00
|
|
|
|
2016-07-07 19:28:23 +00:00
|
|
|
if (home_all_axis || homeX || homeY) {
|
2016-07-08 11:40:38 +00:00
|
|
|
// Raise Z before homing any other axes and z is not already high enough (never lower z)
|
2016-08-04 03:51:05 +00:00
|
|
|
destination[Z_AXIS] = LOGICAL_Z_POSITION(Z_HOMING_HEIGHT);
|
2016-07-15 13:02:15 +00:00
|
|
|
if (destination[Z_AXIS] > current_position[Z_AXIS]) {
|
2016-07-06 01:32:24 +00:00
|
|
|
|
2016-07-07 19:28:23 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-26 20:42:16 +00:00
|
|
|
if (DEBUGGING(LEVELING))
|
|
|
|
SERIAL_ECHOLNPAIR("Raise Z (before homing) to ", destination[Z_AXIS]);
|
2016-07-07 19:28:23 +00:00
|
|
|
#endif
|
2016-07-06 01:32:24 +00:00
|
|
|
|
2016-07-15 13:02:15 +00:00
|
|
|
do_blocking_move_to_z(destination[Z_AXIS]);
|
2016-07-07 19:28:23 +00:00
|
|
|
}
|
2016-07-07 19:14:54 +00:00
|
|
|
}
|
2015-04-01 01:52:19 +00:00
|
|
|
|
2016-07-08 13:08:32 +00:00
|
|
|
#endif
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(QUICK_HOME)
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2016-07-07 19:13:14 +00:00
|
|
|
if (home_all_axis || (homeX && homeY)) quick_home_xy();
|
2015-04-01 08:44:13 +00:00
|
|
|
|
2016-07-06 03:10:15 +00:00
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(HOME_Y_BEFORE_X)
|
2016-07-06 03:10:15 +00:00
|
|
|
|
2015-04-22 20:34:55 +00:00
|
|
|
// Home Y
|
2016-07-07 19:13:14 +00:00
|
|
|
if (home_all_axis || homeY) {
|
2016-06-27 16:01:11 +00:00
|
|
|
HOMEAXIS(Y);
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> homeY", current_position);
|
|
|
|
#endif
|
|
|
|
}
|
2016-07-06 03:10:15 +00:00
|
|
|
|
2015-04-22 20:34:55 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-30 01:06:59 +00:00
|
|
|
// Home X
|
2016-07-07 19:13:14 +00:00
|
|
|
if (home_all_axis || homeX) {
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2016-11-07 06:21:45 +00:00
|
|
|
|
|
|
|
// Always home the 2nd (right) extruder first
|
|
|
|
active_extruder = 1;
|
2013-07-17 12:44:45 +00:00
|
|
|
HOMEAXIS(X);
|
2016-11-07 06:21:45 +00:00
|
|
|
|
|
|
|
// Remember this extruder's position for later tool change
|
2016-07-24 23:35:03 +00:00
|
|
|
inactive_extruder_x_pos = RAW_X_POSITION(current_position[X_AXIS]);
|
2016-11-07 06:21:45 +00:00
|
|
|
|
|
|
|
// Home the 1st (left) extruder
|
|
|
|
active_extruder = 0;
|
2012-11-06 11:06:41 +00:00
|
|
|
HOMEAXIS(X);
|
2016-11-07 06:21:45 +00:00
|
|
|
|
|
|
|
// Consider the active extruder to be parked
|
2013-08-07 14:10:26 +00:00
|
|
|
memcpy(raised_parked_position, current_position, sizeof(raised_parked_position));
|
|
|
|
delayed_move_time = 0;
|
2014-02-05 09:47:12 +00:00
|
|
|
active_extruder_parked = true;
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2014-02-05 09:47:12 +00:00
|
|
|
#else
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2013-08-07 14:10:26 +00:00
|
|
|
HOMEAXIS(X);
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2014-02-05 09:47:12 +00:00
|
|
|
#endif
|
2016-11-07 06:21:45 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-06 02:04:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> homeX", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if DISABLED(HOME_Y_BEFORE_X)
|
2015-04-22 20:34:55 +00:00
|
|
|
// Home Y
|
2016-07-07 19:13:14 +00:00
|
|
|
if (home_all_axis || homeY) {
|
2015-07-09 23:57:44 +00:00
|
|
|
HOMEAXIS(Y);
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-06 02:04:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> homeY", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
}
|
2015-04-22 20:34:55 +00:00
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-03-30 01:06:59 +00:00
|
|
|
// Home Z last if homing towards the bed
|
|
|
|
#if Z_HOME_DIR < 0
|
2015-04-12 03:06:48 +00:00
|
|
|
if (home_all_axis || homeZ) {
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(Z_SAFE_HOMING)
|
2016-09-12 01:39:39 +00:00
|
|
|
home_z_safely();
|
|
|
|
#else
|
2015-04-12 03:06:48 +00:00
|
|
|
HOMEAXIS(Z);
|
2016-09-12 01:39:39 +00:00
|
|
|
#endif
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-06 02:04:42 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> (home_all_axis || homeZ) > final", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2015-04-12 03:06:48 +00:00
|
|
|
} // home_all_axis || homeZ
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif // Z_HOME_DIR < 0
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2013-09-29 16:20:06 +00:00
|
|
|
|
2016-06-21 23:17:48 +00:00
|
|
|
#endif // !DELTA (gcode_G28)
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2016-06-22 21:20:34 +00:00
|
|
|
endstops.not_homing();
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2016-11-21 05:12:07 +00:00
|
|
|
#if ENABLED(DELTA) && ENABLED(DELTA_HOME_TO_SAFE_ZONE)
|
2016-10-02 06:48:17 +00:00
|
|
|
// move to a height where we can use the full xy-area
|
|
|
|
do_blocking_move_to_z(delta_clip_start_height);
|
|
|
|
#endif
|
|
|
|
|
2016-05-17 21:38:08 +00:00
|
|
|
// Enable mesh leveling again
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-05-24 20:53:15 +00:00
|
|
|
if (mbl.has_mesh()) {
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("MBL has mesh");
|
|
|
|
#endif
|
2016-05-24 20:53:15 +00:00
|
|
|
if (home_all_axis || (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && homeZ)) {
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("MBL Z homing");
|
|
|
|
#endif
|
2016-06-25 19:58:02 +00:00
|
|
|
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
|
|
|
|
#if Z_HOME_DIR > 0
|
|
|
|
+ Z_MAX_POS
|
|
|
|
#endif
|
|
|
|
;
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-06-04 04:31:38 +00:00
|
|
|
mbl.set_active(true);
|
2016-05-24 20:53:15 +00:00
|
|
|
#if ENABLED(MESH_G28_REST_ORIGIN)
|
|
|
|
current_position[Z_AXIS] = 0.0;
|
|
|
|
set_destination_to_current();
|
2016-09-21 23:40:30 +00:00
|
|
|
line_to_destination(homing_feedrate_mm_s[Z_AXIS]);
|
2016-05-24 20:53:15 +00:00
|
|
|
stepper.synchronize();
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("MBL Rest Origin", current_position);
|
|
|
|
#endif
|
2016-05-24 20:53:15 +00:00
|
|
|
#else
|
2016-09-23 08:01:27 +00:00
|
|
|
planner.unapply_leveling(current_position);
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("MBL adjusted MESH_HOME_SEARCH_Z", current_position);
|
|
|
|
#endif
|
2016-05-24 20:53:15 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else if ((axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS]) && (homeX || homeY)) {
|
|
|
|
current_position[Z_AXIS] = pre_home_z;
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-06-04 04:31:38 +00:00
|
|
|
mbl.set_active(true);
|
2016-09-23 08:01:27 +00:00
|
|
|
planner.unapply_leveling(current_position);
|
2016-07-17 06:35:15 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("MBL Home X or Y", current_position);
|
|
|
|
#endif
|
2016-05-24 20:53:15 +00:00
|
|
|
}
|
2015-03-15 22:18:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-06-22 21:20:34 +00:00
|
|
|
clean_up_after_endstop_or_probe_move();
|
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-06-21 23:18:19 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< gcode_G28");
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-20 02:37:31 +00:00
|
|
|
// Restore the active tool after homing
|
|
|
|
#if HOTENDS > 1
|
|
|
|
tool_change(old_tool_index, 0, true);
|
|
|
|
#endif
|
|
|
|
|
2016-04-26 01:23:09 +00:00
|
|
|
report_current_position();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2013-09-29 16:20:06 +00:00
|
|
|
|
2016-06-22 21:03:22 +00:00
|
|
|
#if HAS_PROBING_PROCEDURE
|
|
|
|
|
|
|
|
void out_of_range_error(const char* p_edge) {
|
|
|
|
SERIAL_PROTOCOLPGM("?Probe ");
|
|
|
|
serialprintPGM(p_edge);
|
|
|
|
SERIAL_PROTOCOLLNPGM(" position out of range.");
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-08-29 01:45:18 +00:00
|
|
|
|
2016-04-13 09:37:41 +00:00
|
|
|
inline void _mbl_goto_xy(float x, float y) {
|
2016-08-07 07:20:25 +00:00
|
|
|
float old_feedrate_mm_s = feedrate_mm_s;
|
2016-11-20 00:34:41 +00:00
|
|
|
feedrate_mm_s = homing_feedrate_mm_s[Z_AXIS];
|
2016-04-13 09:37:41 +00:00
|
|
|
|
2016-04-16 21:17:06 +00:00
|
|
|
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
|
2016-09-20 08:49:42 +00:00
|
|
|
#if Z_CLEARANCE_BETWEEN_PROBES > Z_HOMING_HEIGHT
|
|
|
|
+ Z_CLEARANCE_BETWEEN_PROBES
|
2016-08-04 03:51:05 +00:00
|
|
|
#elif Z_HOMING_HEIGHT > 0
|
|
|
|
+ Z_HOMING_HEIGHT
|
2016-04-16 21:17:06 +00:00
|
|
|
#endif
|
|
|
|
;
|
|
|
|
line_to_current_position();
|
2016-04-13 09:37:41 +00:00
|
|
|
|
2016-11-20 00:34:41 +00:00
|
|
|
feedrate_mm_s = MMM_TO_MMS(XY_PROBE_SPEED);
|
2016-07-24 23:34:01 +00:00
|
|
|
current_position[X_AXIS] = LOGICAL_X_POSITION(x);
|
|
|
|
current_position[Y_AXIS] = LOGICAL_Y_POSITION(y);
|
2016-04-13 09:37:41 +00:00
|
|
|
line_to_current_position();
|
|
|
|
|
2016-09-20 08:49:42 +00:00
|
|
|
#if Z_CLEARANCE_BETWEEN_PROBES > 0 || Z_HOMING_HEIGHT > 0
|
2016-11-20 00:34:41 +00:00
|
|
|
feedrate_mm_s = homing_feedrate_mm_s[Z_AXIS];
|
2016-07-24 23:34:01 +00:00
|
|
|
current_position[Z_AXIS] = LOGICAL_Z_POSITION(MESH_HOME_SEARCH_Z);
|
2016-04-13 09:37:41 +00:00
|
|
|
line_to_current_position();
|
|
|
|
#endif
|
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = old_feedrate_mm_s;
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2016-04-13 09:37:41 +00:00
|
|
|
}
|
|
|
|
|
2016-12-04 01:21:27 +00:00
|
|
|
// Save 130 bytes with non-duplication of PSTR
|
|
|
|
void say_not_entered() { SERIAL_PROTOCOLLNPGM(" not entered."); }
|
|
|
|
|
2015-03-26 03:36:24 +00:00
|
|
|
/**
|
2015-08-20 14:07:55 +00:00
|
|
|
* G29: Mesh-based Z probe, probes a grid and produces a
|
2015-03-26 03:36:24 +00:00
|
|
|
* mesh to compensate for variable bed height
|
|
|
|
*
|
|
|
|
* Parameters With MESH_BED_LEVELING:
|
|
|
|
*
|
2015-04-01 19:18:51 +00:00
|
|
|
* S0 Produce a mesh report
|
|
|
|
* S1 Start probing mesh points
|
|
|
|
* S2 Probe the next mesh point
|
|
|
|
* S3 Xn Yn Zn.nn Manually modify a single point
|
2016-03-24 21:16:09 +00:00
|
|
|
* S4 Zn.nn Set z offset. Positive away from bed, negative closer to bed.
|
2016-05-24 20:53:15 +00:00
|
|
|
* S5 Reset and disable mesh
|
2015-03-26 03:36:24 +00:00
|
|
|
*
|
2015-04-01 19:18:51 +00:00
|
|
|
* The S0 report the points as below
|
|
|
|
*
|
2016-03-24 21:16:09 +00:00
|
|
|
* +----> X-axis 1-n
|
2015-04-01 19:18:51 +00:00
|
|
|
* |
|
|
|
|
* |
|
2016-03-24 21:16:09 +00:00
|
|
|
* v Y-axis 1-n
|
2015-08-05 11:40:36 +00:00
|
|
|
*
|
2015-03-26 03:36:24 +00:00
|
|
|
*/
|
2015-03-21 13:50:47 +00:00
|
|
|
inline void gcode_G29() {
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2015-03-21 13:50:47 +00:00
|
|
|
static int probe_point = -1;
|
2016-05-31 15:26:08 +00:00
|
|
|
MeshLevelingState state = code_seen('S') ? (MeshLevelingState)code_value_byte() : MeshReport;
|
2016-05-24 20:53:15 +00:00
|
|
|
if (state < 0 || state > 5) {
|
|
|
|
SERIAL_PROTOCOLLNPGM("S out of range (0-5).");
|
2015-04-03 22:31:35 +00:00
|
|
|
return;
|
2015-03-21 13:50:47 +00:00
|
|
|
}
|
|
|
|
|
2016-05-22 00:38:14 +00:00
|
|
|
int8_t px, py;
|
2015-04-05 02:16:16 +00:00
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
switch (state) {
|
2015-04-03 22:31:35 +00:00
|
|
|
case MeshReport:
|
2016-05-24 20:53:15 +00:00
|
|
|
if (mbl.has_mesh()) {
|
2016-08-21 01:11:08 +00:00
|
|
|
SERIAL_PROTOCOLPAIR("State: ", mbl.active() ? MSG_ON : MSG_OFF);
|
2016-08-11 01:49:25 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("\nNum X,Y: " STRINGIFY(MESH_NUM_X_POINTS) "," STRINGIFY(MESH_NUM_Y_POINTS));
|
|
|
|
SERIAL_PROTOCOLLNPGM("Z search height: " STRINGIFY(MESH_HOME_SEARCH_Z));
|
|
|
|
SERIAL_PROTOCOLPGM("Z offset: "); SERIAL_PROTOCOL_F(mbl.z_offset, 5);
|
2015-04-03 22:31:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("\nMeasured points:");
|
2016-05-22 00:38:14 +00:00
|
|
|
for (py = 0; py < MESH_NUM_Y_POINTS; py++) {
|
|
|
|
for (px = 0; px < MESH_NUM_X_POINTS; px++) {
|
2015-04-03 22:31:35 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" ");
|
2016-05-22 00:38:14 +00:00
|
|
|
SERIAL_PROTOCOL_F(mbl.z_values[py][px], 5);
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
2015-03-21 13:50:47 +00:00
|
|
|
}
|
|
|
|
}
|
2015-04-03 22:31:35 +00:00
|
|
|
else
|
|
|
|
SERIAL_PROTOCOLLNPGM("Mesh bed leveling not active.");
|
|
|
|
break;
|
2015-03-21 13:50:47 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
case MeshStart:
|
|
|
|
mbl.reset();
|
|
|
|
probe_point = 0;
|
2016-02-21 01:35:35 +00:00
|
|
|
enqueue_and_echo_commands_P(PSTR("G28\nG29 S2"));
|
2015-04-03 22:31:35 +00:00
|
|
|
break;
|
2015-03-21 13:50:47 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
case MeshNext:
|
|
|
|
if (probe_point < 0) {
|
|
|
|
SERIAL_PROTOCOLLNPGM("Start mesh probing with \"G29 S1\" first.");
|
|
|
|
return;
|
|
|
|
}
|
2016-04-13 09:37:41 +00:00
|
|
|
// For each G29 S2...
|
2015-04-03 22:31:35 +00:00
|
|
|
if (probe_point == 0) {
|
2016-07-19 00:56:14 +00:00
|
|
|
// For the initial G29 S2 make Z a positive value (e.g., 4.0)
|
2016-06-25 19:58:02 +00:00
|
|
|
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
|
|
|
|
#if Z_HOME_DIR > 0
|
|
|
|
+ Z_MAX_POS
|
|
|
|
#endif
|
|
|
|
;
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-04-13 09:37:41 +00:00
|
|
|
// For G29 S2 after adjusting Z.
|
|
|
|
mbl.set_zigzag_z(probe_point - 1, current_position[Z_AXIS]);
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
2016-04-13 09:37:41 +00:00
|
|
|
// If there's another point to sample, move there with optional lift.
|
2016-03-13 06:38:55 +00:00
|
|
|
if (probe_point < (MESH_NUM_X_POINTS) * (MESH_NUM_Y_POINTS)) {
|
2016-05-22 00:38:14 +00:00
|
|
|
mbl.zigzag(probe_point, px, py);
|
|
|
|
_mbl_goto_xy(mbl.get_probe_x(px), mbl.get_probe_y(py));
|
2015-04-03 22:31:35 +00:00
|
|
|
probe_point++;
|
|
|
|
}
|
|
|
|
else {
|
2016-04-13 09:37:41 +00:00
|
|
|
// One last "return to the bed" (as originally coded) at completion
|
2016-04-17 07:10:52 +00:00
|
|
|
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z
|
2016-09-20 08:49:42 +00:00
|
|
|
#if Z_CLEARANCE_BETWEEN_PROBES > Z_HOMING_HEIGHT
|
|
|
|
+ Z_CLEARANCE_BETWEEN_PROBES
|
2016-08-04 03:51:05 +00:00
|
|
|
#elif Z_HOMING_HEIGHT > 0
|
|
|
|
+ Z_HOMING_HEIGHT
|
2016-04-17 07:10:52 +00:00
|
|
|
#endif
|
|
|
|
;
|
2016-04-13 09:37:41 +00:00
|
|
|
line_to_current_position();
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2016-04-13 09:37:41 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
// After recording the last point, activate the mbl and home
|
|
|
|
SERIAL_PROTOCOLLNPGM("Mesh probing done.");
|
|
|
|
probe_point = -1;
|
2016-06-04 04:31:38 +00:00
|
|
|
mbl.set_has_mesh(true);
|
2016-02-21 01:35:35 +00:00
|
|
|
enqueue_and_echo_commands_P(PSTR("G28"));
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
2015-04-05 02:06:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MeshSet:
|
2015-07-07 05:55:13 +00:00
|
|
|
if (code_seen('X')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
px = code_value_int() - 1;
|
2016-05-22 00:38:14 +00:00
|
|
|
if (px < 0 || px >= MESH_NUM_X_POINTS) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("X out of range (1-" STRINGIFY(MESH_NUM_X_POINTS) ").");
|
2015-04-05 02:06:02 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-10-13 10:51:34 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_CHAR('X'); say_not_entered();
|
2015-10-03 06:08:58 +00:00
|
|
|
return;
|
2015-04-05 02:06:02 +00:00
|
|
|
}
|
2016-08-22 17:46:08 +00:00
|
|
|
|
2015-07-07 05:55:13 +00:00
|
|
|
if (code_seen('Y')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
py = code_value_int() - 1;
|
2016-05-22 00:38:14 +00:00
|
|
|
if (py < 0 || py >= MESH_NUM_Y_POINTS) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Y out of range (1-" STRINGIFY(MESH_NUM_Y_POINTS) ").");
|
2015-04-05 02:06:02 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-10-13 10:51:34 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_CHAR('Y'); say_not_entered();
|
2015-10-03 06:08:58 +00:00
|
|
|
return;
|
2015-04-05 02:06:02 +00:00
|
|
|
}
|
2016-08-22 17:46:08 +00:00
|
|
|
|
2015-07-07 05:55:13 +00:00
|
|
|
if (code_seen('Z')) {
|
2016-07-10 00:53:49 +00:00
|
|
|
mbl.z_values[py][px] = code_value_axis_units(Z_AXIS);
|
2015-10-03 06:08:58 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_CHAR('Z'); say_not_entered();
|
2015-04-01 19:18:51 +00:00
|
|
|
return;
|
2015-04-05 02:06:02 +00:00
|
|
|
}
|
2016-03-24 21:16:09 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MeshSetZOffset:
|
|
|
|
if (code_seen('Z')) {
|
2016-07-10 00:53:49 +00:00
|
|
|
mbl.z_offset = code_value_axis_units(Z_AXIS);
|
2016-03-27 03:36:36 +00:00
|
|
|
}
|
2016-03-24 21:16:09 +00:00
|
|
|
else {
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_CHAR('Z'); say_not_entered();
|
2016-03-24 21:16:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-05-24 20:53:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MeshReset:
|
2016-06-04 04:31:38 +00:00
|
|
|
if (mbl.active()) {
|
2016-12-05 07:53:36 +00:00
|
|
|
current_position[Z_AXIS] -= MESH_HOME_SEARCH_Z;
|
|
|
|
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS]);
|
2016-05-24 20:53:15 +00:00
|
|
|
mbl.reset();
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-05-24 20:53:15 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
mbl.reset();
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
} // switch(state)
|
2016-05-17 00:22:23 +00:00
|
|
|
|
|
|
|
report_current_position();
|
2015-03-21 13:50:47 +00:00
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#elif HAS_ABL
|
2014-02-19 08:51:43 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-08-20 14:07:55 +00:00
|
|
|
* G29: Detailed Z probe, probes the bed at 3 or more points.
|
2015-03-05 12:27:24 +00:00
|
|
|
* Will fail if the printer has not been homed with G28.
|
|
|
|
*
|
|
|
|
* Enhanced G29 Auto Bed Leveling Probe Routine
|
2015-08-05 11:40:36 +00:00
|
|
|
*
|
2016-09-26 04:17:39 +00:00
|
|
|
* Parameters With ABL_GRID:
|
2015-03-05 12:27:24 +00:00
|
|
|
*
|
|
|
|
* P Set the size of the grid that will be probed (P x P points).
|
2015-03-07 18:36:21 +00:00
|
|
|
* Not supported by non-linear delta printer bed leveling.
|
2015-03-05 12:27:24 +00:00
|
|
|
* Example: "G29 P4"
|
|
|
|
*
|
2016-07-04 03:08:22 +00:00
|
|
|
* S Set the XY travel speed between probe points (in units/min)
|
2015-03-11 12:51:56 +00:00
|
|
|
*
|
2015-03-26 04:14:00 +00:00
|
|
|
* D Dry-Run mode. Just evaluate the bed Topology - Don't apply
|
|
|
|
* or clean the rotation Matrix. Useful to check the topology
|
|
|
|
* after a first run of G29.
|
2015-03-25 14:12:30 +00:00
|
|
|
*
|
2015-03-05 12:27:24 +00:00
|
|
|
* V Set the verbose level (0-4). Example: "G29 V3"
|
|
|
|
*
|
|
|
|
* T Generate a Bed Topology Report. Example: "G29 P5 T" for a detailed report.
|
|
|
|
* This is useful for manual bed leveling and finding flaws in the bed (to
|
|
|
|
* assist with part placement).
|
2015-03-07 18:36:21 +00:00
|
|
|
* Not supported by non-linear delta printer bed leveling.
|
2015-03-05 12:27:24 +00:00
|
|
|
*
|
|
|
|
* F Set the Front limit of the probing grid
|
|
|
|
* B Set the Back limit of the probing grid
|
|
|
|
* L Set the Left limit of the probing grid
|
|
|
|
* R Set the Right limit of the probing grid
|
|
|
|
*
|
|
|
|
* Global Parameters:
|
|
|
|
*
|
2015-08-20 14:07:55 +00:00
|
|
|
* E/e By default G29 will engage the Z probe, test the bed, then disengage.
|
|
|
|
* Include "E" to engage/disengage the Z probe for each sample.
|
|
|
|
* There's no extra effect if you have a fixed Z probe.
|
2015-03-05 12:27:24 +00:00
|
|
|
* Usage: "G29 E" or "G29 e"
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
inline void gcode_G29() {
|
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-27 04:39:20 +00:00
|
|
|
bool query = code_seen('Q');
|
|
|
|
uint8_t old_debug_flags = marlin_debug_flags;
|
|
|
|
if (query) marlin_debug_flags |= DEBUG_LEVELING;
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-09-27 04:39:20 +00:00
|
|
|
DEBUG_POS(">>> gcode_G29", current_position);
|
2016-08-29 01:45:18 +00:00
|
|
|
log_machine_info();
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2016-09-27 04:39:20 +00:00
|
|
|
marlin_debug_flags = old_debug_flags;
|
|
|
|
if (query) return;
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
// Don't allow auto-leveling without homing first
|
2016-06-27 22:46:40 +00:00
|
|
|
if (axis_unhomed_error(true, true, true)) return;
|
2015-03-06 22:52:05 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
int verbose_level = code_seen('V') ? code_value_int() : 1;
|
2015-04-03 22:31:35 +00:00
|
|
|
if (verbose_level < 0 || verbose_level > 4) {
|
2016-08-19 09:30:09 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("?(V)erbose Level is implausible (0-4).");
|
2015-04-03 22:31:35 +00:00
|
|
|
return;
|
2015-03-06 22:52:05 +00:00
|
|
|
}
|
|
|
|
|
2016-09-15 18:34:24 +00:00
|
|
|
bool dryrun = code_seen('D'),
|
|
|
|
stow_probe_after_each = code_seen('E');
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ABL_GRID
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2015-04-01 02:58:03 +00:00
|
|
|
if (verbose_level > 0) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("G29 Auto Bed Leveling");
|
|
|
|
if (dryrun) SERIAL_PROTOCOLLNPGM("Running in DRY-RUN mode");
|
2015-03-25 14:12:30 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ABL_PLANAR
|
2016-09-29 06:17:16 +00:00
|
|
|
|
|
|
|
bool do_topography_map = verbose_level > 2 || code_seen('T');
|
|
|
|
|
|
|
|
// X and Y specify points in each direction, overriding the default
|
|
|
|
// These values may be saved with the completed mesh
|
2016-12-10 05:38:28 +00:00
|
|
|
int abl_grid_points_x = code_seen('X') ? code_value_int() : ABL_GRID_MAX_POINTS_X,
|
|
|
|
abl_grid_points_y = code_seen('Y') ? code_value_int() : ABL_GRID_MAX_POINTS_Y;
|
2016-09-29 06:17:16 +00:00
|
|
|
|
2016-09-15 18:56:56 +00:00
|
|
|
if (code_seen('P')) abl_grid_points_x = abl_grid_points_y = code_value_int();
|
2016-09-29 06:17:16 +00:00
|
|
|
|
|
|
|
if (abl_grid_points_x < 2 || abl_grid_points_y < 2) {
|
|
|
|
SERIAL_PROTOCOLLNPGM("?Number of probe points is implausible (2 minimum).");
|
2015-03-07 18:36:21 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-09-29 06:17:16 +00:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
2016-12-10 05:38:28 +00:00
|
|
|
const int abl_grid_points_x = ABL_GRID_MAX_POINTS_X, abl_grid_points_y = ABL_GRID_MAX_POINTS_Y;
|
2016-09-29 06:17:16 +00:00
|
|
|
|
2015-03-07 18:36:21 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
xy_probe_feedrate_mm_s = MMM_TO_MMS(code_seen('S') ? code_value_linear_units() : XY_PROBE_SPEED);
|
2015-03-11 12:51:56 +00:00
|
|
|
|
2016-07-25 01:33:31 +00:00
|
|
|
int left_probe_bed_position = code_seen('L') ? (int)code_value_axis_units(X_AXIS) : LOGICAL_X_POSITION(LEFT_PROBE_BED_POSITION),
|
|
|
|
right_probe_bed_position = code_seen('R') ? (int)code_value_axis_units(X_AXIS) : LOGICAL_X_POSITION(RIGHT_PROBE_BED_POSITION),
|
|
|
|
front_probe_bed_position = code_seen('F') ? (int)code_value_axis_units(Y_AXIS) : LOGICAL_Y_POSITION(FRONT_PROBE_BED_POSITION),
|
|
|
|
back_probe_bed_position = code_seen('B') ? (int)code_value_axis_units(Y_AXIS) : LOGICAL_Y_POSITION(BACK_PROBE_BED_POSITION);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-25 01:33:31 +00:00
|
|
|
bool left_out_l = left_probe_bed_position < LOGICAL_X_POSITION(MIN_PROBE_X),
|
2016-03-13 06:38:55 +00:00
|
|
|
left_out = left_out_l || left_probe_bed_position > right_probe_bed_position - (MIN_PROBE_EDGE),
|
2016-07-25 01:33:31 +00:00
|
|
|
right_out_r = right_probe_bed_position > LOGICAL_X_POSITION(MAX_PROBE_X),
|
2015-03-07 06:14:34 +00:00
|
|
|
right_out = right_out_r || right_probe_bed_position < left_probe_bed_position + MIN_PROBE_EDGE,
|
2016-07-25 01:33:31 +00:00
|
|
|
front_out_f = front_probe_bed_position < LOGICAL_Y_POSITION(MIN_PROBE_Y),
|
2016-03-13 06:38:55 +00:00
|
|
|
front_out = front_out_f || front_probe_bed_position > back_probe_bed_position - (MIN_PROBE_EDGE),
|
2016-07-25 01:33:31 +00:00
|
|
|
back_out_b = back_probe_bed_position > LOGICAL_Y_POSITION(MAX_PROBE_Y),
|
2015-03-07 06:14:34 +00:00
|
|
|
back_out = back_out_b || back_probe_bed_position < front_probe_bed_position + MIN_PROBE_EDGE;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
if (left_out || right_out || front_out || back_out) {
|
|
|
|
if (left_out) {
|
2015-05-25 03:18:02 +00:00
|
|
|
out_of_range_error(PSTR("(L)eft"));
|
2016-07-25 01:33:31 +00:00
|
|
|
left_probe_bed_position = left_out_l ? LOGICAL_X_POSITION(MIN_PROBE_X) : right_probe_bed_position - (MIN_PROBE_EDGE);
|
2015-03-05 05:32:11 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
if (right_out) {
|
2015-05-25 03:18:02 +00:00
|
|
|
out_of_range_error(PSTR("(R)ight"));
|
2016-07-25 01:33:31 +00:00
|
|
|
right_probe_bed_position = right_out_r ? LOGICAL_Y_POSITION(MAX_PROBE_X) : left_probe_bed_position + MIN_PROBE_EDGE;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
if (front_out) {
|
2015-05-25 03:18:02 +00:00
|
|
|
out_of_range_error(PSTR("(F)ront"));
|
2016-07-25 01:33:31 +00:00
|
|
|
front_probe_bed_position = front_out_f ? LOGICAL_Y_POSITION(MIN_PROBE_Y) : back_probe_bed_position - (MIN_PROBE_EDGE);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
if (back_out) {
|
2015-05-25 03:18:02 +00:00
|
|
|
out_of_range_error(PSTR("(B)ack"));
|
2016-07-25 01:33:31 +00:00
|
|
|
back_probe_bed_position = back_out_b ? LOGICAL_Y_POSITION(MAX_PROBE_Y) : front_probe_bed_position + MIN_PROBE_EDGE;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // ABL_GRID
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
stepper.synchronize();
|
2016-04-09 00:38:26 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
// Disable auto bed leveling during G29
|
2016-09-27 04:39:45 +00:00
|
|
|
bool abl_should_enable = planner.abl_enabled;
|
2016-04-22 14:09:42 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
planner.abl_enabled = false;
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
if (!dryrun) {
|
2016-08-21 08:10:55 +00:00
|
|
|
// Re-orient the current position without leveling
|
|
|
|
// based on where the steppers are positioned.
|
2016-09-29 06:18:37 +00:00
|
|
|
set_current_from_steppers_for_axis(ALL_AXES);
|
2015-04-01 02:58:03 +00:00
|
|
|
|
2016-09-29 06:02:54 +00:00
|
|
|
// Sync the planner to where the steppers stopped
|
2016-10-23 00:45:13 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-08-21 08:10:55 +00:00
|
|
|
}
|
2016-04-09 00:38:26 +00:00
|
|
|
|
2016-06-21 22:32:28 +00:00
|
|
|
setup_for_endstop_or_probe_move();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
// Deploy the probe. Probe will raise if needed.
|
2016-09-22 23:57:04 +00:00
|
|
|
if (DEPLOY_PROBE()) {
|
2016-09-27 04:39:45 +00:00
|
|
|
planner.abl_enabled = abl_should_enable;
|
2016-09-22 23:57:04 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-06-21 23:03:02 +00:00
|
|
|
|
2016-09-21 23:41:35 +00:00
|
|
|
float xProbe = 0, yProbe = 0, measured_z = 0;
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ABL_GRID
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
// probe at the points of a lattice grid
|
2016-09-15 18:56:56 +00:00
|
|
|
const float xGridSpacing = (right_probe_bed_position - left_probe_bed_position) / (abl_grid_points_x - 1),
|
|
|
|
yGridSpacing = (back_probe_bed_position - front_probe_bed_position) / (abl_grid_points_y - 1);
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-09-12 01:56:16 +00:00
|
|
|
|
2016-04-13 09:33:53 +00:00
|
|
|
float zoffset = zprobe_zoffset;
|
2016-07-07 01:37:21 +00:00
|
|
|
if (code_seen('Z')) zoffset += code_value_axis_units(Z_AXIS);
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2016-09-27 07:38:38 +00:00
|
|
|
if ( xGridSpacing != bilinear_grid_spacing[X_AXIS]
|
|
|
|
|| yGridSpacing != bilinear_grid_spacing[Y_AXIS]
|
|
|
|
|| left_probe_bed_position != bilinear_start[X_AXIS]
|
|
|
|
|| front_probe_bed_position != bilinear_start[Y_AXIS]
|
|
|
|
) {
|
2016-12-14 07:50:28 +00:00
|
|
|
// Before reset bed level, re-enable to correct the position
|
|
|
|
planner.abl_enabled = abl_should_enable;
|
|
|
|
// Reset grid to 0.0 or "not probed". (Also disables ABL)
|
2016-10-06 22:00:53 +00:00
|
|
|
reset_bed_level();
|
2016-12-14 07:50:28 +00:00
|
|
|
|
2016-11-05 16:01:26 +00:00
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
|
|
|
bilinear_grid_spacing_virt[X_AXIS] = xGridSpacing / (BILINEAR_SUBDIVISIONS);
|
|
|
|
bilinear_grid_spacing_virt[Y_AXIS] = yGridSpacing / (BILINEAR_SUBDIVISIONS);
|
|
|
|
#endif
|
2016-09-26 04:17:39 +00:00
|
|
|
bilinear_grid_spacing[X_AXIS] = xGridSpacing;
|
|
|
|
bilinear_grid_spacing[Y_AXIS] = yGridSpacing;
|
2016-09-27 07:38:38 +00:00
|
|
|
bilinear_start[X_AXIS] = RAW_X_POSITION(left_probe_bed_position);
|
|
|
|
bilinear_start[Y_AXIS] = RAW_Y_POSITION(front_probe_bed_position);
|
2016-12-14 07:50:28 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
// Can't re-enable (on error) until the new grid is written
|
2016-09-27 04:39:45 +00:00
|
|
|
abl_should_enable = false;
|
2016-09-22 23:57:04 +00:00
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_LINEAR)
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* solve the plane equation ax + by + d = z
|
|
|
|
* A is the matrix with rows [x y 1] for all the probed points
|
|
|
|
* B is the vector of the Z positions
|
|
|
|
* the normal vector to the plane is formed by the coefficients of the
|
|
|
|
* plane equation in the standard form, which is Vx*x+Vy*y+Vz*z+d = 0
|
|
|
|
* so Vx = -a Vy = -b Vz = 1 (we want the vector facing towards positive Z
|
|
|
|
*/
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-22 09:37:31 +00:00
|
|
|
int abl2 = abl_grid_points_x * abl_grid_points_y,
|
|
|
|
indexIntoAB[abl_grid_points_x][abl_grid_points_y],
|
|
|
|
probePointCounter = -1;
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-22 09:37:31 +00:00
|
|
|
float eqnAMatrix[abl2 * 3], // "A" matrix of the linear system of equations
|
|
|
|
eqnBVector[abl2], // "B" vector of Z points
|
|
|
|
mean = 0.0;
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // AUTO_BED_LEVELING_LINEAR
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-29 06:19:59 +00:00
|
|
|
#if ENABLED(PROBE_Y_FIRST)
|
|
|
|
#define PR_OUTER_VAR xCount
|
|
|
|
#define PR_OUTER_END abl_grid_points_x
|
|
|
|
#define PR_INNER_VAR yCount
|
|
|
|
#define PR_INNER_END abl_grid_points_y
|
|
|
|
#else
|
|
|
|
#define PR_OUTER_VAR yCount
|
|
|
|
#define PR_OUTER_END abl_grid_points_y
|
|
|
|
#define PR_INNER_VAR xCount
|
|
|
|
#define PR_INNER_END abl_grid_points_x
|
|
|
|
#endif
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2016-10-01 10:21:52 +00:00
|
|
|
bool zig = PR_OUTER_END & 1; // Always end at RIGHT and BACK_PROBE_BED_POSITION
|
2016-09-15 18:56:56 +00:00
|
|
|
|
2016-10-01 10:21:52 +00:00
|
|
|
// Outer loop is Y with PROBE_Y_FIRST disabled
|
2016-09-29 06:19:59 +00:00
|
|
|
for (uint8_t PR_OUTER_VAR = 0; PR_OUTER_VAR < PR_OUTER_END; PR_OUTER_VAR++) {
|
|
|
|
|
|
|
|
int8_t inStart, inStop, inInc;
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2016-10-01 10:21:52 +00:00
|
|
|
if (zig) { // away from origin
|
2016-09-29 06:19:59 +00:00
|
|
|
inStart = 0;
|
|
|
|
inStop = PR_INNER_END;
|
|
|
|
inInc = 1;
|
2015-03-07 18:36:21 +00:00
|
|
|
}
|
2016-10-01 10:21:52 +00:00
|
|
|
else { // towards origin
|
2016-09-29 06:19:59 +00:00
|
|
|
inStart = PR_INNER_END - 1;
|
|
|
|
inStop = -1;
|
|
|
|
inInc = -1;
|
2015-03-07 18:36:21 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-01 10:21:52 +00:00
|
|
|
zig = !zig; // zag
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-10-01 10:21:52 +00:00
|
|
|
// Inner loop is Y with PROBE_Y_FIRST enabled
|
2016-09-29 06:19:59 +00:00
|
|
|
for (int8_t PR_INNER_VAR = inStart; PR_INNER_VAR != inStop; PR_INNER_VAR += inInc) {
|
|
|
|
|
|
|
|
float xBase = left_probe_bed_position + xGridSpacing * xCount,
|
|
|
|
yBase = front_probe_bed_position + yGridSpacing * yCount;
|
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
xProbe = floor(xBase + (xBase < 0 ? 0 : 0.5));
|
2016-09-29 06:19:59 +00:00
|
|
|
yProbe = floor(yBase + (yBase < 0 ? 0 : 0.5));
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_LINEAR)
|
2016-09-22 09:37:31 +00:00
|
|
|
indexIntoAB[xCount][yCount] = ++probePointCounter;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
// Avoid probing outside the round or hexagonal area
|
|
|
|
float pos[XYZ] = { xProbe, yProbe, 0 };
|
|
|
|
if (!position_is_reachable(pos, true)) continue;
|
2016-08-19 06:12:41 +00:00
|
|
|
#endif
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-18 21:24:47 +00:00
|
|
|
measured_z = probe_pt(xProbe, yProbe, stow_probe_after_each, verbose_level);
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
if (measured_z == NAN) {
|
2016-09-27 04:39:45 +00:00
|
|
|
planner.abl_enabled = abl_should_enable;
|
2016-09-22 23:57:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_LINEAR)
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
mean += measured_z;
|
2015-03-26 03:36:24 +00:00
|
|
|
eqnBVector[probePointCounter] = measured_z;
|
|
|
|
eqnAMatrix[probePointCounter + 0 * abl2] = xProbe;
|
|
|
|
eqnAMatrix[probePointCounter + 1 * abl2] = yProbe;
|
|
|
|
eqnAMatrix[probePointCounter + 2 * abl2] = 1;
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2016-09-12 02:46:27 +00:00
|
|
|
bed_level_grid[xCount][yCount] = measured_z + zoffset;
|
2016-09-12 01:11:30 +00:00
|
|
|
|
2015-03-26 03:36:24 +00:00
|
|
|
#endif
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-05-27 03:08:21 +00:00
|
|
|
idle();
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
} //xProbe
|
|
|
|
} //yProbe
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_3POINT)
|
2016-06-24 03:22:28 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-06-24 01:17:31 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("> 3-point Leveling");
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-24 03:22:28 +00:00
|
|
|
// Probe at 3 arbitrary points
|
2016-09-12 09:02:17 +00:00
|
|
|
vector_3 points[3] = {
|
|
|
|
vector_3(ABL_PROBE_PT_1_X, ABL_PROBE_PT_1_Y, 0),
|
|
|
|
vector_3(ABL_PROBE_PT_2_X, ABL_PROBE_PT_2_Y, 0),
|
|
|
|
vector_3(ABL_PROBE_PT_3_X, ABL_PROBE_PT_3_Y, 0)
|
|
|
|
};
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
for (uint8_t i = 0; i < 3; ++i) {
|
|
|
|
// Retain the last probe position
|
|
|
|
xProbe = LOGICAL_X_POSITION(points[i].x);
|
|
|
|
yProbe = LOGICAL_Y_POSITION(points[i].y);
|
|
|
|
measured_z = points[i].z = probe_pt(xProbe, yProbe, stow_probe_after_each, verbose_level);
|
|
|
|
}
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2016-09-22 23:57:04 +00:00
|
|
|
if (measured_z == NAN) {
|
2016-09-27 04:39:45 +00:00
|
|
|
planner.abl_enabled = abl_should_enable;
|
2016-09-22 23:57:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-09-12 09:02:17 +00:00
|
|
|
if (!dryrun) {
|
|
|
|
vector_3 planeNormal = vector_3::cross(points[0] - points[1], points[2] - points[1]).get_normal();
|
2016-08-21 08:10:55 +00:00
|
|
|
if (planeNormal.z < 0) {
|
|
|
|
planeNormal.x *= -1;
|
|
|
|
planeNormal.y *= -1;
|
|
|
|
planeNormal.z *= -1;
|
|
|
|
}
|
|
|
|
planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
|
2016-09-22 23:57:04 +00:00
|
|
|
|
|
|
|
// Can't re-enable (on error) until the new grid is written
|
2016-09-27 04:39:45 +00:00
|
|
|
abl_should_enable = false;
|
2016-08-21 08:10:55 +00:00
|
|
|
}
|
2016-06-24 03:22:28 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#endif // AUTO_BED_LEVELING_3POINT
|
2016-06-24 03:22:28 +00:00
|
|
|
|
2016-09-20 08:49:42 +00:00
|
|
|
// Raise to _Z_CLEARANCE_DEPLOY_PROBE. Stow the probe.
|
2016-09-22 23:57:04 +00:00
|
|
|
if (STOW_PROBE()) {
|
2016-09-27 04:39:45 +00:00
|
|
|
planner.abl_enabled = abl_should_enable;
|
2016-09-22 23:57:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Unless this is a dry run, auto bed leveling will
|
|
|
|
// definitely be enabled after this point
|
|
|
|
//
|
2016-06-24 03:22:28 +00:00
|
|
|
|
|
|
|
// Restore state after probing
|
|
|
|
clean_up_after_endstop_or_probe_move();
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("> probing complete", current_position);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Calculate leveling, print reports, correct the position
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2015-03-26 04:14:00 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
if (!dryrun) extrapolate_unprobed_bed_level();
|
|
|
|
print_bed_level();
|
2015-03-26 04:14:00 +00:00
|
|
|
|
2016-11-05 16:01:26 +00:00
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
|
|
|
bed_level_virt_prepare();
|
|
|
|
bed_level_virt_interpolate();
|
|
|
|
bed_level_virt_print();
|
|
|
|
#endif
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_LINEAR)
|
2015-03-26 04:14:00 +00:00
|
|
|
|
2016-09-15 05:20:30 +00:00
|
|
|
// For LINEAR leveling calculate matrix, print reports, correct the position
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// solve lsq problem
|
2016-09-22 09:37:31 +00:00
|
|
|
float plane_equation_coefficients[3];
|
2016-09-13 07:11:45 +00:00
|
|
|
qr_solve(plane_equation_coefficients, abl2, 3, eqnAMatrix, eqnBVector);
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
mean /= abl2;
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
if (verbose_level) {
|
|
|
|
SERIAL_PROTOCOLPGM("Eqn coefficients: a: ");
|
|
|
|
SERIAL_PROTOCOL_F(plane_equation_coefficients[0], 8);
|
|
|
|
SERIAL_PROTOCOLPGM(" b: ");
|
|
|
|
SERIAL_PROTOCOL_F(plane_equation_coefficients[1], 8);
|
|
|
|
SERIAL_PROTOCOLPGM(" d: ");
|
|
|
|
SERIAL_PROTOCOL_F(plane_equation_coefficients[2], 8);
|
|
|
|
SERIAL_EOL;
|
|
|
|
if (verbose_level > 2) {
|
|
|
|
SERIAL_PROTOCOLPGM("Mean of sampled points: ");
|
|
|
|
SERIAL_PROTOCOL_F(mean, 8);
|
2015-03-07 06:14:34 +00:00
|
|
|
SERIAL_EOL;
|
2016-08-21 08:10:55 +00:00
|
|
|
}
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
2015-05-04 16:35:36 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Create the matrix but don't correct the position yet
|
|
|
|
if (!dryrun) {
|
|
|
|
planner.bed_level_matrix = matrix_3x3::create_look_at(
|
|
|
|
vector_3(-plane_equation_coefficients[0], -plane_equation_coefficients[1], 1)
|
|
|
|
);
|
|
|
|
}
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Show the Topography map if enabled
|
|
|
|
if (do_topography_map) {
|
|
|
|
|
|
|
|
SERIAL_PROTOCOLLNPGM("\nBed Height Topography:\n"
|
|
|
|
" +--- BACK --+\n"
|
|
|
|
" | |\n"
|
|
|
|
" L | (+) | R\n"
|
|
|
|
" E | | I\n"
|
|
|
|
" F | (-) N (+) | G\n"
|
|
|
|
" T | | H\n"
|
|
|
|
" | (-) | T\n"
|
|
|
|
" | |\n"
|
|
|
|
" O-- FRONT --+\n"
|
|
|
|
" (0,0)");
|
|
|
|
|
|
|
|
float min_diff = 999;
|
|
|
|
|
2016-09-15 18:56:56 +00:00
|
|
|
for (int8_t yy = abl_grid_points_y - 1; yy >= 0; yy--) {
|
|
|
|
for (uint8_t xx = 0; xx < abl_grid_points_x; xx++) {
|
2016-09-13 07:11:45 +00:00
|
|
|
int ind = indexIntoAB[xx][yy];
|
|
|
|
float diff = eqnBVector[ind] - mean,
|
|
|
|
x_tmp = eqnAMatrix[ind + 0 * abl2],
|
|
|
|
y_tmp = eqnAMatrix[ind + 1 * abl2],
|
|
|
|
z_tmp = 0;
|
|
|
|
|
|
|
|
apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp);
|
|
|
|
|
|
|
|
NOMORE(min_diff, eqnBVector[ind] - z_tmp);
|
|
|
|
|
|
|
|
if (diff >= 0.0)
|
|
|
|
SERIAL_PROTOCOLPGM(" +"); // Include + for column alignment
|
|
|
|
else
|
|
|
|
SERIAL_PROTOCOLCHAR(' ');
|
|
|
|
SERIAL_PROTOCOL_F(diff, 5);
|
|
|
|
} // xx
|
|
|
|
SERIAL_EOL;
|
|
|
|
} // yy
|
|
|
|
SERIAL_EOL;
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
if (verbose_level > 3) {
|
|
|
|
SERIAL_PROTOCOLLNPGM("\nCorrected Bed Height vs. Bed Topology:");
|
2015-05-04 16:35:36 +00:00
|
|
|
|
2016-09-15 18:56:56 +00:00
|
|
|
for (int8_t yy = abl_grid_points_y - 1; yy >= 0; yy--) {
|
|
|
|
for (uint8_t xx = 0; xx < abl_grid_points_x; xx++) {
|
2015-08-06 11:46:05 +00:00
|
|
|
int ind = indexIntoAB[xx][yy];
|
2015-07-14 17:44:28 +00:00
|
|
|
float x_tmp = eqnAMatrix[ind + 0 * abl2],
|
2015-10-03 06:08:58 +00:00
|
|
|
y_tmp = eqnAMatrix[ind + 1 * abl2],
|
|
|
|
z_tmp = 0;
|
2015-05-04 16:35:36 +00:00
|
|
|
|
2016-04-28 01:06:32 +00:00
|
|
|
apply_rotation_xyz(planner.bed_level_matrix, x_tmp, y_tmp, z_tmp);
|
2015-05-04 16:35:36 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
float diff = eqnBVector[ind] - z_tmp - min_diff;
|
2015-03-26 03:36:24 +00:00
|
|
|
if (diff >= 0.0)
|
2016-09-13 07:11:45 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" +");
|
|
|
|
// Include + for column alignment
|
2015-03-26 03:36:24 +00:00
|
|
|
else
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_PROTOCOLCHAR(' ');
|
2015-03-26 03:36:24 +00:00
|
|
|
SERIAL_PROTOCOL_F(diff, 5);
|
|
|
|
} // xx
|
|
|
|
SERIAL_EOL;
|
|
|
|
} // yy
|
2015-03-07 06:14:34 +00:00
|
|
|
SERIAL_EOL;
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
|
|
|
} //do_topography_map
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // AUTO_BED_LEVELING_LINEAR
|
2016-09-20 09:46:41 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ABL_PLANAR
|
2016-09-20 09:46:41 +00:00
|
|
|
|
2016-09-15 05:20:30 +00:00
|
|
|
// For LINEAR and 3POINT leveling correct the current position
|
|
|
|
|
2015-03-26 03:36:24 +00:00
|
|
|
if (verbose_level > 0)
|
2016-06-27 23:29:35 +00:00
|
|
|
planner.bed_level_matrix.debug("\n\nBed Level Correction Matrix:");
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2015-03-30 06:16:12 +00:00
|
|
|
if (!dryrun) {
|
2016-08-21 08:10:55 +00:00
|
|
|
//
|
|
|
|
// Correct the current XYZ position based on the tilted plane.
|
|
|
|
//
|
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
// 1. Get the distance from the current position to the reference point.
|
2016-08-21 08:10:55 +00:00
|
|
|
float x_dist = RAW_CURRENT_POSITION(X_AXIS) - X_TILT_FULCRUM,
|
|
|
|
y_dist = RAW_CURRENT_POSITION(Y_AXIS) - Y_TILT_FULCRUM,
|
2016-09-26 05:11:27 +00:00
|
|
|
z_real = current_position[Z_AXIS],
|
2016-08-21 08:10:55 +00:00
|
|
|
z_zero = 0;
|
2015-03-26 03:36:24 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-21 08:10:55 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("G29 uncorrected XYZ", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
matrix_3x3 inverse = matrix_3x3::transpose(planner.bed_level_matrix);
|
2016-03-27 03:36:36 +00:00
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
// 2. Apply the inverse matrix to the distance
|
|
|
|
// from the reference point to X, Y, and zero.
|
|
|
|
apply_rotation_xyz(inverse, x_dist, y_dist, z_zero);
|
|
|
|
|
|
|
|
// 3. Get the matrix-based corrected Z.
|
|
|
|
// (Even if not used, get it for comparison.)
|
|
|
|
float new_z = z_real + z_zero;
|
|
|
|
|
|
|
|
// 4. Use the last measured distance to the bed, if possible
|
|
|
|
if ( NEAR(current_position[X_AXIS], xProbe - (X_PROBE_OFFSET_FROM_EXTRUDER))
|
|
|
|
&& NEAR(current_position[Y_AXIS], yProbe - (Y_PROBE_OFFSET_FROM_EXTRUDER))
|
|
|
|
) {
|
|
|
|
float simple_z = z_real - (measured_z - (-zprobe_zoffset));
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("Z from Probe:", simple_z);
|
|
|
|
SERIAL_ECHOPAIR(" Matrix:", new_z);
|
|
|
|
SERIAL_ECHOLNPAIR(" Discrepancy:", simple_z - new_z);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
new_z = simple_z;
|
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2016-08-21 08:10:55 +00:00
|
|
|
// 5. The rotated XY and corrected Z are now current_position
|
|
|
|
current_position[X_AXIS] = LOGICAL_X_POSITION(x_dist) + X_TILT_FULCRUM;
|
|
|
|
current_position[Y_AXIS] = LOGICAL_Y_POSITION(y_dist) + Y_TILT_FULCRUM;
|
2016-09-26 05:11:27 +00:00
|
|
|
current_position[Z_AXIS] = new_z;
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-21 08:10:55 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("G29 corrected XYZ", current_position);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2015-03-26 04:14:00 +00:00
|
|
|
}
|
2016-08-21 08:10:55 +00:00
|
|
|
|
2016-09-26 05:11:27 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
|
|
|
|
if (!dryrun) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-27 04:39:45 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPAIR("G29 uncorrected Z:", current_position[Z_AXIS]);
|
2016-09-26 05:11:27 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-29 06:18:37 +00:00
|
|
|
// Unapply the offset because it is going to be immediately applied
|
|
|
|
// and cause compensation movement in Z
|
2016-09-26 05:11:27 +00:00
|
|
|
current_position[Z_AXIS] -= bilinear_z_offset(current_position);
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-27 04:39:45 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPAIR(" corrected Z:", current_position[Z_AXIS]);
|
2016-09-26 05:11:27 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // ABL_PLANAR
|
2015-03-03 04:00:17 +00:00
|
|
|
|
2015-03-26 03:36:24 +00:00
|
|
|
#ifdef Z_PROBE_END_SCRIPT
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-09-12 22:49:35 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPAIR("Z Probe End Script: ", Z_PROBE_END_SCRIPT);
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2016-02-21 01:35:35 +00:00
|
|
|
enqueue_and_echo_commands_P(PSTR(Z_PROBE_END_SCRIPT));
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-03-26 03:36:24 +00:00
|
|
|
#endif
|
2015-07-09 23:57:44 +00:00
|
|
|
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-06-24 03:22:28 +00:00
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< gcode_G29");
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-26 01:23:09 +00:00
|
|
|
report_current_position();
|
2016-05-09 01:28:46 +00:00
|
|
|
|
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
2016-09-22 23:57:04 +00:00
|
|
|
|
|
|
|
// Auto Bed Leveling is complete! Enable if possible.
|
2016-09-27 04:39:45 +00:00
|
|
|
planner.abl_enabled = dryrun ? abl_should_enable : true;
|
2016-09-29 06:18:37 +00:00
|
|
|
|
|
|
|
if (planner.abl_enabled)
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // HAS_ABL
|
2014-11-25 00:56:37 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
#if HAS_BED_PROBE
|
2015-08-11 23:04:40 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
/**
|
|
|
|
* G30: Do a single Z probe at the current XY
|
2016-11-05 10:08:41 +00:00
|
|
|
* Usage:
|
|
|
|
* G30 <X#> <Y#> <S#>
|
|
|
|
* X = Probe X position (default=current probe position)
|
|
|
|
* Y = Probe Y position (default=current probe position)
|
|
|
|
* S = Stows the probe if 1 (default=1)
|
2016-06-20 22:50:51 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_G30() {
|
2016-11-15 20:10:28 +00:00
|
|
|
float X_probe_location = code_seen('X') ? code_value_axis_units(X_AXIS) : current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER,
|
|
|
|
Y_probe_location = code_seen('Y') ? code_value_axis_units(Y_AXIS) : current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
|
|
|
|
float pos[XYZ] = { X_probe_location, Y_probe_location, LOGICAL_Z_POSITION(0) };
|
|
|
|
if (!position_is_reachable(pos, true)) return;
|
|
|
|
|
2016-11-05 10:08:41 +00:00
|
|
|
bool stow = code_seen('S') ? code_value_bool() : true;
|
2016-06-20 23:18:30 +00:00
|
|
|
|
2016-09-29 06:00:34 +00:00
|
|
|
// Disable leveling so the planner won't mess with us
|
|
|
|
#if PLANNER_LEVELING
|
|
|
|
set_bed_leveling_enabled(false);
|
2016-09-12 08:58:40 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-21 22:32:28 +00:00
|
|
|
setup_for_endstop_or_probe_move();
|
2016-06-20 23:18:30 +00:00
|
|
|
|
2016-11-15 20:10:28 +00:00
|
|
|
float measured_z = probe_pt(X_probe_location, Y_probe_location, stow, 1);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Bed X: ");
|
2016-11-15 20:10:28 +00:00
|
|
|
SERIAL_PROTOCOL(X_probe_location + 0.0001);
|
2016-06-20 22:50:51 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" Y: ");
|
2016-11-15 20:10:28 +00:00
|
|
|
SERIAL_PROTOCOL(Y_probe_location + 0.0001);
|
2016-06-20 22:50:51 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" Z: ");
|
2016-11-15 20:10:28 +00:00
|
|
|
SERIAL_PROTOCOLLN(measured_z + 0.0001);
|
2015-08-11 23:04:40 +00:00
|
|
|
|
2016-06-21 22:32:28 +00:00
|
|
|
clean_up_after_endstop_or_probe_move();
|
2016-06-20 23:18:30 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
report_current_position();
|
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-06-24 00:04:13 +00:00
|
|
|
#if ENABLED(Z_PROBE_SLED)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* G31: Deploy the Z probe
|
|
|
|
*/
|
2016-07-06 01:40:21 +00:00
|
|
|
inline void gcode_G31() { DEPLOY_PROBE(); }
|
2016-06-24 00:04:13 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* G32: Stow the Z probe
|
|
|
|
*/
|
2016-07-06 01:40:21 +00:00
|
|
|
inline void gcode_G32() { STOW_PROBE(); }
|
2016-06-24 00:04:13 +00:00
|
|
|
|
|
|
|
#endif // Z_PROBE_SLED
|
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-09-29 20:06:01 +00:00
|
|
|
#if ENABLED(G38_PROBE_TARGET)
|
2016-09-26 06:30:34 +00:00
|
|
|
|
|
|
|
static bool G38_run_probe() {
|
|
|
|
|
|
|
|
bool G38_pass_fail = false;
|
|
|
|
|
|
|
|
// Get direction of move and retract
|
|
|
|
float retract_mm[XYZ];
|
|
|
|
LOOP_XYZ(i) {
|
|
|
|
float dist = destination[i] - current_position[i];
|
2016-11-02 22:42:24 +00:00
|
|
|
retract_mm[i] = fabs(dist) < G38_MINIMUM_MOVE ? 0 : home_bump_mm((AxisEnum)i) * (dist > 0 ? -1 : 1);
|
2016-09-26 06:30:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
stepper.synchronize(); // wait until the machine is idle
|
|
|
|
|
|
|
|
// Move until destination reached or target hit
|
|
|
|
endstops.enable(true);
|
|
|
|
G38_move = true;
|
|
|
|
G38_endstop_hit = false;
|
|
|
|
prepare_move_to_destination();
|
|
|
|
stepper.synchronize();
|
|
|
|
G38_move = false;
|
|
|
|
|
|
|
|
endstops.hit_on_purpose();
|
|
|
|
set_current_from_steppers_for_axis(ALL_AXES);
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
|
|
|
// Only do remaining moves if target was hit
|
|
|
|
if (G38_endstop_hit) {
|
|
|
|
|
|
|
|
G38_pass_fail = true;
|
|
|
|
|
|
|
|
// Move away by the retract distance
|
|
|
|
set_destination_to_current();
|
|
|
|
LOOP_XYZ(i) destination[i] += retract_mm[i];
|
|
|
|
endstops.enable(false);
|
|
|
|
prepare_move_to_destination();
|
|
|
|
stepper.synchronize();
|
|
|
|
|
|
|
|
feedrate_mm_s /= 4;
|
|
|
|
|
|
|
|
// Bump the target more slowly
|
|
|
|
LOOP_XYZ(i) destination[i] -= retract_mm[i] * 2;
|
|
|
|
|
|
|
|
endstops.enable(true);
|
|
|
|
G38_move = true;
|
|
|
|
prepare_move_to_destination();
|
|
|
|
stepper.synchronize();
|
|
|
|
G38_move = false;
|
|
|
|
|
|
|
|
set_current_from_steppers_for_axis(ALL_AXES);
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-09-19 19:17:10 +00:00
|
|
|
}
|
2016-09-26 06:30:34 +00:00
|
|
|
|
|
|
|
endstops.hit_on_purpose();
|
|
|
|
endstops.not_homing();
|
|
|
|
return G38_pass_fail;
|
2016-09-19 19:17:10 +00:00
|
|
|
}
|
2016-09-26 06:30:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* G38.2 - probe toward workpiece, stop on contact, signal error if failure
|
|
|
|
* G38.3 - probe toward workpiece, stop on contact
|
|
|
|
*
|
|
|
|
* Like G28 except uses Z min endstop for all axes
|
|
|
|
*/
|
|
|
|
inline void gcode_G38(bool is_38_2) {
|
|
|
|
// Get X Y Z E F
|
|
|
|
gcode_get_destination();
|
|
|
|
|
|
|
|
setup_for_endstop_or_probe_move();
|
|
|
|
|
|
|
|
// If any axis has enough movement, do the move
|
|
|
|
LOOP_XYZ(i)
|
|
|
|
if (fabs(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
|
|
|
|
if (!code_seen('F')) feedrate_mm_s = homing_feedrate_mm_s[i];
|
|
|
|
// If G38.2 fails throw an error
|
|
|
|
if (!G38_run_probe() && is_38_2) {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM("Failed to reach target");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
clean_up_after_endstop_or_probe_move();
|
2016-09-19 19:17:10 +00:00
|
|
|
}
|
|
|
|
|
2016-09-29 20:06:01 +00:00
|
|
|
#endif // G38_PROBE_TARGET
|
2016-09-19 19:17:10 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* G92: Set current position to given X Y Z E
|
|
|
|
*/
|
|
|
|
inline void gcode_G92() {
|
2016-09-15 18:34:24 +00:00
|
|
|
bool didXYZ = false,
|
|
|
|
didE = code_seen('E');
|
2016-04-20 20:01:58 +00:00
|
|
|
|
2016-04-27 14:15:20 +00:00
|
|
|
if (!didE) stepper.synchronize();
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) {
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen(axis_codes[i])) {
|
2016-09-15 20:39:44 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
current_position[i] = code_value_axis_units(i);
|
|
|
|
if (i != E_AXIS) didXYZ = true;
|
|
|
|
#else
|
|
|
|
float p = current_position[i],
|
|
|
|
v = code_value_axis_units(i);
|
2016-03-24 10:55:18 +00:00
|
|
|
|
2016-09-15 20:39:44 +00:00
|
|
|
current_position[i] = v;
|
2016-03-24 10:55:18 +00:00
|
|
|
|
2016-09-15 20:39:44 +00:00
|
|
|
if (i != E_AXIS) {
|
|
|
|
didXYZ = true;
|
|
|
|
position_shift[i] += v - p; // Offset the coordinate space
|
|
|
|
update_software_endstops((AxisEnum)i);
|
|
|
|
}
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
2016-06-22 01:56:25 +00:00
|
|
|
if (didXYZ)
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
else if (didE)
|
2016-04-20 20:01:58 +00:00
|
|
|
sync_plan_position_e();
|
2016-09-21 22:54:44 +00:00
|
|
|
|
|
|
|
report_current_position();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2013-10-22 08:02:18 +00:00
|
|
|
|
2016-10-26 22:21:46 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER) || ENABLED(ULTIPANEL)
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2016-07-10 00:53:49 +00:00
|
|
|
* M0: Unconditional stop - Wait for user button press on LCD
|
|
|
|
* M1: Conditional stop - Wait for user button press on LCD
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M0_M1() {
|
2015-10-03 06:08:58 +00:00
|
|
|
char* args = current_command_args;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-13 01:07:08 +00:00
|
|
|
millis_t codenum = 0;
|
2015-03-05 12:27:24 +00:00
|
|
|
bool hasP = false, hasS = false;
|
|
|
|
if (code_seen('P')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
codenum = code_value_millis(); // milliseconds to wait
|
2015-03-05 12:27:24 +00:00
|
|
|
hasP = codenum > 0;
|
|
|
|
}
|
|
|
|
if (code_seen('S')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
codenum = code_value_millis_from_seconds(); // seconds to wait
|
2015-03-05 12:27:24 +00:00
|
|
|
hasS = codenum > 0;
|
|
|
|
}
|
2015-05-17 06:14:02 +00:00
|
|
|
|
2016-09-12 01:51:53 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
|
|
|
|
if (!hasP && !hasS && *args != '\0')
|
|
|
|
lcd_setstatus(args, true);
|
|
|
|
else {
|
|
|
|
LCD_MESSAGEPGM(MSG_USERWAIT);
|
|
|
|
#if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
|
|
|
|
dontExpireStatus();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
if (!hasP && !hasS && *args != '\0') {
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLN(args);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-26 06:42:52 +00:00
|
|
|
wait_for_user = true;
|
2016-10-26 04:25:47 +00:00
|
|
|
KEEPALIVE_STATE(PAUSED_FOR_USER);
|
|
|
|
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-04-03 22:31:35 +00:00
|
|
|
refresh_cmd_timeout();
|
2016-09-12 01:51:53 +00:00
|
|
|
|
2016-10-26 06:42:52 +00:00
|
|
|
if (codenum > 0) {
|
|
|
|
codenum += previous_cmd_ms; // wait until this time for a click
|
|
|
|
while (PENDING(millis(), codenum) && wait_for_user) idle();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if ENABLED(ULTIPANEL)
|
|
|
|
if (lcd_detected()) {
|
|
|
|
while (wait_for_user) idle();
|
|
|
|
IS_SD_PRINTING ? LCD_MESSAGEPGM(MSG_RESUMING) : LCD_MESSAGEPGM(WELCOME_MSG);
|
|
|
|
}
|
2016-10-26 04:25:47 +00:00
|
|
|
#else
|
2016-10-26 06:42:52 +00:00
|
|
|
while (wait_for_user) idle();
|
2016-10-26 04:25:47 +00:00
|
|
|
#endif
|
2016-10-26 06:42:52 +00:00
|
|
|
}
|
2016-10-26 04:25:47 +00:00
|
|
|
|
2016-10-26 06:42:52 +00:00
|
|
|
wait_for_user = false;
|
2016-09-12 01:51:53 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-10-26 22:21:46 +00:00
|
|
|
#endif // EMERGENCY_PARSER || ULTIPANEL
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M17: Enable power on all stepper motors
|
|
|
|
*/
|
|
|
|
inline void gcode_M17() {
|
|
|
|
LCD_MESSAGEPGM(MSG_NO_MOVE);
|
2015-04-04 02:25:22 +00:00
|
|
|
enable_all_steppers();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M20: List SD card to serial output
|
|
|
|
*/
|
|
|
|
inline void gcode_M20() {
|
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_BEGIN_FILE_LIST);
|
|
|
|
card.ls();
|
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_END_FILE_LIST);
|
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M21: Init SD Card
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M21() { card.initsd(); }
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M22: Release SD Card
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M22() { card.release(); }
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2016-02-21 01:35:35 +00:00
|
|
|
* M23: Open a file
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M23() { card.openFile(current_command_args, true); }
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M24: Start SD Print
|
|
|
|
*/
|
|
|
|
inline void gcode_M24() {
|
|
|
|
card.startFileprint();
|
2016-04-06 03:34:03 +00:00
|
|
|
print_job_timer.start();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M25: Pause SD Print
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M25() { card.pauseSDPrint(); }
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M26: Set SD Card file index
|
|
|
|
*/
|
|
|
|
inline void gcode_M26() {
|
|
|
|
if (card.cardOK && code_seen('S'))
|
2016-05-09 20:12:31 +00:00
|
|
|
card.setIndex(code_value_long());
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M27: Get SD Card status
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M27() { card.getStatus(); }
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M28: Start SD Write
|
|
|
|
*/
|
2016-09-13 07:11:45 +00:00
|
|
|
inline void gcode_M28() { card.openFile(current_command_args, false); }
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M29: Stop SD Write
|
|
|
|
* Processed in write to file routine above
|
|
|
|
*/
|
|
|
|
inline void gcode_M29() {
|
|
|
|
// card.saving = false;
|
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M30 <filename>: Delete SD Card file
|
|
|
|
*/
|
|
|
|
inline void gcode_M30() {
|
|
|
|
if (card.cardOK) {
|
|
|
|
card.closefile();
|
2015-05-17 23:58:37 +00:00
|
|
|
card.removeFile(current_command_args);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#endif // SDSUPPORT
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M31: Get the time since the start of SD Print (or last M109)
|
|
|
|
*/
|
|
|
|
inline void gcode_M31() {
|
2016-07-22 14:47:56 +00:00
|
|
|
char buffer[21];
|
2016-07-24 02:13:35 +00:00
|
|
|
duration_t elapsed = print_job_timer.duration();
|
|
|
|
elapsed.toString(buffer);
|
2016-07-13 19:57:59 +00:00
|
|
|
|
2016-07-22 14:47:56 +00:00
|
|
|
lcd_setstatus(buffer);
|
2016-07-13 19:57:59 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Print time: ", buffer);
|
2016-07-13 19:57:59 +00:00
|
|
|
|
2016-10-10 20:34:35 +00:00
|
|
|
#if ENABLED(AUTOTEMP)
|
|
|
|
thermalManager.autotempShutdown();
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M32: Select file and start SD Print
|
|
|
|
*/
|
|
|
|
inline void gcode_M32() {
|
|
|
|
if (card.sdprinting)
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-05-17 23:58:37 +00:00
|
|
|
char* namestartpos = strchr(current_command_args, '!'); // Find ! to indicate filename string start.
|
2015-05-17 06:14:02 +00:00
|
|
|
if (!namestartpos)
|
2015-05-17 23:58:37 +00:00
|
|
|
namestartpos = current_command_args; // Default name position, 4 letters after the M
|
2015-03-05 12:27:24 +00:00
|
|
|
else
|
|
|
|
namestartpos++; //to skip the '!'
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
bool call_procedure = code_seen('P') && (seen_pointer < namestartpos);
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
if (card.cardOK) {
|
2016-03-29 10:16:35 +00:00
|
|
|
card.openFile(namestartpos, true, call_procedure);
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
if (code_seen('S') && seen_pointer < namestartpos) // "S" (must occur _before_ the filename!)
|
2016-05-09 20:12:31 +00:00
|
|
|
card.setIndex(code_value_long());
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
card.startFileprint();
|
2016-03-12 07:16:39 +00:00
|
|
|
|
|
|
|
// Procedure calls count as normal print time.
|
2016-04-06 03:41:36 +00:00
|
|
|
if (!call_procedure) print_job_timer.start();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
|
2015-05-18 00:36:32 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M33: Get the long full path of a file or folder
|
|
|
|
*
|
|
|
|
* Parameters:
|
|
|
|
* <dospath> Case-insensitive DOS-style path to a file or folder
|
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
* M33 miscel~1/armchair/armcha~1.gco
|
|
|
|
*
|
|
|
|
* Output:
|
|
|
|
* /Miscellaneous/Armchair/Armchair.gcode
|
|
|
|
*/
|
|
|
|
inline void gcode_M33() {
|
2015-05-28 21:17:39 +00:00
|
|
|
card.printLongPath(current_command_args);
|
2015-05-18 00:36:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M928: Start SD Write
|
|
|
|
*/
|
|
|
|
inline void gcode_M928() {
|
2015-05-17 23:58:37 +00:00
|
|
|
card.openLogFile(current_command_args);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif // SDSUPPORT
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
/**
|
|
|
|
* Sensitive pin test for M42, M226
|
|
|
|
*/
|
|
|
|
static bool pin_is_protected(uint8_t pin) {
|
|
|
|
static const int sensitive_pins[] = SENSITIVE_PINS;
|
|
|
|
for (uint8_t i = 0; i < COUNT(sensitive_pins); i++)
|
|
|
|
if (sensitive_pins[i] == pin) return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M42: Change pin status via GCode
|
2016-03-06 10:20:03 +00:00
|
|
|
*
|
|
|
|
* P<pin> Pin number (LED if omitted)
|
|
|
|
* S<byte> Pin status from 0 - 255
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M42() {
|
2016-07-10 00:53:49 +00:00
|
|
|
if (!code_seen('S')) return;
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-07-10 00:53:49 +00:00
|
|
|
int pin_status = code_value_int();
|
|
|
|
if (pin_status < 0 || pin_status > 255) return;
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-07-10 00:53:49 +00:00
|
|
|
int pin_number = code_seen('P') ? code_value_int() : LED_PIN;
|
|
|
|
if (pin_number < 0) return;
|
2016-03-06 02:27:45 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
if (pin_is_protected(pin_number)) {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_PROTECTED_PIN);
|
|
|
|
return;
|
|
|
|
}
|
2016-03-06 02:27:45 +00:00
|
|
|
|
2016-07-10 00:53:49 +00:00
|
|
|
pinMode(pin_number, OUTPUT);
|
|
|
|
digitalWrite(pin_number, pin_status);
|
|
|
|
analogWrite(pin_number, pin_status);
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-07-10 00:53:49 +00:00
|
|
|
#if FAN_COUNT > 0
|
|
|
|
switch (pin_number) {
|
|
|
|
#if HAS_FAN0
|
|
|
|
case FAN_PIN: fanSpeeds[0] = pin_status; break;
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN1
|
|
|
|
case FAN1_PIN: fanSpeeds[1] = pin_status; break;
|
|
|
|
#endif
|
|
|
|
#if HAS_FAN2
|
|
|
|
case FAN2_PIN: fanSpeeds[2] = pin_status; break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-10-05 10:50:22 +00:00
|
|
|
#if ENABLED(PINS_DEBUGGING)
|
|
|
|
|
|
|
|
#include "pinsDebug.h"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M43: Pin report and debug
|
|
|
|
*
|
2016-10-31 01:10:17 +00:00
|
|
|
* E<bool> Enable / disable background endstop monitoring
|
|
|
|
* - Machine continues to operate
|
|
|
|
* - Reports changes to endstops
|
|
|
|
* - Toggles LED when an endstop changes
|
|
|
|
*
|
|
|
|
* or
|
|
|
|
*
|
|
|
|
* P<pin> Pin to read or watch. If omitted, read/watch all pins.
|
|
|
|
* W<bool> Watch pins -reporting changes- until reset, click, or M108.
|
|
|
|
* I<bool> Flag to ignore Marlin's pin protection.
|
2016-10-29 18:42:43 +00:00
|
|
|
*
|
2016-10-05 10:50:22 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M43() {
|
2016-10-31 01:10:17 +00:00
|
|
|
|
|
|
|
// Enable or disable endstop monitoring
|
|
|
|
if (code_seen('E')) {
|
|
|
|
endstop_monitor_flag = code_value_bool();
|
|
|
|
SERIAL_PROTOCOLPGM("endstop monitor ");
|
|
|
|
SERIAL_PROTOCOL(endstop_monitor_flag ? "en" : "dis");
|
|
|
|
SERIAL_PROTOCOLLNPGM("abled");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the range of pins to test or watch
|
2016-10-31 12:36:01 +00:00
|
|
|
int first_pin = 0, last_pin = NUM_DIGITAL_PINS - 1;
|
2016-10-05 10:50:22 +00:00
|
|
|
if (code_seen('P')) {
|
|
|
|
first_pin = last_pin = code_value_byte();
|
2016-10-31 12:36:01 +00:00
|
|
|
if (first_pin > NUM_DIGITAL_PINS - 1) return;
|
2016-10-05 10:50:22 +00:00
|
|
|
}
|
|
|
|
|
2016-10-31 01:10:17 +00:00
|
|
|
bool ignore_protection = code_seen('I') ? code_value_bool() : false;
|
|
|
|
|
|
|
|
// Watch until click, M108, or reset
|
2016-10-05 10:50:22 +00:00
|
|
|
if (code_seen('W') && code_value_bool()) { // watch digital pins
|
|
|
|
byte pin_state[last_pin - first_pin + 1];
|
|
|
|
for (int8_t pin = first_pin; pin <= last_pin; pin++) {
|
2016-10-31 01:10:17 +00:00
|
|
|
if (pin_is_protected(pin) && !ignore_protection) continue;
|
2016-10-05 10:50:22 +00:00
|
|
|
pinMode(pin, INPUT_PULLUP);
|
|
|
|
// if (IS_ANALOG(pin))
|
|
|
|
// pin_state[pin - first_pin] = analogRead(pin - analogInputToDigitalPin(0)); // int16_t pin_state[...]
|
|
|
|
// else
|
|
|
|
pin_state[pin - first_pin] = digitalRead(pin);
|
|
|
|
}
|
|
|
|
|
2016-10-26 22:21:46 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER) || ENABLED(ULTIPANEL)
|
2016-10-05 10:50:22 +00:00
|
|
|
wait_for_user = true;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
for (int8_t pin = first_pin; pin <= last_pin; pin++) {
|
|
|
|
if (pin_is_protected(pin)) continue;
|
|
|
|
byte val;
|
|
|
|
// if (IS_ANALOG(pin))
|
|
|
|
// val = analogRead(pin - analogInputToDigitalPin(0)); // int16_t val
|
|
|
|
// else
|
|
|
|
val = digitalRead(pin);
|
|
|
|
if (val != pin_state[pin - first_pin]) {
|
|
|
|
report_pin_state(pin);
|
|
|
|
pin_state[pin - first_pin] = val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-26 22:21:46 +00:00
|
|
|
#if ENABLED(EMERGENCY_PARSER) || ENABLED(ULTIPANEL)
|
2016-10-05 10:50:22 +00:00
|
|
|
if (!wait_for_user) break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
safe_delay(500);
|
|
|
|
}
|
2016-10-31 01:10:17 +00:00
|
|
|
return;
|
2016-10-05 10:50:22 +00:00
|
|
|
}
|
2016-10-31 01:10:17 +00:00
|
|
|
|
|
|
|
// Report current state of selected pin(s)
|
|
|
|
for (uint8_t pin = first_pin; pin <= last_pin; pin++)
|
|
|
|
report_pin_state_extended(pin, ignore_protection);
|
2016-10-05 10:50:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // PINS_DEBUGGING
|
|
|
|
|
2016-06-21 08:28:36 +00:00
|
|
|
#if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-08-20 14:07:55 +00:00
|
|
|
* M48: Z probe repeatability measurement function.
|
2015-03-05 12:27:24 +00:00
|
|
|
*
|
|
|
|
* Usage:
|
2015-04-15 16:17:58 +00:00
|
|
|
* M48 <P#> <X#> <Y#> <V#> <E> <L#>
|
2015-03-30 01:56:09 +00:00
|
|
|
* P = Number of sampled points (4-50, default 10)
|
2015-03-05 12:27:24 +00:00
|
|
|
* X = Sample X position
|
|
|
|
* Y = Sample Y position
|
|
|
|
* V = Verbose level (0-4, default=1)
|
2015-08-20 14:07:55 +00:00
|
|
|
* E = Engage Z probe for each reading
|
2015-03-05 12:27:24 +00:00
|
|
|
* L = Number of legs of movement before probe
|
2016-02-28 04:49:49 +00:00
|
|
|
* S = Schizoid (Or Star if you prefer)
|
2015-08-05 11:40:36 +00:00
|
|
|
*
|
2015-03-30 01:06:59 +00:00
|
|
|
* This function assumes the bed has been homed. Specifically, that a G28 command
|
2015-08-20 14:07:55 +00:00
|
|
|
* as been issued prior to invoking the M48 Z probe repeatability measurement function.
|
2015-03-05 12:27:24 +00:00
|
|
|
* Any information generated by a prior G29 Bed leveling command will be lost and need to be
|
|
|
|
* regenerated.
|
|
|
|
*/
|
|
|
|
inline void gcode_M48() {
|
|
|
|
|
2016-06-27 22:46:40 +00:00
|
|
|
if (axis_unhomed_error(true, true, true)) return;
|
2016-03-03 03:55:01 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
int8_t verbose_level = code_seen('V') ? code_value_byte() : 1;
|
|
|
|
if (verbose_level < 0 || verbose_level > 4) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("?Verbose Level not plausible (0-4).");
|
2016-06-18 08:41:57 +00:00
|
|
|
return;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2015-03-06 22:54:30 +00:00
|
|
|
if (verbose_level > 0)
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("M48 Z-Probe Repeatability Test");
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
int8_t n_samples = code_seen('P') ? code_value_byte() : 10;
|
|
|
|
if (n_samples < 4 || n_samples > 50) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("?Sample size not plausible (4-50).");
|
2016-06-18 08:41:57 +00:00
|
|
|
return;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
float X_current = current_position[X_AXIS],
|
2016-06-22 23:53:04 +00:00
|
|
|
Y_current = current_position[Y_AXIS];
|
2016-06-22 04:01:01 +00:00
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
bool stow_probe_after_each = code_seen('E');
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
float X_probe_location = code_seen('X') ? code_value_axis_units(X_AXIS) : X_current + X_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
#if DISABLED(DELTA)
|
2016-07-25 01:33:31 +00:00
|
|
|
if (X_probe_location < LOGICAL_X_POSITION(MIN_PROBE_X) || X_probe_location > LOGICAL_X_POSITION(MAX_PROBE_X)) {
|
2016-06-18 08:41:57 +00:00
|
|
|
out_of_range_error(PSTR("X"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2016-02-28 04:49:49 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
float Y_probe_location = code_seen('Y') ? code_value_axis_units(Y_AXIS) : Y_current + Y_PROBE_OFFSET_FROM_EXTRUDER;
|
|
|
|
#if DISABLED(DELTA)
|
2016-07-25 01:33:31 +00:00
|
|
|
if (Y_probe_location < LOGICAL_Y_POSITION(MIN_PROBE_Y) || Y_probe_location > LOGICAL_Y_POSITION(MAX_PROBE_Y)) {
|
2016-06-18 08:41:57 +00:00
|
|
|
out_of_range_error(PSTR("Y"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#else
|
2016-09-15 21:21:38 +00:00
|
|
|
float pos[XYZ] = { X_probe_location, Y_probe_location, 0 };
|
2016-09-22 00:16:01 +00:00
|
|
|
if (!position_is_reachable(pos, true)) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("? (X,Y) location outside of probeable radius.");
|
2015-03-05 12:27:24 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-02-28 04:49:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
bool seen_L = code_seen('L');
|
2016-06-18 08:41:57 +00:00
|
|
|
uint8_t n_legs = seen_L ? code_value_byte() : 0;
|
2016-06-22 22:49:05 +00:00
|
|
|
if (n_legs > 15) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("?Number of legs in movement not plausible (0-15).");
|
2016-06-18 08:41:57 +00:00
|
|
|
return;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2016-06-18 08:41:57 +00:00
|
|
|
if (n_legs == 1) n_legs = 2;
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
bool schizoid_flag = code_seen('S');
|
|
|
|
if (schizoid_flag && !seen_L) n_legs = 7;
|
2014-08-09 20:37:23 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* Now get everything to the specified probe point So we can safely do a
|
|
|
|
* probe to get us close to the bed. If the Z-Axis is far from the bed,
|
|
|
|
* we don't want to use that as a starting point for each probe.
|
|
|
|
*/
|
2015-03-05 12:27:24 +00:00
|
|
|
if (verbose_level > 2)
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Positioning the probe...");
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-15 18:34:24 +00:00
|
|
|
// Disable bed level correction in M48 because we want the raw data when we probe
|
2016-09-26 04:17:39 +00:00
|
|
|
#if HAS_ABL
|
2016-03-27 03:36:36 +00:00
|
|
|
reset_bed_level();
|
2016-02-28 04:49:49 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-22 22:49:05 +00:00
|
|
|
setup_for_endstop_or_probe_move();
|
|
|
|
|
2016-06-24 02:22:45 +00:00
|
|
|
// Move to the first point, deploy, and probe
|
|
|
|
probe_pt(X_probe_location, Y_probe_location, stow_probe_after_each, verbose_level);
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-06-18 08:41:57 +00:00
|
|
|
randomSeed(millis());
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-10-05 23:49:05 +00:00
|
|
|
double mean = 0.0, sigma = 0.0, min = 99999.9, max = -99999.9, sample_set[n_samples];
|
2016-10-05 20:09:39 +00:00
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
for (uint8_t n = 0; n < n_samples; n++) {
|
2015-03-05 12:27:24 +00:00
|
|
|
if (n_legs) {
|
2016-02-28 04:49:49 +00:00
|
|
|
int dir = (random(0, 10) > 5.0) ? -1 : 1; // clockwise or counter clockwise
|
2016-06-18 08:41:57 +00:00
|
|
|
float angle = random(0.0, 360.0),
|
|
|
|
radius = random(
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
DELTA_PROBEABLE_RADIUS / 8, DELTA_PROBEABLE_RADIUS / 3
|
|
|
|
#else
|
|
|
|
5, X_MAX_LENGTH / 8
|
|
|
|
#endif
|
|
|
|
);
|
2016-02-28 04:49:49 +00:00
|
|
|
|
|
|
|
if (verbose_level > 3) {
|
|
|
|
SERIAL_ECHOPAIR("Starting radius: ", radius);
|
|
|
|
SERIAL_ECHOPAIR(" angle: ", angle);
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOPGM(" Direction: ");
|
|
|
|
if (dir > 0) SERIAL_ECHOPGM("Counter-");
|
|
|
|
SERIAL_ECHOLNPGM("Clockwise");
|
2016-02-28 04:49:49 +00:00
|
|
|
}
|
2014-08-01 15:29:59 +00:00
|
|
|
|
2015-04-08 21:59:01 +00:00
|
|
|
for (uint8_t l = 0; l < n_legs - 1; l++) {
|
2016-02-28 04:49:49 +00:00
|
|
|
double delta_angle;
|
2016-03-27 03:36:36 +00:00
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
if (schizoid_flag)
|
2016-03-27 03:36:36 +00:00
|
|
|
// The points of a 5 point star are 72 degrees apart. We need to
|
|
|
|
// skip a point and go to the next one on the star.
|
|
|
|
delta_angle = dir * 2.0 * 72.0;
|
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
else
|
2016-03-27 03:36:36 +00:00
|
|
|
// If we do this line, we are just trying to move further
|
|
|
|
// around the circle.
|
|
|
|
delta_angle = dir * (float) random(25, 45);
|
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
angle += delta_angle;
|
2016-03-27 03:36:36 +00:00
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
while (angle > 360.0) // We probably do not need to keep the angle between 0 and 2*PI, but the
|
|
|
|
angle -= 360.0; // Arduino documentation says the trig functions should not be given values
|
|
|
|
while (angle < 0.0) // outside of this range. It looks like they behave correctly with
|
|
|
|
angle += 360.0; // numbers outside of the range, but just to be safe we clamp them.
|
2016-03-27 03:36:36 +00:00
|
|
|
|
2016-04-16 21:35:22 +00:00
|
|
|
X_current = X_probe_location - (X_PROBE_OFFSET_FROM_EXTRUDER) + cos(RADIANS(angle)) * radius;
|
|
|
|
Y_current = Y_probe_location - (Y_PROBE_OFFSET_FROM_EXTRUDER) + sin(RADIANS(angle)) * radius;
|
2016-03-27 03:36:36 +00:00
|
|
|
|
2016-02-28 04:49:49 +00:00
|
|
|
#if DISABLED(DELTA)
|
|
|
|
X_current = constrain(X_current, X_MIN_POS, X_MAX_POS);
|
|
|
|
Y_current = constrain(Y_current, Y_MIN_POS, Y_MAX_POS);
|
|
|
|
#else
|
|
|
|
// If we have gone out too far, we can do a simple fix and scale the numbers
|
|
|
|
// back in closer to the origin.
|
2016-07-16 01:50:25 +00:00
|
|
|
while (HYPOT(X_current, Y_current) > DELTA_PROBEABLE_RADIUS) {
|
2016-02-28 04:49:49 +00:00
|
|
|
X_current /= 1.25;
|
|
|
|
Y_current /= 1.25;
|
|
|
|
if (verbose_level > 3) {
|
|
|
|
SERIAL_ECHOPAIR("Pulling point towards center:", X_current);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR(", ", Y_current);
|
2016-02-28 04:49:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
if (verbose_level > 3) {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Going to:");
|
|
|
|
SERIAL_ECHOPAIR(" X", X_current);
|
|
|
|
SERIAL_ECHOPAIR(" Y", Y_current);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" Z", current_position[Z_AXIS]);
|
2013-06-06 22:49:25 +00:00
|
|
|
}
|
2016-02-28 04:49:49 +00:00
|
|
|
do_blocking_move_to_xy(X_current, Y_current);
|
2015-04-01 01:52:19 +00:00
|
|
|
} // n_legs loop
|
|
|
|
} // n_legs
|
2013-11-04 11:04:04 +00:00
|
|
|
|
2016-06-18 10:16:13 +00:00
|
|
|
// Probe a single point
|
2016-10-05 20:09:39 +00:00
|
|
|
sample_set[n] = probe_pt(X_probe_location, Y_probe_location, stow_probe_after_each, 0);
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* Get the current mean for the data points we have so far
|
|
|
|
*/
|
2016-06-18 08:41:57 +00:00
|
|
|
double sum = 0.0;
|
2015-04-08 21:59:01 +00:00
|
|
|
for (uint8_t j = 0; j <= n; j++) sum += sample_set[j];
|
2015-04-01 01:52:19 +00:00
|
|
|
mean = sum / (n + 1);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-09 17:21:05 +00:00
|
|
|
NOMORE(min, sample_set[n]);
|
|
|
|
NOLESS(max, sample_set[n]);
|
2016-10-05 20:09:39 +00:00
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* Now, use that mean to calculate the standard deviation for the
|
|
|
|
* data points we have so far
|
|
|
|
*/
|
2015-03-05 12:27:24 +00:00
|
|
|
sum = 0.0;
|
2016-07-16 01:50:25 +00:00
|
|
|
for (uint8_t j = 0; j <= n; j++)
|
|
|
|
sum += sq(sample_set[j] - mean);
|
|
|
|
|
2015-04-01 01:52:19 +00:00
|
|
|
sigma = sqrt(sum / (n + 1));
|
2016-06-18 22:38:15 +00:00
|
|
|
if (verbose_level > 0) {
|
|
|
|
if (verbose_level > 1) {
|
|
|
|
SERIAL_PROTOCOL(n + 1);
|
|
|
|
SERIAL_PROTOCOLPGM(" of ");
|
|
|
|
SERIAL_PROTOCOL((int)n_samples);
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOLPGM(": z: ");
|
|
|
|
SERIAL_PROTOCOL_F(sample_set[n], 3);
|
2016-06-18 22:38:15 +00:00
|
|
|
if (verbose_level > 2) {
|
|
|
|
SERIAL_PROTOCOLPGM(" mean: ");
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOL_F(mean, 4);
|
|
|
|
SERIAL_PROTOCOLPGM(" sigma: ");
|
2016-06-18 22:38:15 +00:00
|
|
|
SERIAL_PROTOCOL_F(sigma, 6);
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" min: ");
|
|
|
|
SERIAL_PROTOCOL_F(min, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" max: ");
|
|
|
|
SERIAL_PROTOCOL_F(max, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" range: ");
|
|
|
|
SERIAL_PROTOCOL_F(max-min, 3);
|
2016-06-18 22:38:15 +00:00
|
|
|
}
|
2015-04-01 01:52:19 +00:00
|
|
|
}
|
2016-06-18 22:38:15 +00:00
|
|
|
SERIAL_EOL;
|
Fixed error found by the free coverity tool (https://scan.coverity.com/)
===================================================
Hi,
Please find the latest report on new defect(s) introduced to ErikZalm/Marlin found with Coverity Scan.
Defect(s) Reported-by: Coverity Scan
Showing 15 of 15 defect(s)
** CID 59629: Unchecked return value (CHECKED_RETURN)
/Marlin_main.cpp: 2154 in process_commands()()
** CID 59630: Operands don't affect result (CONSTANT_EXPRESSION_RESULT)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Tone.cpp: 319 in tone(unsigned char, unsigned int, unsigned long)()
** CID 59631: Missing break in switch (MISSING_BREAK)
/Marlin_main.cpp: 1187 in process_commands()()
** CID 59632: Missing break in switch (MISSING_BREAK)
/Marlin_main.cpp: 1193 in process_commands()()
** CID 59633: Out-of-bounds write (OVERRUN)
/temperature.cpp: 914 in disable_heater()()
** CID 59634: Out-of-bounds write (OVERRUN)
/temperature.cpp: 913 in disable_heater()()
** CID 59635: Out-of-bounds read (OVERRUN)
/temperature.cpp: 626 in analog2temp(int, unsigned char)()
** CID 59636: Out-of-bounds read (OVERRUN)
/temperature.cpp: 620 in analog2temp(int, unsigned char)()
** CID 59637: Out-of-bounds write (OVERRUN)
/temperature.cpp: 202 in PID_autotune(float, int, int)()
** CID 59638: Out-of-bounds read (OVERRUN)
/temperature.cpp: 214 in PID_autotune(float, int, int)()
** CID 59639: Out-of-bounds write (OVERRUN)
/Marlin_main.cpp: 2278 in process_commands()()
** CID 59640: Out-of-bounds read (OVERRUN)
/Marlin_main.cpp: 1802 in process_commands()()
** CID 59641: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 51 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
** CID 59642: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 45 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
** CID 59643: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 32 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
________________________________________________________________________________________________________
*** CID 59629: Unchecked return value (CHECKED_RETURN)
/Marlin_main.cpp: 2154 in process_commands()()
2148 }
2149 #endif
2150 }
2151 }
2152 break;
2153 case 85: // M85
CID 59629: Unchecked return value (CHECKED_RETURN)
Calling "code_seen" without checking return value (as is done elsewhere 66 out of 67 times).
2154 code_seen('S');
2155 max_inactive_time = code_value() * 1000;
2156 break;
2157 case 92: // M92
2158 for(int8_t i=0; i < NUM_AXIS; i++)
2159 {
________________________________________________________________________________________________________
*** CID 59630: Operands don't affect result (CONSTANT_EXPRESSION_RESULT)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Tone.cpp: 319 in tone(unsigned char, unsigned int, unsigned long)()
313 else
314 {
315 // two choices for the 16 bit timers: ck/1 or ck/64
316 ocr = F_CPU / frequency / 2 - 1;
317
318 prescalarbits = 0b001;
CID 59630: Operands don't affect result (CONSTANT_EXPRESSION_RESULT)
"ocr > 65535U" is always false regardless of the values of its operands. This occurs as the logical operand of if.
319 if (ocr > 0xffff)
320 {
321 ocr = F_CPU / frequency / 2 / 64 - 1;
322 prescalarbits = 0b011;
323 }
324
________________________________________________________________________________________________________
*** CID 59631: Missing break in switch (MISSING_BREAK)
/Marlin_main.cpp: 1187 in process_commands()()
1181 case 2: // G2 - CW ARC
1182 if(Stopped == false) {
1183 get_arc_coordinates();
1184 prepare_arc_move(true);
1185 return;
1186 }
CID 59631: Missing break in switch (MISSING_BREAK)
The above case falls through to this one.
1187 case 3: // G3 - CCW ARC
1188 if(Stopped == false) {
1189 get_arc_coordinates();
1190 prepare_arc_move(false);
1191 return;
1192 }
________________________________________________________________________________________________________
*** CID 59632: Missing break in switch (MISSING_BREAK)
/Marlin_main.cpp: 1193 in process_commands()()
1187 case 3: // G3 - CCW ARC
1188 if(Stopped == false) {
1189 get_arc_coordinates();
1190 prepare_arc_move(false);
1191 return;
1192 }
CID 59632: Missing break in switch (MISSING_BREAK)
The above case falls through to this one.
1193 case 4: // G4 dwell
1194 LCD_MESSAGEPGM(MSG_DWELL);
1195 codenum = 0;
1196 if(code_seen('P')) codenum = code_value(); // milliseconds to wait
1197 if(code_seen('S')) codenum = code_value() * 1000; // seconds to wait
1198
________________________________________________________________________________________________________
*** CID 59633: Out-of-bounds write (OVERRUN)
/temperature.cpp: 914 in disable_heater()()
908 WRITE(HEATER_0_PIN,LOW);
909 #endif
910 #endif
911
912 #if defined(TEMP_1_PIN) && TEMP_1_PIN > -1
913 target_temperature[1]=0;
CID 59633: Out-of-bounds write (OVERRUN)
Overrunning array "soft_pwm" of 1 bytes at byte offset 1 using index "1".
914 soft_pwm[1]=0;
915 #if defined(HEATER_1_PIN) && HEATER_1_PIN > -1
916 WRITE(HEATER_1_PIN,LOW);
917 #endif
918 #endif
919
________________________________________________________________________________________________________
*** CID 59634: Out-of-bounds write (OVERRUN)
/temperature.cpp: 913 in disable_heater()()
907 #if defined(HEATER_0_PIN) && HEATER_0_PIN > -1
908 WRITE(HEATER_0_PIN,LOW);
909 #endif
910 #endif
911
912 #if defined(TEMP_1_PIN) && TEMP_1_PIN > -1
CID 59634: Out-of-bounds write (OVERRUN)
Overrunning array "target_temperature" of 1 2-byte elements at element index 1 (byte offset 2) using index "1".
913 target_temperature[1]=0;
914 soft_pwm[1]=0;
915 #if defined(HEATER_1_PIN) && HEATER_1_PIN > -1
916 WRITE(HEATER_1_PIN,LOW);
917 #endif
918 #endif
________________________________________________________________________________________________________
*** CID 59635: Out-of-bounds read (OVERRUN)
/temperature.cpp: 626 in analog2temp(int, unsigned char)()
620 if(heater_ttbl_map[e] != NULL)
621 {
622 float celsius = 0;
623 uint8_t i;
624 short (*tt)[][2] = (short (*)[][2])(heater_ttbl_map[e]);
625
CID 59635: Out-of-bounds read (OVERRUN)
Overrunning array "heater_ttbllen_map" of 1 bytes at byte offset 1 using index "e" (which evaluates to 1).
626 for (i=1; i<heater_ttbllen_map[e]; i++)
627 {
628 if (PGM_RD_W((*tt)[i][0]) > raw)
629 {
630 celsius = PGM_RD_W((*tt)[i-1][1]) +
631 (raw - PGM_RD_W((*tt)[i-1][0])) *
________________________________________________________________________________________________________
*** CID 59636: Out-of-bounds read (OVERRUN)
/temperature.cpp: 620 in analog2temp(int, unsigned char)()
614 if (e == 0)
615 {
616 return 0.25 * raw;
617 }
618 #endif
619
CID 59636: Out-of-bounds read (OVERRUN)
Overrunning array "heater_ttbl_map" of 1 2-byte elements at element index 1 (byte offset 2) using index "e" (which evaluates to 1).
620 if(heater_ttbl_map[e] != NULL)
621 {
622 float celsius = 0;
623 uint8_t i;
624 short (*tt)[][2] = (short (*)[][2])(heater_ttbl_map[e]);
625
________________________________________________________________________________________________________
*** CID 59637: Out-of-bounds write (OVERRUN)
/temperature.cpp: 202 in PID_autotune(float, int, int)()
196 {
197 soft_pwm_bed = (MAX_BED_POWER)/2;
198 bias = d = (MAX_BED_POWER)/2;
199 }
200 else
201 {
CID 59637: Out-of-bounds write (OVERRUN)
Overrunning array "soft_pwm" of 1 bytes at byte offset 1 using index "extruder" (which evaluates to 1).
202 soft_pwm[extruder] = (PID_MAX)/2;
203 bias = d = (PID_MAX)/2;
204 }
205
206
207
________________________________________________________________________________________________________
*** CID 59638: Out-of-bounds read (OVERRUN)
/temperature.cpp: 214 in PID_autotune(float, int, int)()
208
209 for(;;) {
210
211 if(temp_meas_ready == true) { // temp sample ready
212 updateTemperaturesFromRawValues();
213
CID 59638: Out-of-bounds read (OVERRUN)
Overrunning array "current_temperature" of 1 4-byte elements at element index 1 (byte offset 4) using index "extruder" (which evaluates to 1).
214 input = (extruder<0)?current_temperature_bed:current_temperature[extruder];
215
216 max=max(max,input);
217 min=min(min,input);
218 if(heating == true && input > temp) {
219 if(millis() - t2 > 5000) {
________________________________________________________________________________________________________
*** CID 59639: Out-of-bounds write (OVERRUN)
/Marlin_main.cpp: 2278 in process_commands()()
2272 tmp_extruder = code_value();
2273 if(tmp_extruder >= EXTRUDERS) {
2274 SERIAL_ECHO_START;
2275 SERIAL_ECHO(MSG_M200_INVALID_EXTRUDER);
2276 }
2277 }
CID 59639: Out-of-bounds write (OVERRUN)
Overrunning array "volumetric_multiplier" of 1 4-byte elements at element index 1 (byte offset 4) using index "tmp_extruder" (which evaluates to 1).
2278 volumetric_multiplier[tmp_extruder] = 1 / area;
2279 }
2280 break;
2281 case 201: // M201
2282 for(int8_t i=0; i < NUM_AXIS; i++)
2283 {
________________________________________________________________________________________________________
*** CID 59640: Out-of-bounds read (OVERRUN)
/Marlin_main.cpp: 1802 in process_commands()()
1796 int pin_status = code_value();
1797 int pin_number = LED_PIN;
1798 if (code_seen('P') && pin_status >= 0 && pin_status <= 255)
1799 pin_number = code_value();
1800 for(int8_t i = 0; i < (int8_t)sizeof(sensitive_pins); i++)
1801 {
CID 59640: Out-of-bounds read (OVERRUN)
Overrunning array "sensitive_pins" of 28 2-byte elements at element index 55 (byte offset 110) using index "i" (which evaluates to 55).
1802 if (sensitive_pins[i] == pin_number)
1803 {
1804 pin_number = -1;
1805 break;
1806 }
1807 }
________________________________________________________________________________________________________
*** CID 59641: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 51 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
45 }
46
47 LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
48 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
49 {
50 init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);
CID 59641: Uninitialized scalar field (UNINIT_CTOR)
Non-static class member "_initialized" is not initialized in this constructor nor in any functions that it calls.
51 }
52
53 void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
54 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
55 uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
56 {
________________________________________________________________________________________________________
*** CID 59642: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 45 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
39 }
40
41 LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
42 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
43 {
44 init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);
CID 59642: Uninitialized scalar field (UNINIT_CTOR)
Non-static class member "_initialized" is not initialized in this constructor nor in any functions that it calls.
45 }
46
47 LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
48 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
49 {
50 init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);
________________________________________________________________________________________________________
*** CID 59643: Uninitialized scalar field (UNINIT_CTOR)
/Applications/Arduino.app/Contents/Resources/Java/libraries/LiquidCrystal/LiquidCrystal.cpp: 32 in LiquidCrystal::LiquidCrystal(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)()
26
27 LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
28 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
29 uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
30 {
31 init(0, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7);
CID 59643: Uninitialized scalar field (UNINIT_CTOR)
Non-static class member "_initialized" is not initialized in this constructor nor in any functions that it calls.
32 }
33
34 LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
35 uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
36 uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
37 {
________________________________________________________________________________________________________
To view the defects in Coverity Scan visit, http://scan.coverity.com/projects/2224?tab=overview
2014-05-14 19:59:48 +00:00
|
|
|
}
|
2016-06-18 10:16:13 +00:00
|
|
|
|
|
|
|
} // End of probe loop
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-07-06 01:40:21 +00:00
|
|
|
if (STOW_PROBE()) return;
|
2016-06-24 02:22:45 +00:00
|
|
|
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Finished!");
|
|
|
|
SERIAL_EOL;
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
if (verbose_level > 0) {
|
|
|
|
SERIAL_PROTOCOLPGM("Mean: ");
|
|
|
|
SERIAL_PROTOCOL_F(mean, 6);
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" Min: ");
|
|
|
|
SERIAL_PROTOCOL_F(min, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" Max: ");
|
|
|
|
SERIAL_PROTOCOL_F(max, 3);
|
|
|
|
SERIAL_PROTOCOLPGM(" Range: ");
|
|
|
|
SERIAL_PROTOCOL_F(max-min, 3);
|
2015-03-07 06:14:34 +00:00
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-12-29 01:43:14 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Standard Deviation: ");
|
|
|
|
SERIAL_PROTOCOL_F(sigma, 6);
|
2016-10-05 20:09:39 +00:00
|
|
|
SERIAL_EOL;
|
|
|
|
SERIAL_EOL;
|
2016-02-28 04:49:49 +00:00
|
|
|
|
2016-06-21 22:32:28 +00:00
|
|
|
clean_up_after_endstop_or_probe_move();
|
2016-03-24 18:01:20 +00:00
|
|
|
|
2016-04-26 01:23:09 +00:00
|
|
|
report_current_position();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-12-29 01:43:14 +00:00
|
|
|
|
2016-06-21 08:28:36 +00:00
|
|
|
#endif // Z_MIN_PROBE_REPEATABILITY_TEST
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-06 03:38:42 +00:00
|
|
|
/**
|
|
|
|
* M75: Start print timer
|
|
|
|
*/
|
2016-05-14 21:04:53 +00:00
|
|
|
inline void gcode_M75() { print_job_timer.start(); }
|
2016-04-06 03:38:42 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M76: Pause print timer
|
|
|
|
*/
|
2016-05-14 21:04:53 +00:00
|
|
|
inline void gcode_M76() { print_job_timer.pause(); }
|
2016-04-06 03:38:42 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M77: Stop print timer
|
|
|
|
*/
|
2016-05-14 21:04:53 +00:00
|
|
|
inline void gcode_M77() { print_job_timer.stop(); }
|
2016-04-06 03:38:42 +00:00
|
|
|
|
2016-04-27 01:13:27 +00:00
|
|
|
#if ENABLED(PRINTCOUNTER)
|
2016-07-19 02:27:42 +00:00
|
|
|
/**
|
2016-04-27 01:13:27 +00:00
|
|
|
* M78: Show print statistics
|
|
|
|
*/
|
|
|
|
inline void gcode_M78() {
|
2016-05-14 21:02:30 +00:00
|
|
|
// "M78 S78" will reset the statistics
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S') && code_value_int() == 78)
|
2016-05-14 21:02:30 +00:00
|
|
|
print_job_timer.initStats();
|
2016-09-13 07:11:45 +00:00
|
|
|
else
|
|
|
|
print_job_timer.showStats();
|
2016-04-27 01:13:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M104: Set hot end temperature
|
|
|
|
*/
|
|
|
|
inline void gcode_M104() {
|
2016-04-18 07:01:28 +00:00
|
|
|
if (get_target_extruder_from_command(104)) return;
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(DRYRUN)) return;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-30 07:42:26 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE)
|
|
|
|
if (target_extruder != active_extruder) return;
|
|
|
|
#endif
|
|
|
|
|
2015-04-04 04:43:30 +00:00
|
|
|
if (code_seen('S')) {
|
2016-07-09 23:25:48 +00:00
|
|
|
thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2015-04-04 04:43:30 +00:00
|
|
|
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
|
2016-07-09 23:25:48 +00:00
|
|
|
thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
|
2015-04-04 04:43:30 +00:00
|
|
|
#endif
|
2016-03-30 10:33:24 +00:00
|
|
|
|
2016-05-14 21:04:53 +00:00
|
|
|
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
|
|
|
|
/**
|
2016-07-13 01:14:59 +00:00
|
|
|
* Stop the timer at the end of print, starting is managed by
|
2016-07-08 13:00:39 +00:00
|
|
|
* 'heat and wait' M109.
|
2016-05-14 21:04:53 +00:00
|
|
|
* We use half EXTRUDE_MINTEMP here to allow nozzles to be put into hot
|
|
|
|
* stand by mode, for instance in a dual extruder setup, without affecting
|
|
|
|
* the running print timer.
|
|
|
|
*/
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_value_temp_abs() <= (EXTRUDE_MINTEMP)/2) {
|
2016-05-14 21:04:53 +00:00
|
|
|
print_job_timer.stop();
|
|
|
|
LCD_MESSAGEPGM(WELCOME_MSG);
|
|
|
|
}
|
|
|
|
#endif
|
2016-04-06 03:34:03 +00:00
|
|
|
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_value_temp_abs() > thermalManager.degHotend(target_extruder)) LCD_MESSAGEPGM(MSG_HEATING);
|
2015-04-04 04:43:30 +00:00
|
|
|
}
|
2016-11-14 10:29:45 +00:00
|
|
|
|
|
|
|
#if ENABLED(AUTOTEMP)
|
|
|
|
planner.autotemp_M104_M109();
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-04-03 23:18:49 +00:00
|
|
|
#if HAS_TEMP_HOTEND || HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-11-09 23:02:11 +00:00
|
|
|
void print_heaterstates() {
|
2016-04-03 23:18:49 +00:00
|
|
|
#if HAS_TEMP_HOTEND
|
2015-04-04 02:16:38 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" T:");
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degHotend(target_extruder), 1);
|
2015-04-04 02:16:38 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" /");
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(target_extruder), 1);
|
2016-07-28 23:02:54 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[target_extruder] / OVERSAMPLENR);
|
2016-07-30 13:43:33 +00:00
|
|
|
SERIAL_CHAR(')');
|
2016-07-28 23:02:54 +00:00
|
|
|
#endif
|
2015-04-04 02:16:38 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" B:");
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degBed(), 1);
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" /");
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degTargetBed(), 1);
|
2016-07-28 23:02:54 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_bed_raw / OVERSAMPLENR);
|
2016-07-30 13:43:33 +00:00
|
|
|
SERIAL_CHAR(')');
|
2016-07-28 23:02:54 +00:00
|
|
|
#endif
|
2015-04-02 12:10:14 +00:00
|
|
|
#endif
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2016-07-10 04:11:17 +00:00
|
|
|
HOTEND_LOOP() {
|
2016-07-28 21:51:18 +00:00
|
|
|
SERIAL_PROTOCOLPAIR(" T", e);
|
2015-11-09 23:02:11 +00:00
|
|
|
SERIAL_PROTOCOLCHAR(':');
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degHotend(e), 1);
|
2015-11-09 23:02:11 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" /");
|
2016-04-29 01:18:13 +00:00
|
|
|
SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(e), 1);
|
2016-07-28 23:02:54 +00:00
|
|
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
|
|
|
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[e] / OVERSAMPLENR);
|
2016-07-30 13:43:33 +00:00
|
|
|
SERIAL_CHAR(')');
|
2016-07-28 23:02:54 +00:00
|
|
|
#endif
|
2015-11-09 23:02:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-07-28 23:03:16 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" @:");
|
2016-07-29 22:14:13 +00:00
|
|
|
SERIAL_PROTOCOL(thermalManager.getHeaterPower(target_extruder));
|
2015-11-09 23:02:11 +00:00
|
|
|
#if HAS_TEMP_BED
|
|
|
|
SERIAL_PROTOCOLPGM(" B@:");
|
2016-07-29 22:14:13 +00:00
|
|
|
SERIAL_PROTOCOL(thermalManager.getHeaterPower(-1));
|
2015-11-09 23:02:11 +00:00
|
|
|
#endif
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2016-07-10 04:11:17 +00:00
|
|
|
HOTEND_LOOP() {
|
2016-07-28 21:51:18 +00:00
|
|
|
SERIAL_PROTOCOLPAIR(" @", e);
|
2015-11-09 23:02:11 +00:00
|
|
|
SERIAL_PROTOCOLCHAR(':');
|
2016-07-29 22:14:13 +00:00
|
|
|
SERIAL_PROTOCOL(thermalManager.getHeaterPower(e));
|
2015-11-09 23:02:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M105: Read hot end and bed temperature
|
|
|
|
*/
|
|
|
|
inline void gcode_M105() {
|
2016-04-18 07:01:28 +00:00
|
|
|
if (get_target_extruder_from_command(105)) return;
|
2015-11-09 23:02:11 +00:00
|
|
|
|
2016-04-03 23:18:49 +00:00
|
|
|
#if HAS_TEMP_HOTEND || HAS_TEMP_BED
|
2015-11-09 23:02:11 +00:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_OK);
|
|
|
|
print_heaterstates();
|
2016-04-03 23:18:49 +00:00
|
|
|
#else // !HAS_TEMP_HOTEND && !HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS);
|
|
|
|
#endif
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-04-02 12:10:14 +00:00
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-11-09 00:03:40 +00:00
|
|
|
#if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED)
|
|
|
|
|
|
|
|
static uint8_t auto_report_temp_interval;
|
|
|
|
static millis_t next_temp_report_ms;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M155: Set temperature auto-report interval. M155 S<seconds>
|
|
|
|
*/
|
|
|
|
inline void gcode_M155() {
|
|
|
|
if (code_seen('S')) {
|
|
|
|
auto_report_temp_interval = code_value_byte();
|
|
|
|
NOMORE(auto_report_temp_interval, 60);
|
|
|
|
next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void auto_report_temperatures() {
|
|
|
|
if (auto_report_temp_interval && ELAPSED(millis(), next_temp_report_ms)) {
|
|
|
|
next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval;
|
|
|
|
print_heaterstates();
|
2016-12-05 20:04:53 +00:00
|
|
|
SERIAL_EOL;
|
2016-11-09 00:03:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // AUTO_REPORT_TEMPERATURES
|
|
|
|
|
2016-03-06 02:27:45 +00:00
|
|
|
#if FAN_COUNT > 0
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M106: Set Fan Speed
|
2016-03-06 02:27:45 +00:00
|
|
|
*
|
|
|
|
* S<int> Speed between 0-255
|
|
|
|
* P<index> Fan index, if more than one fan
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-03-06 02:27:45 +00:00
|
|
|
inline void gcode_M106() {
|
2016-05-31 15:26:08 +00:00
|
|
|
uint16_t s = code_seen('S') ? code_value_ushort() : 255,
|
|
|
|
p = code_seen('P') ? code_value_ushort() : 0;
|
2016-03-06 02:27:45 +00:00
|
|
|
NOMORE(s, 255);
|
|
|
|
if (p < FAN_COUNT) fanSpeeds[p] = s;
|
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M107: Fan Off
|
|
|
|
*/
|
2016-03-06 02:27:45 +00:00
|
|
|
inline void gcode_M107() {
|
2016-05-31 15:26:08 +00:00
|
|
|
uint16_t p = code_seen('P') ? code_value_ushort() : 0;
|
2016-03-06 02:27:45 +00:00
|
|
|
if (p < FAN_COUNT) fanSpeeds[p] = 0;
|
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif // FAN_COUNT > 0
|
2014-12-20 16:33:43 +00:00
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#if DISABLED(EMERGENCY_PARSER)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M108: Stop the waiting for heaters in M109, M190, M303. Does not affect the target temperature.
|
|
|
|
*/
|
|
|
|
inline void gcode_M108() { wait_for_heatup = false; }
|
|
|
|
|
2016-07-06 18:52:36 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M112: Emergency Stop
|
|
|
|
*/
|
|
|
|
inline void gcode_M112() { kill(PSTR(MSG_KILLED)); }
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M410: Quickstop - Abort all planned moves
|
|
|
|
*
|
|
|
|
* This will stop the carriages mid-move, so most likely they
|
|
|
|
* will be out of sync with the stepper position after this.
|
|
|
|
*/
|
2016-07-06 19:00:28 +00:00
|
|
|
inline void gcode_M410() { quickstop_stepper(); }
|
2016-07-06 18:52:36 +00:00
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#endif
|
2016-04-25 14:33:33 +00:00
|
|
|
|
2016-07-10 09:42:49 +00:00
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG
|
|
|
|
#define MIN_COOLING_SLOPE_DEG 1.50
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME
|
|
|
|
#define MIN_COOLING_SLOPE_TIME 60
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2016-02-22 04:10:53 +00:00
|
|
|
* M109: Sxxx Wait for extruder(s) to reach temperature. Waits only when heating.
|
|
|
|
* Rxxx Wait for extruder(s) to reach temperature. Waits when heating and cooling.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M109() {
|
2015-11-09 12:21:47 +00:00
|
|
|
|
2016-04-18 07:01:28 +00:00
|
|
|
if (get_target_extruder_from_command(109)) return;
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(DRYRUN)) return;
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-05-30 07:42:26 +00:00
|
|
|
#if ENABLED(SINGLENOZZLE)
|
|
|
|
if (target_extruder != active_extruder) return;
|
|
|
|
#endif
|
|
|
|
|
2016-04-11 20:33:35 +00:00
|
|
|
bool no_wait_for_cooling = code_seen('S');
|
2015-04-14 00:17:36 +00:00
|
|
|
if (no_wait_for_cooling || code_seen('R')) {
|
2016-07-09 23:25:48 +00:00
|
|
|
thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2015-04-04 04:43:30 +00:00
|
|
|
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
|
2016-07-09 23:25:48 +00:00
|
|
|
thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-05-14 21:04:53 +00:00
|
|
|
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
|
|
|
|
/**
|
|
|
|
* We use half EXTRUDE_MINTEMP here to allow nozzles to be put into hot
|
|
|
|
* stand by mode, for instance in a dual extruder setup, without affecting
|
|
|
|
* the running print timer.
|
|
|
|
*/
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_value_temp_abs() <= (EXTRUDE_MINTEMP)/2) {
|
2016-05-14 21:04:53 +00:00
|
|
|
print_job_timer.stop();
|
|
|
|
LCD_MESSAGEPGM(WELCOME_MSG);
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* We do not check if the timer is already running because this check will
|
|
|
|
* be done for us inside the Stopwatch::start() method thus a running timer
|
|
|
|
* will not restart.
|
|
|
|
*/
|
|
|
|
else print_job_timer.start();
|
|
|
|
#endif
|
2016-04-06 03:34:03 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
if (thermalManager.isHeatingHotend(target_extruder)) LCD_MESSAGEPGM(MSG_HEATING);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(AUTOTEMP)
|
2016-11-14 10:29:45 +00:00
|
|
|
planner.autotemp_M104_M109();
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
2016-04-10 22:55:12 +00:00
|
|
|
millis_t residency_start_ms = 0;
|
2016-02-22 04:10:53 +00:00
|
|
|
// Loop until the temperature has stabilized
|
2016-04-10 22:55:12 +00:00
|
|
|
#define TEMP_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + (TEMP_RESIDENCY_TIME) * 1000UL))
|
2015-03-05 12:27:24 +00:00
|
|
|
#else
|
2016-02-28 06:26:44 +00:00
|
|
|
// Loop until the temperature is very close target
|
2016-04-29 01:18:13 +00:00
|
|
|
#define TEMP_CONDITIONS (wants_to_cool ? thermalManager.isCoolingHotend(target_extruder) : thermalManager.isHeatingHotend(target_extruder))
|
2016-04-15 17:20:32 +00:00
|
|
|
#endif //TEMP_RESIDENCY_TIME > 0
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float theTarget = -1.0, old_temp = 9999.0;
|
2016-07-04 01:12:11 +00:00
|
|
|
bool wants_to_cool = false;
|
2016-07-06 16:17:50 +00:00
|
|
|
wait_for_heatup = true;
|
2016-06-29 02:00:59 +00:00
|
|
|
millis_t now, next_temp_ms = 0, next_cool_check_ms = 0;
|
2016-04-30 23:29:02 +00:00
|
|
|
|
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
|
2016-04-11 20:33:35 +00:00
|
|
|
do {
|
2016-06-18 00:26:21 +00:00
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (theTarget != thermalManager.degTargetHotend(target_extruder)) {
|
|
|
|
wants_to_cool = thermalManager.isCoolingHotend(target_extruder);
|
|
|
|
theTarget = thermalManager.degTargetHotend(target_extruder);
|
|
|
|
|
|
|
|
// Exit if S<lower>, continue if S<higher>, R<lower>, or R<higher>
|
|
|
|
if (no_wait_for_cooling && wants_to_cool) break;
|
|
|
|
}
|
|
|
|
|
2016-02-22 04:10:53 +00:00
|
|
|
now = millis();
|
2016-04-10 22:55:12 +00:00
|
|
|
if (ELAPSED(now, next_temp_ms)) { //Print temp & remaining time every 1s while waiting
|
2016-02-22 04:10:53 +00:00
|
|
|
next_temp_ms = now + 1000UL;
|
2016-06-18 00:26:21 +00:00
|
|
|
print_heaterstates();
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
2015-10-03 06:08:58 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" W:");
|
2016-04-10 22:55:12 +00:00
|
|
|
if (residency_start_ms) {
|
2016-03-13 06:38:55 +00:00
|
|
|
long rem = (((TEMP_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL;
|
2016-02-22 04:10:53 +00:00
|
|
|
SERIAL_PROTOCOLLN(rem);
|
2015-10-03 06:08:58 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_PROTOCOLLNPGM("?");
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
#else
|
|
|
|
SERIAL_EOL;
|
2016-02-22 04:10:53 +00:00
|
|
|
#endif
|
2013-03-25 04:35:05 +00:00
|
|
|
}
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
idle();
|
2015-10-08 19:23:18 +00:00
|
|
|
refresh_cmd_timeout(); // to prevent stepper_inactive_time from running out
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float temp = thermalManager.degHotend(target_extruder);
|
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_RESIDENCY_TIME > 0
|
2016-04-09 04:18:40 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float temp_diff = fabs(theTarget - temp);
|
2016-04-09 04:18:40 +00:00
|
|
|
|
2016-04-10 22:55:12 +00:00
|
|
|
if (!residency_start_ms) {
|
2016-04-09 04:18:40 +00:00
|
|
|
// Start the TEMP_RESIDENCY_TIME timer when we reach target temp for the first time.
|
2016-06-18 00:26:21 +00:00
|
|
|
if (temp_diff < TEMP_WINDOW) residency_start_ms = now;
|
2016-04-09 04:18:40 +00:00
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
2016-06-18 00:26:21 +00:00
|
|
|
residency_start_ms = now;
|
2016-04-09 04:18:40 +00:00
|
|
|
}
|
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#endif //TEMP_RESIDENCY_TIME > 0
|
2016-02-22 04:10:53 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M109 R0
|
|
|
|
if (wants_to_cool) {
|
2016-07-10 09:42:49 +00:00
|
|
|
// break after MIN_COOLING_SLOPE_TIME seconds
|
|
|
|
// if the temperature did not drop at least MIN_COOLING_SLOPE_DEG
|
2016-06-29 02:00:59 +00:00
|
|
|
if (!next_cool_check_ms || ELAPSED(now, next_cool_check_ms)) {
|
2016-07-10 09:42:49 +00:00
|
|
|
if (old_temp - temp < MIN_COOLING_SLOPE_DEG) break;
|
|
|
|
next_cool_check_ms = now + 1000UL * MIN_COOLING_SLOPE_TIME;
|
2016-06-29 02:00:59 +00:00
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-06 16:17:50 +00:00
|
|
|
} while (wait_for_heatup && TEMP_CONDITIONS);
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2016-09-06 02:09:30 +00:00
|
|
|
if (wait_for_heatup) LCD_MESSAGEPGM(MSG_HEATING_COMPLETE);
|
|
|
|
|
2016-04-29 04:11:15 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-10 09:42:49 +00:00
|
|
|
#ifndef MIN_COOLING_SLOPE_DEG_BED
|
|
|
|
#define MIN_COOLING_SLOPE_DEG_BED 1.50
|
|
|
|
#endif
|
|
|
|
#ifndef MIN_COOLING_SLOPE_TIME_BED
|
|
|
|
#define MIN_COOLING_SLOPE_TIME_BED 60
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M190: Sxxx Wait for bed current temp to reach target temp. Waits only when heating
|
|
|
|
* Rxxx Wait for bed current temp to reach target temp. Waits when heating and cooling
|
|
|
|
*/
|
|
|
|
inline void gcode_M190() {
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(DRYRUN)) return;
|
2015-06-01 16:34:45 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
LCD_MESSAGEPGM(MSG_BED_HEATING);
|
2016-02-22 04:10:53 +00:00
|
|
|
bool no_wait_for_cooling = code_seen('S');
|
2016-07-08 13:00:39 +00:00
|
|
|
if (no_wait_for_cooling || code_seen('R')) {
|
|
|
|
thermalManager.setTargetBed(code_value_temp_abs());
|
|
|
|
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
|
2016-07-09 23:25:48 +00:00
|
|
|
if (code_value_temp_abs() > BED_MINTEMP) {
|
2016-07-08 13:00:39 +00:00
|
|
|
/**
|
2016-07-13 01:14:59 +00:00
|
|
|
* We start the timer when 'heating and waiting' command arrives, LCD
|
2016-07-08 13:00:39 +00:00
|
|
|
* functions never wait. Cooling down managed by extruders.
|
|
|
|
*
|
|
|
|
* We do not check if the timer is already running because this check will
|
|
|
|
* be done for us inside the Stopwatch::start() method thus a running timer
|
|
|
|
* will not restart.
|
|
|
|
*/
|
|
|
|
print_job_timer.start();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2016-04-11 20:33:35 +00:00
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
2016-04-12 14:40:57 +00:00
|
|
|
millis_t residency_start_ms = 0;
|
|
|
|
// Loop until the temperature has stabilized
|
|
|
|
#define TEMP_BED_CONDITIONS (!residency_start_ms || PENDING(now, residency_start_ms + (TEMP_BED_RESIDENCY_TIME) * 1000UL))
|
|
|
|
#else
|
|
|
|
// Loop until the temperature is very close target
|
2016-04-29 01:18:13 +00:00
|
|
|
#define TEMP_BED_CONDITIONS (wants_to_cool ? thermalManager.isCoolingBed() : thermalManager.isHeatingBed())
|
2016-04-15 17:20:32 +00:00
|
|
|
#endif //TEMP_BED_RESIDENCY_TIME > 0
|
2016-04-12 14:40:57 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float theTarget = -1.0, old_temp = 9999.0;
|
2016-07-04 01:12:11 +00:00
|
|
|
bool wants_to_cool = false;
|
2016-07-06 16:17:50 +00:00
|
|
|
wait_for_heatup = true;
|
2016-06-29 02:00:59 +00:00
|
|
|
millis_t now, next_temp_ms = 0, next_cool_check_ms = 0;
|
2016-04-11 20:33:35 +00:00
|
|
|
|
2016-04-29 04:11:15 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
2016-04-30 23:29:02 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
target_extruder = active_extruder; // for print_heaterstates
|
|
|
|
|
2016-04-11 20:33:35 +00:00
|
|
|
do {
|
2016-06-18 00:26:21 +00:00
|
|
|
// Target temperature might be changed during the loop
|
|
|
|
if (theTarget != thermalManager.degTargetBed()) {
|
|
|
|
wants_to_cool = thermalManager.isCoolingBed();
|
|
|
|
theTarget = thermalManager.degTargetBed();
|
|
|
|
|
|
|
|
// Exit if S<lower>, continue if S<higher>, R<lower>, or R<higher>
|
|
|
|
if (no_wait_for_cooling && wants_to_cool) break;
|
|
|
|
}
|
|
|
|
|
2016-04-12 14:40:57 +00:00
|
|
|
now = millis();
|
2016-04-10 22:55:12 +00:00
|
|
|
if (ELAPSED(now, next_temp_ms)) { //Print Temp Reading every 1 second while heating up.
|
2016-02-22 04:10:53 +00:00
|
|
|
next_temp_ms = now + 1000UL;
|
|
|
|
print_heaterstates();
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
2016-04-12 14:40:57 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" W:");
|
|
|
|
if (residency_start_ms) {
|
|
|
|
long rem = (((TEMP_BED_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL;
|
|
|
|
SERIAL_PROTOCOLLN(rem);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_PROTOCOLLNPGM("?");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
SERIAL_EOL;
|
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-04-12 14:40:57 +00:00
|
|
|
|
2015-05-27 03:08:21 +00:00
|
|
|
idle();
|
2015-10-08 19:23:18 +00:00
|
|
|
refresh_cmd_timeout(); // to prevent stepper_inactive_time from running out
|
2016-04-12 14:40:57 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float temp = thermalManager.degBed();
|
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
2016-04-12 14:40:57 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
float temp_diff = fabs(theTarget - temp);
|
2016-04-12 14:40:57 +00:00
|
|
|
|
|
|
|
if (!residency_start_ms) {
|
|
|
|
// Start the TEMP_BED_RESIDENCY_TIME timer when we reach target temp for the first time.
|
2016-06-18 00:26:21 +00:00
|
|
|
if (temp_diff < TEMP_BED_WINDOW) residency_start_ms = now;
|
2016-04-12 14:40:57 +00:00
|
|
|
}
|
|
|
|
else if (temp_diff > TEMP_BED_HYSTERESIS) {
|
|
|
|
// Restart the timer whenever the temperature falls outside the hysteresis.
|
2016-06-18 00:26:21 +00:00
|
|
|
residency_start_ms = now;
|
2016-04-12 14:40:57 +00:00
|
|
|
}
|
|
|
|
|
2016-04-15 17:20:32 +00:00
|
|
|
#endif //TEMP_BED_RESIDENCY_TIME > 0
|
2016-04-12 14:40:57 +00:00
|
|
|
|
2016-06-29 02:00:59 +00:00
|
|
|
// Prevent a wait-forever situation if R is misused i.e. M190 R0
|
|
|
|
if (wants_to_cool) {
|
2016-07-10 09:42:49 +00:00
|
|
|
// break after MIN_COOLING_SLOPE_TIME_BED seconds
|
|
|
|
// if the temperature did not drop at least MIN_COOLING_SLOPE_DEG_BED
|
2016-06-29 02:00:59 +00:00
|
|
|
if (!next_cool_check_ms || ELAPSED(now, next_cool_check_ms)) {
|
2016-07-10 09:42:49 +00:00
|
|
|
if (old_temp - temp < MIN_COOLING_SLOPE_DEG_BED) break;
|
|
|
|
next_cool_check_ms = now + 1000UL * MIN_COOLING_SLOPE_TIME_BED;
|
2016-06-29 02:00:59 +00:00
|
|
|
old_temp = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-06 16:17:50 +00:00
|
|
|
} while (wait_for_heatup && TEMP_BED_CONDITIONS);
|
2016-06-29 02:00:59 +00:00
|
|
|
|
2016-09-06 02:09:30 +00:00
|
|
|
if (wait_for_heatup) LCD_MESSAGEPGM(MSG_BED_DONE);
|
2016-04-29 04:11:15 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif // HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-03-07 21:27:01 +00:00
|
|
|
/**
|
|
|
|
* M110: Set Current Line Number
|
|
|
|
*/
|
|
|
|
inline void gcode_M110() {
|
|
|
|
if (code_seen('N')) gcode_N = code_value_long();
|
|
|
|
}
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-04-27 03:08:45 +00:00
|
|
|
* M111: Set the debug level
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2015-04-27 03:08:45 +00:00
|
|
|
inline void gcode_M111() {
|
2016-06-16 18:24:11 +00:00
|
|
|
marlin_debug_flags = code_seen('S') ? code_value_byte() : (uint8_t) DEBUG_NONE;
|
2015-08-28 01:40:10 +00:00
|
|
|
|
2016-04-04 13:51:47 +00:00
|
|
|
const static char str_debug_1[] PROGMEM = MSG_DEBUG_ECHO;
|
|
|
|
const static char str_debug_2[] PROGMEM = MSG_DEBUG_INFO;
|
|
|
|
const static char str_debug_4[] PROGMEM = MSG_DEBUG_ERRORS;
|
|
|
|
const static char str_debug_8[] PROGMEM = MSG_DEBUG_DRYRUN;
|
|
|
|
const static char str_debug_16[] PROGMEM = MSG_DEBUG_COMMUNICATION;
|
2015-08-28 01:40:10 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-04-04 13:51:47 +00:00
|
|
|
const static char str_debug_32[] PROGMEM = MSG_DEBUG_LEVELING;
|
2015-08-28 01:40:10 +00:00
|
|
|
#endif
|
2016-03-30 02:18:45 +00:00
|
|
|
|
2016-04-04 13:51:47 +00:00
|
|
|
const static char* const debug_strings[] PROGMEM = {
|
2016-03-30 02:18:45 +00:00
|
|
|
str_debug_1, str_debug_2, str_debug_4, str_debug_8, str_debug_16,
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
str_debug_32
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_DEBUG_PREFIX);
|
|
|
|
if (marlin_debug_flags) {
|
|
|
|
uint8_t comma = 0;
|
|
|
|
for (uint8_t i = 0; i < COUNT(debug_strings); i++) {
|
|
|
|
if (TEST(marlin_debug_flags, i)) {
|
2016-04-04 22:36:07 +00:00
|
|
|
if (comma++) SERIAL_CHAR(',');
|
2016-04-04 00:32:00 +00:00
|
|
|
serialprintPGM((char*)pgm_read_word(&(debug_strings[i])));
|
2016-03-30 02:18:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ECHOPGM(MSG_DEBUG_OFF);
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-04-07 00:31:49 +00:00
|
|
|
#if ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M113: Get or set Host Keepalive interval (0 to disable)
|
|
|
|
*
|
|
|
|
* S<seconds> Optional. Set the keepalive interval.
|
|
|
|
*/
|
|
|
|
inline void gcode_M113() {
|
|
|
|
if (code_seen('S')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
host_keepalive_interval = code_value_byte();
|
2016-04-07 00:31:49 +00:00
|
|
|
NOMORE(host_keepalive_interval, 60);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ECHO_START;
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("M113 S", (unsigned long)host_keepalive_interval);
|
2016-04-07 00:31:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(BARICUDA)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HEATER_1
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M126: Heater 1 valve open
|
|
|
|
*/
|
2016-05-31 15:26:08 +00:00
|
|
|
inline void gcode_M126() { baricuda_valve_pressure = code_seen('S') ? code_value_byte() : 255; }
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M127: Heater 1 valve close
|
|
|
|
*/
|
2016-04-18 06:12:15 +00:00
|
|
|
inline void gcode_M127() { baricuda_valve_pressure = 0; }
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HEATER_2
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M128: Heater 2 valve open
|
|
|
|
*/
|
2016-05-31 15:26:08 +00:00
|
|
|
inline void gcode_M128() { baricuda_e_to_p_pressure = code_seen('S') ? code_value_byte() : 255; }
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M129: Heater 2 valve close
|
|
|
|
*/
|
2016-04-18 06:12:15 +00:00
|
|
|
inline void gcode_M129() { baricuda_e_to_p_pressure = 0; }
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif //BARICUDA
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M140: Set bed temperature
|
|
|
|
*/
|
|
|
|
inline void gcode_M140() {
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(DRYRUN)) return;
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) thermalManager.setTargetBed(code_value_temp_abs());
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-04-27 01:44:01 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M145: Set the heatup state for a material in the LCD menu
|
|
|
|
* S<material> (0=PLA, 1=ABS)
|
|
|
|
* H<hotend temp>
|
|
|
|
* B<bed temp>
|
|
|
|
* F<fan speed>
|
|
|
|
*/
|
|
|
|
inline void gcode_M145() {
|
2016-10-27 10:53:44 +00:00
|
|
|
uint8_t material = code_seen('S') ? (uint8_t)code_value_int() : 0;
|
|
|
|
if (material >= COUNT(lcd_preheat_hotend_temp)) {
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int v;
|
2016-10-27 07:40:37 +00:00
|
|
|
if (code_seen('H')) {
|
|
|
|
v = code_value_int();
|
|
|
|
lcd_preheat_hotend_temp[material] = constrain(v, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - 15);
|
2015-04-27 01:44:01 +00:00
|
|
|
}
|
2016-10-27 07:40:37 +00:00
|
|
|
if (code_seen('F')) {
|
|
|
|
v = code_value_int();
|
|
|
|
lcd_preheat_fan_speed[material] = constrain(v, 0, 255);
|
|
|
|
}
|
|
|
|
#if TEMP_SENSOR_BED != 0
|
|
|
|
if (code_seen('B')) {
|
|
|
|
v = code_value_int();
|
|
|
|
lcd_preheat_bed_temp[material] = constrain(v, BED_MINTEMP, BED_MAXTEMP - 15);
|
|
|
|
}
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#endif // ULTIPANEL
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
|
|
|
/**
|
|
|
|
* M149: Set temperature units
|
|
|
|
*/
|
|
|
|
inline void gcode_M149() {
|
2016-10-27 07:40:55 +00:00
|
|
|
if (code_seen('C')) set_input_temp_units(TEMPUNIT_C);
|
|
|
|
else if (code_seen('K')) set_input_temp_units(TEMPUNIT_K);
|
|
|
|
else if (code_seen('F')) set_input_temp_units(TEMPUNIT_F);
|
2016-05-31 15:26:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-03-30 23:39:47 +00:00
|
|
|
#if HAS_POWER_SWITCH
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M80: Turn on Power Supply
|
|
|
|
*/
|
|
|
|
inline void gcode_M80() {
|
|
|
|
OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE); //GND
|
|
|
|
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
|
|
|
* If you have a switch on suicide pin, this is useful
|
|
|
|
* if you want to start another print with suicide feature after
|
|
|
|
* a print without suicide...
|
|
|
|
*/
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SUICIDE
|
2015-03-05 12:27:24 +00:00
|
|
|
OUT_WRITE(SUICIDE_PIN, HIGH);
|
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-03-05 12:27:24 +00:00
|
|
|
powersupply = true;
|
|
|
|
LCD_MESSAGEPGM(WELCOME_MSG);
|
|
|
|
lcd_update();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-03-30 23:50:05 +00:00
|
|
|
#endif // HAS_POWER_SWITCH
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M81: Turn off Power, including Power Supply, if there is one.
|
|
|
|
*
|
|
|
|
* This code should ALWAYS be available for EMERGENCY SHUTDOWN!
|
|
|
|
*/
|
|
|
|
inline void gcode_M81() {
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.disable_all_heaters();
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.finish_and_disable();
|
2016-03-06 02:27:45 +00:00
|
|
|
#if FAN_COUNT > 0
|
|
|
|
#if FAN_COUNT > 1
|
|
|
|
for (uint8_t i = 0; i < FAN_COUNT; i++) fanSpeeds[i] = 0;
|
|
|
|
#else
|
|
|
|
fanSpeeds[0] = 0;
|
|
|
|
#endif
|
|
|
|
#endif
|
2015-03-30 23:50:05 +00:00
|
|
|
delay(1000); // Wait 1 second before switching off
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SUICIDE
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-03-30 23:50:05 +00:00
|
|
|
suicide();
|
|
|
|
#elif HAS_POWER_SWITCH
|
|
|
|
OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP);
|
|
|
|
#endif
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-03-30 23:50:05 +00:00
|
|
|
#if HAS_POWER_SWITCH
|
2015-03-30 23:39:47 +00:00
|
|
|
powersupply = false;
|
|
|
|
#endif
|
2015-03-30 23:50:05 +00:00
|
|
|
LCD_MESSAGEPGM(MACHINE_NAME " " MSG_OFF ".");
|
|
|
|
lcd_update();
|
|
|
|
#endif
|
|
|
|
}
|
2015-03-30 23:39:47 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M82: Set E codes absolute (default)
|
|
|
|
*/
|
|
|
|
inline void gcode_M82() { axis_relative_modes[E_AXIS] = false; }
|
|
|
|
|
|
|
|
/**
|
2015-06-28 04:49:37 +00:00
|
|
|
* M83: Set E codes relative while in Absolute Coordinates (G90) mode
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M83() { axis_relative_modes[E_AXIS] = true; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M18, M84: Disable all stepper motors
|
|
|
|
*/
|
|
|
|
inline void gcode_M18_M84() {
|
|
|
|
if (code_seen('S')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
stepper_inactive_time = code_value_millis_from_seconds();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-07-07 01:37:21 +00:00
|
|
|
bool all_axis = !((code_seen('X')) || (code_seen('Y')) || (code_seen('Z')) || (code_seen('E')));
|
2015-03-05 12:27:24 +00:00
|
|
|
if (all_axis) {
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.finish_and_disable();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
else {
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen('X')) disable_x();
|
|
|
|
if (code_seen('Y')) disable_y();
|
|
|
|
if (code_seen('Z')) disable_z();
|
|
|
|
#if ((E0_ENABLE_PIN != X_ENABLE_PIN) && (E1_ENABLE_PIN != Y_ENABLE_PIN)) // Only enable on boards that have seperate ENABLE_PINS
|
|
|
|
if (code_seen('E')) {
|
|
|
|
disable_e0();
|
|
|
|
disable_e1();
|
|
|
|
disable_e2();
|
|
|
|
disable_e3();
|
2014-06-23 15:09:57 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M85: Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
|
|
|
|
*/
|
|
|
|
inline void gcode_M85() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) max_inactive_time = code_value_millis_from_seconds();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-12-04 04:02:27 +00:00
|
|
|
/**
|
|
|
|
* Multi-stepper support for M92, M201, M203
|
|
|
|
*/
|
|
|
|
#if ENABLED(DISTINCT_E_FACTORS)
|
|
|
|
#define GET_TARGET_EXTRUDER(CMD) if (get_target_extruder_from_command(CMD)) return
|
|
|
|
#define TARGET_EXTRUDER target_extruder
|
|
|
|
#else
|
|
|
|
#define GET_TARGET_EXTRUDER(CMD) NOOP
|
|
|
|
#define TARGET_EXTRUDER 0
|
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-04-27 01:44:01 +00:00
|
|
|
* M92: Set axis steps-per-unit for one or more axes, X, Y, Z, and E.
|
|
|
|
* (Follows the same syntax as G92)
|
2016-12-04 04:02:27 +00:00
|
|
|
*
|
|
|
|
* With multiple extruders use T to specify which one.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M92() {
|
2016-12-04 04:02:27 +00:00
|
|
|
|
|
|
|
GET_TARGET_EXTRUDER(92);
|
|
|
|
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) {
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen(axis_codes[i])) {
|
|
|
|
if (i == E_AXIS) {
|
2016-12-04 04:02:27 +00:00
|
|
|
float value = code_value_per_axis_unit(E_AXIS + TARGET_EXTRUDER);
|
2015-03-05 12:27:24 +00:00
|
|
|
if (value < 20.0) {
|
2016-12-04 04:02:27 +00:00
|
|
|
float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab.
|
2016-10-02 09:37:13 +00:00
|
|
|
planner.max_jerk[E_AXIS] *= factor;
|
2016-12-04 04:02:27 +00:00
|
|
|
planner.max_feedrate_mm_s[E_AXIS + TARGET_EXTRUDER] *= factor;
|
|
|
|
planner.max_acceleration_steps_per_s2[E_AXIS + TARGET_EXTRUDER] *= factor;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2016-12-04 04:02:27 +00:00
|
|
|
planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] = value;
|
2014-06-23 15:09:57 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
else {
|
2016-06-09 23:53:21 +00:00
|
|
|
planner.axis_steps_per_mm[i] = code_value_per_axis_unit(i);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-07-24 02:36:26 +00:00
|
|
|
planner.refresh_positioning();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-04-26 01:23:09 +00:00
|
|
|
* Output the current position to serial
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-04-26 01:23:09 +00:00
|
|
|
static void report_current_position() {
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_PROTOCOLPGM("X:");
|
|
|
|
SERIAL_PROTOCOL(current_position[X_AXIS]);
|
|
|
|
SERIAL_PROTOCOLPGM(" Y:");
|
|
|
|
SERIAL_PROTOCOL(current_position[Y_AXIS]);
|
|
|
|
SERIAL_PROTOCOLPGM(" Z:");
|
|
|
|
SERIAL_PROTOCOL(current_position[Z_AXIS]);
|
|
|
|
SERIAL_PROTOCOLPGM(" E:");
|
|
|
|
SERIAL_PROTOCOL(current_position[E_AXIS]);
|
|
|
|
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.report_positions();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
#if IS_SCARA
|
2016-09-28 19:05:50 +00:00
|
|
|
SERIAL_PROTOCOLPAIR("SCARA Theta:", stepper.get_axis_position_degrees(A_AXIS));
|
|
|
|
SERIAL_PROTOCOLLNPAIR(" Psi+Theta:", stepper.get_axis_position_degrees(B_AXIS));
|
2016-09-15 06:21:31 +00:00
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
}
|
2015-03-03 01:07:12 +00:00
|
|
|
|
2016-04-26 01:23:09 +00:00
|
|
|
/**
|
|
|
|
* M114: Output current position to serial port
|
|
|
|
*/
|
|
|
|
inline void gcode_M114() { report_current_position(); }
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M115: Capabilities string
|
|
|
|
*/
|
|
|
|
inline void gcode_M115() {
|
2016-11-09 00:05:59 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_M115_REPORT);
|
|
|
|
|
|
|
|
#if ENABLED(EXTENDED_CAPABILITIES_REPORT)
|
|
|
|
|
|
|
|
// EEPROM (M500, M501)
|
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:EEPROM:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:EEPROM:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// AUTOREPORT_TEMP (M155)
|
|
|
|
#if ENABLED(AUTO_REPORT_TEMPERATURES)
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:AUTOREPORT_TEMP:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:AUTOREPORT_TEMP:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// PROGRESS (M530 S L, M531 <file>, M532 X L)
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:PROGRESS:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
|
|
|
|
// AUTOLEVEL (G29)
|
|
|
|
#if HAS_ABL
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:AUTOLEVEL:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:AUTOLEVEL:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Z_PROBE (G30)
|
|
|
|
#if HAS_BED_PROBE
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:Z_PROBE:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:Z_PROBE:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// SOFTWARE_POWER (G30)
|
|
|
|
#if HAS_POWER_SWITCH
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:SOFTWARE_POWER:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:SOFTWARE_POWER:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// TOGGLE_LIGHTS (M355)
|
|
|
|
#if HAS_CASE_LIGHT
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:TOGGLE_LIGHTS:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:TOGGLE_LIGHTS:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// EMERGENCY_PARSER (M108, M112, M410)
|
|
|
|
#if ENABLED(EMERGENCY_PARSER)
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:EMERGENCY_PARSER:1");
|
2016-11-09 00:05:59 +00:00
|
|
|
#else
|
2016-12-04 01:21:27 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Cap:EMERGENCY_PARSER:0");
|
2016-11-09 00:05:59 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // EXTENDED_CAPABILITIES_REPORT
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-03-03 01:07:12 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
/**
|
|
|
|
* M117: Set LCD Status Message
|
|
|
|
*/
|
|
|
|
inline void gcode_M117() {
|
2015-05-17 23:58:37 +00:00
|
|
|
lcd_setstatus(current_command_args);
|
2015-05-17 12:00:09 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M119: Output endstop states to serial output
|
|
|
|
*/
|
2016-04-27 21:46:24 +00:00
|
|
|
inline void gcode_M119() { endstops.M119(); }
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-03-24 10:18:45 +00:00
|
|
|
* M120: Enable endstops and set non-homing endstop state to "enabled"
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-04-27 14:15:20 +00:00
|
|
|
inline void gcode_M120() { endstops.enable_globally(true); }
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-03-24 10:18:45 +00:00
|
|
|
* M121: Disable endstops and set non-homing endstop state to "disabled"
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2016-04-27 14:15:20 +00:00
|
|
|
inline void gcode_M121() { endstops.enable_globally(false); }
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-14 06:48:47 +00:00
|
|
|
#if ENABLED(HAVE_TMC2130DRIVER)
|
2016-11-07 22:06:33 +00:00
|
|
|
|
2016-09-14 06:48:47 +00:00
|
|
|
/**
|
|
|
|
* M122: Output Trinamic TMC2130 status to serial output. Very bad formatting.
|
|
|
|
*/
|
2016-11-07 22:06:33 +00:00
|
|
|
|
|
|
|
static void tmc2130_report(Trinamic_TMC2130 &stepr, const char *name) {
|
|
|
|
stepr.read_STAT();
|
|
|
|
SERIAL_PROTOCOL(name);
|
|
|
|
SERIAL_PROTOCOL(": ");
|
|
|
|
stepr.isReset() ? SERIAL_PROTOCOLPGM("RESET ") : SERIAL_PROTOCOLPGM("----- ");
|
|
|
|
stepr.isError() ? SERIAL_PROTOCOLPGM("ERROR ") : SERIAL_PROTOCOLPGM("----- ");
|
|
|
|
stepr.isStallguard() ? SERIAL_PROTOCOLPGM("SLGRD ") : SERIAL_PROTOCOLPGM("----- ");
|
|
|
|
stepr.isStandstill() ? SERIAL_PROTOCOLPGM("STILL ") : SERIAL_PROTOCOLPGM("----- ");
|
|
|
|
SERIAL_PROTOCOLLN(stepr.debug());
|
|
|
|
}
|
|
|
|
|
2016-09-14 06:48:47 +00:00
|
|
|
inline void gcode_M122() {
|
2016-11-07 22:06:33 +00:00
|
|
|
SERIAL_PROTOCOLLNPGM("Reporting TMC2130 status");
|
|
|
|
#if ENABLED(X_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperX, "X");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(X2_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperX2, "X2");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Y_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperY, "Y");
|
2016-09-14 06:48:47 +00:00
|
|
|
#endif
|
2016-11-07 22:06:33 +00:00
|
|
|
#if ENABLED(Y2_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperY2, "Y2");
|
2016-09-14 06:48:47 +00:00
|
|
|
#endif
|
2016-11-07 22:06:33 +00:00
|
|
|
#if ENABLED(Z_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperZ, "Z");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(Z2_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperZ2, "Z2");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E0_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperE0, "E0");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E1_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperE1, "E1");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E2_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperE2, "E2");
|
|
|
|
#endif
|
|
|
|
#if ENABLED(E3_IS_TMC2130)
|
|
|
|
tmc2130_report(stepperE3, "E3");
|
2016-09-14 06:48:47 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // HAVE_TMC2130DRIVER
|
|
|
|
|
2016-11-30 01:51:13 +00:00
|
|
|
#if ENABLED(BLINKM) || ENABLED(RGB_LED)
|
|
|
|
|
|
|
|
void set_led_color(const uint8_t r, const uint8_t g, const uint8_t b) {
|
|
|
|
|
|
|
|
#if ENABLED(BLINKM)
|
|
|
|
|
|
|
|
// This variant uses i2c to send the RGB components to the device.
|
2016-12-03 07:51:11 +00:00
|
|
|
SendColors(r, g, b);
|
2016-11-30 01:51:13 +00:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
// This variant uses 3 separate pins for the RGB components.
|
|
|
|
// If the pins can do PWM then their intensity will be set.
|
|
|
|
digitalWrite(RGB_LED_R_PIN, r ? HIGH : LOW);
|
|
|
|
digitalWrite(RGB_LED_G_PIN, g ? HIGH : LOW);
|
|
|
|
digitalWrite(RGB_LED_B_PIN, b ? HIGH : LOW);
|
|
|
|
analogWrite(RGB_LED_R_PIN, r);
|
|
|
|
analogWrite(RGB_LED_G_PIN, g);
|
|
|
|
analogWrite(RGB_LED_B_PIN, b);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M150: Set Status LED Color - Use R-U-B for R-G-B
|
2016-11-30 01:51:13 +00:00
|
|
|
*
|
|
|
|
* Always sets all 3 components. If a component is left out, set to 0.
|
|
|
|
*
|
|
|
|
* Examples:
|
|
|
|
*
|
|
|
|
* M150 R255 ; Turn LED red
|
|
|
|
* M150 R255 U127 ; Turn LED orange (PWM only)
|
|
|
|
* M150 ; Turn LED off
|
|
|
|
* M150 R U B ; Turn LED white
|
|
|
|
*
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M150() {
|
2016-11-30 01:51:13 +00:00
|
|
|
set_led_color(
|
|
|
|
code_seen('R') ? (code_has_value() ? code_value_byte() : 255) : 0,
|
|
|
|
code_seen('U') ? (code_has_value() ? code_value_byte() : 255) : 0,
|
|
|
|
code_seen('B') ? (code_has_value() ? code_value_byte() : 255) : 0
|
2015-03-05 12:27:24 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2016-11-30 01:51:13 +00:00
|
|
|
#endif // BLINKM || RGB_LED
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-05-31 15:26:08 +00:00
|
|
|
* M200: Set filament diameter and set E axis units to cubic units
|
2015-05-29 05:25:28 +00:00
|
|
|
*
|
|
|
|
* T<extruder> - Optional extruder number. Current extruder if omitted.
|
2016-07-04 03:08:22 +00:00
|
|
|
* D<linear> - Diameter of the filament. Use "D0" to switch back to linear units on the E axis.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M200() {
|
2015-05-29 05:25:28 +00:00
|
|
|
|
2016-04-18 07:01:28 +00:00
|
|
|
if (get_target_extruder_from_command(200)) return;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
if (code_seen('D')) {
|
|
|
|
// setting any extruder filament size disables volumetric on the assumption that
|
|
|
|
// slicers either generate in extruder values as cubic mm or as as filament feeds
|
|
|
|
// for all extruders
|
2016-07-09 23:25:48 +00:00
|
|
|
volumetric_enabled = (code_value_linear_units() != 0.0);
|
2015-03-05 12:27:24 +00:00
|
|
|
if (volumetric_enabled) {
|
2016-07-09 23:25:48 +00:00
|
|
|
filament_size[target_extruder] = code_value_linear_units();
|
2015-03-05 12:27:24 +00:00
|
|
|
// make sure all extruders have some sane value for the filament size
|
2016-07-19 15:24:44 +00:00
|
|
|
for (uint8_t i = 0; i < COUNT(filament_size); i++)
|
2015-03-05 12:27:24 +00:00
|
|
|
if (! filament_size[i]) filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
//reserved for setting filament diameter via UFID or filament measuring device
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
calculate_volumetric_multipliers();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M201: Set max acceleration in units/s^2 for print moves (M201 X1000 Y1000)
|
2016-12-04 04:02:27 +00:00
|
|
|
*
|
|
|
|
* With multiple extruders use T to specify which one.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M201() {
|
2016-12-04 04:02:27 +00:00
|
|
|
|
|
|
|
GET_TARGET_EXTRUDER(201);
|
|
|
|
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) {
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen(axis_codes[i])) {
|
2016-12-04 04:02:27 +00:00
|
|
|
const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0);
|
|
|
|
planner.max_acceleration_mm_per_s2[a] = code_value_axis_units(a);
|
2013-09-29 16:20:06 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
// steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
|
2016-04-28 01:06:32 +00:00
|
|
|
planner.reset_acceleration_rates();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
#if 0 // Not used for Sprinter/grbl gen6
|
|
|
|
inline void gcode_M202() {
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) {
|
2016-06-09 23:53:21 +00:00
|
|
|
if (code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value_axis_units(i) * planner.axis_steps_per_mm[i];
|
2013-09-29 16:20:06 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2014-02-05 09:47:12 +00:00
|
|
|
#endif
|
2014-08-07 00:30:57 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-07-04 03:08:22 +00:00
|
|
|
* M203: Set maximum feedrate that your machine can sustain (M203 X200 Y200 Z300 E10000) in units/sec
|
2016-12-04 04:02:27 +00:00
|
|
|
*
|
|
|
|
* With multiple extruders use T to specify which one.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M203() {
|
2016-12-04 04:02:27 +00:00
|
|
|
|
|
|
|
GET_TARGET_EXTRUDER(203);
|
|
|
|
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i)
|
2016-12-04 04:02:27 +00:00
|
|
|
if (code_seen(axis_codes[i])) {
|
|
|
|
const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0);
|
|
|
|
planner.max_feedrate_mm_s[a] = code_value_axis_units(a);
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-07-04 03:08:22 +00:00
|
|
|
* M204: Set Accelerations in units/sec^2 (M204 P1200 R3000 T3000)
|
2015-03-05 12:27:24 +00:00
|
|
|
*
|
2015-03-11 16:19:02 +00:00
|
|
|
* P = Printing moves
|
|
|
|
* R = Retract only (no X, Y, Z) moves
|
|
|
|
* T = Travel (non printing) moves
|
2015-03-05 12:27:24 +00:00
|
|
|
*
|
|
|
|
* Also sets minimum segment time in ms (B20000) to prevent buffer under-runs and M20 minimum feedrate
|
|
|
|
*/
|
|
|
|
inline void gcode_M204() {
|
2015-04-04 04:43:30 +00:00
|
|
|
if (code_seen('S')) { // Kept for legacy compatibility. Should NOT BE USED for new developments.
|
2016-05-31 15:26:08 +00:00
|
|
|
planner.travel_acceleration = planner.acceleration = code_value_linear_units();
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Setting Print and Travel Acceleration: ", planner.acceleration);
|
2015-03-18 15:19:30 +00:00
|
|
|
}
|
2015-04-04 04:43:30 +00:00
|
|
|
if (code_seen('P')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
planner.acceleration = code_value_linear_units();
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Setting Print Acceleration: ", planner.acceleration);
|
2015-03-11 16:19:02 +00:00
|
|
|
}
|
2015-04-04 04:43:30 +00:00
|
|
|
if (code_seen('R')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
planner.retract_acceleration = code_value_linear_units();
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Setting Retract Acceleration: ", planner.retract_acceleration);
|
2015-03-11 16:19:02 +00:00
|
|
|
}
|
2015-04-04 04:43:30 +00:00
|
|
|
if (code_seen('T')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
planner.travel_acceleration = code_value_linear_units();
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Setting Travel Acceleration: ", planner.travel_acceleration);
|
2015-03-11 16:19:02 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M205: Set Advanced Settings
|
|
|
|
*
|
2016-07-04 03:08:22 +00:00
|
|
|
* S = Min Feed Rate (units/s)
|
|
|
|
* T = Min Travel Feed Rate (units/s)
|
2015-03-05 12:27:24 +00:00
|
|
|
* B = Min Segment Time (µs)
|
2016-10-03 06:54:15 +00:00
|
|
|
* X = Max X Jerk (units/sec^2)
|
|
|
|
* Y = Max Y Jerk (units/sec^2)
|
2016-07-04 03:08:22 +00:00
|
|
|
* Z = Max Z Jerk (units/sec^2)
|
|
|
|
* E = Max E Jerk (units/sec^2)
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M205() {
|
2016-07-16 01:49:34 +00:00
|
|
|
if (code_seen('S')) planner.min_feedrate_mm_s = code_value_linear_units();
|
|
|
|
if (code_seen('T')) planner.min_travel_feedrate_mm_s = code_value_linear_units();
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('B')) planner.min_segment_time = code_value_millis();
|
2016-10-02 09:37:13 +00:00
|
|
|
if (code_seen('X')) planner.max_jerk[X_AXIS] = code_value_axis_units(X_AXIS);
|
|
|
|
if (code_seen('Y')) planner.max_jerk[Y_AXIS] = code_value_axis_units(Y_AXIS);
|
|
|
|
if (code_seen('Z')) planner.max_jerk[Z_AXIS] = code_value_axis_units(Z_AXIS);
|
|
|
|
if (code_seen('E')) planner.max_jerk[E_AXIS] = code_value_axis_units(E_AXIS);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M206: Set Additional Homing Offset (X Y Z). SCARA aliases T=X, P=Y
|
|
|
|
*/
|
|
|
|
inline void gcode_M206() {
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZ(i)
|
2016-04-10 02:07:24 +00:00
|
|
|
if (code_seen(axis_codes[i]))
|
2016-05-31 15:26:08 +00:00
|
|
|
set_home_offset((AxisEnum)i, code_value_axis_units(i));
|
2016-04-10 02:07:24 +00:00
|
|
|
|
2016-09-15 19:11:00 +00:00
|
|
|
#if ENABLED(MORGAN_SCARA)
|
|
|
|
if (code_seen('T')) set_home_offset(A_AXIS, code_value_axis_units(A_AXIS)); // Theta
|
|
|
|
if (code_seen('P')) set_home_offset(B_AXIS, code_value_axis_units(B_AXIS)); // Psi
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2016-04-26 01:24:12 +00:00
|
|
|
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-04-26 01:24:12 +00:00
|
|
|
report_current_position();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M665: Set delta configurations
|
|
|
|
*
|
|
|
|
* L = diagonal rod
|
|
|
|
* R = delta radius
|
|
|
|
* S = segments per second
|
2015-09-03 05:38:47 +00:00
|
|
|
* A = Alpha (Tower 1) diagonal rod trim
|
|
|
|
* B = Beta (Tower 2) diagonal rod trim
|
|
|
|
* C = Gamma (Tower 3) diagonal rod trim
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M665() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
|
|
|
|
if (code_seen('R')) delta_radius = code_value_linear_units();
|
|
|
|
if (code_seen('S')) delta_segments_per_second = code_value_float();
|
|
|
|
if (code_seen('A')) delta_diagonal_rod_trim_tower_1 = code_value_linear_units();
|
|
|
|
if (code_seen('B')) delta_diagonal_rod_trim_tower_2 = code_value_linear_units();
|
|
|
|
if (code_seen('C')) delta_diagonal_rod_trim_tower_3 = code_value_linear_units();
|
2015-03-05 12:27:24 +00:00
|
|
|
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* M666: Set delta endstop adjustment
|
|
|
|
*/
|
|
|
|
inline void gcode_M666() {
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2015-08-05 11:40:36 +00:00
|
|
|
SERIAL_ECHOLNPGM(">>> gcode_M666");
|
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZ(i) {
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen(axis_codes[i])) {
|
2016-05-31 15:26:08 +00:00
|
|
|
endstop_adj[i] = code_value_axis_units(i);
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR("endstop_adj[", axis_codes[i]);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("] = ", endstop_adj[i]);
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
2015-08-05 11:40:36 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(LEVELING)) {
|
2015-08-05 11:40:36 +00:00
|
|
|
SERIAL_ECHOLNPGM("<<< gcode_M666");
|
|
|
|
}
|
2015-07-09 23:57:44 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#elif ENABLED(Z_DUAL_ENDSTOPS) // !DELTA && ENABLED(Z_DUAL_ENDSTOPS)
|
2015-10-03 06:08:58 +00:00
|
|
|
|
2015-03-24 17:06:44 +00:00
|
|
|
/**
|
|
|
|
* M666: For Z Dual Endstop setup, set z axis offset to the z2 axis.
|
|
|
|
*/
|
|
|
|
inline void gcode_M666() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('Z')) z_endstop_adj = code_value_axis_units(Z_AXIS);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Z Endstop Adjustment set to (mm):", z_endstop_adj);
|
2015-03-24 17:06:44 +00:00
|
|
|
}
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#endif // !DELTA && Z_DUAL_ENDSTOPS
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2015-04-27 01:44:01 +00:00
|
|
|
* M207: Set firmware retraction values
|
|
|
|
*
|
2016-07-04 03:08:22 +00:00
|
|
|
* S[+units] retract_length
|
|
|
|
* W[+units] retract_length_swap (multi-extruder)
|
|
|
|
* F[units/min] retract_feedrate_mm_s
|
|
|
|
* Z[units] retract_zlift
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M207() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) retract_length = code_value_axis_units(E_AXIS);
|
2016-07-16 01:49:34 +00:00
|
|
|
if (code_seen('F')) retract_feedrate_mm_s = MMM_TO_MMS(code_value_axis_units(E_AXIS));
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('Z')) retract_zlift = code_value_axis_units(Z_AXIS);
|
2015-04-27 01:44:01 +00:00
|
|
|
#if EXTRUDERS > 1
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('W')) retract_length_swap = code_value_axis_units(E_AXIS);
|
2015-04-27 01:44:01 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-04-27 01:44:01 +00:00
|
|
|
* M208: Set firmware un-retraction values
|
|
|
|
*
|
2016-07-04 03:08:22 +00:00
|
|
|
* S[+units] retract_recover_length (in addition to M207 S*)
|
|
|
|
* W[+units] retract_recover_length_swap (multi-extruder)
|
2016-07-16 01:49:34 +00:00
|
|
|
* F[units/min] retract_recover_feedrate_mm_s
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M208() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) retract_recover_length = code_value_axis_units(E_AXIS);
|
2016-07-16 01:49:34 +00:00
|
|
|
if (code_seen('F')) retract_recover_feedrate_mm_s = MMM_TO_MMS(code_value_axis_units(E_AXIS));
|
2015-04-27 01:44:01 +00:00
|
|
|
#if EXTRUDERS > 1
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('W')) retract_recover_length_swap = code_value_axis_units(E_AXIS);
|
2015-04-27 01:44:01 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M209: Enable automatic retract (M209 S1)
|
2016-10-05 09:39:01 +00:00
|
|
|
* For slicers that don't support G10/11, reversed extrude-only
|
|
|
|
* moves will be classified as retraction.
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M209() {
|
|
|
|
if (code_seen('S')) {
|
2016-08-21 01:11:08 +00:00
|
|
|
autoretract_enabled = code_value_bool();
|
2015-10-03 06:08:58 +00:00
|
|
|
for (int i = 0; i < EXTRUDERS; i++) retracted[i] = false;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // FWRETRACT
|
|
|
|
|
2016-08-21 01:07:42 +00:00
|
|
|
/**
|
|
|
|
* M211: Enable, Disable, and/or Report software endstops
|
|
|
|
*
|
|
|
|
* Usage: M211 S1 to enable, M211 S0 to disable, M211 alone for report
|
|
|
|
*/
|
|
|
|
inline void gcode_M211() {
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
#if ENABLED(min_software_endstops) || ENABLED(max_software_endstops)
|
|
|
|
if (code_seen('S')) soft_endstops_enabled = code_value_bool();
|
|
|
|
#endif
|
|
|
|
#if ENABLED(min_software_endstops) || ENABLED(max_software_endstops)
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPGM(MSG_SOFT_ENDSTOPS);
|
2016-08-21 01:07:42 +00:00
|
|
|
serialprintPGM(soft_endstops_enabled ? PSTR(MSG_ON) : PSTR(MSG_OFF));
|
|
|
|
#else
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPGM(MSG_SOFT_ENDSTOPS);
|
|
|
|
SERIAL_ECHOPGM(MSG_OFF);
|
2016-08-21 01:07:42 +00:00
|
|
|
#endif
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPGM(MSG_SOFT_MIN);
|
2016-08-21 01:07:42 +00:00
|
|
|
SERIAL_ECHOPAIR( MSG_X, soft_endstop_min[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" " MSG_Y, soft_endstop_min[Y_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" " MSG_Z, soft_endstop_min[Z_AXIS]);
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPGM(MSG_SOFT_MAX);
|
2016-08-21 01:07:42 +00:00
|
|
|
SERIAL_ECHOPAIR( MSG_X, soft_endstop_max[X_AXIS]);
|
|
|
|
SERIAL_ECHOPAIR(" " MSG_Y, soft_endstop_max[Y_AXIS]);
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" " MSG_Z, soft_endstop_max[Z_AXIS]);
|
2016-08-21 01:07:42 +00:00
|
|
|
}
|
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-07-04 03:08:22 +00:00
|
|
|
* M218 - set hotend offset (in linear units)
|
2016-04-13 00:16:58 +00:00
|
|
|
*
|
|
|
|
* T<tool>
|
|
|
|
* X<xoffset>
|
|
|
|
* Y<yoffset>
|
2016-06-28 22:06:56 +00:00
|
|
|
* Z<zoffset> - Available with DUAL_X_CARRIAGE and SWITCHING_EXTRUDER
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M218() {
|
2016-10-28 23:39:23 +00:00
|
|
|
if (get_target_extruder_from_command(218) || target_extruder == 0) return;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('X')) hotend_offset[X_AXIS][target_extruder] = code_value_axis_units(X_AXIS);
|
|
|
|
if (code_seen('Y')) hotend_offset[Y_AXIS][target_extruder] = code_value_axis_units(Y_AXIS);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER)
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('Z')) hotend_offset[Z_AXIS][target_extruder] = code_value_axis_units(Z_AXIS);
|
2014-08-07 00:30:57 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
|
2016-07-10 04:11:17 +00:00
|
|
|
HOTEND_LOOP() {
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(' ');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHO(hotend_offset[X_AXIS][e]);
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(',');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHO(hotend_offset[Y_AXIS][e]);
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_EXTRUDER)
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(',');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHO(hotend_offset[Z_AXIS][e]);
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
SERIAL_EOL;
|
|
|
|
}
|
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
#endif // HOTENDS > 1
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M220: Set speed percentage factor, aka "Feed Rate" (M220 S95)
|
|
|
|
*/
|
|
|
|
inline void gcode_M220() {
|
2016-07-16 01:49:34 +00:00
|
|
|
if (code_seen('S')) feedrate_percentage = code_value_int();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M221: Set extrusion percentage (M221 T0 S95)
|
|
|
|
*/
|
|
|
|
inline void gcode_M221() {
|
2016-07-10 00:53:49 +00:00
|
|
|
if (get_target_extruder_from_command(221)) return;
|
|
|
|
if (code_seen('S'))
|
2016-08-19 03:13:47 +00:00
|
|
|
flow_percentage[target_extruder] = code_value_int();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M226: Wait until the specified pin reaches the state required (M226 P<pin> S<state>)
|
|
|
|
*/
|
|
|
|
inline void gcode_M226() {
|
|
|
|
if (code_seen('P')) {
|
2016-10-05 06:50:36 +00:00
|
|
|
int pin_number = code_value_int(),
|
|
|
|
pin_state = code_seen('S') ? code_value_int() : -1; // required pin state - default is inverted
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
if (pin_state >= -1 && pin_state <= 1 && pin_number > -1 && !pin_is_protected(pin_number)) {
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
int target = LOW;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
stepper.synchronize();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
pinMode(pin_number, INPUT);
|
|
|
|
switch (pin_state) {
|
|
|
|
case 1:
|
|
|
|
target = HIGH;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
target = LOW;
|
|
|
|
break;
|
|
|
|
case -1:
|
|
|
|
target = !digitalRead(pin_number);
|
|
|
|
break;
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
while (digitalRead(pin_number) != target) idle();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 06:50:36 +00:00
|
|
|
} // pin_state -1 0 1 && pin_number > -1
|
2015-03-05 12:27:24 +00:00
|
|
|
} // code_seen('P')
|
|
|
|
}
|
|
|
|
|
2016-11-08 22:28:42 +00:00
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M260: Send data to a I2C slave device
|
|
|
|
*
|
|
|
|
* This is a PoC, the formating and arguments for the GCODE will
|
|
|
|
* change to be more compatible, the current proposal is:
|
|
|
|
*
|
|
|
|
* M260 A<slave device address base 10> ; Sets the I2C slave address the data will be sent to
|
|
|
|
*
|
|
|
|
* M260 B<byte-1 value in base 10>
|
|
|
|
* M260 B<byte-2 value in base 10>
|
|
|
|
* M260 B<byte-3 value in base 10>
|
|
|
|
*
|
|
|
|
* M260 S1 ; Send the buffered data and reset the buffer
|
|
|
|
* M260 R1 ; Reset the buffer without sending data
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
inline void gcode_M260() {
|
|
|
|
// Set the target address
|
|
|
|
if (code_seen('A')) i2c.address(code_value_byte());
|
|
|
|
|
|
|
|
// Add a new byte to the buffer
|
|
|
|
if (code_seen('B')) i2c.addbyte(code_value_byte());
|
|
|
|
|
|
|
|
// Flush the buffer to the bus
|
|
|
|
if (code_seen('S')) i2c.send();
|
|
|
|
|
|
|
|
// Reset and rewind the buffer
|
|
|
|
else if (code_seen('R')) i2c.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M261: Request X bytes from I2C slave device
|
|
|
|
*
|
|
|
|
* Usage: M261 A<slave device address base 10> B<number of bytes>
|
|
|
|
*/
|
|
|
|
inline void gcode_M261() {
|
|
|
|
if (code_seen('A')) i2c.address(code_value_byte());
|
|
|
|
|
|
|
|
uint8_t bytes = code_seen('B') ? code_value_byte() : 1;
|
|
|
|
|
|
|
|
if (i2c.addr && bytes && bytes <= TWIBUS_BUFFER_SIZE) {
|
|
|
|
i2c.relay(bytes);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLN("Bad i2c request");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // EXPERIMENTAL_I2CBUS
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if HAS_SERVOS
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-07-10 00:53:49 +00:00
|
|
|
* M280: Get or set servo position. P<index> [S<angle>]
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M280() {
|
2016-07-10 00:53:49 +00:00
|
|
|
if (!code_seen('P')) return;
|
|
|
|
int servo_index = code_value_int();
|
|
|
|
if (servo_index >= 0 && servo_index < NUM_SERVOS) {
|
|
|
|
if (code_seen('S'))
|
|
|
|
MOVE_SERVO(servo_index, code_value_int());
|
2015-03-05 12:27:24 +00:00
|
|
|
else {
|
2016-07-10 00:53:49 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" Servo ", servo_index);
|
|
|
|
SERIAL_ECHOLNPAIR(": ", servo[servo_index].read());
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
2016-07-10 00:53:49 +00:00
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR("Servo ", servo_index);
|
|
|
|
SERIAL_ECHOLNPGM(" out of range");
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#endif // HAS_SERVOS
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-06-14 22:12:02 +00:00
|
|
|
#if HAS_BUZZER
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M300: Play beep sound S<frequency Hz> P<duration ms>
|
|
|
|
*/
|
|
|
|
inline void gcode_M300() {
|
2016-06-04 19:29:01 +00:00
|
|
|
uint16_t const frequency = code_seen('S') ? code_value_ushort() : 260;
|
|
|
|
uint16_t duration = code_seen('P') ? code_value_ushort() : 1000;
|
|
|
|
|
|
|
|
// Limits the tone duration to 0-5 seconds.
|
|
|
|
NOMORE(duration, 5000);
|
|
|
|
|
2016-08-02 04:10:53 +00:00
|
|
|
BUZZ(duration, frequency);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-06-14 22:12:02 +00:00
|
|
|
#endif // HAS_BUZZER
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2015-08-31 02:04:30 +00:00
|
|
|
* M301: Set PID parameters P I D (and optionally C, L)
|
|
|
|
*
|
|
|
|
* P[float] Kp term
|
|
|
|
* I[float] Ki term (unscaled)
|
|
|
|
* D[float] Kd term (unscaled)
|
|
|
|
*
|
2016-08-01 00:49:34 +00:00
|
|
|
* With PID_EXTRUSION_SCALING:
|
2015-08-31 02:04:30 +00:00
|
|
|
*
|
|
|
|
* C[float] Kc term
|
|
|
|
* L[float] LPQ length
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M301() {
|
|
|
|
|
|
|
|
// multi-extruder PID patch: M301 updates or prints a single extruder's PID values
|
|
|
|
// default behaviour (omitting E parameter) is to update for extruder 0 only
|
2016-05-31 15:26:08 +00:00
|
|
|
int e = code_seen('E') ? code_value_int() : 0; // extruder being updated
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
if (e < HOTENDS) { // catch bad input value
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('P')) PID_PARAM(Kp, e) = code_value_float();
|
|
|
|
if (code_seen('I')) PID_PARAM(Ki, e) = scalePID_i(code_value_float());
|
|
|
|
if (code_seen('D')) PID_PARAM(Kd, e) = scalePID_d(code_value_float());
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('C')) PID_PARAM(Kc, e) = code_value_float();
|
|
|
|
if (code_seen('L')) lpq_len = code_value_float();
|
2015-08-31 02:04:30 +00:00
|
|
|
NOMORE(lpq_len, LPQ_MAX_LEN);
|
2015-08-05 11:40:36 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.updatePID();
|
2016-02-09 12:36:03 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-05-27 00:43:20 +00:00
|
|
|
#if ENABLED(PID_PARAMS_PER_HOTEND)
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" e:", e); // specify extruder in serial output
|
2016-05-27 00:43:20 +00:00
|
|
|
#endif // PID_PARAMS_PER_HOTEND
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" p:", PID_PARAM(Kp, e));
|
|
|
|
SERIAL_ECHOPAIR(" i:", unscalePID_i(PID_PARAM(Ki, e)));
|
|
|
|
SERIAL_ECHOPAIR(" d:", unscalePID_d(PID_PARAM(Kd, e)));
|
2016-08-01 00:49:34 +00:00
|
|
|
#if ENABLED(PID_EXTRUSION_SCALING)
|
2015-03-05 12:27:24 +00:00
|
|
|
//Kc does not have scaling applied above, or in resetting defaults
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" c:", PID_PARAM(Kc, e));
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2015-08-05 11:40:36 +00:00
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-02-09 12:36:03 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLN(MSG_INVALID_EXTRUDER);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // PIDTEMP
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
inline void gcode_M304() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('P')) thermalManager.bedKp = code_value_float();
|
|
|
|
if (code_seen('I')) thermalManager.bedKi = scalePID_i(code_value_float());
|
|
|
|
if (code_seen('D')) thermalManager.bedKd = scalePID_d(code_value_float());
|
2016-04-29 01:18:13 +00:00
|
|
|
|
|
|
|
thermalManager.updatePID();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-02-09 12:36:03 +00:00
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" p:", thermalManager.bedKp);
|
|
|
|
SERIAL_ECHOPAIR(" i:", unscalePID_i(thermalManager.bedKi));
|
|
|
|
SERIAL_ECHOLNPAIR(" d:", unscalePID_d(thermalManager.bedKd));
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // PIDTEMPBED
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if defined(CHDK) || HAS_PHOTOGRAPH
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M240: Trigger a camera by emulating a Canon RC-1
|
|
|
|
* See http://www.doc-diy.net/photo/rc-1_hacked/
|
|
|
|
*/
|
|
|
|
inline void gcode_M240() {
|
|
|
|
#ifdef CHDK
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2015-10-03 06:08:58 +00:00
|
|
|
OUT_WRITE(CHDK, HIGH);
|
|
|
|
chdkHigh = millis();
|
|
|
|
chdkActive = true;
|
2015-07-31 05:24:43 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#elif HAS_PHOTOGRAPH
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
const uint8_t NUM_PULSES = 16;
|
|
|
|
const float PULSE_LENGTH = 0.01524;
|
|
|
|
for (int i = 0; i < NUM_PULSES; i++) {
|
|
|
|
WRITE(PHOTOGRAPH_PIN, HIGH);
|
|
|
|
_delay_ms(PULSE_LENGTH);
|
|
|
|
WRITE(PHOTOGRAPH_PIN, LOW);
|
|
|
|
_delay_ms(PULSE_LENGTH);
|
|
|
|
}
|
|
|
|
delay(7.33);
|
|
|
|
for (int i = 0; i < NUM_PULSES; i++) {
|
|
|
|
WRITE(PHOTOGRAPH_PIN, HIGH);
|
|
|
|
_delay_ms(PULSE_LENGTH);
|
|
|
|
WRITE(PHOTOGRAPH_PIN, LOW);
|
|
|
|
_delay_ms(PULSE_LENGTH);
|
|
|
|
}
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif // !CHDK && HAS_PHOTOGRAPH
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // CHDK || PHOTOGRAPH_PIN
|
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if HAS_LCD_CONTRAST
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M250: Read and optionally set the LCD contrast
|
|
|
|
*/
|
|
|
|
inline void gcode_M250() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('C')) set_lcd_contrast(code_value_int());
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_PROTOCOLPGM("lcd contrast value: ");
|
|
|
|
SERIAL_PROTOCOL(lcd_contrast);
|
2015-04-02 12:10:14 +00:00
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-04-08 11:26:29 +00:00
|
|
|
#endif // HAS_LCD_CONTRAST
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-08-21 04:34:24 +00:00
|
|
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-07-06 15:28:09 +00:00
|
|
|
* M302: Allow cold extrudes, or set the minimum extrude temperature
|
|
|
|
*
|
|
|
|
* S<temperature> sets the minimum extrude temperature
|
|
|
|
* P<bool> enables (1) or disables (0) cold extrusion
|
|
|
|
*
|
|
|
|
* Examples:
|
|
|
|
*
|
|
|
|
* M302 ; report current cold extrusion state
|
|
|
|
* M302 P0 ; enable cold extrusion checking
|
|
|
|
* M302 P1 ; disables cold extrusion checking
|
|
|
|
* M302 S0 ; always allow extrusion (disables checking)
|
|
|
|
* M302 S170 ; only allow extrusion above 170
|
|
|
|
* M302 S170 P1 ; set min extrude temp to 170 but leave disabled
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M302() {
|
2016-07-06 15:28:09 +00:00
|
|
|
bool seen_S = code_seen('S');
|
|
|
|
if (seen_S) {
|
|
|
|
thermalManager.extrude_min_temp = code_value_temp_abs();
|
|
|
|
thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (code_seen('P'))
|
|
|
|
thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || code_value_bool();
|
|
|
|
else if (!seen_S) {
|
|
|
|
// Report current state
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPAIR("Cold extrudes are ", (thermalManager.allow_cold_extrude ? "en" : "dis"));
|
|
|
|
SERIAL_ECHOPAIR("abled (min temp ", int(thermalManager.extrude_min_temp + 0.5));
|
|
|
|
SERIAL_ECHOLNPGM("C)");
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-08-21 04:34:24 +00:00
|
|
|
#endif // PREVENT_COLD_EXTRUSION
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M303: PID relay autotune
|
2016-03-22 01:10:08 +00:00
|
|
|
*
|
|
|
|
* S<temperature> sets the target temperature. (default 150C)
|
|
|
|
* E<extruder> (-1 for the bed) (default 0)
|
2015-03-05 12:27:24 +00:00
|
|
|
* C<cycles>
|
2016-03-22 01:10:08 +00:00
|
|
|
* U<bool> with a non-zero value will apply the result to current settings
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M303() {
|
2016-04-20 01:09:29 +00:00
|
|
|
#if HAS_PID_HEATING
|
2016-05-31 15:26:08 +00:00
|
|
|
int e = code_seen('E') ? code_value_int() : 0;
|
|
|
|
int c = code_seen('C') ? code_value_int() : 5;
|
|
|
|
bool u = code_seen('U') && code_value_bool();
|
2016-03-24 18:01:20 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
float temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70.0 : 150.0);
|
2015-11-09 23:02:11 +00:00
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
if (e >= 0 && e < HOTENDS)
|
2016-04-19 02:02:11 +00:00
|
|
|
target_extruder = e;
|
2016-03-07 11:48:14 +00:00
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY); // don't send "busy: processing" messages during autotune output
|
2016-03-22 01:10:08 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.PID_autotune(temp, e, c, u);
|
2016-03-22 01:10:08 +00:00
|
|
|
|
2016-04-19 02:02:11 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
|
|
#else
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_M303_DISABLED);
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
#if ENABLED(MORGAN_SCARA)
|
2016-09-15 18:34:24 +00:00
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
bool SCARA_move_to_cal(uint8_t delta_a, uint8_t delta_b) {
|
2015-04-08 07:56:19 +00:00
|
|
|
if (IsRunning()) {
|
2016-09-12 08:48:29 +00:00
|
|
|
forward_kinematics_SCARA(delta_a, delta_b);
|
2016-09-15 18:58:42 +00:00
|
|
|
destination[X_AXIS] = LOGICAL_X_POSITION(cartes[X_AXIS]);
|
|
|
|
destination[Y_AXIS] = LOGICAL_Y_POSITION(cartes[Y_AXIS]);
|
2016-09-12 08:48:29 +00:00
|
|
|
destination[Z_AXIS] = current_position[Z_AXIS];
|
2016-06-11 02:23:41 +00:00
|
|
|
prepare_move_to_destination();
|
2015-03-05 12:27:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-03-21 23:32:22 +00:00
|
|
|
/**
|
|
|
|
* M360: SCARA calibration: Move to cal-position ThetaA (0 deg calibration)
|
|
|
|
*/
|
|
|
|
inline bool gcode_M360() {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Cal: Theta 0");
|
2015-03-21 23:32:22 +00:00
|
|
|
return SCARA_move_to_cal(0, 120);
|
|
|
|
}
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M361: SCARA calibration: Move to cal-position ThetaB (90 deg calibration - steps per degree)
|
|
|
|
*/
|
|
|
|
inline bool gcode_M361() {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Cal: Theta 90");
|
2015-03-21 23:32:22 +00:00
|
|
|
return SCARA_move_to_cal(90, 130);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M362: SCARA calibration: Move to cal-position PsiA (0 deg calibration)
|
|
|
|
*/
|
|
|
|
inline bool gcode_M362() {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Cal: Psi 0");
|
2015-03-21 23:32:22 +00:00
|
|
|
return SCARA_move_to_cal(60, 180);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M363: SCARA calibration: Move to cal-position PsiB (90 deg calibration - steps per degree)
|
|
|
|
*/
|
|
|
|
inline bool gcode_M363() {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Cal: Psi 90");
|
2015-03-21 23:32:22 +00:00
|
|
|
return SCARA_move_to_cal(50, 90);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M364: SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
|
|
|
|
*/
|
|
|
|
inline bool gcode_M364() {
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_ECHOLNPGM(" Cal: Theta-Psi 90");
|
2015-03-21 23:32:22 +00:00
|
|
|
return SCARA_move_to_cal(45, 135);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // SCARA
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(EXT_SOLENOID)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
void enable_solenoid(uint8_t num) {
|
2015-10-03 06:08:58 +00:00
|
|
|
switch (num) {
|
2015-03-05 12:27:24 +00:00
|
|
|
case 0:
|
|
|
|
OUT_WRITE(SOL0_PIN, HIGH);
|
|
|
|
break;
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SOLENOID_1
|
2015-03-05 12:27:24 +00:00
|
|
|
case 1:
|
|
|
|
OUT_WRITE(SOL1_PIN, HIGH);
|
|
|
|
break;
|
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SOLENOID_2
|
2015-03-05 12:27:24 +00:00
|
|
|
case 2:
|
|
|
|
OUT_WRITE(SOL2_PIN, HIGH);
|
|
|
|
break;
|
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_SOLENOID_3
|
2015-03-05 12:27:24 +00:00
|
|
|
case 3:
|
|
|
|
OUT_WRITE(SOL3_PIN, HIGH);
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void enable_solenoid_on_active_extruder() { enable_solenoid(active_extruder); }
|
|
|
|
|
|
|
|
void disable_all_solenoids() {
|
|
|
|
OUT_WRITE(SOL0_PIN, LOW);
|
|
|
|
OUT_WRITE(SOL1_PIN, LOW);
|
|
|
|
OUT_WRITE(SOL2_PIN, LOW);
|
|
|
|
OUT_WRITE(SOL3_PIN, LOW);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M380: Enable solenoid on the active extruder
|
|
|
|
*/
|
|
|
|
inline void gcode_M380() { enable_solenoid_on_active_extruder(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M381: Disable all solenoids
|
|
|
|
*/
|
|
|
|
inline void gcode_M381() { disable_all_solenoids(); }
|
|
|
|
|
|
|
|
#endif // EXT_SOLENOID
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M400: Finish all moves
|
|
|
|
*/
|
2016-04-27 14:15:20 +00:00
|
|
|
inline void gcode_M400() { stepper.synchronize(); }
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-21 22:04:09 +00:00
|
|
|
#if HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M401: Engage Z Servo endstop if available
|
|
|
|
*/
|
2016-07-06 01:40:21 +00:00
|
|
|
inline void gcode_M401() { DEPLOY_PROBE(); }
|
2015-04-16 14:24:33 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M402: Retract Z Servo endstop if enabled
|
|
|
|
*/
|
2016-07-06 01:40:21 +00:00
|
|
|
inline void gcode_M402() { STOW_PROBE(); }
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-21 22:04:09 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-03-30 03:28:23 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2016-07-04 03:08:22 +00:00
|
|
|
* M404: Display or set (in current units) the nominal filament width (3mm, 1.75mm ) W<3.0>
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M404() {
|
2016-03-30 03:43:41 +00:00
|
|
|
if (code_seen('W')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
filament_width_nominal = code_value_linear_units();
|
2016-03-30 03:43:41 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_PROTOCOLPGM("Filament dia (nominal mm):");
|
|
|
|
SERIAL_PROTOCOLLN(filament_width_nominal);
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M405: Turn on filament sensor for control
|
|
|
|
*/
|
|
|
|
inline void gcode_M405() {
|
2016-05-31 15:26:08 +00:00
|
|
|
// This is technically a linear measurement, but since it's quantized to centimeters and is a different unit than
|
|
|
|
// everything else, it uses code_value_int() instead of code_value_linear_units().
|
|
|
|
if (code_seen('D')) meas_delay_cm = code_value_int();
|
2016-02-22 06:17:32 +00:00
|
|
|
NOMORE(meas_delay_cm, MAX_MEASUREMENT_DELAY);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-06 04:57:12 +00:00
|
|
|
if (filwidth_delay_index[1] == -1) { // Initialize the ring buffer if not done since startup
|
2016-04-29 01:18:13 +00:00
|
|
|
int temp_ratio = thermalManager.widthFil_to_size_ratio();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-07 02:29:08 +00:00
|
|
|
for (uint8_t i = 0; i < COUNT(measurement_delay); ++i)
|
|
|
|
measurement_delay[i] = temp_ratio - 100; // Subtract 100 to scale within a signed byte
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-06 04:57:12 +00:00
|
|
|
filwidth_delay_index[0] = filwidth_delay_index[1] = 0;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
filament_sensor = true;
|
|
|
|
|
|
|
|
//SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
|
|
|
|
//SERIAL_PROTOCOL(filament_width_meas);
|
|
|
|
//SERIAL_PROTOCOLPGM("Extrusion ratio(%):");
|
2016-08-19 03:13:47 +00:00
|
|
|
//SERIAL_PROTOCOL(flow_percentage[active_extruder]);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M406: Turn off filament sensor for control
|
|
|
|
*/
|
|
|
|
inline void gcode_M406() { filament_sensor = false; }
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M407: Get measured filament diameter on serial output
|
|
|
|
*/
|
|
|
|
inline void gcode_M407() {
|
2015-08-05 11:40:36 +00:00
|
|
|
SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
|
|
|
|
SERIAL_PROTOCOLLN(filament_width_meas);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-03-30 03:28:23 +00:00
|
|
|
#endif // FILAMENT_WIDTH_SENSOR
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-06 19:00:28 +00:00
|
|
|
void quickstop_stepper() {
|
|
|
|
stepper.quick_stop();
|
2016-09-15 20:02:36 +00:00
|
|
|
stepper.synchronize();
|
|
|
|
set_current_from_steppers_for_axis(ALL_AXES);
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-05-31 22:16:21 +00:00
|
|
|
}
|
2015-04-19 06:07:48 +00:00
|
|
|
|
2016-09-29 06:03:28 +00:00
|
|
|
#if PLANNER_LEVELING
|
2015-04-27 01:44:01 +00:00
|
|
|
/**
|
2016-11-26 05:32:47 +00:00
|
|
|
* M420: Enable/Disable Bed Leveling and/or set the Z fade height.
|
|
|
|
*
|
|
|
|
* S[bool] Turns leveling on or off
|
|
|
|
* Z[height] Sets the Z fade height (0 or none to disable)
|
2015-04-27 01:44:01 +00:00
|
|
|
*/
|
2016-11-26 05:32:47 +00:00
|
|
|
inline void gcode_M420() {
|
|
|
|
if (code_seen('S')) set_bed_leveling_enabled(code_value_bool());
|
|
|
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
|
|
|
if (code_seen('Z')) set_z_fade_height(code_value_linear_units());
|
|
|
|
#endif
|
|
|
|
}
|
2016-09-29 06:03:28 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-27 01:44:01 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M421: Set a single Mesh Bed Leveling Z coordinate
|
2016-07-04 03:08:22 +00:00
|
|
|
* Use either 'M421 X<linear> Y<linear> Z<linear>' or 'M421 I<xindex> J<yindex> Z<linear>'
|
2015-04-27 01:44:01 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M421() {
|
2016-04-30 09:51:18 +00:00
|
|
|
int8_t px = 0, py = 0;
|
2016-05-22 02:06:27 +00:00
|
|
|
float z = 0;
|
|
|
|
bool hasX, hasY, hasZ, hasI, hasJ;
|
2016-05-31 15:26:08 +00:00
|
|
|
if ((hasX = code_seen('X'))) px = mbl.probe_index_x(code_value_axis_units(X_AXIS));
|
|
|
|
if ((hasY = code_seen('Y'))) py = mbl.probe_index_y(code_value_axis_units(Y_AXIS));
|
|
|
|
if ((hasI = code_seen('I'))) px = code_value_axis_units(X_AXIS);
|
|
|
|
if ((hasJ = code_seen('J'))) py = code_value_axis_units(Y_AXIS);
|
|
|
|
if ((hasZ = code_seen('Z'))) z = code_value_axis_units(Z_AXIS);
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-05-15 00:12:44 +00:00
|
|
|
if (hasX && hasY && hasZ) {
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-05-22 00:38:14 +00:00
|
|
|
if (px >= 0 && py >= 0)
|
|
|
|
mbl.set_z(px, py, z);
|
2016-05-15 00:12:44 +00:00
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
|
|
|
|
}
|
|
|
|
}
|
2016-05-20 22:18:09 +00:00
|
|
|
else if (hasI && hasJ && hasZ) {
|
2016-05-22 00:38:14 +00:00
|
|
|
if (px >= 0 && px < MESH_NUM_X_POINTS && py >= 0 && py < MESH_NUM_Y_POINTS)
|
|
|
|
mbl.set_z(px, py, z);
|
2016-05-20 22:18:09 +00:00
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
|
|
|
|
}
|
|
|
|
}
|
2016-05-22 00:38:14 +00:00
|
|
|
else {
|
2015-04-27 01:44:01 +00:00
|
|
|
SERIAL_ERROR_START;
|
2016-05-22 02:06:27 +00:00
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
|
2015-04-27 01:44:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-04-30 01:26:16 +00:00
|
|
|
/**
|
|
|
|
* M428: Set home_offset based on the distance between the
|
2015-04-30 02:05:48 +00:00
|
|
|
* current_position and the nearest "reference point."
|
|
|
|
* If an axis is past center its endstop position
|
2015-04-30 01:26:16 +00:00
|
|
|
* is the reference-point. Otherwise it uses 0. This allows
|
|
|
|
* the Z offset to be set near the bed when using a max endstop.
|
|
|
|
*
|
2015-04-30 02:05:48 +00:00
|
|
|
* M428 can't be used more than 2cm away from 0 or an endstop.
|
|
|
|
*
|
2015-04-30 01:26:16 +00:00
|
|
|
* Use M206 to set these values directly.
|
|
|
|
*/
|
|
|
|
inline void gcode_M428() {
|
2015-04-30 02:05:48 +00:00
|
|
|
bool err = false;
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZ(i) {
|
2016-03-25 13:05:20 +00:00
|
|
|
if (axis_homed[i]) {
|
2016-11-02 22:42:24 +00:00
|
|
|
float base = (current_position[i] > (soft_endstop_min[i] + soft_endstop_max[i]) * 0.5) ? base_home_pos((AxisEnum)i) : 0,
|
2016-07-23 00:46:05 +00:00
|
|
|
diff = current_position[i] - LOGICAL_POSITION(base, i);
|
2015-04-30 02:05:48 +00:00
|
|
|
if (diff > -20 && diff < 20) {
|
2016-04-10 02:07:24 +00:00
|
|
|
set_home_offset((AxisEnum)i, home_offset[i] - diff);
|
2015-04-30 02:05:48 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_M428_TOO_FAR);
|
|
|
|
LCD_ALERTMESSAGEPGM("Err: Too far!");
|
2016-08-02 04:10:53 +00:00
|
|
|
BUZZ(200, 40);
|
2015-04-30 02:05:48 +00:00
|
|
|
err = true;
|
|
|
|
break;
|
|
|
|
}
|
2015-04-30 01:26:16 +00:00
|
|
|
}
|
|
|
|
}
|
2015-04-30 02:05:48 +00:00
|
|
|
|
|
|
|
if (!err) {
|
2016-06-22 01:56:25 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-04-26 01:24:12 +00:00
|
|
|
report_current_position();
|
2016-04-16 01:48:49 +00:00
|
|
|
LCD_MESSAGEPGM(MSG_HOME_OFFSETS_APPLIED);
|
2016-08-02 04:10:53 +00:00
|
|
|
BUZZ(200, 659);
|
|
|
|
BUZZ(200, 698);
|
2015-04-30 02:05:48 +00:00
|
|
|
}
|
2015-04-30 01:26:16 +00:00
|
|
|
}
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M500: Store settings in EEPROM
|
|
|
|
*/
|
|
|
|
inline void gcode_M500() {
|
|
|
|
Config_StoreSettings();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M501: Read settings from EEPROM
|
|
|
|
*/
|
|
|
|
inline void gcode_M501() {
|
|
|
|
Config_RetrieveSettings();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M502: Revert to default settings
|
|
|
|
*/
|
|
|
|
inline void gcode_M502() {
|
|
|
|
Config_ResetDefault();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M503: print settings currently in memory
|
|
|
|
*/
|
|
|
|
inline void gcode_M503() {
|
2016-05-31 15:26:08 +00:00
|
|
|
Config_PrintSettings(code_seen('S') && !code_value_bool());
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M540: Set whether SD card print should abort on endstop hit (M540 S<0|1>)
|
|
|
|
*/
|
|
|
|
inline void gcode_M540() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) stepper.abort_on_endstop_hit = code_value_bool();
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
|
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#if HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
inline void gcode_M851() {
|
2015-08-13 00:52:50 +00:00
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET);
|
|
|
|
SERIAL_CHAR(' ');
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
if (code_seen('Z')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
float value = code_value_axis_units(Z_AXIS);
|
2015-03-05 12:27:24 +00:00
|
|
|
if (Z_PROBE_OFFSET_RANGE_MIN <= value && value <= Z_PROBE_OFFSET_RANGE_MAX) {
|
2015-05-27 00:47:04 +00:00
|
|
|
zprobe_zoffset = value;
|
2016-02-09 12:36:03 +00:00
|
|
|
SERIAL_ECHO(zprobe_zoffset);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(MSG_Z_MIN, Z_PROBE_OFFSET_RANGE_MIN);
|
2016-06-27 23:29:35 +00:00
|
|
|
SERIAL_CHAR(' ');
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(MSG_Z_MAX, Z_PROBE_OFFSET_RANGE_MAX);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2015-08-13 00:52:50 +00:00
|
|
|
SERIAL_ECHOPAIR(": ", zprobe_zoffset);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-08-13 00:56:21 +00:00
|
|
|
|
|
|
|
SERIAL_EOL;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-06-15 01:05:20 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
#if ENABLED(FILAMENT_CHANGE_FEATURE)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
2015-06-16 00:54:41 +00:00
|
|
|
* M600: Pause for filament change
|
|
|
|
*
|
|
|
|
* E[distance] - Retract the filament this far (negative value)
|
|
|
|
* Z[distance] - Move the Z axis by this distance
|
|
|
|
* X[position] - Move to this X position, with Y
|
|
|
|
* Y[position] - Move to this Y position, with X
|
|
|
|
* L[distance] - Retract distance for removal (manual reload)
|
|
|
|
*
|
|
|
|
* Default values are used for omitted arguments.
|
|
|
|
*
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M600() {
|
2015-06-16 00:52:51 +00:00
|
|
|
|
2016-04-29 01:18:13 +00:00
|
|
|
if (thermalManager.tooColdToExtrude(active_extruder)) {
|
2015-06-16 00:50:26 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_TOO_COLD_FOR_M600);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Show initial message and wait for synchronize steppers
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_INIT);
|
|
|
|
stepper.synchronize();
|
|
|
|
|
2016-04-02 21:28:17 +00:00
|
|
|
float lastpos[NUM_AXIS];
|
2015-06-16 00:52:51 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Save current position of all axes
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i)
|
2015-06-16 00:52:51 +00:00
|
|
|
lastpos[i] = destination[i] = current_position[i];
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Define runplan for move axes
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_KINEMATIC
|
2016-10-06 08:56:05 +00:00
|
|
|
#define RUNPLAN(RATE_MM_S) planner.buffer_line_kinematic(destination, RATE_MM_S, active_extruder);
|
2015-03-05 12:27:24 +00:00
|
|
|
#else
|
2016-08-07 07:20:25 +00:00
|
|
|
#define RUNPLAN(RATE_MM_S) line_to_destination(RATE_MM_S);
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
|
|
|
|
|
|
// Initial retract before move to filament change position
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('E')) destination[E_AXIS] += code_value_axis_units(E_AXIS);
|
2016-04-28 16:57:21 +00:00
|
|
|
#if defined(FILAMENT_CHANGE_RETRACT_LENGTH) && FILAMENT_CHANGE_RETRACT_LENGTH > 0
|
|
|
|
else destination[E_AXIS] -= FILAMENT_CHANGE_RETRACT_LENGTH;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_RETRACT_FEEDRATE);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Lift Z axis
|
|
|
|
float z_lift = code_seen('Z') ? code_value_axis_units(Z_AXIS) :
|
|
|
|
#if defined(FILAMENT_CHANGE_Z_ADD) && FILAMENT_CHANGE_Z_ADD > 0
|
|
|
|
FILAMENT_CHANGE_Z_ADD
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
if (z_lift > 0) {
|
|
|
|
destination[Z_AXIS] += z_lift;
|
|
|
|
NOMORE(destination[Z_AXIS], Z_MAX_POS);
|
|
|
|
RUNPLAN(FILAMENT_CHANGE_Z_FEEDRATE);
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Move XY axes to filament exchange position
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('X')) destination[X_AXIS] = code_value_axis_units(X_AXIS);
|
2016-04-28 16:57:21 +00:00
|
|
|
#ifdef FILAMENT_CHANGE_X_POS
|
|
|
|
else destination[X_AXIS] = FILAMENT_CHANGE_X_POS;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('Y')) destination[Y_AXIS] = code_value_axis_units(Y_AXIS);
|
2016-04-28 16:57:21 +00:00
|
|
|
#ifdef FILAMENT_CHANGE_Y_POS
|
|
|
|
else destination[Y_AXIS] = FILAMENT_CHANGE_Y_POS;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_XY_FEEDRATE);
|
|
|
|
|
|
|
|
stepper.synchronize();
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_UNLOAD);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Unload filament
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('L')) destination[E_AXIS] += code_value_axis_units(E_AXIS);
|
2016-04-28 16:57:21 +00:00
|
|
|
#if defined(FILAMENT_CHANGE_UNLOAD_LENGTH) && FILAMENT_CHANGE_UNLOAD_LENGTH > 0
|
|
|
|
else destination[E_AXIS] -= FILAMENT_CHANGE_UNLOAD_LENGTH;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_UNLOAD_FEEDRATE);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Synchronize steppers and then disable extruders steppers for manual filament changing
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2015-03-05 12:27:24 +00:00
|
|
|
disable_e0();
|
|
|
|
disable_e1();
|
|
|
|
disable_e2();
|
|
|
|
disable_e3();
|
|
|
|
delay(100);
|
2016-04-28 16:57:21 +00:00
|
|
|
|
2016-04-30 09:51:18 +00:00
|
|
|
#if HAS_BUZZER
|
2016-10-05 02:31:50 +00:00
|
|
|
millis_t next_buzz = 0;
|
2016-04-30 09:51:18 +00:00
|
|
|
#endif
|
2016-04-28 16:57:21 +00:00
|
|
|
|
|
|
|
// Wait for filament insert by user and press button
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_INSERT);
|
|
|
|
|
2016-10-26 06:42:52 +00:00
|
|
|
// LCD click or M108 will clear this
|
|
|
|
wait_for_user = true;
|
|
|
|
|
|
|
|
while (wait_for_user) {
|
2016-04-28 16:57:21 +00:00
|
|
|
#if HAS_BUZZER
|
2015-06-16 00:55:39 +00:00
|
|
|
millis_t ms = millis();
|
2016-10-05 02:31:50 +00:00
|
|
|
if (ms >= next_buzz) {
|
2016-08-02 04:10:53 +00:00
|
|
|
BUZZ(300, 2000);
|
2016-10-05 02:31:50 +00:00
|
|
|
next_buzz = ms + 2500; // Beep every 2.5s while waiting
|
2015-06-16 00:55:39 +00:00
|
|
|
}
|
2015-04-09 12:23:34 +00:00
|
|
|
#endif
|
2016-04-28 16:57:21 +00:00
|
|
|
idle(true);
|
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Show load message
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_LOAD);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Load filament
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('L')) destination[E_AXIS] -= code_value_axis_units(E_AXIS);
|
2016-04-28 16:57:21 +00:00
|
|
|
#if defined(FILAMENT_CHANGE_LOAD_LENGTH) && FILAMENT_CHANGE_LOAD_LENGTH > 0
|
|
|
|
else destination[E_AXIS] += FILAMENT_CHANGE_LOAD_LENGTH;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_LOAD_FEEDRATE);
|
|
|
|
stepper.synchronize();
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
#if defined(FILAMENT_CHANGE_EXTRUDE_LENGTH) && FILAMENT_CHANGE_EXTRUDE_LENGTH > 0
|
|
|
|
do {
|
|
|
|
// Extrude filament to get into hotend
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_EXTRUDE);
|
|
|
|
destination[E_AXIS] += FILAMENT_CHANGE_EXTRUDE_LENGTH;
|
|
|
|
RUNPLAN(FILAMENT_CHANGE_EXTRUDE_FEEDRATE);
|
|
|
|
stepper.synchronize();
|
|
|
|
// Ask user if more filament should be extruded
|
|
|
|
KEEPALIVE_STATE(PAUSED_FOR_USER);
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_OPTION);
|
|
|
|
while (filament_change_menu_response == FILAMENT_CHANGE_RESPONSE_WAIT_FOR) idle(true);
|
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
|
|
} while (filament_change_menu_response != FILAMENT_CHANGE_RESPONSE_RESUME_PRINT);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_RESUME);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
|
|
|
|
|
|
// Set extruder to saved position
|
2016-10-09 18:25:25 +00:00
|
|
|
destination[E_AXIS] = current_position[E_AXIS] = lastpos[E_AXIS];
|
2016-04-28 16:57:21 +00:00
|
|
|
planner.set_e_position_mm(current_position[E_AXIS]);
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_KINEMATIC
|
2016-10-06 08:56:05 +00:00
|
|
|
// Move XYZ to starting position
|
|
|
|
planner.buffer_line_kinematic(lastpos, FILAMENT_CHANGE_XY_FEEDRATE, active_extruder);
|
2015-03-05 12:27:24 +00:00
|
|
|
#else
|
2016-10-06 08:56:05 +00:00
|
|
|
// Move XY to starting position, then Z
|
2015-06-16 00:52:51 +00:00
|
|
|
destination[X_AXIS] = lastpos[X_AXIS];
|
|
|
|
destination[Y_AXIS] = lastpos[Y_AXIS];
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_XY_FEEDRATE);
|
2015-06-16 00:52:51 +00:00
|
|
|
destination[Z_AXIS] = lastpos[Z_AXIS];
|
2016-04-28 16:57:21 +00:00
|
|
|
RUNPLAN(FILAMENT_CHANGE_Z_FEEDRATE);
|
2015-08-05 11:40:36 +00:00
|
|
|
#endif
|
2016-04-28 16:57:21 +00:00
|
|
|
stepper.synchronize();
|
2015-03-07 20:43:15 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
2016-04-18 06:16:49 +00:00
|
|
|
filament_ran_out = false;
|
2015-03-07 20:43:15 +00:00
|
|
|
#endif
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
// Show status screen
|
|
|
|
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_STATUS);
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
#endif // FILAMENT_CHANGE_FEATURE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M605: Set dual x-carriage movement mode
|
|
|
|
*
|
|
|
|
* M605 S0: Full control mode. The slicer has full control over x-carriage movement
|
|
|
|
* M605 S1: Auto-park mode. The inactive head will auto park/unpark without slicer involvement
|
|
|
|
* M605 S2 [Xnnn] [Rmmm]: Duplication mode. The second extruder will duplicate the first with nnn
|
2016-07-04 03:08:22 +00:00
|
|
|
* units x-offset and an optional differential hotend temperature of
|
2015-03-05 12:27:24 +00:00
|
|
|
* mmm degrees. E.g., with "M605 S2 X100 R2" the second extruder will duplicate
|
|
|
|
* the first with a spacing of 100mm in the x direction and 2 degrees hotter.
|
|
|
|
*
|
|
|
|
* Note: the X axis should be homed after changing dual x-carriage mode.
|
|
|
|
*/
|
|
|
|
inline void gcode_M605() {
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2016-11-03 02:37:46 +00:00
|
|
|
if (code_seen('S')) dual_x_carriage_mode = (DualXMode)code_value_byte();
|
2015-10-03 06:08:58 +00:00
|
|
|
switch (dual_x_carriage_mode) {
|
2016-11-03 02:38:26 +00:00
|
|
|
case DXC_FULL_CONTROL_MODE:
|
|
|
|
case DXC_AUTO_PARK_MODE:
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
case DXC_DUPLICATION_MODE:
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('X')) duplicate_extruder_x_offset = max(code_value_axis_units(X_AXIS), X2_MIN_POS - x_home_pos(0));
|
|
|
|
if (code_seen('R')) duplicate_extruder_temp_offset = code_value_temp_diff();
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(' ');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHO(hotend_offset[X_AXIS][0]);
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(',');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHO(hotend_offset[Y_AXIS][0]);
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(' ');
|
2015-03-05 12:27:24 +00:00
|
|
|
SERIAL_ECHO(duplicate_extruder_x_offset);
|
2015-04-04 04:43:30 +00:00
|
|
|
SERIAL_CHAR(',');
|
2016-05-27 00:43:20 +00:00
|
|
|
SERIAL_ECHOLN(hotend_offset[Y_AXIS][1]);
|
2015-03-05 12:27:24 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
active_extruder_parked = false;
|
|
|
|
extruder_duplication_enabled = false;
|
|
|
|
delayed_move_time = 0;
|
|
|
|
}
|
|
|
|
|
2016-07-20 17:30:10 +00:00
|
|
|
#elif ENABLED(DUAL_NOZZLE_DUPLICATION_MODE)
|
|
|
|
|
|
|
|
inline void gcode_M605() {
|
|
|
|
stepper.synchronize();
|
|
|
|
extruder_duplication_enabled = code_seen('S') && code_value_int() == 2;
|
|
|
|
SERIAL_ECHO_START;
|
2016-08-21 01:11:08 +00:00
|
|
|
SERIAL_ECHOLNPAIR(MSG_DUPLICATION_MODE, extruder_duplication_enabled ? MSG_ON : MSG_OFF);
|
2016-07-20 17:30:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // M605
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-04 16:53:17 +00:00
|
|
|
#if ENABLED(LIN_ADVANCE)
|
2016-05-04 19:10:42 +00:00
|
|
|
/**
|
|
|
|
* M905: Set advance factor
|
|
|
|
*/
|
|
|
|
inline void gcode_M905() {
|
|
|
|
stepper.synchronize();
|
2016-10-31 15:17:30 +00:00
|
|
|
planner.advance_M905(code_seen('K') ? code_value_float() : -1.0);
|
2016-05-04 19:10:42 +00:00
|
|
|
}
|
2016-05-04 16:53:17 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M907: Set digital trimpot motor current using axis codes X, Y, Z, E, B, S
|
|
|
|
*/
|
|
|
|
inline void gcode_M907() {
|
2015-03-14 11:28:22 +00:00
|
|
|
#if HAS_DIGIPOTSS
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i)
|
2016-09-25 11:32:58 +00:00
|
|
|
if (code_seen(axis_codes[i])) stepper.digipot_current(i, code_value_int());
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('B')) stepper.digipot_current(4, code_value_int());
|
|
|
|
if (code_seen('S')) for (int i = 0; i <= 4; i++) stepper.digipot_current(i, code_value_int());
|
2016-09-25 11:32:58 +00:00
|
|
|
#elif HAS_MOTOR_CURRENT_PWM
|
|
|
|
#if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
|
|
|
|
if (code_seen('X')) stepper.digipot_current(0, code_value_int());
|
|
|
|
#endif
|
|
|
|
#if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
|
|
|
|
if (code_seen('Z')) stepper.digipot_current(1, code_value_int());
|
|
|
|
#endif
|
|
|
|
#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
|
|
|
|
if (code_seen('E')) stepper.digipot_current(2, code_value_int());
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DIGIPOT_I2C)
|
2015-03-05 12:27:24 +00:00
|
|
|
// this one uses actual amps in floating point
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) if (code_seen(axis_codes[i])) digipot_i2c_set_current(i, code_value_float());
|
2015-03-05 12:27:24 +00:00
|
|
|
// for each additional extruder (named B,C,D,E..., channels 4,5,6,7...)
|
2016-05-31 15:26:08 +00:00
|
|
|
for (int i = NUM_AXIS; i < DIGIPOT_I2C_NUM_CHANNELS; i++) if (code_seen('B' + i - (NUM_AXIS))) digipot_i2c_set_current(i, code_value_float());
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2016-03-20 01:19:41 +00:00
|
|
|
#if ENABLED(DAC_STEPPER_CURRENT)
|
|
|
|
if (code_seen('S')) {
|
2016-05-31 15:26:08 +00:00
|
|
|
float dac_percent = code_value_float();
|
2016-03-20 01:19:41 +00:00
|
|
|
for (uint8_t i = 0; i <= 4; i++) dac_current_percent(i, dac_percent);
|
|
|
|
}
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) if (code_seen(axis_codes[i])) dac_current_percent(i, code_value_float());
|
2016-03-20 01:19:41 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-03-20 01:19:41 +00:00
|
|
|
#if HAS_DIGIPOTSS || ENABLED(DAC_STEPPER_CURRENT)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* M908: Control digital trimpot directly (M908 P<pin> S<current>)
|
|
|
|
*/
|
|
|
|
inline void gcode_M908() {
|
2016-03-20 01:44:08 +00:00
|
|
|
#if HAS_DIGIPOTSS
|
2016-05-03 09:23:27 +00:00
|
|
|
stepper.digitalPotWrite(
|
2016-05-31 15:26:08 +00:00
|
|
|
code_seen('P') ? code_value_int() : 0,
|
|
|
|
code_seen('S') ? code_value_int() : 0
|
2016-03-20 01:44:08 +00:00
|
|
|
);
|
|
|
|
#endif
|
2016-03-20 01:19:41 +00:00
|
|
|
#ifdef DAC_STEPPER_CURRENT
|
|
|
|
dac_current_raw(
|
2016-05-31 15:26:08 +00:00
|
|
|
code_seen('P') ? code_value_byte() : -1,
|
|
|
|
code_seen('S') ? code_value_ushort() : 0
|
2016-03-20 01:19:41 +00:00
|
|
|
);
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-03-20 01:19:41 +00:00
|
|
|
#if ENABLED(DAC_STEPPER_CURRENT) // As with Printrbot RevF
|
|
|
|
|
|
|
|
inline void gcode_M909() { dac_print_values(); }
|
|
|
|
|
|
|
|
inline void gcode_M910() { dac_commit_eeprom(); }
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // HAS_DIGIPOTSS || DAC_STEPPER_CURRENT
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_MICROSTEPS
|
|
|
|
|
|
|
|
// M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
|
|
|
|
inline void gcode_M350() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) for (int i = 0; i <= 4; i++) stepper.microstep_mode(i, code_value_byte());
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_mode(i, code_value_byte());
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('B')) stepper.microstep_mode(4, code_value_byte());
|
2016-05-03 09:23:27 +00:00
|
|
|
stepper.microstep_readings();
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
/**
|
|
|
|
* M351: Toggle MS1 MS2 pins directly with axis codes X Y Z E B
|
|
|
|
* S# determines MS1 or MS2, X# sets the pin high/low.
|
|
|
|
*/
|
|
|
|
inline void gcode_M351() {
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S')) switch (code_value_byte()) {
|
2015-03-05 12:27:24 +00:00
|
|
|
case 1:
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_ms(i, code_value_byte(), -1);
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('B')) stepper.microstep_ms(4, code_value_byte(), -1);
|
2015-03-05 12:27:24 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2016-07-23 20:07:23 +00:00
|
|
|
LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_ms(i, -1, code_value_byte());
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('B')) stepper.microstep_ms(4, -1, code_value_byte());
|
2015-03-05 12:27:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2016-05-03 09:23:27 +00:00
|
|
|
stepper.microstep_readings();
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_MICROSTEPS
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 19:34:07 +00:00
|
|
|
#if HAS_CASE_LIGHT
|
2016-11-09 09:07:24 +00:00
|
|
|
|
2016-11-28 05:51:51 +00:00
|
|
|
uint8_t case_light_brightness = 255;
|
|
|
|
|
|
|
|
void update_case_light() {
|
2016-12-02 05:31:03 +00:00
|
|
|
digitalWrite(CASE_LIGHT_PIN, case_light_on != INVERT_CASE_LIGHT ? HIGH : LOW);
|
|
|
|
analogWrite(CASE_LIGHT_PIN, case_light_on != INVERT_CASE_LIGHT ? case_light_brightness : 0);
|
2016-11-28 05:51:51 +00:00
|
|
|
}
|
|
|
|
|
2016-10-05 19:34:07 +00:00
|
|
|
/**
|
2016-11-09 09:07:24 +00:00
|
|
|
* M355: Turn case lights on/off and set brightness
|
2016-10-05 19:34:07 +00:00
|
|
|
*
|
2016-11-09 09:07:24 +00:00
|
|
|
* S<bool> Turn case light on or off
|
|
|
|
* P<byte> Set case light brightness (PWM pin required)
|
2016-10-05 19:34:07 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M355() {
|
2016-11-09 09:07:24 +00:00
|
|
|
if (code_seen('P')) case_light_brightness = code_value_byte();
|
2016-11-28 05:51:51 +00:00
|
|
|
if (code_seen('S')) case_light_on = code_value_bool();
|
|
|
|
update_case_light();
|
2016-11-09 09:07:24 +00:00
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM("Case lights ");
|
|
|
|
case_light_on ? SERIAL_ECHOLNPGM("on") : SERIAL_ECHOLNPGM("off");
|
2016-10-05 19:34:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAS_CASE_LIGHT
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MIXING_EXTRUDER)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M163: Set a single mix factor for a mixing extruder
|
|
|
|
* This is called "weight" by some systems.
|
|
|
|
*
|
|
|
|
* S[index] The channel index to set
|
|
|
|
* P[float] The mix value
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
inline void gcode_M163() {
|
|
|
|
int mix_index = code_seen('S') ? code_value_int() : 0;
|
2016-11-12 20:33:07 +00:00
|
|
|
if (mix_index < MIXING_STEPPERS) {
|
|
|
|
float mix_value = code_seen('P') ? code_value_float() : 0.0;
|
|
|
|
NOLESS(mix_value, 0.0);
|
|
|
|
mixing_factor[mix_index] = RECIPROCAL(mix_value);
|
|
|
|
}
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if MIXING_VIRTUAL_TOOLS > 1
|
|
|
|
|
|
|
|
/**
|
|
|
|
* M164: Store the current mix factors as a virtual tool.
|
|
|
|
*
|
|
|
|
* S[index] The virtual tool to store
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
inline void gcode_M164() {
|
|
|
|
int tool_index = code_seen('S') ? code_value_int() : 0;
|
|
|
|
if (tool_index < MIXING_VIRTUAL_TOOLS) {
|
|
|
|
normalize_mix();
|
|
|
|
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
|
|
|
|
mixing_virtual_tool_mix[tool_index][i] = mixing_factor[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(DIRECT_MIXING_IN_G1)
|
|
|
|
/**
|
|
|
|
* M165: Set multiple mix factors for a mixing extruder.
|
|
|
|
* Factors that are left out will be set to 0.
|
|
|
|
* All factors together must add up to 1.0.
|
|
|
|
*
|
|
|
|
* A[factor] Mix factor for extruder stepper 1
|
|
|
|
* B[factor] Mix factor for extruder stepper 2
|
|
|
|
* C[factor] Mix factor for extruder stepper 3
|
|
|
|
* D[factor] Mix factor for extruder stepper 4
|
|
|
|
* H[factor] Mix factor for extruder stepper 5
|
|
|
|
* I[factor] Mix factor for extruder stepper 6
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
inline void gcode_M165() { gcode_get_mix(); }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // MIXING_EXTRUDER
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
|
|
|
* M999: Restart after being stopped
|
2016-05-18 23:13:33 +00:00
|
|
|
*
|
|
|
|
* Default behaviour is to flush the serial buffer and request
|
|
|
|
* a resend to the host starting on the last N line received.
|
|
|
|
*
|
|
|
|
* Sending "M999 S1" will resume printing without flushing the
|
|
|
|
* existing command buffer.
|
|
|
|
*
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
|
|
|
inline void gcode_M999() {
|
2015-04-08 07:56:19 +00:00
|
|
|
Running = true;
|
2015-03-05 12:27:24 +00:00
|
|
|
lcd_reset_alert_level();
|
2016-05-18 23:13:33 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
if (code_seen('S') && code_value_bool()) return;
|
2016-05-18 23:13:33 +00:00
|
|
|
|
2015-08-07 02:57:35 +00:00
|
|
|
// gcode_LastN = Stopped_gcode_LastN;
|
2015-03-05 12:27:24 +00:00
|
|
|
FlushSerialRequestResend();
|
|
|
|
}
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(SWITCHING_EXTRUDER)
|
|
|
|
inline void move_extruder_servo(uint8_t e) {
|
|
|
|
const int angles[2] = SWITCHING_EXTRUDER_SERVO_ANGLES;
|
|
|
|
MOVE_SERVO(SWITCHING_EXTRUDER_SERVO_NR, angles[e]);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
inline void invalid_extruder_error(const uint8_t &e) {
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_CHAR('T');
|
|
|
|
SERIAL_PROTOCOL_F(e, DEC);
|
|
|
|
SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
|
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Perform a tool-change, which may result in moving the
|
|
|
|
* previous tool out of the way and the new tool into place.
|
|
|
|
*/
|
2016-08-07 07:20:25 +00:00
|
|
|
void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool no_move/*=false*/) {
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MIXING_EXTRUDER) && MIXING_VIRTUAL_TOOLS > 1
|
|
|
|
|
2016-11-07 06:21:45 +00:00
|
|
|
if (tmp_extruder >= MIXING_VIRTUAL_TOOLS)
|
|
|
|
return invalid_extruder_error(tmp_extruder);
|
2016-07-04 01:06:54 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// T0-Tnnn: Switch virtual tool by changing the mix
|
|
|
|
for (uint8_t j = 0; j < MIXING_STEPPERS; j++)
|
|
|
|
mixing_factor[j] = mixing_virtual_tool_mix[tmp_extruder][j];
|
2016-04-26 22:57:45 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#else //!MIXING_EXTRUDER || MIXING_VIRTUAL_TOOLS <= 1
|
2016-06-16 07:05:36 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if HOTENDS > 1
|
|
|
|
|
2016-11-07 06:21:45 +00:00
|
|
|
if (tmp_extruder >= EXTRUDERS)
|
|
|
|
return invalid_extruder_error(tmp_extruder);
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
float old_feedrate_mm_s = feedrate_mm_s;
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = fr_mm_s > 0.0 ? (old_feedrate_mm_s = fr_mm_s) : XY_PROBE_FEEDRATE_MM_S;
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
if (tmp_extruder != active_extruder) {
|
|
|
|
if (!no_move && axis_unhomed_error(true, true, true)) {
|
|
|
|
SERIAL_ECHOLNPGM("No move on toolchange");
|
|
|
|
no_move = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save current position to destination, for use later
|
|
|
|
set_destination_to_current();
|
|
|
|
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2016-07-15 01:34:08 +00:00
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-06-28 22:06:56 +00:00
|
|
|
SERIAL_ECHOPGM("Dual X Carriage Mode ");
|
|
|
|
switch (dual_x_carriage_mode) {
|
|
|
|
case DXC_FULL_CONTROL_MODE: SERIAL_ECHOLNPGM("DXC_FULL_CONTROL_MODE"); break;
|
2016-11-03 02:38:26 +00:00
|
|
|
case DXC_AUTO_PARK_MODE: SERIAL_ECHOLNPGM("DXC_AUTO_PARK_MODE"); break;
|
|
|
|
case DXC_DUPLICATION_MODE: SERIAL_ECHOLNPGM("DXC_DUPLICATION_MODE"); break;
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
2016-07-15 01:34:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
2015-04-04 04:43:30 +00:00
|
|
|
|
2016-11-07 06:21:45 +00:00
|
|
|
const float xhome = x_home_pos(active_extruder);
|
|
|
|
if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE
|
|
|
|
&& IsRunning()
|
|
|
|
&& (delayed_move_time || current_position[X_AXIS] != xhome)
|
2016-06-28 22:06:56 +00:00
|
|
|
) {
|
2016-11-07 06:21:45 +00:00
|
|
|
float raised_z = current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT;
|
|
|
|
#if ENABLED(max_software_endstops)
|
|
|
|
NOMORE(raised_z, soft_endstop_max[Z_AXIS]);
|
|
|
|
#endif
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-11-07 06:21:45 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Raise to ", raised_z);
|
|
|
|
SERIAL_ECHOLNPAIR("MoveX to ", xhome);
|
|
|
|
SERIAL_ECHOLNPAIR("Lower to ", current_position[Z_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
// Park old head: 1) raise 2) move to park position 3) lower
|
|
|
|
for (uint8_t i = 0; i < 3; i++)
|
|
|
|
planner.buffer_line(
|
2016-11-07 06:21:45 +00:00
|
|
|
i == 0 ? current_position[X_AXIS] : xhome,
|
2016-06-28 22:06:56 +00:00
|
|
|
current_position[Y_AXIS],
|
2016-11-07 06:21:45 +00:00
|
|
|
i == 2 ? current_position[Z_AXIS] : raised_z,
|
2016-06-28 22:06:56 +00:00
|
|
|
current_position[E_AXIS],
|
2016-07-16 01:49:34 +00:00
|
|
|
planner.max_feedrate_mm_s[i == 1 ? X_AXIS : Z_AXIS],
|
2016-06-28 22:06:56 +00:00
|
|
|
active_extruder
|
|
|
|
);
|
|
|
|
stepper.synchronize();
|
|
|
|
}
|
2015-04-04 04:43:30 +00:00
|
|
|
|
2016-11-07 06:21:45 +00:00
|
|
|
// Apply Y & Z extruder offset (X offset is used as home pos with Dual X)
|
2016-06-28 22:06:56 +00:00
|
|
|
current_position[Y_AXIS] -= hotend_offset[Y_AXIS][active_extruder] - hotend_offset[Y_AXIS][tmp_extruder];
|
|
|
|
current_position[Z_AXIS] -= hotend_offset[Z_AXIS][active_extruder] - hotend_offset[Z_AXIS][tmp_extruder];
|
2016-11-07 06:21:45 +00:00
|
|
|
|
|
|
|
// Activate the new extruder
|
2016-06-28 22:06:56 +00:00
|
|
|
active_extruder = tmp_extruder;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// This function resets the max/min values - the current position may be overwritten below.
|
|
|
|
set_axis_is_at_home(X_AXIS);
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("New Extruder", current_position);
|
|
|
|
#endif
|
2016-07-15 10:25:34 +00:00
|
|
|
|
2016-11-07 08:46:16 +00:00
|
|
|
// Only when auto-parking are carriages safe to move
|
|
|
|
if (dual_x_carriage_mode != DXC_AUTO_PARK_MODE) no_move = true;
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
switch (dual_x_carriage_mode) {
|
|
|
|
case DXC_FULL_CONTROL_MODE:
|
2016-11-07 06:21:45 +00:00
|
|
|
// New current position is the position of the activated extruder
|
2016-07-24 23:35:03 +00:00
|
|
|
current_position[X_AXIS] = LOGICAL_X_POSITION(inactive_extruder_x_pos);
|
2016-11-07 06:21:45 +00:00
|
|
|
// Save the inactive extruder's position (from the old current_position)
|
2016-07-24 23:35:03 +00:00
|
|
|
inactive_extruder_x_pos = RAW_X_POSITION(destination[X_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
break;
|
2016-11-03 02:36:50 +00:00
|
|
|
case DXC_AUTO_PARK_MODE:
|
|
|
|
// record raised toolhead position for use by unpark
|
|
|
|
memcpy(raised_parked_position, current_position, sizeof(raised_parked_position));
|
|
|
|
raised_parked_position[Z_AXIS] += TOOLCHANGE_UNPARK_ZLIFT;
|
|
|
|
#if ENABLED(max_software_endstops)
|
|
|
|
NOMORE(raised_parked_position[Z_AXIS], soft_endstop_max[Z_AXIS]);
|
|
|
|
#endif
|
|
|
|
active_extruder_parked = true;
|
|
|
|
delayed_move_time = 0;
|
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
case DXC_DUPLICATION_MODE:
|
2016-11-07 06:21:45 +00:00
|
|
|
// If the new extruder is the left one, set it "parked"
|
|
|
|
// This triggers the second extruder to move into the duplication position
|
|
|
|
active_extruder_parked = (active_extruder == 0);
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
if (active_extruder_parked)
|
2016-07-24 23:35:03 +00:00
|
|
|
current_position[X_AXIS] = LOGICAL_X_POSITION(inactive_extruder_x_pos);
|
2016-06-28 22:06:56 +00:00
|
|
|
else
|
|
|
|
current_position[X_AXIS] = destination[X_AXIS] + duplicate_extruder_x_offset;
|
2016-07-24 23:35:03 +00:00
|
|
|
inactive_extruder_x_pos = RAW_X_POSITION(destination[X_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
extruder_duplication_enabled = false;
|
|
|
|
break;
|
2016-07-15 01:34:08 +00:00
|
|
|
}
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-26 22:57:45 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
2016-08-26 20:42:16 +00:00
|
|
|
SERIAL_ECHOLNPAIR("Active extruder parked: ", active_extruder_parked ? "yes" : "no");
|
2016-06-28 22:06:56 +00:00
|
|
|
DEBUG_POS("New extruder (parked)", current_position);
|
2016-04-26 22:57:45 +00:00
|
|
|
}
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
// No extra case for HAS_ABL in DUAL_X_CARRIAGE. Does that mean they don't work together?
|
2016-06-28 22:06:56 +00:00
|
|
|
#else // !DUAL_X_CARRIAGE
|
|
|
|
|
|
|
|
#if ENABLED(SWITCHING_EXTRUDER)
|
|
|
|
// <0 if the new nozzle is higher, >0 if lower. A bigger raise when lower.
|
|
|
|
float z_diff = hotend_offset[Z_AXIS][active_extruder] - hotend_offset[Z_AXIS][tmp_extruder],
|
|
|
|
z_raise = 0.3 + (z_diff > 0.0 ? z_diff : 0.0);
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-11-07 06:21:45 +00:00
|
|
|
// Always raise by some amount (destination copied from current_position earlier)
|
2016-10-09 20:21:04 +00:00
|
|
|
destination[Z_AXIS] += z_raise;
|
|
|
|
planner.buffer_line_kinematic(destination, planner.max_feedrate_mm_s[Z_AXIS], active_extruder);
|
2016-06-28 22:06:56 +00:00
|
|
|
stepper.synchronize();
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
move_extruder_servo(active_extruder);
|
|
|
|
delay(500);
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Move back down, if needed
|
|
|
|
if (z_raise != z_diff) {
|
2016-10-09 20:21:04 +00:00
|
|
|
destination[Z_AXIS] = current_position[Z_AXIS] + z_diff;
|
|
|
|
planner.buffer_line_kinematic(destination, planner.max_feedrate_mm_s[Z_AXIS], active_extruder);
|
2016-06-28 22:06:56 +00:00
|
|
|
stepper.synchronize();
|
|
|
|
}
|
2016-04-26 22:57:45 +00:00
|
|
|
#endif
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
/**
|
|
|
|
* Set current_position to the position of the new nozzle.
|
|
|
|
* Offsets are based on linear distance, so we need to get
|
|
|
|
* the resulting position in coordinate space.
|
|
|
|
*
|
|
|
|
* - With grid or 3-point leveling, offset XYZ by a tilted vector
|
|
|
|
* - With mesh leveling, update Z for the new position
|
|
|
|
* - Otherwise, just use the raw linear distance
|
|
|
|
*
|
|
|
|
* Software endstops are altered here too. Consider a case where:
|
|
|
|
* E0 at X=0 ... E1 at X=10
|
|
|
|
* When we switch to E1 now X=10, but E1 can't move left.
|
|
|
|
* To express this we apply the change in XY to the software endstops.
|
|
|
|
* E1 can move farther right than E0, so the right limit is extended.
|
|
|
|
*
|
|
|
|
* Note that we don't adjust the Z software endstops. Why not?
|
|
|
|
* Consider a case where Z=0 (here) and switching to E1 makes Z=1
|
|
|
|
* because the bed is 1mm lower at the new position. As long as
|
|
|
|
* the first nozzle is out of the way, the carriage should be
|
|
|
|
* allowed to move 1mm lower. This technically "breaks" the
|
|
|
|
* Z software endstop. But this is technically correct (and
|
|
|
|
* there is no viable alternative).
|
|
|
|
*/
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ABL_PLANAR
|
2016-06-28 22:06:56 +00:00
|
|
|
// Offset extruder, make sure to apply the bed level rotation matrix
|
|
|
|
vector_3 tmp_offset_vec = vector_3(hotend_offset[X_AXIS][tmp_extruder],
|
|
|
|
hotend_offset[Y_AXIS][tmp_extruder],
|
|
|
|
0),
|
|
|
|
act_offset_vec = vector_3(hotend_offset[X_AXIS][active_extruder],
|
|
|
|
hotend_offset[Y_AXIS][active_extruder],
|
|
|
|
0),
|
|
|
|
offset_vec = tmp_offset_vec - act_offset_vec;
|
2016-04-12 03:30:00 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
tmp_offset_vec.debug("tmp_offset_vec");
|
|
|
|
act_offset_vec.debug("act_offset_vec");
|
|
|
|
offset_vec.debug("offset_vec (BEFORE)");
|
|
|
|
}
|
|
|
|
#endif
|
2016-07-04 01:06:54 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
offset_vec.apply_rotation(planner.bed_level_matrix.transpose(planner.bed_level_matrix));
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) offset_vec.debug("offset_vec (AFTER)");
|
|
|
|
#endif
|
2016-07-04 01:06:54 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Adjustments to the current position
|
|
|
|
float xydiff[2] = { offset_vec.x, offset_vec.y };
|
|
|
|
current_position[Z_AXIS] += offset_vec.z;
|
2016-07-03 23:51:26 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#else // !ABL_PLANAR
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
float xydiff[2] = {
|
|
|
|
hotend_offset[X_AXIS][tmp_extruder] - hotend_offset[X_AXIS][active_extruder],
|
|
|
|
hotend_offset[Y_AXIS][tmp_extruder] - hotend_offset[Y_AXIS][active_extruder]
|
|
|
|
};
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
if (mbl.active()) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOPAIR("Z before MBL: ", current_position[Z_AXIS]);
|
|
|
|
#endif
|
2016-12-05 07:53:36 +00:00
|
|
|
float x2 = current_position[X_AXIS] + xydiff[X_AXIS],
|
|
|
|
y2 = current_position[Y_AXIS] + xydiff[Y_AXIS],
|
|
|
|
z1 = current_position[Z_AXIS], z2 = z1;
|
|
|
|
planner.apply_leveling(current_position[X_AXIS], current_position[Y_AXIS], z1);
|
|
|
|
planner.apply_leveling(x2, y2, z2);
|
|
|
|
current_position[Z_AXIS] += z2 - z1;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-08-26 20:42:16 +00:00
|
|
|
if (DEBUGGING(LEVELING))
|
|
|
|
SERIAL_ECHOLNPAIR(" after: ", current_position[Z_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif
|
|
|
|
}
|
2016-06-11 19:59:44 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif // MESH_BED_LEVELING
|
2016-07-19 13:31:09 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // !HAS_ABL
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR("Offset Tool XY by { ", xydiff[X_AXIS]);
|
2016-07-18 00:04:32 +00:00
|
|
|
SERIAL_ECHOPAIR(", ", xydiff[Y_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
SERIAL_ECHOLNPGM(" }");
|
|
|
|
}
|
|
|
|
#endif
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// The newly-selected extruder XY is actually at...
|
|
|
|
current_position[X_AXIS] += xydiff[X_AXIS];
|
|
|
|
current_position[Y_AXIS] += xydiff[Y_AXIS];
|
|
|
|
for (uint8_t i = X_AXIS; i <= Y_AXIS; i++) {
|
|
|
|
position_shift[i] += xydiff[i];
|
|
|
|
update_software_endstops((AxisEnum)i);
|
|
|
|
}
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Set the new active extruder
|
|
|
|
active_extruder = tmp_extruder;
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif // !DUAL_X_CARRIAGE
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-07-15 01:34:08 +00:00
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
2016-06-28 22:06:56 +00:00
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("Sync After Toolchange", current_position);
|
2016-07-15 01:34:08 +00:00
|
|
|
#endif
|
2016-04-28 02:35:55 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Tell the planner the new "current position"
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
2016-04-12 03:30:00 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Move to the "old position" (move the extruder into place)
|
|
|
|
if (!no_move && IsRunning()) {
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) DEBUG_POS("Move back", destination);
|
|
|
|
#endif
|
|
|
|
prepare_move_to_destination();
|
|
|
|
}
|
2016-07-15 01:34:08 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
} // (tmp_extruder != active_extruder)
|
2016-04-12 03:30:00 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
stepper.synchronize();
|
2016-06-16 07:05:36 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(EXT_SOLENOID)
|
|
|
|
disable_all_solenoids();
|
|
|
|
enable_solenoid_on_active_extruder();
|
|
|
|
#endif // EXT_SOLENOID
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
feedrate_mm_s = old_feedrate_mm_s;
|
2016-06-16 07:05:36 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#else // HOTENDS <= 1
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
// Set the new active extruder
|
|
|
|
active_extruder = tmp_extruder;
|
2016-07-04 01:06:54 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
UNUSED(fr_mm_s);
|
2016-07-22 15:08:56 +00:00
|
|
|
UNUSED(no_move);
|
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif // HOTENDS <= 1
|
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOLNPAIR(MSG_ACTIVE_EXTRUDER, (int)active_extruder);
|
2016-06-28 22:06:56 +00:00
|
|
|
|
|
|
|
#endif //!MIXING_EXTRUDER || MIXING_VIRTUAL_TOOLS <= 1
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-07-20 02:37:31 +00:00
|
|
|
/**
|
|
|
|
* T0-T3: Switch tool, usually switching extruders
|
|
|
|
*
|
|
|
|
* F[units/min] Set the movement feedrate
|
|
|
|
* S1 Don't move the tool in XY after change
|
|
|
|
*/
|
|
|
|
inline void gcode_T(uint8_t tmp_extruder) {
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
SERIAL_ECHOPAIR(">>> gcode_T(", tmp_extruder);
|
2016-10-02 06:48:17 +00:00
|
|
|
SERIAL_CHAR(')');
|
|
|
|
SERIAL_EOL;
|
2016-07-20 02:37:31 +00:00
|
|
|
DEBUG_POS("BEFORE", current_position);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HOTENDS == 1 || (ENABLED(MIXING_EXTRUDER) && MIXING_VIRTUAL_TOOLS > 1)
|
|
|
|
|
|
|
|
tool_change(tmp_extruder);
|
|
|
|
|
|
|
|
#elif HOTENDS > 1
|
|
|
|
|
|
|
|
tool_change(
|
|
|
|
tmp_extruder,
|
2016-08-07 07:20:25 +00:00
|
|
|
code_seen('F') ? MMM_TO_MMS(code_value_axis_units(X_AXIS)) : 0.0,
|
2016-07-20 02:37:31 +00:00
|
|
|
(tmp_extruder == active_extruder) || (code_seen('S') && code_value_bool())
|
|
|
|
);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
|
|
|
if (DEBUGGING(LEVELING)) {
|
|
|
|
DEBUG_POS("AFTER", current_position);
|
|
|
|
SERIAL_ECHOLNPGM("<<< gcode_T");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
/**
|
2015-05-17 06:14:02 +00:00
|
|
|
* Process a single command and dispatch it to its handler
|
2015-04-03 22:31:35 +00:00
|
|
|
* This is called from the main loop()
|
2015-03-05 12:27:24 +00:00
|
|
|
*/
|
2015-05-17 03:47:40 +00:00
|
|
|
void process_next_command() {
|
2015-05-17 06:14:02 +00:00
|
|
|
current_command = command_queue[cmd_queue_index_r];
|
2015-04-27 03:08:45 +00:00
|
|
|
|
2016-03-30 02:50:01 +00:00
|
|
|
if (DEBUGGING(ECHO)) {
|
2015-04-27 03:08:45 +00:00
|
|
|
SERIAL_ECHO_START;
|
2015-05-17 06:14:02 +00:00
|
|
|
SERIAL_ECHOLN(current_command);
|
2015-04-27 03:08:45 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 06:14:02 +00:00
|
|
|
// Sanitize the current command:
|
|
|
|
// - Skip leading spaces
|
2016-02-10 02:16:35 +00:00
|
|
|
// - Bypass N[-0-9][0-9]*[ ]*
|
2015-05-17 06:14:02 +00:00
|
|
|
// - Overwrite * with nul to mark the end
|
|
|
|
while (*current_command == ' ') ++current_command;
|
2016-03-28 10:52:49 +00:00
|
|
|
if (*current_command == 'N' && NUMERIC_SIGNED(current_command[1])) {
|
2015-07-09 00:30:39 +00:00
|
|
|
current_command += 2; // skip N[-0-9]
|
2016-03-28 10:52:49 +00:00
|
|
|
while (NUMERIC(*current_command)) ++current_command; // skip [0-9]*
|
2015-06-08 21:38:28 +00:00
|
|
|
while (*current_command == ' ') ++current_command; // skip [ ]*
|
2015-04-27 03:08:45 +00:00
|
|
|
}
|
2015-10-03 06:08:58 +00:00
|
|
|
char* starpos = strchr(current_command, '*'); // * should always be the last parameter
|
2015-07-09 22:02:16 +00:00
|
|
|
if (starpos) while (*starpos == ' ' || *starpos == '*') *starpos-- = '\0'; // nullify '*' and ' '
|
2015-04-27 03:08:45 +00:00
|
|
|
|
2016-03-25 22:20:31 +00:00
|
|
|
char *cmd_ptr = current_command;
|
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
// Get the command code, which must be G, M, or T
|
2016-03-25 22:20:31 +00:00
|
|
|
char command_code = *cmd_ptr++;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-03-25 22:20:31 +00:00
|
|
|
// Skip spaces to get the numeric part
|
|
|
|
while (*cmd_ptr == ' ') cmd_ptr++;
|
2016-02-26 06:50:09 +00:00
|
|
|
|
2016-09-26 06:30:34 +00:00
|
|
|
// Allow for decimal point in command
|
2016-09-29 20:06:01 +00:00
|
|
|
#if ENABLED(G38_PROBE_TARGET)
|
2016-09-26 06:30:34 +00:00
|
|
|
uint8_t subcode = 0;
|
|
|
|
#endif
|
|
|
|
|
2016-03-28 10:53:09 +00:00
|
|
|
uint16_t codenum = 0; // define ahead of goto
|
2016-03-25 22:20:31 +00:00
|
|
|
|
2016-03-28 10:53:09 +00:00
|
|
|
// Bail early if there's no code
|
|
|
|
bool code_is_good = NUMERIC(*cmd_ptr);
|
|
|
|
if (!code_is_good) goto ExitUnknownCommand;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-03-25 22:20:31 +00:00
|
|
|
// Get and skip the code number
|
2016-03-28 10:53:09 +00:00
|
|
|
do {
|
|
|
|
codenum = (codenum * 10) + (*cmd_ptr - '0');
|
2016-03-25 22:20:31 +00:00
|
|
|
cmd_ptr++;
|
2016-03-28 10:53:09 +00:00
|
|
|
} while (NUMERIC(*cmd_ptr));
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-26 06:30:34 +00:00
|
|
|
// Allow for decimal point in command
|
2016-09-29 20:06:01 +00:00
|
|
|
#if ENABLED(G38_PROBE_TARGET)
|
2016-09-26 06:30:34 +00:00
|
|
|
if (*cmd_ptr == '.') {
|
|
|
|
cmd_ptr++;
|
|
|
|
while (NUMERIC(*cmd_ptr))
|
|
|
|
subcode = (subcode * 10) + (*cmd_ptr++ - '0');
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-03-28 10:53:09 +00:00
|
|
|
// Skip all spaces to get to the first argument, or nul
|
2016-03-25 22:20:31 +00:00
|
|
|
while (*cmd_ptr == ' ') cmd_ptr++;
|
2015-05-17 23:58:37 +00:00
|
|
|
|
2016-03-28 10:53:09 +00:00
|
|
|
// The command's arguments (if any) start here, for sure!
|
2016-03-25 22:20:31 +00:00
|
|
|
current_command_args = cmd_ptr;
|
2015-05-17 12:42:04 +00:00
|
|
|
|
2016-03-07 11:48:14 +00:00
|
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
|
|
|
2015-05-17 12:42:04 +00:00
|
|
|
// Handle a known G, M, or T
|
2015-10-03 06:08:58 +00:00
|
|
|
switch (command_code) {
|
2015-05-17 12:00:09 +00:00
|
|
|
case 'G': switch (codenum) {
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:31:24 +00:00
|
|
|
// G0, G1
|
|
|
|
case 0:
|
|
|
|
case 1:
|
2016-09-15 19:15:08 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
gcode_G0_G1(codenum == 0);
|
|
|
|
#else
|
|
|
|
gcode_G0_G1();
|
|
|
|
#endif
|
2015-05-23 00:31:24 +00:00
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:31:38 +00:00
|
|
|
// G2, G3
|
2016-05-13 22:29:13 +00:00
|
|
|
#if ENABLED(ARC_SUPPORT) && DISABLED(SCARA)
|
2015-05-23 00:31:38 +00:00
|
|
|
case 2: // G2 - CW ARC
|
|
|
|
case 3: // G3 - CCW ARC
|
|
|
|
gcode_G2_G3(codenum == 2);
|
|
|
|
break;
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:32:27 +00:00
|
|
|
// G4 Dwell
|
|
|
|
case 4:
|
|
|
|
gcode_G4();
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-12 20:33:47 +00:00
|
|
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
|
|
|
// G5
|
|
|
|
case 5: // G5 - Cubic B_spline
|
|
|
|
gcode_G5();
|
|
|
|
break;
|
|
|
|
#endif // BEZIER_CURVE_SUPPORT
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2015-05-23 00:32:27 +00:00
|
|
|
case 10: // G10: retract
|
|
|
|
case 11: // G11: retract_recover
|
|
|
|
gcode_G10_G11(codenum == 10);
|
|
|
|
break;
|
2016-05-12 20:33:47 +00:00
|
|
|
#endif // FWRETRACT
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-07-19 00:56:14 +00:00
|
|
|
#if ENABLED(NOZZLE_CLEAN_FEATURE)
|
2016-06-16 04:18:44 +00:00
|
|
|
case 12:
|
2016-07-14 15:29:04 +00:00
|
|
|
gcode_G12(); // G12: Nozzle Clean
|
2016-06-16 04:18:44 +00:00
|
|
|
break;
|
2016-07-13 23:07:36 +00:00
|
|
|
#endif // NOZZLE_CLEAN_FEATURE
|
2016-06-16 04:18:44 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(INCH_MODE_SUPPORT)
|
|
|
|
case 20: //G20: Inch Mode
|
|
|
|
gcode_G20();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 21: //G21: MM Mode
|
|
|
|
gcode_G21();
|
|
|
|
break;
|
2016-06-16 04:18:44 +00:00
|
|
|
#endif // INCH_MODE_SUPPORT
|
2016-05-31 15:26:08 +00:00
|
|
|
|
2016-07-14 15:29:04 +00:00
|
|
|
#if ENABLED(NOZZLE_PARK_FEATURE)
|
|
|
|
case 27: // G27: Nozzle Park
|
|
|
|
gcode_G27();
|
|
|
|
break;
|
|
|
|
#endif // NOZZLE_PARK_FEATURE
|
|
|
|
|
2015-05-23 00:32:27 +00:00
|
|
|
case 28: // G28: Home all axes, one at a time
|
|
|
|
gcode_G28();
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-29 06:03:28 +00:00
|
|
|
#if PLANNER_LEVELING
|
2015-08-20 14:07:55 +00:00
|
|
|
case 29: // G29 Detailed Z probe, probes the bed at 3 or more points.
|
2015-05-23 00:32:46 +00:00
|
|
|
gcode_G29();
|
|
|
|
break;
|
2016-09-29 06:03:28 +00:00
|
|
|
#endif // PLANNER_LEVELING
|
2015-03-21 13:50:47 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
#if HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
case 30: // G30 Single Z probe
|
|
|
|
gcode_G30();
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-20 22:50:51 +00:00
|
|
|
#if ENABLED(Z_PROBE_SLED)
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:33:17 +00:00
|
|
|
case 31: // G31: dock the sled
|
2016-06-24 00:04:13 +00:00
|
|
|
gcode_G31();
|
2016-06-20 22:50:51 +00:00
|
|
|
break;
|
2016-06-24 00:04:13 +00:00
|
|
|
|
2015-05-23 00:33:17 +00:00
|
|
|
case 32: // G32: undock the sled
|
2016-06-24 00:04:13 +00:00
|
|
|
gcode_G32();
|
2015-05-23 00:33:17 +00:00
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:33:17 +00:00
|
|
|
#endif // Z_PROBE_SLED
|
2016-06-20 22:50:51 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-09-29 20:06:01 +00:00
|
|
|
#if ENABLED(G38_PROBE_TARGET)
|
2016-09-26 06:30:34 +00:00
|
|
|
case 38: // G38.2 & G38.3
|
|
|
|
if (subcode == 2 || subcode == 3)
|
|
|
|
gcode_G38(subcode == 2);
|
2016-09-19 19:17:10 +00:00
|
|
|
break;
|
2016-09-26 06:30:34 +00:00
|
|
|
#endif
|
|
|
|
|
2015-05-23 00:34:08 +00:00
|
|
|
case 90: // G90
|
|
|
|
relative_mode = false;
|
|
|
|
break;
|
|
|
|
case 91: // G91
|
|
|
|
relative_mode = true;
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-23 00:34:08 +00:00
|
|
|
case 92: // G92
|
|
|
|
gcode_G92();
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
2015-05-17 12:00:09 +00:00
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
case 'M': switch (codenum) {
|
2016-09-15 07:53:46 +00:00
|
|
|
#if ENABLED(ULTIPANEL) || ENABLED(EMERGENCY_PARSER)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 0: // M0: Unconditional stop - Wait for user button press on LCD
|
|
|
|
case 1: // M1: Conditional stop - Wait for user button press on LCD
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M0_M1();
|
|
|
|
break;
|
|
|
|
#endif // ULTIPANEL
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 17: // M17: Enable all stepper motors
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M17();
|
|
|
|
break;
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 20: // M20: list SD card
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M20(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 21: // M21: init SD card
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M21(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 22: // M22: release SD card
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M22(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 23: // M23: Select file
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M23(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 24: // M24: Start SD print
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M24(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 25: // M25: Pause SD print
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M25(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 26: // M26: Set SD index
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M26(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 27: // M27: Get SD status
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M27(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 28: // M28: Start SD write
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M28(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 29: // M29: Stop SD write
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M29(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 30: // M30 <filename> Delete File
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M30(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 32: // M32: Select file and start SD print
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M32(); break;
|
2015-05-18 00:36:32 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 33: // M33: Get the long full path to a file or folder
|
2015-05-18 00:36:32 +00:00
|
|
|
gcode_M33(); break;
|
2016-10-05 09:39:01 +00:00
|
|
|
#endif
|
2015-05-18 00:36:32 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 928: // M928: Start SD write
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M928(); break;
|
|
|
|
#endif //SDSUPPORT
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 31: // M31: Report time since the start of SD print or last M109
|
|
|
|
gcode_M31(); break;
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 10:50:22 +00:00
|
|
|
case 42: // M42: Change pin state
|
|
|
|
gcode_M42(); break;
|
|
|
|
|
|
|
|
#if ENABLED(PINS_DEBUGGING)
|
|
|
|
case 43: // M43: Read pin state
|
|
|
|
gcode_M43(); break;
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-06-21 08:28:36 +00:00
|
|
|
#if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 48: // M48: Z probe repeatability test
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M48();
|
|
|
|
break;
|
2016-06-21 08:28:36 +00:00
|
|
|
#endif // Z_MIN_PROBE_REPEATABILITY_TEST
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 75: // M75: Start print timer
|
|
|
|
gcode_M75(); break;
|
|
|
|
case 76: // M76: Pause print timer
|
|
|
|
gcode_M76(); break;
|
|
|
|
case 77: // M77: Stop print timer
|
|
|
|
gcode_M77(); break;
|
2016-04-06 03:38:42 +00:00
|
|
|
|
2016-04-27 01:13:27 +00:00
|
|
|
#if ENABLED(PRINTCOUNTER)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 78: // M78: Show print statistics
|
|
|
|
gcode_M78(); break;
|
2016-04-27 01:13:27 +00:00
|
|
|
#endif
|
|
|
|
|
2015-08-03 19:30:37 +00:00
|
|
|
#if ENABLED(M100_FREE_MEMORY_WATCHER)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 100: // M100: Free Memory Report
|
2015-07-18 23:59:12 +00:00
|
|
|
gcode_M100();
|
2015-07-06 00:42:13 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 104: // M104: Set hot end temperature
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M104();
|
|
|
|
break;
|
|
|
|
|
2016-03-07 21:27:01 +00:00
|
|
|
case 110: // M110: Set Current Line Number
|
|
|
|
gcode_M110();
|
|
|
|
break;
|
|
|
|
|
2015-04-27 01:44:01 +00:00
|
|
|
case 111: // M111: Set debug level
|
2015-04-27 03:08:45 +00:00
|
|
|
gcode_M111();
|
|
|
|
break;
|
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#if DISABLED(EMERGENCY_PARSER)
|
2016-07-06 18:52:36 +00:00
|
|
|
|
|
|
|
case 108: // M108: Cancel Waiting
|
|
|
|
gcode_M108();
|
|
|
|
break;
|
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
case 112: // M112: Emergency Stop
|
|
|
|
gcode_M112();
|
|
|
|
break;
|
2016-07-06 18:52:36 +00:00
|
|
|
|
|
|
|
case 410: // M410 quickstop - Abort all the planned moves.
|
|
|
|
gcode_M410();
|
|
|
|
break;
|
|
|
|
|
Add an emergency-command parser to MarlinSerial (supporting M108)
Add an emergency-command parser to MarlinSerial's RX interrupt.
The parser tries to find and execute M108,M112,M410 before the commands disappear in the RX-buffer.
To avoid false positives for M117, comments and commands followed by filenames (M23, M28, M30, M32, M33) are filtered.
This enables Marlin to receive and react on the Emergency command at all times - regardless of whether the buffers are full or not. It remains to convince hosts to send the commands. To inform the hosts about the new feature a new entry in the M115-report was made. "`EMERGENCY_CODES:M112,M108,M410;`".
The parser is fast. It only ever needs two switch decisions and one assignment of the new state for every character.
One problem remains. If the host has sent an incomplete line before sending an emergency command the emergency command could be omitted when the parser is in `state_IGNORE`.
In that case the host should send "\ncommand\n"
Also introduces M108 to break the waiting for the heaters in M109, M190 and M303.
Rename `cancel_heatup` to `wait_for_heatup` to better see the purpose.
2016-07-04 21:23:22 +00:00
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-04-11 01:53:03 +00:00
|
|
|
#if ENABLED(HOST_KEEPALIVE_FEATURE)
|
|
|
|
case 113: // M113: Set Host Keepalive interval
|
|
|
|
gcode_M113();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 140: // M140: Set bed temperature
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M140();
|
|
|
|
break;
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 105: // M105: Report current temperature
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M105();
|
2016-03-20 09:40:26 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
2015-05-17 12:00:09 +00:00
|
|
|
return; // "ok" already printed
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-11-09 00:03:40 +00:00
|
|
|
#if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED)
|
|
|
|
case 155: // M155: Set temperature auto-report interval
|
|
|
|
gcode_M155();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 109: // M109: Wait for hotend temperature to reach target
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M109();
|
|
|
|
break;
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_TEMP_BED
|
2016-10-05 09:39:01 +00:00
|
|
|
case 190: // M190: Wait for bed temperature to reach target
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M190();
|
|
|
|
break;
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif // HAS_TEMP_BED
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-03-06 02:27:45 +00:00
|
|
|
#if FAN_COUNT > 0
|
2015-04-27 03:08:45 +00:00
|
|
|
case 106: // M106: Fan On
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M106();
|
|
|
|
break;
|
2015-04-27 03:08:45 +00:00
|
|
|
case 107: // M107: Fan Off
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M107();
|
|
|
|
break;
|
2016-03-06 02:27:45 +00:00
|
|
|
#endif // FAN_COUNT > 0
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(BARICUDA)
|
2015-03-05 12:27:24 +00:00
|
|
|
// PWM for HEATER_1_PIN
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HEATER_1
|
2015-04-27 03:08:45 +00:00
|
|
|
case 126: // M126: valve open
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M126();
|
|
|
|
break;
|
2015-04-27 03:08:45 +00:00
|
|
|
case 127: // M127: valve closed
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M127();
|
|
|
|
break;
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif // HAS_HEATER_1
|
2015-03-05 12:27:24 +00:00
|
|
|
|
|
|
|
// PWM for HEATER_2_PIN
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HEATER_2
|
2015-04-27 03:08:45 +00:00
|
|
|
case 128: // M128: valve open
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M128();
|
|
|
|
break;
|
2015-04-27 03:08:45 +00:00
|
|
|
case 129: // M129: valve closed
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M129();
|
|
|
|
break;
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif // HAS_HEATER_2
|
|
|
|
#endif // BARICUDA
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-03-30 23:50:05 +00:00
|
|
|
#if HAS_POWER_SWITCH
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-27 03:08:45 +00:00
|
|
|
case 80: // M80: Turn on Power Supply
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M80();
|
|
|
|
break;
|
|
|
|
|
2015-03-30 23:50:05 +00:00
|
|
|
#endif // HAS_POWER_SWITCH
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2015-04-27 03:08:45 +00:00
|
|
|
case 81: // M81: Turn off Power, including Power Supply, if possible
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M81();
|
|
|
|
break;
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 82: // M83: Set E axis normal mode (same as other axes)
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M82();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 83: // M83: Set E axis relative mode
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M83();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 18: // M18 => M84
|
|
|
|
case 84: // M84: Disable all steppers or set timeout
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M18_M84();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 85: // M85: Set inactivity stepper shutdown timeout
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M85();
|
|
|
|
break;
|
2015-04-27 01:44:01 +00:00
|
|
|
case 92: // M92: Set the steps-per-unit for one or more axes
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M92();
|
|
|
|
break;
|
2016-11-07 21:52:42 +00:00
|
|
|
case 114: // M114: Report current position
|
|
|
|
gcode_M114();
|
|
|
|
break;
|
2015-04-27 01:44:01 +00:00
|
|
|
case 115: // M115: Report capabilities
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M115();
|
|
|
|
break;
|
2015-05-17 12:00:09 +00:00
|
|
|
case 117: // M117: Set LCD message text, if possible
|
|
|
|
gcode_M117();
|
|
|
|
break;
|
2016-11-07 21:52:42 +00:00
|
|
|
case 119: // M119: Report endstop states
|
|
|
|
gcode_M119();
|
2015-03-05 12:27:24 +00:00
|
|
|
break;
|
2015-04-27 01:44:01 +00:00
|
|
|
case 120: // M120: Enable endstops
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M120();
|
|
|
|
break;
|
2015-04-27 01:44:01 +00:00
|
|
|
case 121: // M121: Disable endstops
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M121();
|
|
|
|
break;
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2016-09-14 06:48:47 +00:00
|
|
|
#if ENABLED(HAVE_TMC2130DRIVER)
|
|
|
|
case 122: // M122: Diagnose, used to debug TMC2130
|
|
|
|
gcode_M122();
|
|
|
|
break;
|
|
|
|
#endif
|
2015-04-27 01:44:01 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTIPANEL)
|
2015-04-27 01:44:01 +00:00
|
|
|
|
|
|
|
case 145: // M145: Set material heatup parameters
|
|
|
|
gcode_M145();
|
|
|
|
break;
|
|
|
|
|
|
|
|
#endif
|
2015-03-05 12:27:24 +00:00
|
|
|
|
2016-05-31 15:26:08 +00:00
|
|
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 149: // M149: Set temperature units
|
2016-05-31 15:26:08 +00:00
|
|
|
gcode_M149();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2016-11-30 01:51:13 +00:00
|
|
|
#if ENABLED(BLINKM) || ENABLED(RGB_LED)
|
2014-08-07 00:30:57 +00:00
|
|
|
|
2016-11-30 01:51:13 +00:00
|
|
|
case 150: // M150: Set Status LED Color
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M150();
|
|
|
|
break;
|
2014-08-07 00:30:57 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
#endif // BLINKM
|
2014-08-07 00:30:57 +00:00
|
|
|
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(MIXING_EXTRUDER)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 163: // M163: Set a component weight for mixing extruder
|
2016-06-28 22:06:56 +00:00
|
|
|
gcode_M163();
|
|
|
|
break;
|
|
|
|
#if MIXING_VIRTUAL_TOOLS > 1
|
2016-10-05 09:39:01 +00:00
|
|
|
case 164: // M164: Save current mix as a virtual extruder
|
2016-06-28 22:06:56 +00:00
|
|
|
gcode_M164();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if ENABLED(DIRECT_MIXING_IN_G1)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 165: // M165: Set multiple mix weights
|
2016-06-28 22:06:56 +00:00
|
|
|
gcode_M165();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 200: // M200: Set filament diameter, E to cubic units
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M200();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 201: // M201: Set max acceleration for print moves (units/s^2)
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M201();
|
|
|
|
break;
|
|
|
|
#if 0 // Not used for Sprinter/grbl gen6
|
2015-10-03 06:08:58 +00:00
|
|
|
case 202: // M202
|
|
|
|
gcode_M202();
|
|
|
|
break;
|
2015-03-05 12:27:24 +00:00
|
|
|
#endif
|
2016-10-05 09:39:01 +00:00
|
|
|
case 203: // M203: Set max feedrate (units/sec)
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M203();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 204: // M204: Set acceleration
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M204();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 205: //M205: Set advanced settings
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M205();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 206: // M206: Set home offsets
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M206();
|
|
|
|
break;
|
2014-02-19 22:59:10 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 665: // M665: Set delta configurations
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M665();
|
|
|
|
break;
|
2015-03-30 02:39:43 +00:00
|
|
|
#endif
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA) || ENABLED(Z_DUAL_ENDSTOPS)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 666: // M666: Set delta or dual endstop adjustment
|
2015-03-24 17:06:44 +00:00
|
|
|
gcode_M666();
|
|
|
|
break;
|
2015-03-30 02:39:43 +00:00
|
|
|
#endif
|
2014-02-19 22:59:10 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(FWRETRACT)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 207: // M207: Set Retract Length, Feedrate, and Z lift
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M207();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 208: // M208: Set Recover (unretract) Additional Length and Feedrate
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M208();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 209: // M209: Turn Automatic Retract Detection on/off
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M209();
|
|
|
|
break;
|
|
|
|
#endif // FWRETRACT
|
2015-02-03 17:57:16 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 211: // M211: Enable, Disable, and/or Report software endstops
|
2016-08-21 01:07:42 +00:00
|
|
|
gcode_M211();
|
|
|
|
break;
|
|
|
|
|
2016-05-27 00:43:20 +00:00
|
|
|
#if HOTENDS > 1
|
2016-10-05 09:39:01 +00:00
|
|
|
case 218: // M218: Set a tool offset
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M218();
|
|
|
|
break;
|
|
|
|
#endif
|
2015-02-03 17:57:16 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 220: // M220: Set Feedrate Percentage: S<percent> ("FR" on your LCD)
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M220();
|
|
|
|
break;
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 221: // M221: Set Flow Percentage
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M221();
|
|
|
|
break;
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 226: // M226: Wait until a pin reaches a state
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M226();
|
|
|
|
break;
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if HAS_SERVOS
|
2016-10-05 09:39:01 +00:00
|
|
|
case 280: // M280: Set servo position absolute
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M280();
|
|
|
|
break;
|
2015-07-31 05:24:43 +00:00
|
|
|
#endif // HAS_SERVOS
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-06-14 22:12:02 +00:00
|
|
|
#if HAS_BUZZER
|
2016-10-05 09:39:01 +00:00
|
|
|
case 300: // M300: Play beep tone
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M300();
|
|
|
|
break;
|
2015-06-14 22:12:02 +00:00
|
|
|
#endif // HAS_BUZZER
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PIDTEMP)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 301: // M301: Set hotend PID parameters
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M301();
|
|
|
|
break;
|
|
|
|
#endif // PIDTEMP
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(PIDTEMPBED)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 304: // M304: Set bed PID parameters
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M304();
|
|
|
|
break;
|
|
|
|
#endif // PIDTEMPBED
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if defined(CHDK) || HAS_PHOTOGRAPH
|
2016-10-05 09:39:01 +00:00
|
|
|
case 240: // M240: Trigger a camera by emulating a Canon RC-1 : http://www.doc-diy.net/photo/rc-1_hacked/
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M240();
|
|
|
|
break;
|
|
|
|
#endif // CHDK || PHOTOGRAPH_PIN
|
2015-02-03 17:57:16 +00:00
|
|
|
|
2016-05-31 18:47:02 +00:00
|
|
|
#if HAS_LCD_CONTRAST
|
2016-10-05 09:39:01 +00:00
|
|
|
case 250: // M250: Set LCD contrast
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M250();
|
|
|
|
break;
|
2015-04-08 11:26:29 +00:00
|
|
|
#endif // HAS_LCD_CONTRAST
|
2015-02-03 17:57:16 +00:00
|
|
|
|
2016-11-08 22:28:42 +00:00
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS)
|
|
|
|
|
|
|
|
case 260: // M260: Send data to an i2c slave
|
|
|
|
gcode_M260();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 261: // M261: Request data from an i2c slave
|
|
|
|
gcode_M261();
|
|
|
|
break;
|
|
|
|
|
|
|
|
#endif // EXPERIMENTAL_I2CBUS
|
|
|
|
|
2016-08-21 04:34:24 +00:00
|
|
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 302: // M302: Allow cold extrudes (set the minimum extrude temperature)
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M302();
|
|
|
|
break;
|
2016-08-21 04:34:24 +00:00
|
|
|
#endif // PREVENT_COLD_EXTRUSION
|
2015-02-18 20:33:38 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 303: // M303: PID autotune
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M303();
|
|
|
|
break;
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
#if ENABLED(MORGAN_SCARA)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 360: // M360: SCARA Theta pos1
|
2015-03-05 12:27:24 +00:00
|
|
|
if (gcode_M360()) return;
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 361: // M361: SCARA Theta pos2
|
2015-03-05 12:27:24 +00:00
|
|
|
if (gcode_M361()) return;
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 362: // M362: SCARA Psi pos1
|
2015-03-05 12:27:24 +00:00
|
|
|
if (gcode_M362()) return;
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 363: // M363: SCARA Psi pos2
|
2015-03-05 12:27:24 +00:00
|
|
|
if (gcode_M363()) return;
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 364: // M364: SCARA Psi pos3 (90 deg to Theta)
|
2015-03-05 12:27:24 +00:00
|
|
|
if (gcode_M364()) return;
|
|
|
|
break;
|
|
|
|
#endif // SCARA
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 400: // M400: Finish all moves
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M400();
|
|
|
|
break;
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2016-06-21 22:04:09 +00:00
|
|
|
#if HAS_BED_PROBE
|
2016-10-05 09:39:01 +00:00
|
|
|
case 401: // M401: Deploy probe
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M401();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 402: // M402: Stow probe
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M402();
|
|
|
|
break;
|
2016-06-21 22:04:09 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-03-30 03:28:23 +00:00
|
|
|
#if ENABLED(FILAMENT_WIDTH_SENSOR)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 404: // M404: Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or display nominal filament width
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M404();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 405: // M405: Turn on filament sensor for control
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M405();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 406: // M406: Turn off filament sensor for control
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M406();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 407: // M407: Display measured filament diameter
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M407();
|
|
|
|
break;
|
2016-03-30 03:28:23 +00:00
|
|
|
#endif // ENABLED(FILAMENT_WIDTH_SENSOR)
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-10-28 18:53:48 +00:00
|
|
|
#if PLANNER_LEVELING
|
|
|
|
case 420: // M420: Enable/Disable Bed Leveling
|
2015-04-27 01:44:01 +00:00
|
|
|
gcode_M420();
|
|
|
|
break;
|
2016-10-28 18:53:48 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 421: // M421: Set a Mesh Bed Leveling Z coordinate
|
2015-04-27 01:44:01 +00:00
|
|
|
gcode_M421();
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 428: // M428: Apply current_position to home_offset
|
2015-04-30 01:26:16 +00:00
|
|
|
gcode_M428();
|
|
|
|
break;
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 500: // M500: Store settings in EEPROM
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M500();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 501: // M501: Read settings from EEPROM
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M501();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 502: // M502: Revert to default settings
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M502();
|
|
|
|
break;
|
2016-10-05 09:39:01 +00:00
|
|
|
case 503: // M503: print settings currently in memory
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M503();
|
|
|
|
break;
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
|
2016-11-22 00:08:00 +00:00
|
|
|
case 540: // M540: Set abort on endstop hit for SD printing
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M540();
|
2012-11-21 19:36:30 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-06-18 20:58:42 +00:00
|
|
|
#if HAS_BED_PROBE
|
2016-10-05 09:39:01 +00:00
|
|
|
case 851: // M851: Set Z Probe Z Offset
|
2016-06-15 01:05:20 +00:00
|
|
|
gcode_M851();
|
2015-03-05 12:27:24 +00:00
|
|
|
break;
|
2016-06-18 20:58:42 +00:00
|
|
|
#endif // HAS_BED_PROBE
|
2014-02-05 09:47:12 +00:00
|
|
|
|
2016-04-28 16:57:21 +00:00
|
|
|
#if ENABLED(FILAMENT_CHANGE_FEATURE)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 600: // M600: Pause for filament change
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M600();
|
|
|
|
break;
|
2016-04-28 16:57:21 +00:00
|
|
|
#endif // FILAMENT_CHANGE_FEATURE
|
2013-07-17 12:44:45 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 605: // M605: Set Dual X Carriage movement mode
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M605();
|
|
|
|
break;
|
|
|
|
#endif // DUAL_X_CARRIAGE
|
2016-06-16 18:24:11 +00:00
|
|
|
|
2016-05-04 16:53:17 +00:00
|
|
|
#if ENABLED(LIN_ADVANCE)
|
2016-10-05 09:39:01 +00:00
|
|
|
case 905: // M905: Set advance K factor.
|
2016-05-04 16:53:17 +00:00
|
|
|
gcode_M905();
|
|
|
|
break;
|
|
|
|
#endif
|
2013-07-17 12:44:45 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 907: // M907: Set digital trimpot motor current using axis codes.
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M907();
|
|
|
|
break;
|
2014-04-01 01:26:19 +00:00
|
|
|
|
2016-03-20 01:19:41 +00:00
|
|
|
#if HAS_DIGIPOTSS || ENABLED(DAC_STEPPER_CURRENT)
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 908: // M908: Control digital trimpot directly.
|
2015-03-05 12:27:24 +00:00
|
|
|
gcode_M908();
|
|
|
|
break;
|
2016-03-20 01:19:41 +00:00
|
|
|
|
|
|
|
#if ENABLED(DAC_STEPPER_CURRENT) // As with Printrbot RevF
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 909: // M909: Print digipot/DAC current value
|
2016-03-20 01:19:41 +00:00
|
|
|
gcode_M909();
|
|
|
|
break;
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 910: // M910: Commit digipot/DAC value to external EEPROM
|
2016-03-20 01:19:41 +00:00
|
|
|
gcode_M910();
|
|
|
|
break;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // HAS_DIGIPOTSS || DAC_STEPPER_CURRENT
|
2014-04-01 01:26:19 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_MICROSTEPS
|
2015-03-03 01:07:12 +00:00
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 350: // M350: Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
|
2015-04-03 22:31:35 +00:00
|
|
|
gcode_M350();
|
|
|
|
break;
|
|
|
|
|
2016-10-05 09:39:01 +00:00
|
|
|
case 351: // M351: Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
|
2015-04-03 22:31:35 +00:00
|
|
|
gcode_M351();
|
|
|
|
break;
|
|
|
|
|
|
|
|
#endif // HAS_MICROSTEPS
|
2015-03-03 01:07:12 +00:00
|
|
|
|
2016-10-05 19:34:07 +00:00
|
|
|
#if HAS_CASE_LIGHT
|
|
|
|
|
|
|
|
case 355: // M355 Turn case lights on/off
|
|
|
|
gcode_M355();
|
|
|
|
break;
|
|
|
|
|
|
|
|
#endif // HAS_CASE_LIGHT
|
|
|
|
|
2015-03-05 12:27:24 +00:00
|
|
|
case 999: // M999: Restart after being Stopped
|
|
|
|
gcode_M999();
|
|
|
|
break;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2015-05-17 12:00:09 +00:00
|
|
|
break;
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-05-17 12:00:09 +00:00
|
|
|
case 'T':
|
2015-05-17 12:07:51 +00:00
|
|
|
gcode_T(codenum);
|
2015-10-03 06:08:58 +00:00
|
|
|
break;
|
2015-05-29 00:44:09 +00:00
|
|
|
|
|
|
|
default: code_is_good = false;
|
2015-03-05 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-03-07 11:48:14 +00:00
|
|
|
KEEPALIVE_STATE(NOT_BUSY);
|
|
|
|
|
2015-05-17 12:42:04 +00:00
|
|
|
ExitUnknownCommand:
|
|
|
|
|
|
|
|
// Still unknown command? Throw an error
|
2015-05-17 12:00:09 +00:00
|
|
|
if (!code_is_good) unknown_command_error();
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2015-05-12 09:08:20 +00:00
|
|
|
ok_to_send();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Send a "Resend: nnn" message to the host to
|
|
|
|
* indicate that a command needs to be re-sent.
|
|
|
|
*/
|
2015-04-03 22:31:35 +00:00
|
|
|
void FlushSerialRequestResend() {
|
2015-04-14 00:17:36 +00:00
|
|
|
//char command_queue[cmd_queue_index_r][100]="Resend:";
|
2012-11-06 11:06:41 +00:00
|
|
|
MYSERIAL.flush();
|
|
|
|
SERIAL_PROTOCOLPGM(MSG_RESEND);
|
|
|
|
SERIAL_PROTOCOLLN(gcode_LastN + 1);
|
2015-05-12 09:08:20 +00:00
|
|
|
ok_to_send();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Send an "ok" message to the host, indicating
|
|
|
|
* that a command was successfully processed.
|
|
|
|
*
|
|
|
|
* If ADVANCED_OK is enabled also include:
|
|
|
|
* N<int> Line number of the command, if any
|
|
|
|
* P<int> Planner space remaining
|
|
|
|
* B<int> Block queue space remaining
|
|
|
|
*/
|
2015-05-12 09:08:20 +00:00
|
|
|
void ok_to_send() {
|
2015-04-03 22:31:35 +00:00
|
|
|
refresh_cmd_timeout();
|
2016-02-21 01:35:35 +00:00
|
|
|
if (!send_ok[cmd_queue_index_r]) return;
|
2015-04-19 22:22:40 +00:00
|
|
|
SERIAL_PROTOCOLPGM(MSG_OK);
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ADVANCED_OK)
|
2016-02-09 18:23:26 +00:00
|
|
|
char* p = command_queue[cmd_queue_index_r];
|
|
|
|
if (*p == 'N') {
|
|
|
|
SERIAL_PROTOCOL(' ');
|
|
|
|
SERIAL_ECHO(*p++);
|
2016-03-28 10:52:49 +00:00
|
|
|
while (NUMERIC_SIGNED(*p))
|
2016-02-09 18:23:26 +00:00
|
|
|
SERIAL_ECHO(*p++);
|
|
|
|
}
|
2016-05-02 13:04:26 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" P"); SERIAL_PROTOCOL(int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
|
2015-05-11 11:04:00 +00:00
|
|
|
SERIAL_PROTOCOLPGM(" B"); SERIAL_PROTOCOL(BUFSIZE - commands_in_queue);
|
2015-04-19 22:22:40 +00:00
|
|
|
#endif
|
2015-08-05 11:40:36 +00:00
|
|
|
SERIAL_EOL;
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-08-21 01:07:42 +00:00
|
|
|
#if ENABLED(min_software_endstops) || ENABLED(max_software_endstops)
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Constrain the given coordinates to the software endstops.
|
|
|
|
*/
|
2016-08-21 01:07:42 +00:00
|
|
|
void clamp_to_software_endstops(float target[XYZ]) {
|
|
|
|
#if ENABLED(min_software_endstops)
|
|
|
|
NOLESS(target[X_AXIS], soft_endstop_min[X_AXIS]);
|
|
|
|
NOLESS(target[Y_AXIS], soft_endstop_min[Y_AXIS]);
|
|
|
|
NOLESS(target[Z_AXIS], soft_endstop_min[Z_AXIS]);
|
|
|
|
#endif
|
|
|
|
#if ENABLED(max_software_endstops)
|
|
|
|
NOMORE(target[X_AXIS], soft_endstop_max[X_AXIS]);
|
|
|
|
NOMORE(target[Y_AXIS], soft_endstop_max[Y_AXIS]);
|
|
|
|
NOMORE(target[Z_AXIS], soft_endstop_max[Z_AXIS]);
|
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-08-21 01:07:42 +00:00
|
|
|
|
|
|
|
#endif
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
2016-09-15 05:20:30 +00:00
|
|
|
|
2016-11-05 16:01:26 +00:00
|
|
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
|
|
|
#define ABL_BG_SPACING(A) bilinear_grid_spacing_virt[A]
|
|
|
|
#define ABL_BG_POINTS_X ABL_GRID_POINTS_VIRT_X
|
|
|
|
#define ABL_BG_POINTS_Y ABL_GRID_POINTS_VIRT_Y
|
|
|
|
#define ABL_BG_GRID(X,Y) bed_level_grid_virt[X][Y]
|
|
|
|
#else
|
|
|
|
#define ABL_BG_SPACING(A) bilinear_grid_spacing[A]
|
2016-12-10 05:38:28 +00:00
|
|
|
#define ABL_BG_POINTS_X ABL_GRID_MAX_POINTS_X
|
|
|
|
#define ABL_BG_POINTS_Y ABL_GRID_MAX_POINTS_Y
|
2016-11-05 16:01:26 +00:00
|
|
|
#define ABL_BG_GRID(X,Y) bed_level_grid[X][Y]
|
|
|
|
#endif
|
|
|
|
|
2016-09-15 05:20:30 +00:00
|
|
|
// Get the Z adjustment for non-linear bed leveling
|
2016-09-26 04:17:39 +00:00
|
|
|
float bilinear_z_offset(float cartesian[XYZ]) {
|
2016-09-15 05:20:30 +00:00
|
|
|
|
2016-09-28 17:56:35 +00:00
|
|
|
// XY relative to the probed area
|
|
|
|
const float x = RAW_X_POSITION(cartesian[X_AXIS]) - bilinear_start[X_AXIS],
|
|
|
|
y = RAW_Y_POSITION(cartesian[Y_AXIS]) - bilinear_start[Y_AXIS];
|
2016-09-27 07:38:38 +00:00
|
|
|
|
2016-09-28 17:56:35 +00:00
|
|
|
// Convert to grid box units
|
2016-11-05 16:01:26 +00:00
|
|
|
float ratio_x = x / ABL_BG_SPACING(X_AXIS),
|
|
|
|
ratio_y = y / ABL_BG_SPACING(Y_AXIS);
|
2016-09-27 07:38:38 +00:00
|
|
|
|
2016-10-26 23:11:26 +00:00
|
|
|
// Whole units for the grid line indices. Constrained within bounds.
|
2016-11-05 16:01:26 +00:00
|
|
|
const int gridx = constrain(floor(ratio_x), 0, ABL_BG_POINTS_X - 1),
|
|
|
|
gridy = constrain(floor(ratio_y), 0, ABL_BG_POINTS_Y - 1),
|
|
|
|
nextx = min(gridx + 1, ABL_BG_POINTS_X - 1),
|
|
|
|
nexty = min(gridy + 1, ABL_BG_POINTS_Y - 1);
|
2016-09-28 17:56:35 +00:00
|
|
|
|
|
|
|
// Subtract whole to get the ratio within the grid box
|
2016-10-26 23:11:26 +00:00
|
|
|
ratio_x -= gridx; ratio_y -= gridy;
|
|
|
|
|
|
|
|
// Never less than 0.0. (Over 1.0 is fine due to previous contraints.)
|
|
|
|
NOLESS(ratio_x, 0); NOLESS(ratio_y, 0);
|
2016-09-27 07:38:38 +00:00
|
|
|
|
2016-09-29 06:01:38 +00:00
|
|
|
// Z at the box corners
|
2016-11-05 16:01:26 +00:00
|
|
|
const float z1 = ABL_BG_GRID(gridx, gridy), // left-front
|
|
|
|
z2 = ABL_BG_GRID(gridx, nexty), // left-back
|
|
|
|
z3 = ABL_BG_GRID(nextx, gridy), // right-front
|
|
|
|
z4 = ABL_BG_GRID(nextx, nexty), // right-back
|
2016-09-27 07:38:38 +00:00
|
|
|
|
2016-09-29 06:01:38 +00:00
|
|
|
// Bilinear interpolate
|
2016-09-28 17:56:35 +00:00
|
|
|
L = z1 + (z2 - z1) * ratio_y, // Linear interp. LF -> LB
|
2016-09-29 06:01:38 +00:00
|
|
|
R = z3 + (z4 - z3) * ratio_y, // Linear interp. RF -> RB
|
|
|
|
offset = L + ratio_x * (R - L);
|
2016-09-15 05:20:30 +00:00
|
|
|
|
|
|
|
/*
|
2016-09-29 06:01:38 +00:00
|
|
|
static float last_offset = 0;
|
|
|
|
if (fabs(last_offset - offset) > 0.2) {
|
|
|
|
SERIAL_ECHOPGM("Sudden Shift at ");
|
|
|
|
SERIAL_ECHOPAIR("x=", x);
|
|
|
|
SERIAL_ECHOPAIR(" / ", bilinear_grid_spacing[X_AXIS]);
|
|
|
|
SERIAL_ECHOLNPAIR(" -> gridx=", gridx);
|
|
|
|
SERIAL_ECHOPAIR(" y=", y);
|
|
|
|
SERIAL_ECHOPAIR(" / ", bilinear_grid_spacing[Y_AXIS]);
|
|
|
|
SERIAL_ECHOLNPAIR(" -> gridy=", gridy);
|
2016-09-15 05:20:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" ratio_x=", ratio_x);
|
2016-09-29 06:01:38 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" ratio_y=", ratio_y);
|
2016-09-15 05:20:30 +00:00
|
|
|
SERIAL_ECHOPAIR(" z1=", z1);
|
|
|
|
SERIAL_ECHOPAIR(" z2=", z2);
|
|
|
|
SERIAL_ECHOPAIR(" z3=", z3);
|
2016-09-29 06:01:38 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" z4=", z4);
|
2016-09-27 07:38:38 +00:00
|
|
|
SERIAL_ECHOPAIR(" L=", L);
|
|
|
|
SERIAL_ECHOPAIR(" R=", R);
|
2016-09-29 06:01:38 +00:00
|
|
|
SERIAL_ECHOLNPAIR(" offset=", offset);
|
|
|
|
}
|
|
|
|
last_offset = offset;
|
2016-09-15 05:20:30 +00:00
|
|
|
//*/
|
|
|
|
|
2016-09-29 06:01:38 +00:00
|
|
|
return offset;
|
2016-09-15 05:20:30 +00:00
|
|
|
}
|
|
|
|
|
2016-09-26 04:17:39 +00:00
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
2016-09-15 05:20:30 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
2014-02-18 04:50:59 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Recalculate factors used for delta kinematics whenever
|
|
|
|
* settings have been changed (e.g., by M665).
|
|
|
|
*/
|
2015-04-01 02:58:03 +00:00
|
|
|
void recalc_delta_settings(float radius, float diagonal_rod) {
|
2015-09-03 05:38:47 +00:00
|
|
|
delta_tower1_x = -SIN_60 * (radius + DELTA_RADIUS_TRIM_TOWER_1); // front left tower
|
|
|
|
delta_tower1_y = -COS_60 * (radius + DELTA_RADIUS_TRIM_TOWER_1);
|
|
|
|
delta_tower2_x = SIN_60 * (radius + DELTA_RADIUS_TRIM_TOWER_2); // front right tower
|
|
|
|
delta_tower2_y = -COS_60 * (radius + DELTA_RADIUS_TRIM_TOWER_2);
|
|
|
|
delta_tower3_x = 0.0; // back middle tower
|
|
|
|
delta_tower3_y = (radius + DELTA_RADIUS_TRIM_TOWER_3);
|
2016-03-14 21:47:27 +00:00
|
|
|
delta_diagonal_rod_2_tower_1 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_1);
|
|
|
|
delta_diagonal_rod_2_tower_2 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_2);
|
|
|
|
delta_diagonal_rod_2_tower_3 = sq(diagonal_rod + delta_diagonal_rod_trim_tower_3);
|
2015-04-01 02:58:03 +00:00
|
|
|
}
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#if ENABLED(DELTA_FAST_SQRT)
|
|
|
|
/**
|
|
|
|
* Fast inverse sqrt from Quake III Arena
|
|
|
|
* See: https://en.wikipedia.org/wiki/Fast_inverse_square_root
|
|
|
|
*/
|
|
|
|
float Q_rsqrt(float number) {
|
|
|
|
long i;
|
|
|
|
float x2, y;
|
|
|
|
const float threehalfs = 1.5f;
|
|
|
|
x2 = number * 0.5f;
|
|
|
|
y = number;
|
|
|
|
i = * ( long * ) &y; // evil floating point bit level hacking
|
|
|
|
i = 0x5f3759df - ( i >> 1 ); // what the f***?
|
|
|
|
y = * ( float * ) &i;
|
|
|
|
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
|
|
|
|
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
|
|
|
|
return y;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define _SQRT(n) (1.0f / Q_rsqrt(n))
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define _SQRT(n) sqrt(n)
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Delta Inverse Kinematics
|
|
|
|
*
|
|
|
|
* Calculate the tower positions for a given logical
|
|
|
|
* position, storing the result in the delta[] array.
|
|
|
|
*
|
|
|
|
* This is an expensive calculation, requiring 3 square
|
|
|
|
* roots per segmented linear move, and strains the limits
|
|
|
|
* of a Mega2560 with a Graphical Display.
|
|
|
|
*
|
|
|
|
* Suggested optimizations include:
|
|
|
|
*
|
|
|
|
* - Disable the home_offset (M206) and/or position_shift (G92)
|
|
|
|
* features to remove up to 12 float additions.
|
|
|
|
*
|
|
|
|
* - Use a fast-inverse-sqrt function and add the reciprocal.
|
|
|
|
* (see above)
|
|
|
|
*/
|
2015-04-01 02:58:03 +00:00
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
// Macro to obtain the Z position of an individual tower
|
|
|
|
#define DELTA_Z(T) raw[Z_AXIS] + _SQRT( \
|
|
|
|
delta_diagonal_rod_2_tower_##T - HYPOT2( \
|
|
|
|
delta_tower##T##_x - raw[X_AXIS], \
|
|
|
|
delta_tower##T##_y - raw[Y_AXIS] \
|
|
|
|
) \
|
|
|
|
)
|
|
|
|
|
2016-09-21 22:43:06 +00:00
|
|
|
#define DELTA_RAW_IK() do { \
|
|
|
|
delta[A_AXIS] = DELTA_Z(1); \
|
|
|
|
delta[B_AXIS] = DELTA_Z(2); \
|
|
|
|
delta[C_AXIS] = DELTA_Z(3); \
|
|
|
|
} while(0)
|
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
#define DELTA_LOGICAL_IK() do { \
|
|
|
|
const float raw[XYZ] = { \
|
|
|
|
RAW_X_POSITION(logical[X_AXIS]), \
|
|
|
|
RAW_Y_POSITION(logical[Y_AXIS]), \
|
|
|
|
RAW_Z_POSITION(logical[Z_AXIS]) \
|
|
|
|
}; \
|
2016-09-21 22:43:06 +00:00
|
|
|
DELTA_RAW_IK(); \
|
2016-09-16 18:07:43 +00:00
|
|
|
} while(0)
|
|
|
|
|
|
|
|
#define DELTA_DEBUG() do { \
|
|
|
|
SERIAL_ECHOPAIR("cartesian X:", raw[X_AXIS]); \
|
|
|
|
SERIAL_ECHOPAIR(" Y:", raw[Y_AXIS]); \
|
|
|
|
SERIAL_ECHOLNPAIR(" Z:", raw[Z_AXIS]); \
|
|
|
|
SERIAL_ECHOPAIR("delta A:", delta[A_AXIS]); \
|
|
|
|
SERIAL_ECHOPAIR(" B:", delta[B_AXIS]); \
|
|
|
|
SERIAL_ECHOLNPAIR(" C:", delta[C_AXIS]); \
|
|
|
|
} while(0)
|
2016-09-13 07:11:45 +00:00
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
void inverse_kinematics(const float logical[XYZ]) {
|
|
|
|
DELTA_LOGICAL_IK();
|
|
|
|
// DELTA_DEBUG();
|
2015-04-01 02:58:03 +00:00
|
|
|
}
|
2015-03-07 18:36:21 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Calculate the highest Z position where the
|
|
|
|
* effector has the full range of XY motion.
|
|
|
|
*/
|
2016-07-15 13:20:54 +00:00
|
|
|
float delta_safe_distance_from_top() {
|
2016-08-21 03:38:32 +00:00
|
|
|
float cartesian[XYZ] = {
|
2016-07-24 23:34:01 +00:00
|
|
|
LOGICAL_X_POSITION(0),
|
|
|
|
LOGICAL_Y_POSITION(0),
|
|
|
|
LOGICAL_Z_POSITION(0)
|
2016-07-23 00:46:05 +00:00
|
|
|
};
|
2016-07-21 22:46:22 +00:00
|
|
|
inverse_kinematics(cartesian);
|
2016-08-21 08:10:55 +00:00
|
|
|
float distance = delta[A_AXIS];
|
2016-07-24 23:34:01 +00:00
|
|
|
cartesian[Y_AXIS] = LOGICAL_Y_POSITION(DELTA_PRINTABLE_RADIUS);
|
2016-07-21 22:46:22 +00:00
|
|
|
inverse_kinematics(cartesian);
|
2016-08-21 08:10:55 +00:00
|
|
|
return abs(distance - delta[A_AXIS]);
|
2016-07-15 13:20:54 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Delta Forward Kinematics
|
|
|
|
*
|
|
|
|
* See the Wikipedia article "Trilateration"
|
|
|
|
* https://en.wikipedia.org/wiki/Trilateration
|
|
|
|
*
|
|
|
|
* Establish a new coordinate system in the plane of the
|
|
|
|
* three carriage points. This system has its origin at
|
|
|
|
* tower1, with tower2 on the X axis. Tower3 is in the X-Y
|
|
|
|
* plane with a Z component of zero.
|
|
|
|
* We will define unit vectors in this coordinate system
|
|
|
|
* in our original coordinate system. Then when we calculate
|
|
|
|
* the Xnew, Ynew and Znew values, we can translate back into
|
|
|
|
* the original system by moving along those unit vectors
|
|
|
|
* by the corresponding values.
|
|
|
|
*
|
|
|
|
* Variable names matched to Marlin, c-version, and avoid the
|
|
|
|
* use of any vector library.
|
|
|
|
*
|
|
|
|
* by Andreas Hardtung 2016-06-07
|
|
|
|
* based on a Java function from "Delta Robot Kinematics V3"
|
|
|
|
* by Steve Graves
|
|
|
|
*
|
|
|
|
* The result is stored in the cartes[] array.
|
|
|
|
*/
|
2016-07-21 22:46:22 +00:00
|
|
|
void forward_kinematics_DELTA(float z1, float z2, float z3) {
|
2016-09-13 07:11:45 +00:00
|
|
|
// Create a vector in old coordinates along x axis of new coordinate
|
2016-06-06 23:44:14 +00:00
|
|
|
float p12[3] = { delta_tower2_x - delta_tower1_x, delta_tower2_y - delta_tower1_y, z2 - z1 };
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Get the Magnitude of vector.
|
|
|
|
float d = sqrt( sq(p12[0]) + sq(p12[1]) + sq(p12[2]) );
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Create unit vector by dividing by magnitude.
|
|
|
|
float ex[3] = { p12[0] / d, p12[1] / d, p12[2] / d };
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Get the vector from the origin of the new system to the third point.
|
2016-06-06 23:44:14 +00:00
|
|
|
float p13[3] = { delta_tower3_x - delta_tower1_x, delta_tower3_y - delta_tower1_y, z3 - z1 };
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Use the dot product to find the component of this vector on the X axis.
|
|
|
|
float i = ex[0] * p13[0] + ex[1] * p13[1] + ex[2] * p13[2];
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Create a vector along the x axis that represents the x component of p13.
|
|
|
|
float iex[3] = { ex[0] * i, ex[1] * i, ex[2] * i };
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Subtract the X component from the original vector leaving only Y. We use the
|
|
|
|
// variable that will be the unit vector after we scale it.
|
|
|
|
float ey[3] = { p13[0] - iex[0], p13[1] - iex[1], p13[2] - iex[2] };
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// The magnitude of Y component
|
|
|
|
float j = sqrt( sq(ey[0]) + sq(ey[1]) + sq(ey[2]) );
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Convert to a unit vector
|
2016-06-06 23:44:14 +00:00
|
|
|
ey[0] /= j; ey[1] /= j; ey[2] /= j;
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// The cross product of the unit x and y is the unit z
|
|
|
|
// float[] ez = vectorCrossProd(ex, ey);
|
|
|
|
float ez[3] = {
|
|
|
|
ex[1] * ey[2] - ex[2] * ey[1],
|
|
|
|
ex[2] * ey[0] - ex[0] * ey[2],
|
|
|
|
ex[0] * ey[1] - ex[1] * ey[0]
|
|
|
|
};
|
|
|
|
|
|
|
|
// We now have the d, i and j values defined in Wikipedia.
|
|
|
|
// Plug them into the equations defined in Wikipedia for Xnew, Ynew and Znew
|
|
|
|
float Xnew = (delta_diagonal_rod_2_tower_1 - delta_diagonal_rod_2_tower_2 + sq(d)) / (d * 2),
|
|
|
|
Ynew = ((delta_diagonal_rod_2_tower_1 - delta_diagonal_rod_2_tower_3 + HYPOT2(i, j)) / 2 - i * Xnew) / j,
|
|
|
|
Znew = sqrt(delta_diagonal_rod_2_tower_1 - HYPOT2(Xnew, Ynew));
|
|
|
|
|
|
|
|
// Start from the origin of the old coordinates and add vectors in the
|
|
|
|
// old coords that represent the Xnew, Ynew and Znew to find the point
|
|
|
|
// in the old system.
|
|
|
|
cartes[X_AXIS] = delta_tower1_x + ex[0] * Xnew + ey[0] * Ynew - ez[0] * Znew;
|
|
|
|
cartes[Y_AXIS] = delta_tower1_y + ex[1] * Xnew + ey[1] * Ynew - ez[1] * Znew;
|
|
|
|
cartes[Z_AXIS] = z1 + ex[2] * Xnew + ey[2] * Ynew - ez[2] * Znew;
|
2016-10-13 15:51:44 +00:00
|
|
|
}
|
2016-06-06 23:44:14 +00:00
|
|
|
|
2016-08-21 03:38:32 +00:00
|
|
|
void forward_kinematics_DELTA(float point[ABC]) {
|
|
|
|
forward_kinematics_DELTA(point[A_AXIS], point[B_AXIS], point[C_AXIS]);
|
2016-07-21 16:05:48 +00:00
|
|
|
}
|
|
|
|
|
2015-04-01 02:58:03 +00:00
|
|
|
#endif // DELTA
|
2012-12-10 09:04:12 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Get the stepper positions in the cartes[] array.
|
|
|
|
* Forward kinematics are applied for DELTA and SCARA.
|
|
|
|
*
|
|
|
|
* The result is in the current coordinate space with
|
|
|
|
* leveling applied. The coordinates need to be run through
|
|
|
|
* unapply_leveling to obtain the "ideal" coordinates
|
|
|
|
* suitable for current_position, etc.
|
|
|
|
*/
|
|
|
|
void get_cartesian_from_steppers() {
|
|
|
|
#if ENABLED(DELTA)
|
|
|
|
forward_kinematics_DELTA(
|
|
|
|
stepper.get_axis_position_mm(A_AXIS),
|
|
|
|
stepper.get_axis_position_mm(B_AXIS),
|
|
|
|
stepper.get_axis_position_mm(C_AXIS)
|
|
|
|
);
|
2016-09-15 20:07:14 +00:00
|
|
|
cartes[X_AXIS] += LOGICAL_X_POSITION(0);
|
|
|
|
cartes[Y_AXIS] += LOGICAL_Y_POSITION(0);
|
|
|
|
cartes[Z_AXIS] += LOGICAL_Z_POSITION(0);
|
2016-09-13 07:11:45 +00:00
|
|
|
#elif IS_SCARA
|
|
|
|
forward_kinematics_SCARA(
|
|
|
|
stepper.get_axis_position_degrees(A_AXIS),
|
|
|
|
stepper.get_axis_position_degrees(B_AXIS)
|
|
|
|
);
|
2016-09-15 20:07:14 +00:00
|
|
|
cartes[X_AXIS] += LOGICAL_X_POSITION(0);
|
|
|
|
cartes[Y_AXIS] += LOGICAL_Y_POSITION(0);
|
2016-09-13 07:11:45 +00:00
|
|
|
cartes[Z_AXIS] = stepper.get_axis_position_mm(Z_AXIS);
|
|
|
|
#else
|
|
|
|
cartes[X_AXIS] = stepper.get_axis_position_mm(X_AXIS);
|
|
|
|
cartes[Y_AXIS] = stepper.get_axis_position_mm(Y_AXIS);
|
|
|
|
cartes[Z_AXIS] = stepper.get_axis_position_mm(Z_AXIS);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the current_position for an axis based on
|
|
|
|
* the stepper positions, removing any leveling that
|
|
|
|
* may have been applied.
|
|
|
|
*/
|
2016-09-15 04:50:17 +00:00
|
|
|
void set_current_from_steppers_for_axis(const AxisEnum axis) {
|
2016-09-15 20:02:36 +00:00
|
|
|
get_cartesian_from_steppers();
|
|
|
|
#if PLANNER_LEVELING
|
2016-09-23 08:01:27 +00:00
|
|
|
planner.unapply_leveling(cartes);
|
2016-07-21 21:35:48 +00:00
|
|
|
#endif
|
2016-09-15 20:02:36 +00:00
|
|
|
if (axis == ALL_AXES)
|
|
|
|
memcpy(current_position, cartes, sizeof(cartes));
|
|
|
|
else
|
|
|
|
current_position[axis] = cartes[axis];
|
2016-07-21 21:35:48 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
2015-04-01 02:58:03 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Prepare a mesh-leveled linear move in a Cartesian setup,
|
|
|
|
* splitting the move where it crosses mesh borders.
|
|
|
|
*/
|
|
|
|
void mesh_line_to_destination(float fr_mm_s, uint8_t x_splits = 0xff, uint8_t y_splits = 0xff) {
|
|
|
|
int cx1 = mbl.cell_index_x(RAW_CURRENT_POSITION(X_AXIS)),
|
|
|
|
cy1 = mbl.cell_index_y(RAW_CURRENT_POSITION(Y_AXIS)),
|
|
|
|
cx2 = mbl.cell_index_x(RAW_X_POSITION(destination[X_AXIS])),
|
|
|
|
cy2 = mbl.cell_index_y(RAW_Y_POSITION(destination[Y_AXIS]));
|
|
|
|
NOMORE(cx1, MESH_NUM_X_POINTS - 2);
|
|
|
|
NOMORE(cy1, MESH_NUM_Y_POINTS - 2);
|
|
|
|
NOMORE(cx2, MESH_NUM_X_POINTS - 2);
|
|
|
|
NOMORE(cy2, MESH_NUM_Y_POINTS - 2);
|
|
|
|
|
|
|
|
if (cx1 == cx2 && cy1 == cy2) {
|
|
|
|
// Start and end on same mesh square
|
|
|
|
line_to_destination(fr_mm_s);
|
|
|
|
set_current_to_destination();
|
|
|
|
return;
|
|
|
|
}
|
2016-07-17 02:08:54 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#define MBL_SEGMENT_END(A) (current_position[A ##_AXIS] + (destination[A ##_AXIS] - current_position[A ##_AXIS]) * normalized_dist)
|
2016-07-17 02:20:16 +00:00
|
|
|
|
2016-11-03 09:43:59 +00:00
|
|
|
float normalized_dist, end[XYZE];
|
2016-07-17 19:21:28 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Split at the left/front border of the right/top square
|
|
|
|
int8_t gcx = max(cx1, cx2), gcy = max(cy1, cy2);
|
|
|
|
if (cx2 != cx1 && TEST(x_splits, gcx)) {
|
|
|
|
memcpy(end, destination, sizeof(end));
|
|
|
|
destination[X_AXIS] = LOGICAL_X_POSITION(mbl.get_probe_x(gcx));
|
|
|
|
normalized_dist = (destination[X_AXIS] - current_position[X_AXIS]) / (end[X_AXIS] - current_position[X_AXIS]);
|
|
|
|
destination[Y_AXIS] = MBL_SEGMENT_END(Y);
|
|
|
|
CBI(x_splits, gcx);
|
|
|
|
}
|
|
|
|
else if (cy2 != cy1 && TEST(y_splits, gcy)) {
|
|
|
|
memcpy(end, destination, sizeof(end));
|
|
|
|
destination[Y_AXIS] = LOGICAL_Y_POSITION(mbl.get_probe_y(gcy));
|
|
|
|
normalized_dist = (destination[Y_AXIS] - current_position[Y_AXIS]) / (end[Y_AXIS] - current_position[Y_AXIS]);
|
|
|
|
destination[X_AXIS] = MBL_SEGMENT_END(X);
|
|
|
|
CBI(y_splits, gcy);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Already split on a border
|
|
|
|
line_to_destination(fr_mm_s);
|
|
|
|
set_current_to_destination();
|
|
|
|
return;
|
|
|
|
}
|
2016-07-17 02:16:12 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
destination[Z_AXIS] = MBL_SEGMENT_END(Z);
|
|
|
|
destination[E_AXIS] = MBL_SEGMENT_END(E);
|
2016-07-17 02:28:13 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
// Do the split and look for more borders
|
|
|
|
mesh_line_to_destination(fr_mm_s, x_splits, y_splits);
|
|
|
|
|
|
|
|
// Restore destination from stack
|
|
|
|
memcpy(destination, end, sizeof(end));
|
|
|
|
mesh_line_to_destination(fr_mm_s, x_splits, y_splits);
|
|
|
|
}
|
2016-07-17 02:28:13 +00:00
|
|
|
|
2016-11-03 19:09:51 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR) && !IS_KINEMATIC
|
2016-11-01 12:19:00 +00:00
|
|
|
|
2016-11-05 16:01:26 +00:00
|
|
|
#define CELL_INDEX(A,V) ((RAW_##A##_POSITION(V) - bilinear_start[A##_AXIS]) / ABL_BG_SPACING(A##_AXIS))
|
2016-11-03 09:43:59 +00:00
|
|
|
|
2016-11-01 12:19:00 +00:00
|
|
|
/**
|
2016-11-03 09:43:59 +00:00
|
|
|
* Prepare a bilinear-leveled linear move on Cartesian,
|
|
|
|
* splitting the move where it crosses grid borders.
|
2016-11-01 12:19:00 +00:00
|
|
|
*/
|
2016-11-03 09:43:59 +00:00
|
|
|
void bilinear_line_to_destination(float fr_mm_s, uint16_t x_splits = 0xFFFF, uint16_t y_splits = 0xFFFF) {
|
|
|
|
int cx1 = CELL_INDEX(X, current_position[X_AXIS]),
|
|
|
|
cy1 = CELL_INDEX(Y, current_position[Y_AXIS]),
|
|
|
|
cx2 = CELL_INDEX(X, destination[X_AXIS]),
|
|
|
|
cy2 = CELL_INDEX(Y, destination[Y_AXIS]);
|
2016-11-05 16:01:26 +00:00
|
|
|
cx1 = constrain(cx1, 0, ABL_BG_POINTS_X - 2);
|
|
|
|
cy1 = constrain(cy1, 0, ABL_BG_POINTS_Y - 2);
|
|
|
|
cx2 = constrain(cx2, 0, ABL_BG_POINTS_X - 2);
|
|
|
|
cy2 = constrain(cy2, 0, ABL_BG_POINTS_Y - 2);
|
2016-11-01 12:19:00 +00:00
|
|
|
|
|
|
|
if (cx1 == cx2 && cy1 == cy2) {
|
|
|
|
// Start and end on same mesh square
|
|
|
|
line_to_destination(fr_mm_s);
|
|
|
|
set_current_to_destination();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LINE_SEGMENT_END(A) (current_position[A ##_AXIS] + (destination[A ##_AXIS] - current_position[A ##_AXIS]) * normalized_dist)
|
|
|
|
|
2016-11-03 09:43:59 +00:00
|
|
|
float normalized_dist, end[XYZE];
|
2016-11-01 12:19:00 +00:00
|
|
|
|
|
|
|
// Split at the left/front border of the right/top square
|
|
|
|
int8_t gcx = max(cx1, cx2), gcy = max(cy1, cy2);
|
|
|
|
if (cx2 != cx1 && TEST(x_splits, gcx)) {
|
|
|
|
memcpy(end, destination, sizeof(end));
|
2016-11-05 16:01:26 +00:00
|
|
|
destination[X_AXIS] = LOGICAL_X_POSITION(bilinear_start[X_AXIS] + ABL_BG_SPACING(X_AXIS) * gcx);
|
2016-11-01 12:19:00 +00:00
|
|
|
normalized_dist = (destination[X_AXIS] - current_position[X_AXIS]) / (end[X_AXIS] - current_position[X_AXIS]);
|
|
|
|
destination[Y_AXIS] = LINE_SEGMENT_END(Y);
|
|
|
|
CBI(x_splits, gcx);
|
|
|
|
}
|
|
|
|
else if (cy2 != cy1 && TEST(y_splits, gcy)) {
|
|
|
|
memcpy(end, destination, sizeof(end));
|
2016-11-05 16:01:26 +00:00
|
|
|
destination[Y_AXIS] = LOGICAL_Y_POSITION(bilinear_start[Y_AXIS] + ABL_BG_SPACING(Y_AXIS) * gcy);
|
2016-11-01 12:19:00 +00:00
|
|
|
normalized_dist = (destination[Y_AXIS] - current_position[Y_AXIS]) / (end[Y_AXIS] - current_position[Y_AXIS]);
|
|
|
|
destination[X_AXIS] = LINE_SEGMENT_END(X);
|
|
|
|
CBI(y_splits, gcy);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Already split on a border
|
|
|
|
line_to_destination(fr_mm_s);
|
|
|
|
set_current_to_destination();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
destination[Z_AXIS] = LINE_SEGMENT_END(Z);
|
|
|
|
destination[E_AXIS] = LINE_SEGMENT_END(E);
|
|
|
|
|
|
|
|
// Do the split and look for more borders
|
|
|
|
bilinear_line_to_destination(fr_mm_s, x_splits, y_splits);
|
|
|
|
|
|
|
|
// Restore destination from stack
|
|
|
|
memcpy(destination, end, sizeof(end));
|
|
|
|
bilinear_line_to_destination(fr_mm_s, x_splits, y_splits);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // AUTO_BED_LEVELING_BILINEAR
|
2015-03-15 09:43:26 +00:00
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_KINEMATIC
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Prepare a linear move in a DELTA or SCARA setup.
|
|
|
|
*
|
|
|
|
* This calls planner.buffer_line several times, adding
|
|
|
|
* small incremental moves for DELTA or SCARA.
|
|
|
|
*/
|
2016-09-23 06:46:52 +00:00
|
|
|
inline bool prepare_kinematic_move_to(float ltarget[NUM_AXIS]) {
|
2016-09-15 20:38:48 +00:00
|
|
|
|
|
|
|
// Get the top feedrate of the move in the XY plane
|
|
|
|
float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s);
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// If the move is only in Z/E don't split up the move
|
|
|
|
if (ltarget[X_AXIS] == current_position[X_AXIS] && ltarget[Y_AXIS] == current_position[Y_AXIS]) {
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.buffer_line_kinematic(ltarget, _feedrate_mm_s, active_extruder);
|
2016-09-15 20:38:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Get the cartesian distances moved in XYZE
|
2015-03-30 06:16:12 +00:00
|
|
|
float difference[NUM_AXIS];
|
2016-09-23 06:46:52 +00:00
|
|
|
LOOP_XYZE(i) difference[i] = ltarget[i] - current_position[i];
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Get the linear distance in XYZ
|
2015-04-09 08:40:48 +00:00
|
|
|
float cartesian_mm = sqrt(sq(difference[X_AXIS]) + sq(difference[Y_AXIS]) + sq(difference[Z_AXIS]));
|
2016-09-23 06:46:52 +00:00
|
|
|
|
|
|
|
// If the move is very short, check the E move distance
|
2016-08-21 08:10:55 +00:00
|
|
|
if (UNEAR_ZERO(cartesian_mm)) cartesian_mm = abs(difference[E_AXIS]);
|
2016-09-23 06:46:52 +00:00
|
|
|
|
|
|
|
// No E move either? Game over.
|
2016-08-21 08:10:55 +00:00
|
|
|
if (UNEAR_ZERO(cartesian_mm)) return false;
|
2016-09-15 20:38:48 +00:00
|
|
|
|
|
|
|
// Minimum number of seconds to move the given distance
|
2016-07-16 01:49:34 +00:00
|
|
|
float seconds = cartesian_mm / _feedrate_mm_s;
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-15 20:38:48 +00:00
|
|
|
// The number of segments-per-second times the duration
|
2016-09-23 06:46:52 +00:00
|
|
|
// gives the number of segments
|
2016-09-15 20:38:48 +00:00
|
|
|
uint16_t segments = delta_segments_per_second * seconds;
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// For SCARA minimum segment size is 0.5mm
|
2016-09-15 20:38:48 +00:00
|
|
|
#if IS_SCARA
|
|
|
|
NOMORE(segments, cartesian_mm * 2);
|
|
|
|
#endif
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// At least one segment is required
|
2016-09-15 20:38:48 +00:00
|
|
|
NOLESS(segments, 1);
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// The approximate length of each segment
|
|
|
|
float segment_distance[XYZE] = {
|
|
|
|
difference[X_AXIS] / segments,
|
|
|
|
difference[Y_AXIS] / segments,
|
|
|
|
difference[Z_AXIS] / segments,
|
|
|
|
difference[E_AXIS] / segments
|
2016-09-15 20:38:48 +00:00
|
|
|
};
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-12 22:49:35 +00:00
|
|
|
// SERIAL_ECHOPAIR("mm=", cartesian_mm);
|
|
|
|
// SERIAL_ECHOPAIR(" seconds=", seconds);
|
2016-09-15 20:38:48 +00:00
|
|
|
// SERIAL_ECHOLNPAIR(" segments=", segments);
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Drop one segment so the last move is to the exact target.
|
|
|
|
// If there's only 1 segment, loops will be skipped entirely.
|
|
|
|
--segments;
|
|
|
|
|
|
|
|
// Using "raw" coordinates saves 6 float subtractions
|
|
|
|
// per segment, saving valuable CPU cycles
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-21 22:43:06 +00:00
|
|
|
#if ENABLED(USE_RAW_KINEMATICS)
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
// Get the raw current position as starting point
|
2016-09-23 06:46:52 +00:00
|
|
|
float raw[XYZE] = {
|
2016-09-16 18:07:43 +00:00
|
|
|
RAW_CURRENT_POSITION(X_AXIS),
|
|
|
|
RAW_CURRENT_POSITION(Y_AXIS),
|
2016-09-23 06:46:52 +00:00
|
|
|
RAW_CURRENT_POSITION(Z_AXIS),
|
|
|
|
current_position[E_AXIS]
|
2016-09-16 18:07:43 +00:00
|
|
|
};
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
#define DELTA_VAR raw
|
2016-09-21 22:43:06 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Delta can inline its kinematics
|
2016-09-21 22:43:06 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
#define DELTA_IK() DELTA_RAW_IK()
|
|
|
|
#else
|
|
|
|
#define DELTA_IK() inverse_kinematics(raw)
|
|
|
|
#endif
|
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
#else
|
|
|
|
|
2016-09-21 22:43:06 +00:00
|
|
|
// Get the logical current position as starting point
|
2016-09-23 06:46:52 +00:00
|
|
|
float logical[XYZE];
|
|
|
|
memcpy(logical, current_position, sizeof(logical));
|
2016-09-21 22:43:06 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
#define DELTA_VAR logical
|
2016-09-16 18:07:43 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Delta can inline its kinematics
|
2016-09-16 18:07:43 +00:00
|
|
|
#if ENABLED(DELTA)
|
|
|
|
#define DELTA_IK() DELTA_LOGICAL_IK()
|
|
|
|
#else
|
|
|
|
#define DELTA_IK() inverse_kinematics(logical)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(USE_DELTA_IK_INTERPOLATION)
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Only interpolate XYZ. Advance E normally.
|
|
|
|
#define DELTA_NEXT(ADDEND) LOOP_XYZ(i) DELTA_VAR[i] += ADDEND;
|
|
|
|
|
|
|
|
// Get the starting delta if interpolation is possible
|
2016-10-09 20:19:39 +00:00
|
|
|
if (segments >= 2) {
|
|
|
|
DELTA_IK();
|
|
|
|
ADJUST_DELTA(DELTA_VAR); // Adjust Z if bed leveling is enabled
|
|
|
|
}
|
2016-09-16 18:07:43 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Loop using decrement
|
2016-09-16 18:07:43 +00:00
|
|
|
for (uint16_t s = segments + 1; --s;) {
|
2016-09-23 06:46:52 +00:00
|
|
|
// Are there at least 2 moves left?
|
|
|
|
if (s >= 2) {
|
2016-09-16 18:07:43 +00:00
|
|
|
// Save the previous delta for interpolation
|
|
|
|
float prev_delta[ABC] = { delta[A_AXIS], delta[B_AXIS], delta[C_AXIS] };
|
|
|
|
|
|
|
|
// Get the delta 2 segments ahead (rather than the next)
|
|
|
|
DELTA_NEXT(segment_distance[i] + segment_distance[i]);
|
2016-09-23 06:46:52 +00:00
|
|
|
|
|
|
|
// Advance E normally
|
|
|
|
DELTA_VAR[E_AXIS] += segment_distance[E_AXIS];
|
|
|
|
|
|
|
|
// Get the exact delta for the move after this
|
2016-09-16 18:07:43 +00:00
|
|
|
DELTA_IK();
|
2016-10-09 20:19:39 +00:00
|
|
|
ADJUST_DELTA(DELTA_VAR); // Adjust Z if bed leveling is enabled
|
2016-09-16 18:07:43 +00:00
|
|
|
|
|
|
|
// Move to the interpolated delta position first
|
|
|
|
planner.buffer_line(
|
|
|
|
(prev_delta[A_AXIS] + delta[A_AXIS]) * 0.5,
|
|
|
|
(prev_delta[B_AXIS] + delta[B_AXIS]) * 0.5,
|
|
|
|
(prev_delta[C_AXIS] + delta[C_AXIS]) * 0.5,
|
2016-09-23 06:46:52 +00:00
|
|
|
DELTA_VAR[E_AXIS], _feedrate_mm_s, active_extruder
|
2016-09-16 18:07:43 +00:00
|
|
|
);
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Advance E once more for the next move
|
|
|
|
DELTA_VAR[E_AXIS] += segment_distance[E_AXIS];
|
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
// Do an extra decrement of the loop
|
|
|
|
--s;
|
|
|
|
}
|
|
|
|
else {
|
2016-09-23 06:46:52 +00:00
|
|
|
// Get the last segment delta. (Used when segments is odd)
|
|
|
|
DELTA_NEXT(segment_distance[i]);
|
|
|
|
DELTA_VAR[E_AXIS] += segment_distance[E_AXIS];
|
2016-09-16 18:07:43 +00:00
|
|
|
DELTA_IK();
|
2016-10-09 20:19:39 +00:00
|
|
|
ADJUST_DELTA(DELTA_VAR); // Adjust Z if bed leveling is enabled
|
2016-09-16 18:07:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Move to the non-interpolated position
|
2016-09-23 06:46:52 +00:00
|
|
|
planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], DELTA_VAR[E_AXIS], _feedrate_mm_s, active_extruder);
|
2016-09-16 18:07:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
#define DELTA_NEXT(ADDEND) LOOP_XYZE(i) DELTA_VAR[i] += ADDEND;
|
|
|
|
|
2016-09-16 18:07:43 +00:00
|
|
|
// For non-interpolated delta calculate every segment
|
|
|
|
for (uint16_t s = segments + 1; --s;) {
|
2016-09-23 06:46:52 +00:00
|
|
|
DELTA_NEXT(segment_distance[i]);
|
2016-10-10 22:07:31 +00:00
|
|
|
planner.buffer_line_kinematic(DELTA_VAR, _feedrate_mm_s, active_extruder);
|
2016-09-16 18:07:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-23 06:46:52 +00:00
|
|
|
// Since segment_distance is only approximate,
|
|
|
|
// the final move must be to the exact destination.
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.buffer_line_kinematic(ltarget, _feedrate_mm_s, active_extruder);
|
2015-05-12 09:08:20 +00:00
|
|
|
return true;
|
|
|
|
}
|
2015-03-30 06:16:12 +00:00
|
|
|
|
2016-11-03 19:09:51 +00:00
|
|
|
#else // !IS_KINEMATIC
|
2016-09-13 07:11:45 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Prepare a linear move in a Cartesian setup.
|
|
|
|
* If Mesh Bed Leveling is enabled, perform a mesh move.
|
|
|
|
*/
|
|
|
|
inline bool prepare_move_to_destination_cartesian() {
|
|
|
|
// Do not use feedrate_percentage for E or Z only moves
|
|
|
|
if (current_position[X_AXIS] == destination[X_AXIS] && current_position[Y_AXIS] == destination[Y_AXIS]) {
|
|
|
|
line_to_destination();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if ENABLED(MESH_BED_LEVELING)
|
|
|
|
if (mbl.active()) {
|
|
|
|
mesh_line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
2016-11-01 12:19:00 +00:00
|
|
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
|
|
|
if (planner.abl_enabled) {
|
|
|
|
bilinear_line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
2016-09-13 07:11:45 +00:00
|
|
|
#endif
|
|
|
|
line_to_destination(MMS_SCALED(feedrate_mm_s));
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // !IS_KINEMATIC
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2015-05-12 09:08:20 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Prepare a linear move in a dual X axis setup
|
|
|
|
*/
|
2016-06-30 22:37:32 +00:00
|
|
|
inline bool prepare_move_to_destination_dualx() {
|
2015-04-04 06:42:50 +00:00
|
|
|
if (active_extruder_parked) {
|
2016-11-03 02:38:26 +00:00
|
|
|
switch (dual_x_carriage_mode) {
|
|
|
|
case DXC_FULL_CONTROL_MODE:
|
|
|
|
break;
|
|
|
|
case DXC_AUTO_PARK_MODE:
|
|
|
|
if (current_position[E_AXIS] == destination[E_AXIS]) {
|
|
|
|
// This is a travel move (with no extrusion)
|
|
|
|
// Skip it, but keep track of the current position
|
|
|
|
// (so it can be used as the start of the next non-travel move)
|
|
|
|
if (delayed_move_time != 0xFFFFFFFFUL) {
|
|
|
|
set_current_to_destination();
|
|
|
|
NOLESS(raised_parked_position[Z_AXIS], destination[Z_AXIS]);
|
|
|
|
delayed_move_time = millis();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// unpark extruder: 1) raise, 2) move into starting XY position, 3) lower
|
2016-11-07 06:33:12 +00:00
|
|
|
for (uint8_t i = 0; i < 3; i++)
|
|
|
|
planner.buffer_line(
|
|
|
|
i == 0 ? raised_parked_position[X_AXIS] : current_position[X_AXIS],
|
|
|
|
i == 0 ? raised_parked_position[Y_AXIS] : current_position[Y_AXIS],
|
|
|
|
i == 2 ? current_position[Z_AXIS] : raised_parked_position[Z_AXIS],
|
|
|
|
current_position[E_AXIS],
|
|
|
|
i == 1 ? PLANNER_XY_FEEDRATE() : planner.max_feedrate_mm_s[Z_AXIS],
|
|
|
|
active_extruder
|
|
|
|
);
|
|
|
|
delayed_move_time = 0;
|
2016-11-03 02:38:26 +00:00
|
|
|
active_extruder_parked = false;
|
|
|
|
break;
|
2016-11-07 06:18:44 +00:00
|
|
|
case DXC_DUPLICATION_MODE:
|
|
|
|
if (active_extruder == 0) {
|
|
|
|
// move duplicate extruder into correct duplication position.
|
|
|
|
planner.set_position_mm(
|
|
|
|
LOGICAL_X_POSITION(inactive_extruder_x_pos),
|
|
|
|
current_position[Y_AXIS],
|
|
|
|
current_position[Z_AXIS],
|
|
|
|
current_position[E_AXIS]
|
|
|
|
);
|
2016-11-07 06:21:45 +00:00
|
|
|
planner.buffer_line(
|
|
|
|
current_position[X_AXIS] + duplicate_extruder_x_offset,
|
|
|
|
current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS],
|
|
|
|
planner.max_feedrate_mm_s[X_AXIS], 1
|
|
|
|
);
|
2016-11-07 06:18:44 +00:00
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
stepper.synchronize();
|
|
|
|
extruder_duplication_enabled = true;
|
|
|
|
active_extruder_parked = false;
|
|
|
|
}
|
|
|
|
break;
|
2013-08-07 14:10:26 +00:00
|
|
|
}
|
|
|
|
}
|
2015-05-12 09:08:20 +00:00
|
|
|
return true;
|
|
|
|
}
|
2013-08-07 14:10:26 +00:00
|
|
|
|
2015-05-12 09:08:20 +00:00
|
|
|
#endif // DUAL_X_CARRIAGE
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Prepare a single move and get ready for the next one
|
2015-06-28 04:49:37 +00:00
|
|
|
*
|
2016-09-13 07:11:45 +00:00
|
|
|
* This may result in several calls to planner.buffer_line to
|
|
|
|
* do smaller moves for DELTA, SCARA, mesh moves, etc.
|
2015-05-12 09:08:20 +00:00
|
|
|
*/
|
2016-06-11 02:23:41 +00:00
|
|
|
void prepare_move_to_destination() {
|
2015-05-12 09:08:20 +00:00
|
|
|
clamp_to_software_endstops(destination);
|
|
|
|
refresh_cmd_timeout();
|
|
|
|
|
2016-08-21 04:34:24 +00:00
|
|
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
2016-09-13 07:11:45 +00:00
|
|
|
|
|
|
|
if (!DEBUGGING(DRYRUN)) {
|
|
|
|
if (destination[E_AXIS] != current_position[E_AXIS]) {
|
|
|
|
if (thermalManager.tooColdToExtrude(active_extruder)) {
|
|
|
|
current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
|
|
|
|
}
|
|
|
|
#if ENABLED(PREVENT_LENGTHY_EXTRUDE)
|
|
|
|
if (labs(destination[E_AXIS] - current_position[E_AXIS]) > EXTRUDE_MAXLENGTH) {
|
|
|
|
current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-12 09:08:20 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-12 01:11:30 +00:00
|
|
|
#if IS_KINEMATIC
|
2016-07-21 22:46:22 +00:00
|
|
|
if (!prepare_kinematic_move_to(destination)) return;
|
2016-04-26 03:02:24 +00:00
|
|
|
#else
|
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2016-06-30 22:37:32 +00:00
|
|
|
if (!prepare_move_to_destination_dualx()) return;
|
2016-04-26 03:02:24 +00:00
|
|
|
#endif
|
2016-06-30 22:37:32 +00:00
|
|
|
if (!prepare_move_to_destination_cartesian()) return;
|
2015-05-12 09:08:20 +00:00
|
|
|
#endif
|
2014-06-23 15:09:57 +00:00
|
|
|
|
2015-04-04 06:42:50 +00:00
|
|
|
set_current_to_destination();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
#if ENABLED(ARC_SUPPORT)
|
2016-03-27 03:36:36 +00:00
|
|
|
/**
|
2016-05-13 11:27:45 +00:00
|
|
|
* Plan an arc in 2 dimensions
|
2016-03-27 03:36:36 +00:00
|
|
|
*
|
2016-05-13 11:27:45 +00:00
|
|
|
* The arc is approximated by generating many small linear segments.
|
|
|
|
* The length of each segment is configured in MM_PER_ARC_SEGMENT (Default 1mm)
|
|
|
|
* Arcs should only be made relatively large (over 5mm), as larger arcs with
|
|
|
|
* larger segments will tend to be more efficient. Your slicer should have
|
|
|
|
* options for G2/G3 arc generation. In future these options may be GCode tunable.
|
2016-03-27 03:36:36 +00:00
|
|
|
*/
|
2016-05-13 11:27:45 +00:00
|
|
|
void plan_arc(
|
2016-09-15 07:31:36 +00:00
|
|
|
float logical[NUM_AXIS], // Destination position
|
|
|
|
float* offset, // Center of rotation relative to current_position
|
|
|
|
uint8_t clockwise // Clockwise?
|
2016-05-13 11:27:45 +00:00
|
|
|
) {
|
|
|
|
|
2016-07-16 01:55:09 +00:00
|
|
|
float radius = HYPOT(offset[X_AXIS], offset[Y_AXIS]),
|
2016-05-13 11:27:45 +00:00
|
|
|
center_X = current_position[X_AXIS] + offset[X_AXIS],
|
|
|
|
center_Y = current_position[Y_AXIS] + offset[Y_AXIS],
|
2016-09-15 07:31:36 +00:00
|
|
|
linear_travel = logical[Z_AXIS] - current_position[Z_AXIS],
|
|
|
|
extruder_travel = logical[E_AXIS] - current_position[E_AXIS],
|
2016-05-13 11:27:45 +00:00
|
|
|
r_X = -offset[X_AXIS], // Radius vector from center to current location
|
|
|
|
r_Y = -offset[Y_AXIS],
|
2016-09-15 07:31:36 +00:00
|
|
|
rt_X = logical[X_AXIS] - center_X,
|
|
|
|
rt_Y = logical[Y_AXIS] - center_Y;
|
2016-05-13 11:27:45 +00:00
|
|
|
|
|
|
|
// CCW angle of rotation between position and target from the circle center. Only one atan2() trig computation required.
|
|
|
|
float angular_travel = atan2(r_X * rt_Y - r_Y * rt_X, r_X * rt_X + r_Y * rt_Y);
|
|
|
|
if (angular_travel < 0) angular_travel += RADIANS(360);
|
|
|
|
if (clockwise) angular_travel -= RADIANS(360);
|
|
|
|
|
|
|
|
// Make a circle if the angular rotation is 0
|
2016-09-15 07:31:36 +00:00
|
|
|
if (angular_travel == 0 && current_position[X_AXIS] == logical[X_AXIS] && current_position[Y_AXIS] == logical[Y_AXIS])
|
2016-05-13 11:27:45 +00:00
|
|
|
angular_travel += RADIANS(360);
|
|
|
|
|
2016-07-16 01:55:09 +00:00
|
|
|
float mm_of_travel = HYPOT(angular_travel * radius, fabs(linear_travel));
|
2016-05-13 11:27:45 +00:00
|
|
|
if (mm_of_travel < 0.001) return;
|
2016-10-05 02:31:50 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
uint16_t segments = floor(mm_of_travel / (MM_PER_ARC_SEGMENT));
|
|
|
|
if (segments == 0) segments = 1;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Vector rotation by transformation matrix: r is the original vector, r_T is the rotated vector,
|
|
|
|
* and phi is the angle of rotation. Based on the solution approach by Jens Geisler.
|
|
|
|
* r_T = [cos(phi) -sin(phi);
|
2016-10-05 02:32:37 +00:00
|
|
|
* sin(phi) cos(phi)] * r ;
|
2016-05-13 11:27:45 +00:00
|
|
|
*
|
|
|
|
* For arc generation, the center of the circle is the axis of rotation and the radius vector is
|
|
|
|
* defined from the circle center to the initial position. Each line segment is formed by successive
|
|
|
|
* vector rotations. This requires only two cos() and sin() computations to form the rotation
|
|
|
|
* matrix for the duration of the entire arc. Error may accumulate from numerical round-off, since
|
|
|
|
* all double numbers are single precision on the Arduino. (True double precision will not have
|
|
|
|
* round off issues for CNC applications.) Single precision error can accumulate to be greater than
|
|
|
|
* tool precision in some cases. Therefore, arc path correction is implemented.
|
|
|
|
*
|
|
|
|
* Small angle approximation may be used to reduce computation overhead further. This approximation
|
|
|
|
* holds for everything, but very small circles and large MM_PER_ARC_SEGMENT values. In other words,
|
|
|
|
* theta_per_segment would need to be greater than 0.1 rad and N_ARC_CORRECTION would need to be large
|
|
|
|
* to cause an appreciable drift error. N_ARC_CORRECTION~=25 is more than small enough to correct for
|
|
|
|
* numerical drift error. N_ARC_CORRECTION may be on the order a hundred(s) before error becomes an
|
|
|
|
* issue for CNC machines with the single precision Arduino calculations.
|
|
|
|
*
|
|
|
|
* This approximation also allows plan_arc to immediately insert a line segment into the planner
|
|
|
|
* without the initial overhead of computing cos() or sin(). By the time the arc needs to be applied
|
|
|
|
* a correction, the planner should have caught up to the lag caused by the initial plan_arc overhead.
|
|
|
|
* This is important when there are successive arc motions.
|
|
|
|
*/
|
|
|
|
// Vector rotation matrix values
|
2016-10-05 02:32:37 +00:00
|
|
|
float arc_target[XYZE],
|
|
|
|
theta_per_segment = angular_travel / segments,
|
|
|
|
linear_per_segment = linear_travel / segments,
|
|
|
|
extruder_per_segment = extruder_travel / segments,
|
|
|
|
sin_T = theta_per_segment,
|
|
|
|
cos_T = 1 - 0.5 * sq(theta_per_segment); // Small angle approximation
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
// Initialize the linear axis
|
|
|
|
arc_target[Z_AXIS] = current_position[Z_AXIS];
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
// Initialize the extruder axis
|
|
|
|
arc_target[E_AXIS] = current_position[E_AXIS];
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-08-07 07:20:25 +00:00
|
|
|
float fr_mm_s = MMS_SCALED(feedrate_mm_s);
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-15 00:37:42 +00:00
|
|
|
millis_t next_idle_ms = millis() + 200UL;
|
2016-05-13 22:29:13 +00:00
|
|
|
|
2016-10-05 02:32:37 +00:00
|
|
|
int8_t count = 0;
|
|
|
|
for (uint16_t i = 1; i < segments; i++) { // Iterate (segments-1) times
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-19 18:52:11 +00:00
|
|
|
thermalManager.manage_heater();
|
2016-10-05 02:32:37 +00:00
|
|
|
if (ELAPSED(millis(), next_idle_ms)) {
|
|
|
|
next_idle_ms = millis() + 200UL;
|
2016-05-13 22:29:13 +00:00
|
|
|
idle();
|
|
|
|
}
|
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
if (++count < N_ARC_CORRECTION) {
|
|
|
|
// Apply vector rotation matrix to previous r_X / 1
|
2016-10-05 02:32:37 +00:00
|
|
|
float r_new_Y = r_X * sin_T + r_Y * cos_T;
|
2016-05-13 11:27:45 +00:00
|
|
|
r_X = r_X * cos_T - r_Y * sin_T;
|
|
|
|
r_Y = r_new_Y;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments.
|
|
|
|
// Compute exact location by applying transformation matrix from initial radius vector(=-offset).
|
|
|
|
// To reduce stuttering, the sin and cos could be computed at different times.
|
|
|
|
// For now, compute both at the same time.
|
2016-10-05 02:32:37 +00:00
|
|
|
float cos_Ti = cos(i * theta_per_segment),
|
|
|
|
sin_Ti = sin(i * theta_per_segment);
|
2016-05-13 11:27:45 +00:00
|
|
|
r_X = -offset[X_AXIS] * cos_Ti + offset[Y_AXIS] * sin_Ti;
|
|
|
|
r_Y = -offset[X_AXIS] * sin_Ti - offset[Y_AXIS] * cos_Ti;
|
|
|
|
count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update arc_target location
|
|
|
|
arc_target[X_AXIS] = center_X + r_X;
|
|
|
|
arc_target[Y_AXIS] = center_Y + r_Y;
|
|
|
|
arc_target[Z_AXIS] += linear_per_segment;
|
|
|
|
arc_target[E_AXIS] += extruder_per_segment;
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
clamp_to_software_endstops(arc_target);
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.buffer_line_kinematic(arc_target, fr_mm_s, active_extruder);
|
2016-05-13 11:27:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure last segment arrives at target location.
|
2016-10-06 08:56:05 +00:00
|
|
|
planner.buffer_line_kinematic(logical, fr_mm_s, active_extruder);
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-13 11:27:45 +00:00
|
|
|
// As far as the parser is concerned, the position is now == target. In reality the
|
|
|
|
// motion control system might still be processing the action and the real tool position
|
|
|
|
// in any intermediate location.
|
|
|
|
set_current_to_destination();
|
|
|
|
}
|
|
|
|
#endif
|
2015-07-19 17:49:02 +00:00
|
|
|
|
2016-05-12 20:33:47 +00:00
|
|
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
|
|
|
|
|
|
|
void plan_cubic_move(const float offset[4]) {
|
2016-08-07 07:20:25 +00:00
|
|
|
cubic_b_spline(current_position, destination, offset, MMS_SCALED(feedrate_mm_s), active_extruder);
|
2016-05-12 20:33:47 +00:00
|
|
|
|
2016-09-15 07:31:36 +00:00
|
|
|
// As far as the parser is concerned, the position is now == destination. In reality the
|
2016-05-12 20:33:47 +00:00
|
|
|
// motion control system might still be processing the action and the real tool position
|
|
|
|
// in any intermediate location.
|
|
|
|
set_current_to_destination();
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // BEZIER_CURVE_SUPPORT
|
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_CONTROLLERFAN
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-05-12 09:08:20 +00:00
|
|
|
void controllerFan() {
|
2016-03-21 01:48:31 +00:00
|
|
|
static millis_t lastMotorOn = 0; // Last time a motor was turned on
|
|
|
|
static millis_t nextMotorCheck = 0; // Last time the state was checked
|
2015-05-12 09:08:20 +00:00
|
|
|
millis_t ms = millis();
|
2016-04-10 22:55:12 +00:00
|
|
|
if (ELAPSED(ms, nextMotorCheck)) {
|
|
|
|
nextMotorCheck = ms + 2500UL; // Not a time critical function, so only check every 2.5s
|
2016-04-29 01:18:13 +00:00
|
|
|
if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON || thermalManager.soft_pwm_bed > 0
|
2015-10-03 06:08:58 +00:00
|
|
|
|| E0_ENABLE_READ == E_ENABLE_ON // If any of the drivers are enabled...
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 1
|
2015-10-03 06:08:58 +00:00
|
|
|
|| E1_ENABLE_READ == E_ENABLE_ON
|
|
|
|
#if HAS_X2_ENABLE
|
|
|
|
|| X2_ENABLE_READ == X_ENABLE_ON
|
|
|
|
#endif
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 2
|
2015-10-03 06:08:58 +00:00
|
|
|
|| E2_ENABLE_READ == E_ENABLE_ON
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 3
|
2015-10-03 06:08:58 +00:00
|
|
|
|| E3_ENABLE_READ == E_ENABLE_ON
|
|
|
|
#endif
|
2015-05-12 09:08:20 +00:00
|
|
|
#endif
|
2015-03-15 13:55:31 +00:00
|
|
|
#endif
|
2015-05-12 09:08:20 +00:00
|
|
|
) {
|
2016-03-21 01:48:31 +00:00
|
|
|
lastMotorOn = ms; //... set time to NOW so the fan will turn on
|
2015-05-12 09:08:20 +00:00
|
|
|
}
|
2016-03-21 01:48:31 +00:00
|
|
|
|
|
|
|
// Fan off if no steppers have been enabled for CONTROLLERFAN_SECS seconds
|
2016-04-10 22:55:12 +00:00
|
|
|
uint8_t speed = (!lastMotorOn || ELAPSED(ms, lastMotorOn + (CONTROLLERFAN_SECS) * 1000UL)) ? 0 : CONTROLLERFAN_SPEED;
|
2016-03-21 01:48:31 +00:00
|
|
|
|
2015-05-12 09:08:20 +00:00
|
|
|
// allows digital or PWM fan output to be used (see M42 handling)
|
|
|
|
digitalWrite(CONTROLLERFAN_PIN, speed);
|
|
|
|
analogWrite(CONTROLLERFAN_PIN, speed);
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
}
|
2015-05-12 09:08:20 +00:00
|
|
|
|
|
|
|
#endif // HAS_CONTROLLERFAN
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
#if ENABLED(MORGAN_SCARA)
|
2015-05-17 08:47:02 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
/**
|
|
|
|
* Morgan SCARA Forward Kinematics. Results in cartes[].
|
|
|
|
* Maths and first version by QHARLEY.
|
|
|
|
* Integrated into Marlin and slightly restructured by Joachim Cerny.
|
|
|
|
*/
|
2016-09-12 08:48:29 +00:00
|
|
|
void forward_kinematics_SCARA(const float &a, const float &b) {
|
2015-05-17 08:47:02 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
float a_sin = sin(RADIANS(a)) * L1,
|
|
|
|
a_cos = cos(RADIANS(a)) * L1,
|
|
|
|
b_sin = sin(RADIANS(b)) * L2,
|
|
|
|
b_cos = cos(RADIANS(b)) * L2;
|
2015-05-17 08:47:02 +00:00
|
|
|
|
2016-09-12 08:48:29 +00:00
|
|
|
cartes[X_AXIS] = a_cos + b_cos + SCARA_OFFSET_X; //theta
|
|
|
|
cartes[Y_AXIS] = a_sin + b_sin + SCARA_OFFSET_Y; //theta+phi
|
2015-05-13 09:02:19 +00:00
|
|
|
|
2016-09-12 22:49:35 +00:00
|
|
|
/*
|
2016-09-21 22:54:05 +00:00
|
|
|
SERIAL_ECHOPAIR("SCARA FK Angle a=", a);
|
2016-09-15 05:28:26 +00:00
|
|
|
SERIAL_ECHOPAIR(" b=", b);
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(" a_sin=", a_sin);
|
|
|
|
SERIAL_ECHOPAIR(" a_cos=", a_cos);
|
|
|
|
SERIAL_ECHOPAIR(" b_sin=", b_sin);
|
|
|
|
SERIAL_ECHOLNPAIR(" b_cos=", b_cos);
|
|
|
|
SERIAL_ECHOPAIR(" cartes[X_AXIS]=", cartes[X_AXIS]);
|
|
|
|
SERIAL_ECHOLNPAIR(" cartes[Y_AXIS]=", cartes[Y_AXIS]);
|
|
|
|
//*/
|
2015-08-05 11:40:36 +00:00
|
|
|
}
|
2014-06-23 15:09:57 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
/**
|
|
|
|
* Morgan SCARA Inverse Kinematics. Results in delta[].
|
|
|
|
*
|
|
|
|
* See http://forums.reprap.org/read.php?185,283327
|
2016-09-26 06:30:34 +00:00
|
|
|
*
|
2016-09-15 05:28:26 +00:00
|
|
|
* Maths and first version by QHARLEY.
|
|
|
|
* Integrated into Marlin and slightly restructured by Joachim Cerny.
|
|
|
|
*/
|
2016-09-15 07:31:36 +00:00
|
|
|
void inverse_kinematics(const float logical[XYZ]) {
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-12 01:11:39 +00:00
|
|
|
static float C2, S2, SK1, SK2, THETA, PSI;
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 07:31:36 +00:00
|
|
|
float sx = RAW_X_POSITION(logical[X_AXIS]) - SCARA_OFFSET_X, // Translate SCARA to standard X Y
|
|
|
|
sy = RAW_Y_POSITION(logical[Y_AXIS]) - SCARA_OFFSET_Y; // With scaling factor.
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
if (L1 == L2)
|
|
|
|
C2 = HYPOT2(sx, sy) / L1_2_2 - 1;
|
|
|
|
else
|
|
|
|
C2 = (HYPOT2(sx, sy) - (L1_2 + L2_2)) / (2.0 * L1 * L2);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
S2 = sqrt(sq(C2) - 1);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
// Unrotated Arm1 plus rotated Arm2 gives the distance from Center to End
|
2016-09-12 01:11:39 +00:00
|
|
|
SK1 = L1 + L2 * C2;
|
2016-09-15 05:28:26 +00:00
|
|
|
|
|
|
|
// Rotated Arm2 gives the distance from Arm1 to Arm2
|
2016-09-12 01:11:39 +00:00
|
|
|
SK2 = L2 * S2;
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
// Angle of Arm1 is the difference between Center-to-End angle and the Center-to-Elbow
|
|
|
|
THETA = atan2(SK1, SK2) - atan2(sx, sy);
|
|
|
|
|
|
|
|
// Angle of Arm2
|
2016-09-12 01:11:39 +00:00
|
|
|
PSI = atan2(S2, C2);
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-12 01:11:39 +00:00
|
|
|
delta[A_AXIS] = DEGREES(THETA); // theta is support arm angle
|
|
|
|
delta[B_AXIS] = DEGREES(THETA + PSI); // equal to sub arm angle (inverted motor)
|
2016-09-15 06:21:31 +00:00
|
|
|
delta[C_AXIS] = logical[Z_AXIS];
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-09-15 07:31:36 +00:00
|
|
|
/*
|
|
|
|
DEBUG_POS("SCARA IK", logical);
|
2016-09-12 01:11:39 +00:00
|
|
|
DEBUG_POS("SCARA IK", delta);
|
|
|
|
SERIAL_ECHOPAIR(" SCARA (x,y) ", sx);
|
|
|
|
SERIAL_ECHOPAIR(",", sy);
|
|
|
|
SERIAL_ECHOPAIR(" C2=", C2);
|
|
|
|
SERIAL_ECHOPAIR(" S2=", S2);
|
|
|
|
SERIAL_ECHOPAIR(" Theta=", THETA);
|
|
|
|
SERIAL_ECHOLNPAIR(" Phi=", PHI);
|
|
|
|
//*/
|
|
|
|
}
|
|
|
|
|
2016-09-15 05:28:26 +00:00
|
|
|
#endif // MORGAN_SCARA
|
2016-09-12 08:48:29 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(TEMP_STAT_LEDS)
|
2015-04-13 01:07:08 +00:00
|
|
|
|
|
|
|
static bool red_led = false;
|
|
|
|
static millis_t next_status_led_update_ms = 0;
|
|
|
|
|
|
|
|
void handle_status_leds(void) {
|
2016-04-10 22:55:12 +00:00
|
|
|
if (ELAPSED(millis(), next_status_led_update_ms)) {
|
2015-04-13 01:07:08 +00:00
|
|
|
next_status_led_update_ms += 500; // Update every 0.5s
|
2016-08-16 16:19:51 +00:00
|
|
|
float max_temp = 0.0;
|
|
|
|
#if HAS_TEMP_BED
|
|
|
|
max_temp = MAX3(max_temp, thermalManager.degTargetBed(), thermalManager.degBed());
|
|
|
|
#endif
|
2016-07-10 04:11:17 +00:00
|
|
|
HOTEND_LOOP() {
|
2016-08-19 03:13:47 +00:00
|
|
|
max_temp = MAX3(max_temp, thermalManager.degHotend(e), thermalManager.degTargetHotend(e));
|
2016-07-10 04:11:17 +00:00
|
|
|
}
|
2015-04-13 01:07:08 +00:00
|
|
|
bool new_led = (max_temp > 55.0) ? true : (max_temp < 54.0) ? false : red_led;
|
|
|
|
if (new_led != red_led) {
|
|
|
|
red_led = new_led;
|
2016-10-23 01:07:48 +00:00
|
|
|
#if PIN_EXISTS(STAT_LED_RED)
|
|
|
|
WRITE(STAT_LED_RED_PIN, new_led ? HIGH : LOW);
|
|
|
|
#if PIN_EXISTS(STAT_LED_BLUE)
|
|
|
|
WRITE(STAT_LED_BLUE_PIN, new_led ? LOW : HIGH);
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
WRITE(STAT_LED_BLUE_PIN, new_led ? HIGH : LOW);
|
|
|
|
#endif
|
2015-04-13 01:07:08 +00:00
|
|
|
}
|
2013-10-20 10:12:35 +00:00
|
|
|
}
|
|
|
|
}
|
2015-04-13 01:07:08 +00:00
|
|
|
|
2013-10-20 10:12:35 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
|
|
|
|
|
|
|
void handle_filament_runout() {
|
|
|
|
if (!filament_ran_out) {
|
|
|
|
filament_ran_out = true;
|
|
|
|
enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
|
|
|
|
stepper.synchronize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // FILAMENT_RUNOUT_SENSOR
|
|
|
|
|
|
|
|
#if ENABLED(FAST_PWM_FAN)
|
|
|
|
|
|
|
|
void setPwmFrequency(uint8_t pin, int val) {
|
|
|
|
val &= 0x07;
|
|
|
|
switch (digitalPinToTimer(pin)) {
|
|
|
|
#if defined(TCCR0A)
|
|
|
|
case TIMER0A:
|
|
|
|
case TIMER0B:
|
|
|
|
// TCCR0B &= ~(_BV(CS00) | _BV(CS01) | _BV(CS02));
|
|
|
|
// TCCR0B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR1A)
|
|
|
|
case TIMER1A:
|
|
|
|
case TIMER1B:
|
|
|
|
// TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
|
|
|
|
// TCCR1B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR2)
|
|
|
|
case TIMER2:
|
|
|
|
case TIMER2:
|
|
|
|
TCCR2 &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
|
|
|
|
TCCR2 |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR2A)
|
|
|
|
case TIMER2A:
|
|
|
|
case TIMER2B:
|
|
|
|
TCCR2B &= ~(_BV(CS20) | _BV(CS21) | _BV(CS22));
|
|
|
|
TCCR2B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR3A)
|
|
|
|
case TIMER3A:
|
|
|
|
case TIMER3B:
|
|
|
|
case TIMER3C:
|
|
|
|
TCCR3B &= ~(_BV(CS30) | _BV(CS31) | _BV(CS32));
|
|
|
|
TCCR3B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR4A)
|
|
|
|
case TIMER4A:
|
|
|
|
case TIMER4B:
|
|
|
|
case TIMER4C:
|
|
|
|
TCCR4B &= ~(_BV(CS40) | _BV(CS41) | _BV(CS42));
|
|
|
|
TCCR4B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(TCCR5A)
|
|
|
|
case TIMER5A:
|
|
|
|
case TIMER5B:
|
|
|
|
case TIMER5C:
|
|
|
|
TCCR5B &= ~(_BV(CS50) | _BV(CS51) | _BV(CS52));
|
|
|
|
TCCR5B |= val;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // FAST_PWM_FAN
|
|
|
|
|
|
|
|
float calculate_volumetric_multiplier(float diameter) {
|
|
|
|
if (!volumetric_enabled || diameter == 0) return 1.0;
|
2016-10-05 02:32:37 +00:00
|
|
|
return 1.0 / (M_PI * diameter * 0.5 * diameter * 0.5);
|
2016-09-13 07:11:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void calculate_volumetric_multipliers() {
|
|
|
|
for (uint8_t i = 0; i < COUNT(filament_size); i++)
|
|
|
|
volumetric_multiplier[i] = calculate_volumetric_multiplier(filament_size[i]);
|
|
|
|
}
|
|
|
|
|
2015-04-04 02:25:22 +00:00
|
|
|
void enable_all_steppers() {
|
|
|
|
enable_x();
|
|
|
|
enable_y();
|
|
|
|
enable_z();
|
|
|
|
enable_e0();
|
|
|
|
enable_e1();
|
|
|
|
enable_e2();
|
|
|
|
enable_e3();
|
|
|
|
}
|
|
|
|
|
|
|
|
void disable_all_steppers() {
|
2015-04-03 22:31:35 +00:00
|
|
|
disable_x();
|
|
|
|
disable_y();
|
|
|
|
disable_z();
|
|
|
|
disable_e0();
|
|
|
|
disable_e1();
|
|
|
|
disable_e2();
|
|
|
|
disable_e3();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-04-04 06:42:50 +00:00
|
|
|
* Manage several activities:
|
|
|
|
* - Check for Filament Runout
|
|
|
|
* - Keep the command buffer full
|
|
|
|
* - Check for maximum inactive time between commands
|
|
|
|
* - Check for maximum inactive time between stepper commands
|
|
|
|
* - Check if pin CHDK needs to go LOW
|
|
|
|
* - Check for KILL button held down
|
|
|
|
* - Check for HOME button held down
|
|
|
|
* - Check if cooling fan needs to be switched on
|
|
|
|
* - Check if an idle but hot extruder needs filament extruded (EXTRUDER_RUNOUT_PREVENT)
|
2015-04-03 22:31:35 +00:00
|
|
|
*/
|
|
|
|
void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2016-06-20 01:05:57 +00:00
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
2016-11-09 16:21:21 +00:00
|
|
|
if ((IS_SD_PRINTING || print_job_timer.isRunning()) && (READ(FIL_RUNOUT_PIN) == FIL_RUNOUT_INVERTING))
|
2016-04-18 06:16:49 +00:00
|
|
|
handle_filament_runout();
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif
|
|
|
|
|
2016-03-28 12:25:27 +00:00
|
|
|
if (commands_in_queue < BUFSIZE) get_available_commands();
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2015-04-13 01:07:08 +00:00
|
|
|
millis_t ms = millis();
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2016-04-10 22:55:12 +00:00
|
|
|
if (max_inactive_time && ELAPSED(ms, previous_cmd_ms + max_inactive_time)) kill(PSTR(MSG_KILLED));
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2016-04-10 22:55:12 +00:00
|
|
|
if (stepper_inactive_time && ELAPSED(ms, previous_cmd_ms + stepper_inactive_time)
|
2016-04-28 01:06:32 +00:00
|
|
|
&& !ignore_stepper_queue && !planner.blocks_queued()) {
|
2016-03-14 05:15:45 +00:00
|
|
|
#if ENABLED(DISABLE_INACTIVE_X)
|
2015-06-01 08:42:28 +00:00
|
|
|
disable_x();
|
|
|
|
#endif
|
2016-03-14 05:15:45 +00:00
|
|
|
#if ENABLED(DISABLE_INACTIVE_Y)
|
2015-06-01 08:42:28 +00:00
|
|
|
disable_y();
|
|
|
|
#endif
|
2016-03-14 05:15:45 +00:00
|
|
|
#if ENABLED(DISABLE_INACTIVE_Z)
|
2015-06-01 08:42:28 +00:00
|
|
|
disable_z();
|
|
|
|
#endif
|
2016-03-14 05:15:45 +00:00
|
|
|
#if ENABLED(DISABLE_INACTIVE_E)
|
2015-06-01 08:42:28 +00:00
|
|
|
disable_e0();
|
|
|
|
disable_e1();
|
|
|
|
disable_e2();
|
|
|
|
disable_e3();
|
|
|
|
#endif
|
|
|
|
}
|
2015-03-07 20:43:15 +00:00
|
|
|
|
2015-04-04 06:42:50 +00:00
|
|
|
#ifdef CHDK // Check if pin should be set to LOW after M240 set it to HIGH
|
2016-04-10 22:55:12 +00:00
|
|
|
if (chdkActive && PENDING(ms, chdkHigh + CHDK_DELAY)) {
|
2014-03-10 20:57:08 +00:00
|
|
|
chdkActive = false;
|
|
|
|
WRITE(CHDK, LOW);
|
|
|
|
}
|
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
|
|
|
|
#if HAS_KILL
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2014-12-28 18:54:06 +00:00
|
|
|
// Check if the kill button was pressed and wait just in case it was an accidental
|
|
|
|
// key kill key press
|
|
|
|
// -------------------------------------------------------------------------------
|
2015-04-03 22:45:41 +00:00
|
|
|
static int killCount = 0; // make the inactivity button a bit less responsive
|
|
|
|
const int KILL_DELAY = 750;
|
2015-04-03 22:31:35 +00:00
|
|
|
if (!READ(KILL_PIN))
|
2015-10-03 06:08:58 +00:00
|
|
|
killCount++;
|
2014-12-28 18:54:06 +00:00
|
|
|
else if (killCount > 0)
|
2015-10-03 06:08:58 +00:00
|
|
|
killCount--;
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2014-12-28 18:54:06 +00:00
|
|
|
// Exceeded threshold and we can confirm that it was not accidental
|
|
|
|
// KILL the machine
|
|
|
|
// ----------------------------------------------------------------
|
2015-05-20 18:53:48 +00:00
|
|
|
if (killCount >= KILL_DELAY) kill(PSTR(MSG_KILLED));
|
2012-11-06 11:06:41 +00:00
|
|
|
#endif
|
2014-12-28 18:54:06 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_HOME
|
2014-12-28 18:54:06 +00:00
|
|
|
// Check to see if we have to home, use poor man's debouncer
|
|
|
|
// ---------------------------------------------------------
|
2015-04-03 22:45:41 +00:00
|
|
|
static int homeDebounceCount = 0; // poor man's debouncing count
|
2015-09-13 18:20:43 +00:00
|
|
|
const int HOME_DEBOUNCE_DELAY = 2500;
|
2016-12-06 20:22:34 +00:00
|
|
|
if (!IS_SD_PRINTING && !READ(HOME_PIN)) {
|
2015-04-03 22:31:35 +00:00
|
|
|
if (!homeDebounceCount) {
|
2016-02-21 01:35:35 +00:00
|
|
|
enqueue_and_echo_commands_P(PSTR("G28"));
|
2015-05-04 17:48:49 +00:00
|
|
|
LCD_MESSAGEPGM(MSG_AUTO_HOME);
|
2015-04-03 22:31:35 +00:00
|
|
|
}
|
|
|
|
if (homeDebounceCount < HOME_DEBOUNCE_DELAY)
|
|
|
|
homeDebounceCount++;
|
|
|
|
else
|
|
|
|
homeDebounceCount = 0;
|
2014-12-28 18:54:06 +00:00
|
|
|
}
|
2015-04-03 22:31:35 +00:00
|
|
|
#endif
|
2015-08-05 11:40:36 +00:00
|
|
|
|
2015-04-03 22:31:35 +00:00
|
|
|
#if HAS_CONTROLLERFAN
|
2015-04-04 06:42:50 +00:00
|
|
|
controllerFan(); // Check if fan should be turned on to cool stepper drivers down
|
2012-11-06 11:06:41 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(EXTRUDER_RUNOUT_PREVENT)
|
2016-06-28 22:06:56 +00:00
|
|
|
if (ELAPSED(ms, previous_cmd_ms + (EXTRUDER_RUNOUT_SECONDS) * 1000UL)
|
|
|
|
&& thermalManager.degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP) {
|
2016-09-13 08:26:23 +00:00
|
|
|
bool oldstatus;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(SWITCHING_EXTRUDER)
|
2016-09-13 08:26:23 +00:00
|
|
|
oldstatus = E0_ENABLE_READ;
|
2016-06-28 22:06:56 +00:00
|
|
|
enable_e0();
|
|
|
|
#else // !SWITCHING_EXTRUDER
|
2015-10-03 06:08:58 +00:00
|
|
|
switch (active_extruder) {
|
|
|
|
case 0:
|
|
|
|
oldstatus = E0_ENABLE_READ;
|
|
|
|
enable_e0();
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 1
|
2015-10-03 06:08:58 +00:00
|
|
|
case 1:
|
|
|
|
oldstatus = E1_ENABLE_READ;
|
|
|
|
enable_e1();
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 2
|
2015-10-03 06:08:58 +00:00
|
|
|
case 2:
|
|
|
|
oldstatus = E2_ENABLE_READ;
|
|
|
|
enable_e2();
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 3
|
2015-10-03 06:08:58 +00:00
|
|
|
case 3:
|
|
|
|
oldstatus = E3_ENABLE_READ;
|
|
|
|
enable_e3();
|
|
|
|
break;
|
|
|
|
#endif
|
2015-04-04 06:42:50 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
2015-10-03 06:08:58 +00:00
|
|
|
}
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif // !SWITCHING_EXTRUDER
|
|
|
|
|
2015-04-13 01:07:08 +00:00
|
|
|
previous_cmd_ms = ms; // refresh_cmd_timeout()
|
2016-10-09 20:21:36 +00:00
|
|
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
inverse_kinematics(current_position);
|
|
|
|
ADJUST_DELTA(current_position);
|
|
|
|
planner.buffer_line(
|
|
|
|
delta[A_AXIS], delta[B_AXIS], delta[C_AXIS],
|
|
|
|
current_position[E_AXIS] + EXTRUDER_RUNOUT_EXTRUDE,
|
|
|
|
MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED), active_extruder
|
|
|
|
);
|
|
|
|
#else
|
|
|
|
planner.buffer_line(
|
|
|
|
current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS],
|
|
|
|
current_position[E_AXIS] + EXTRUDER_RUNOUT_EXTRUDE,
|
|
|
|
MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED), active_extruder
|
|
|
|
);
|
|
|
|
#endif
|
2016-04-27 14:15:20 +00:00
|
|
|
stepper.synchronize();
|
2016-09-13 08:26:23 +00:00
|
|
|
planner.set_e_position_mm(current_position[E_AXIS]);
|
2016-06-28 22:06:56 +00:00
|
|
|
#if ENABLED(SWITCHING_EXTRUDER)
|
|
|
|
E0_ENABLE_WRITE(oldstatus);
|
|
|
|
#else
|
|
|
|
switch (active_extruder) {
|
|
|
|
case 0:
|
|
|
|
E0_ENABLE_WRITE(oldstatus);
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 1
|
|
|
|
case 1:
|
|
|
|
E1_ENABLE_WRITE(oldstatus);
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 2
|
|
|
|
case 2:
|
|
|
|
E2_ENABLE_WRITE(oldstatus);
|
2015-04-04 06:42:50 +00:00
|
|
|
break;
|
2016-06-28 22:06:56 +00:00
|
|
|
#if E_STEPPERS > 3
|
|
|
|
case 3:
|
|
|
|
E3_ENABLE_WRITE(oldstatus);
|
|
|
|
break;
|
|
|
|
#endif
|
2015-04-04 06:42:50 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
2016-06-28 22:06:56 +00:00
|
|
|
}
|
|
|
|
#endif // !SWITCHING_EXTRUDER
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
2016-06-28 22:06:56 +00:00
|
|
|
#endif // EXTRUDER_RUNOUT_PREVENT
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(DUAL_X_CARRIAGE)
|
2013-08-07 14:10:26 +00:00
|
|
|
// handle delayed move timeout
|
2016-04-10 22:55:12 +00:00
|
|
|
if (delayed_move_time && ELAPSED(ms, delayed_move_time + 1000UL) && IsRunning()) {
|
2013-08-07 14:10:26 +00:00
|
|
|
// travel moves have been received so enact them
|
|
|
|
delayed_move_time = 0xFFFFFFFFUL; // force moves to be done
|
2015-04-04 06:42:50 +00:00
|
|
|
set_destination_to_current();
|
2016-06-11 02:23:41 +00:00
|
|
|
prepare_move_to_destination();
|
2013-08-07 14:10:26 +00:00
|
|
|
}
|
2013-10-20 10:12:35 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(TEMP_STAT_LEDS)
|
2015-04-03 22:31:35 +00:00
|
|
|
handle_status_leds();
|
2013-10-20 10:12:35 +00:00
|
|
|
#endif
|
2015-04-03 22:31:35 +00:00
|
|
|
|
2016-04-28 01:06:32 +00:00
|
|
|
planner.check_axes_activity();
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Standard idle routine keeps the machine alive
|
|
|
|
*/
|
|
|
|
void idle(
|
|
|
|
#if ENABLED(FILAMENT_CHANGE_FEATURE)
|
|
|
|
bool no_stepper_sleep/*=false*/
|
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
lcd_update();
|
2016-11-09 00:03:40 +00:00
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
host_keepalive();
|
2016-11-09 00:03:40 +00:00
|
|
|
|
|
|
|
#if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED)
|
|
|
|
auto_report_temperatures();
|
|
|
|
#endif
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
manage_inactivity(
|
|
|
|
#if ENABLED(FILAMENT_CHANGE_FEATURE)
|
|
|
|
no_stepper_sleep
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
|
|
|
|
thermalManager.manage_heater();
|
|
|
|
|
|
|
|
#if ENABLED(PRINTCOUNTER)
|
|
|
|
print_job_timer.tick();
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 02:31:50 +00:00
|
|
|
#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
|
2016-09-13 07:11:45 +00:00
|
|
|
buzzer.tick();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Kill all activity and lock the machine.
|
|
|
|
* After this the machine will need to be reset.
|
|
|
|
*/
|
2015-10-03 06:08:58 +00:00
|
|
|
void kill(const char* lcd_msg) {
|
2016-07-10 02:50:45 +00:00
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_KILLED);
|
|
|
|
|
2015-07-31 05:24:43 +00:00
|
|
|
#if ENABLED(ULTRA_LCD)
|
2016-07-10 02:50:45 +00:00
|
|
|
kill_screen(lcd_msg);
|
2015-10-04 15:33:55 +00:00
|
|
|
#else
|
|
|
|
UNUSED(lcd_msg);
|
2015-05-20 20:03:16 +00:00
|
|
|
#endif
|
2015-05-20 18:53:48 +00:00
|
|
|
|
2016-08-09 04:49:34 +00:00
|
|
|
delay(500); // Wait a short time
|
2016-07-10 02:50:45 +00:00
|
|
|
|
2012-11-06 11:06:41 +00:00
|
|
|
cli(); // Stop interrupts
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.disable_all_heaters();
|
2015-04-04 02:25:22 +00:00
|
|
|
disable_all_steppers();
|
2013-06-06 22:49:25 +00:00
|
|
|
|
2015-03-30 23:50:05 +00:00
|
|
|
#if HAS_POWER_SWITCH
|
2016-12-03 04:40:18 +00:00
|
|
|
SET_INPUT(PS_ON_PIN);
|
2015-03-30 23:50:05 +00:00
|
|
|
#endif
|
|
|
|
|
2012-11-06 11:06:41 +00:00
|
|
|
suicide();
|
2016-03-03 23:35:18 +00:00
|
|
|
while (1) {
|
2016-03-07 21:27:01 +00:00
|
|
|
#if ENABLED(USE_WATCHDOG)
|
|
|
|
watchdog_reset();
|
|
|
|
#endif
|
2016-03-03 23:35:18 +00:00
|
|
|
} // Wait for reset
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 07:11:45 +00:00
|
|
|
/**
|
|
|
|
* Turn off heaters and stop the print in progress
|
|
|
|
* After a stop the machine may be resumed with M999
|
|
|
|
*/
|
2016-04-18 07:05:22 +00:00
|
|
|
void stop() {
|
2016-04-29 01:18:13 +00:00
|
|
|
thermalManager.disable_all_heaters();
|
2015-05-17 08:47:02 +00:00
|
|
|
if (IsRunning()) {
|
|
|
|
Running = false;
|
|
|
|
Stopped_gcode_LastN = gcode_LastN; // Save last g_code for restart
|
|
|
|
SERIAL_ERROR_START;
|
|
|
|
SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
|
|
|
|
LCD_MESSAGEPGM(MSG_STOPPED);
|
2012-11-06 11:06:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-12 01:21:54 +00:00
|
|
|
/**
|
|
|
|
* Marlin entry-point: Set up before the program loop
|
|
|
|
* - Set up the kill pin, filament runout, power hold
|
|
|
|
* - Start the serial port
|
|
|
|
* - Print startup messages and diagnostics
|
|
|
|
* - Get EEPROM or default settings
|
|
|
|
* - Initialize managers for:
|
|
|
|
* • temperature
|
|
|
|
* • planner
|
|
|
|
* • watchdog
|
|
|
|
* • stepper
|
|
|
|
* • photo pin
|
|
|
|
* • servos
|
|
|
|
* • LCD controller
|
|
|
|
* • Digipot I2C
|
|
|
|
* • Z probe sled
|
|
|
|
* • status LEDs
|
|
|
|
*/
|
|
|
|
void setup() {
|
|
|
|
|
2016-09-22 22:10:20 +00:00
|
|
|
#ifdef DISABLE_JTAG
|
2016-09-12 01:21:54 +00:00
|
|
|
// Disable JTAG on AT90USB chips to free up pins for IO
|
|
|
|
MCUCR = 0x80;
|
|
|
|
MCUCR = 0x80;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
|
|
|
|
setup_filrunoutpin();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
setup_killpin();
|
|
|
|
|
|
|
|
setup_powerhold();
|
|
|
|
|
|
|
|
#if HAS_STEPPER_RESET
|
|
|
|
disableStepperDrivers();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
MYSERIAL.begin(BAUDRATE);
|
|
|
|
SERIAL_PROTOCOLLNPGM("start");
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
|
|
|
|
// Check startup - does nothing if bootloader sets MCUSR to 0
|
|
|
|
byte mcu = MCUSR;
|
|
|
|
if (mcu & 1) SERIAL_ECHOLNPGM(MSG_POWERUP);
|
|
|
|
if (mcu & 2) SERIAL_ECHOLNPGM(MSG_EXTERNAL_RESET);
|
|
|
|
if (mcu & 4) SERIAL_ECHOLNPGM(MSG_BROWNOUT_RESET);
|
|
|
|
if (mcu & 8) SERIAL_ECHOLNPGM(MSG_WATCHDOG_RESET);
|
|
|
|
if (mcu & 32) SERIAL_ECHOLNPGM(MSG_SOFTWARE_RESET);
|
|
|
|
MCUSR = 0;
|
|
|
|
|
|
|
|
SERIAL_ECHOPGM(MSG_MARLIN);
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_CHAR(' ');
|
|
|
|
SERIAL_ECHOLNPGM(SHORT_BUILD_VERSION);
|
|
|
|
SERIAL_EOL;
|
2016-09-12 01:21:54 +00:00
|
|
|
|
2016-09-12 22:49:35 +00:00
|
|
|
#if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR)
|
|
|
|
SERIAL_ECHO_START;
|
|
|
|
SERIAL_ECHOPGM(MSG_CONFIGURATION_VER);
|
|
|
|
SERIAL_ECHOPGM(STRING_DISTRIBUTION_DATE);
|
|
|
|
SERIAL_ECHOLNPGM(MSG_AUTHOR STRING_CONFIG_H_AUTHOR);
|
|
|
|
SERIAL_ECHOLNPGM("Compiled: " __DATE__);
|
|
|
|
#endif
|
2016-09-12 01:21:54 +00:00
|
|
|
|
|
|
|
SERIAL_ECHO_START;
|
2016-09-12 22:49:35 +00:00
|
|
|
SERIAL_ECHOPAIR(MSG_FREE_MEMORY, freeMemory());
|
|
|
|
SERIAL_ECHOLNPAIR(MSG_PLANNER_BUFFER_BYTES, (int)sizeof(block_t)*BLOCK_BUFFER_SIZE);
|
2016-09-12 01:21:54 +00:00
|
|
|
|
|
|
|
// Send "ok" after commands by default
|
|
|
|
for (int8_t i = 0; i < BUFSIZE; i++) send_ok[i] = true;
|
|
|
|
|
|
|
|
// Load data from EEPROM if available (or use defaults)
|
|
|
|
// This also updates variables in the planner, elsewhere
|
|
|
|
Config_RetrieveSettings();
|
|
|
|
|
|
|
|
// Initialize current position based on home_offset
|
|
|
|
memcpy(current_position, home_offset, sizeof(home_offset));
|
|
|
|
|
|
|
|
// Vital to init stepper/planner equivalent for current_position
|
|
|
|
SYNC_PLAN_POSITION_KINEMATIC();
|
|
|
|
|
|
|
|
thermalManager.init(); // Initialize temperature loop
|
|
|
|
|
|
|
|
#if ENABLED(USE_WATCHDOG)
|
|
|
|
watchdog_init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
stepper.init(); // Initialize stepper, this enables interrupts!
|
|
|
|
servo_init();
|
|
|
|
|
2016-11-01 11:24:21 +00:00
|
|
|
#if HAS_PHOTOGRAPH
|
|
|
|
OUT_WRITE(PHOTOGRAPH_PIN, LOW);
|
|
|
|
#endif
|
|
|
|
|
2016-10-05 19:34:07 +00:00
|
|
|
#if HAS_CASE_LIGHT
|
2016-11-28 05:51:51 +00:00
|
|
|
update_case_light();
|
2016-10-05 19:34:07 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-12 01:21:54 +00:00
|
|
|
#if HAS_BED_PROBE
|
|
|
|
endstops.enable_z_probe(false);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_CONTROLLERFAN
|
|
|
|
SET_OUTPUT(CONTROLLERFAN_PIN); //Set pin used for driver cooling fan
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_STEPPER_RESET
|
|
|
|
enableStepperDrivers();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(DIGIPOT_I2C)
|
|
|
|
digipot_i2c_init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(DAC_STEPPER_CURRENT)
|
|
|
|
dac_init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(Z_PROBE_SLED) && PIN_EXISTS(SLED)
|
2016-09-25 10:52:10 +00:00
|
|
|
OUT_WRITE(SLED_PIN, LOW); // turn it off
|
2016-09-12 01:21:54 +00:00
|
|
|
#endif // Z_PROBE_SLED
|
|
|
|
|
|
|
|
setup_homepin();
|
|
|
|
|
2016-09-24 20:33:29 +00:00
|
|
|
#if PIN_EXISTS(STAT_LED_RED)
|
|
|
|
OUT_WRITE(STAT_LED_RED_PIN, LOW); // turn it off
|
2016-09-12 01:21:54 +00:00
|
|
|
#endif
|
|
|
|
|
2016-09-24 20:33:29 +00:00
|
|
|
#if PIN_EXISTS(STAT_LED_BLUE)
|
|
|
|
OUT_WRITE(STAT_LED_BLUE_PIN, LOW); // turn it off
|
2016-09-12 01:21:54 +00:00
|
|
|
#endif
|
|
|
|
|
2016-11-30 01:51:13 +00:00
|
|
|
#if ENABLED(RGB_LED)
|
|
|
|
pinMode(RGB_LED_R_PIN, OUTPUT);
|
|
|
|
pinMode(RGB_LED_G_PIN, OUTPUT);
|
|
|
|
pinMode(RGB_LED_B_PIN, OUTPUT);
|
|
|
|
#endif
|
|
|
|
|
2016-09-12 01:21:54 +00:00
|
|
|
lcd_init();
|
|
|
|
#if ENABLED(SHOW_BOOTSCREEN)
|
|
|
|
#if ENABLED(DOGLCD)
|
|
|
|
safe_delay(BOOTSCREEN_TIMEOUT);
|
|
|
|
#elif ENABLED(ULTRA_LCD)
|
|
|
|
bootscreen();
|
2016-10-13 07:03:20 +00:00
|
|
|
#if DISABLED(SDSUPPORT)
|
|
|
|
lcd_init();
|
|
|
|
#endif
|
2016-09-12 01:21:54 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(MIXING_EXTRUDER) && MIXING_VIRTUAL_TOOLS > 1
|
|
|
|
// Initialize mixing to 100% color 1
|
|
|
|
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
|
2016-11-12 20:33:07 +00:00
|
|
|
mixing_factor[i] = (i == 0) ? 1.0 : 0.0;
|
2016-09-12 01:21:54 +00:00
|
|
|
for (uint8_t t = 0; t < MIXING_VIRTUAL_TOOLS; t++)
|
|
|
|
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
|
|
|
|
mixing_virtual_tool_mix[t][i] = mixing_factor[i];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(EXPERIMENTAL_I2CBUS) && I2C_SLAVE_ADDRESS > 0
|
|
|
|
i2c.onReceive(i2c_on_receive);
|
|
|
|
i2c.onRequest(i2c_on_request);
|
|
|
|
#endif
|
2016-11-05 21:38:48 +00:00
|
|
|
|
|
|
|
#if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
|
2016-11-19 03:53:45 +00:00
|
|
|
setup_endstop_interrupts();
|
2016-11-05 21:38:48 +00:00
|
|
|
#endif
|
2016-09-12 01:21:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The main Marlin program loop
|
|
|
|
*
|
|
|
|
* - Save or log commands to SD
|
|
|
|
* - Process available commands (if not saving)
|
|
|
|
* - Call heater manager
|
|
|
|
* - Call inactivity manager
|
|
|
|
* - Call endstop manager
|
|
|
|
* - Call LCD update
|
|
|
|
*/
|
|
|
|
void loop() {
|
|
|
|
if (commands_in_queue < BUFSIZE) get_available_commands();
|
|
|
|
|
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
card.checkautostart(false);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (commands_in_queue) {
|
|
|
|
|
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
|
|
|
|
if (card.saving) {
|
|
|
|
char* command = command_queue[cmd_queue_index_r];
|
|
|
|
if (strstr_P(command, PSTR("M29"))) {
|
|
|
|
// M29 closes the file
|
|
|
|
card.closefile();
|
|
|
|
SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
|
|
|
|
ok_to_send();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Write the string from the read buffer to SD
|
|
|
|
card.write_command(command);
|
|
|
|
if (card.logging)
|
|
|
|
process_next_command(); // The card is saving because it's logging
|
|
|
|
else
|
|
|
|
ok_to_send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
process_next_command();
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
process_next_command();
|
|
|
|
|
|
|
|
#endif // SDSUPPORT
|
|
|
|
|
|
|
|
// The queue may be reset by a command handler or by code invoked by idle() within a handler
|
|
|
|
if (commands_in_queue) {
|
|
|
|
--commands_in_queue;
|
|
|
|
cmd_queue_index_r = (cmd_queue_index_r + 1) % BUFSIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
endstops.report_state();
|
|
|
|
idle();
|
|
|
|
}
|