2012-11-06 05:06:41 -06:00
/* -*- c++ -*- */
/*
Reprap firmware based on Sprinter and grbl .
Copyright ( C ) 2011 Camiel Gubbels / Erik van der Zalm
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
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 .
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
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 .
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
You should have received a copy of the GNU General Public License
along with this program . If not , see < http : //www.gnu.org/licenses/>.
*/
/*
This firmware is a mashup between Sprinter and grbl .
( https : //github.com/kliment/Sprinter)
( https : //github.com/simen/grbl/tree)
2013-06-06 17:49:25 -05:00
It has preliminary support for Matthew Roberts advance algorithm
2012-11-06 05:06:41 -06:00
http : //reprap.org/pipermail/reprap-dev/2011-May/003323.html
*/
2012-11-21 13:53:56 -06:00
2012-11-06 05:06:41 -06:00
# include "Marlin.h"
2013-09-29 11:20:06 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
# include "vector_3.h"
2013-12-06 14:46:25 -06:00
# ifdef ACCURATE_BED_LEVELING
# include "qr_solve.h"
# endif
2013-09-29 11:20:06 -05:00
# endif // ENABLE_AUTO_BED_LEVELING
2012-11-06 05:06:41 -06:00
# include "ultralcd.h"
# include "planner.h"
# include "stepper.h"
# include "temperature.h"
# include "motion_control.h"
# include "cardreader.h"
# include "watchdog.h"
2012-11-07 03:02:45 -06:00
# include "ConfigurationStore.h"
2012-11-06 05:06:41 -06:00
# include "language.h"
# include "pins_arduino.h"
2013-11-27 18:37:35 -06:00
# include "math.h"
2012-11-06 05:06:41 -06:00
2013-10-20 02:55:15 -05:00
# ifdef BLINKM
2013-09-10 04:18:29 -05:00
# include "BlinkM.h"
2013-12-08 14:35:57 -06:00
# include "Wire.h"
2013-10-20 02:55:15 -05:00
# endif
2013-09-10 04:18:29 -05:00
2013-06-06 17:49:25 -05:00
# if NUM_SERVOS > 0
# include "Servo.h"
# endif
# if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1
2012-11-21 13:53:56 -06:00
# include <SPI.h>
# endif
2012-11-06 05:06:41 -06:00
# define VERSION_STRING "1.0.0"
// look here for descriptions of gcodes: http://linuxcnc.org/handbook/gcode/g-code.html
// http://objects.reprap.org/wiki/Mendel_User_Manual:_RepRapGCodes
//Implemented Codes
//-------------------
// G0 -> G1
// G1 - Coordinated Movement X Y Z E
// G2 - CW ARC
// G3 - CCW ARC
// G4 - Dwell S<seconds> or P<milliseconds>
// G10 - retract filament according to settings of M207
// G11 - retract recover filament according to settings of M208
// G28 - Home all Axis
2013-09-29 11:20:06 -05:00
// G29 - Detailed Z-Probe, probes the bed at 3 points. You must de at the home position for this to work correctly.
// G30 - Single Z Probe, probes bed at current XY location.
2012-11-06 05:06:41 -06:00
// G90 - Use Absolute Coordinates
// G91 - Use Relative Coordinates
// G92 - Set current position to cordinates given
2013-07-14 14:10:24 -05:00
// M Codes
2012-11-06 05:06:41 -06:00
// 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
// M20 - List SD card
// M21 - Init SD card
// M22 - Release SD card
// M23 - Select SD file (M23 filename.g)
// M24 - Start/resume SD print
// M25 - Pause SD print
// M26 - Set SD position in bytes (M26 S12345)
// M27 - Report SD print status
// M28 - Start SD write (M28 filename.g)
// M29 - Stop SD write
// M30 - Delete file from SD (M30 filename.g)
// M31 - Output time since last M109 or SD card start to serial
2013-12-08 14:35:57 -06:00
// M32 - Select file and start SD print (Can be used _while_ printing from SD card files):
2013-10-22 03:02:18 -05:00
// syntax "M32 /path/filename#", or "M32 S<startpos bytes> !filename#"
// Call gcode file : "M32 P !filename#" and return to caller file after finishing (simiarl to #include).
// The '#' is necessary when calling from within sd files, as it stops buffer prereading
2013-01-31 11:20:23 -06:00
// M42 - Change pin status via gcode Use M42 Px Sy to set pin x to value y, when omitting Px the onboard led will be used.
2012-11-06 05:06:41 -06:00
// M80 - Turn on Power Supply
// M81 - Turn off Power Supply
// M82 - Set E codes absolute (default)
// M83 - Set E codes relative while in Absolute Coordinates (G90) mode
2013-06-06 17:49:25 -05:00
// M84 - Disable steppers until next move,
2012-11-06 05:06:41 -06:00
// or use S<seconds> to specify an inactivity timeout, after which the steppers will be disabled. S0 to disable the timeout.
// M85 - Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
// M92 - Set axis_steps_per_unit - same syntax as G92
2013-07-14 14:10:24 -05:00
// M104 - Set extruder target temp
// M105 - Read current temp
// M106 - Fan on
// M107 - Fan off
// 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
2013-06-06 17:49:25 -05:00
// M114 - Output current position to serial port
// M115 - Capabilities string
2012-11-06 05:06:41 -06:00
// M117 - display message
// M119 - Output Endstop status to serial port
2013-06-06 17:49:25 -05:00
// M126 - Solenoid Air Valve Open (BariCUDA support by jmil)
// M127 - Solenoid Air Valve Closed (BariCUDA vent to atmospheric pressure by jmil)
// M128 - EtoP Open (BariCUDA EtoP = electricity to air pressure transducer by jmil)
// M129 - EtoP Closed (BariCUDA EtoP = electricity to air pressure transducer by jmil)
2012-11-06 05:06:41 -06:00
// M140 - Set bed target temp
2013-09-10 04:18:29 -05:00
// M150 - Set BlinkM Colour Output R: Red<0-255> U(!): Green<0-255> B: Blue<0-255> over i2c, G for green does not work.
2013-07-14 14:10:24 -05: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
2014-02-01 20:49:25 -06:00
// M200 D<millimeters>- set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
2012-11-06 05:06:41 -06:00
// M201 - Set max acceleration in units/s^2 for print moves (M201 X1000 Y1000)
// M202 - Set max acceleration in units/s^2 for travel moves (M202 X1000 Y1000) Unused in Marlin!!
// M203 - Set maximum feedrate that your machine can sustain (M203 X200 Y200 Z300 E10000) in mm/sec
// M204 - Set default acceleration: S normal moves T filament only moves (M204 S3000 T7000) im mm/sec^2 also sets minimum segment time in ms (B20000) to prevent buffer underruns and M20 minimum feedrate
// M205 - advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk, E=maximum E jerk
// M206 - set additional homeing offset
// M207 - set retract length S[positive mm] F[feedrate mm/sec] Z[additional zlift/hop]
// M208 - set recover=unretract length S[positive mm surplus to the M207 S*] F[feedrate mm/sec]
// M209 - S<1=true/0=false> enable automatic retract detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
2013-02-04 22:05:45 -06:00
// M218 - set hotend offset (in mm): T<extruder_number> X<offset_on_X> Y<offset_on_Y>
2012-11-06 05:06:41 -06:00
// M220 S<factor in percent>- set speed factor override percentage
// M221 S<factor in percent>- set extrude factor override percentage
2013-11-08 18:55:23 -06:00
// M226 P<pin number> S<pin state>- Wait until the specified pin reaches the state required
2012-11-06 05:06:41 -06:00
// M240 - Trigger a camera to take a photograph
2013-07-14 03:28:26 -05:00
// M250 - Set LCD contrast C<contrast value> (value 0..63)
2013-06-06 17:49:25 -05:00
// M280 - set servo position absolute. P: servo index, S: angle or microseconds
2013-03-24 23:35:05 -05:00
// M300 - Play beepsound S<frequency Hz> P<duration ms>
2012-11-06 05:06:41 -06:00
// M301 - Set PID parameters P I and D
2013-06-06 17:49:25 -05:00
// M302 - Allow cold extrudes, or set the minimum extrude S<temperature>.
2012-11-06 05:06:41 -06:00
// M303 - PID relay autotune S<temperature> sets the target temperature. (default target temperature = 150C)
// M304 - Set bed PID parameters P I and D
// M400 - Finish all moves
2013-09-29 11:20:06 -05:00
// M401 - Lower z-probe if present
// M402 - Raise z-probe if present
2012-11-06 05:06:41 -06:00
// M500 - stores paramters in EEPROM
2013-06-06 17:49:25 -05:00
// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).
2012-11-06 05:06:41 -06:00
// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to.
2013-02-04 00:41:40 -06:00
// M503 - print the current settings (from memory not from eeprom)
2013-01-08 04:53:18 -06:00
// M540 - Use S[0|1] to enable or disable the stop SD card print on endstop hit (requires ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
// M600 - Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
2013-08-27 18:15:20 -05:00
// M666 - set delta endstop adjustemnt
2013-08-07 09:10:26 -05:00
// M605 - Set dual x-carriage movement mode: S<mode> [ X<duplication x-offset> R<duplication temp offset> ]
2012-11-21 13:36:30 -06:00
// M907 - Set digital trimpot motor current using axis codes.
// M908 - Control digital trimpot directly.
// M350 - Set microstepping mode.
// M351 - Toggle MS1 MS2 pins directly.
2013-03-16 17:02:57 -05:00
// M928 - Start SD logging (M928 filename.g) - ended by M29
2012-11-06 05:06:41 -06:00
// M999 - Restart after being stopped by error
//Stepper Movement Variables
//===========================================================================
//=============================imported variables============================
//===========================================================================
//===========================================================================
//=============================public variables=============================
//===========================================================================
# ifdef SDSUPPORT
CardReader card ;
# endif
float homing_feedrate [ ] = HOMING_FEEDRATE ;
bool axis_relative_modes [ ] = AXIS_RELATIVE_MODES ;
2012-12-05 12:32:02 -06:00
int feedmultiply = 100 ; //100->1 200->2
2012-11-06 05:06:41 -06:00
int saved_feedmultiply ;
2012-12-03 05:13:20 -06:00
int extrudemultiply = 100 ; //100->1 200->2
2014-01-31 10:43:11 -06:00
float volumetric_multiplier [ EXTRUDERS ] = { 1.0
2014-01-31 02:54:19 -06:00
# if EXTRUDERS > 1
, 1.0
# if EXTRUDERS > 2
, 1.0
# endif
# endif
} ;
2012-11-06 05:06:41 -06:00
float current_position [ NUM_AXIS ] = { 0.0 , 0.0 , 0.0 , 0.0 } ;
float add_homeing [ 3 ] = { 0 , 0 , 0 } ;
2013-08-27 18:15:20 -05:00
# ifdef DELTA
float endstop_adj [ 3 ] = { 0 , 0 , 0 } ;
# endif
2012-11-06 05:06:41 -06:00
float min_pos [ 3 ] = { X_MIN_POS , Y_MIN_POS , Z_MIN_POS } ;
float max_pos [ 3 ] = { X_MAX_POS , Y_MAX_POS , Z_MAX_POS } ;
2013-11-27 18:37:35 -06:00
bool axis_known_position [ 3 ] = { false , false , false } ;
2014-01-16 14:13:46 -06:00
float zprobe_zoffset ;
2013-08-07 09:10:26 -05:00
// Extruder offset
2013-03-26 15:43:04 -05:00
# if EXTRUDERS > 1
2013-08-07 09:10:26 -05:00
# ifndef DUAL_X_CARRIAGE
# define NUM_EXTRUDER_OFFSETS 2 // only in XY plane
# else
# define NUM_EXTRUDER_OFFSETS 3 // supports offsets in XYZ plane
# endif
float extruder_offset [ NUM_EXTRUDER_OFFSETS ] [ EXTRUDERS ] = {
2013-02-04 22:05:45 -06:00
# if defined(EXTRUDER_OFFSET_X) && defined(EXTRUDER_OFFSET_Y)
2013-06-06 17:49:25 -05:00
EXTRUDER_OFFSET_X , EXTRUDER_OFFSET_Y
2013-02-04 22:05:45 -06:00
# endif
2013-06-06 17:49:25 -05:00
} ;
2013-02-27 05:32:07 -06:00
# endif
2012-11-06 05:06:41 -06:00
uint8_t active_extruder = 0 ;
2012-12-03 05:13:20 -06:00
int fanSpeed = 0 ;
2013-06-06 11:18:03 -05:00
# ifdef SERVO_ENDSTOPS
int servo_endstops [ ] = SERVO_ENDSTOPS ;
int servo_endstop_angles [ ] = SERVO_ENDSTOP_ANGLES ;
# endif
2013-06-06 17:49:25 -05:00
# ifdef BARICUDA
int ValvePressure = 0 ;
int EtoPPressure = 0 ;
# endif
2012-11-06 05:06:41 -06:00
# ifdef FWRETRACT
bool autoretract_enabled = true ;
bool retracted = false ;
float retract_length = 3 , retract_feedrate = 17 * 60 , retract_zlift = 0.8 ;
float retract_recover_length = 0 , retract_recover_feedrate = 8 * 60 ;
# endif
2013-03-05 07:52:51 -06:00
# ifdef ULTIPANEL
2013-12-08 14:35:57 -06:00
# ifdef PS_DEFAULT_OFF
bool powersupply = false ;
# else
bool powersupply = true ;
# endif
2013-03-05 07:52:51 -06:00
# endif
2013-07-28 15:54:37 -05:00
# ifdef DELTA
float delta [ 3 ] = { 0.0 , 0.0 , 0.0 } ;
# endif
2014-02-05 03:47:12 -06:00
2012-11-06 05:06:41 -06:00
//===========================================================================
//=============================private variables=============================
//===========================================================================
const char axis_codes [ NUM_AXIS ] = { ' X ' , ' Y ' , ' Z ' , ' E ' } ;
static float destination [ NUM_AXIS ] = { 0.0 , 0.0 , 0.0 , 0.0 } ;
static float offset [ 3 ] = { 0.0 , 0.0 , 0.0 } ;
static bool home_all_axis = true ;
static float feedrate = 1500.0 , next_feedrate , saved_feedrate ;
static long gcode_N , gcode_LastN , Stopped_gcode_LastN = 0 ;
static bool relative_mode = false ; //Determines Absolute or Relative Coordinates
static char cmdbuffer [ BUFSIZE ] [ MAX_CMD_SIZE ] ;
static bool fromsd [ BUFSIZE ] ;
static int bufindr = 0 ;
static int bufindw = 0 ;
static int buflen = 0 ;
//static int i = 0;
static char serial_char ;
static int serial_count = 0 ;
static boolean comment_mode = false ;
static char * strchr_pointer ; // just a pointer to find chars in the cmd string like X, Y, Z, E, etc
const int sensitive_pins [ ] = SENSITIVE_PINS ; // Sensitive pin list for M42
//static float tt = 0;
//static float bt = 0;
//Inactivity shutdown variables
static unsigned long previous_millis_cmd = 0 ;
static unsigned long max_inactive_time = 0 ;
static unsigned long stepper_inactive_time = DEFAULT_STEPPER_DEACTIVE_TIME * 1000l ;
unsigned long starttime = 0 ;
unsigned long stoptime = 0 ;
static uint8_t tmp_extruder ;
bool Stopped = false ;
2013-06-06 17:49:25 -05:00
# if NUM_SERVOS > 0
Servo servos [ NUM_SERVOS ] ;
# endif
2013-07-14 14:10:24 -05:00
bool CooldownNoWait = true ;
bool target_direction ;
2012-11-06 05:06:41 -06:00
//===========================================================================
//=============================ROUTINES=============================
//===========================================================================
void get_arc_coordinates ( ) ;
bool setTargetedHotend ( int code ) ;
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 ) ; }
extern " C " {
extern unsigned int __bss_end ;
extern unsigned int __heap_start ;
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 ;
}
}
//adds an command to the main command buffer
//thats really done in a non-safe way.
//needs overworking someday
void enquecommand ( const char * cmd )
{
if ( buflen < BUFSIZE )
{
//this is dangerous if a mixing of serial and this happsens
strcpy ( & ( cmdbuffer [ bufindw ] [ 0 ] ) , cmd ) ;
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( " enqueing \" " ) ;
SERIAL_ECHO ( cmdbuffer [ bufindw ] ) ;
SERIAL_ECHOLNPGM ( " \" " ) ;
bufindw = ( bufindw + 1 ) % BUFSIZE ;
buflen + = 1 ;
}
}
2012-11-28 03:30:34 -06:00
void enquecommand_P ( const char * cmd )
{
if ( buflen < BUFSIZE )
{
//this is dangerous if a mixing of serial and this happsens
strcpy_P ( & ( cmdbuffer [ bufindw ] [ 0 ] ) , cmd ) ;
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( " enqueing \" " ) ;
SERIAL_ECHO ( cmdbuffer [ bufindw ] ) ;
SERIAL_ECHOLNPGM ( " \" " ) ;
bufindw = ( bufindw + 1 ) % BUFSIZE ;
buflen + = 1 ;
}
}
2012-11-06 05:06:41 -06:00
void setup_killpin ( )
{
2013-06-06 17:49:25 -05:00
# if defined(KILL_PIN) && KILL_PIN > -1
2012-11-06 05:06:41 -06:00
pinMode ( KILL_PIN , INPUT ) ;
WRITE ( KILL_PIN , HIGH ) ;
# endif
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
void setup_photpin ( )
{
2013-06-06 17:49:25 -05:00
# if defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1
2012-11-06 05:06:41 -06:00
SET_OUTPUT ( PHOTOGRAPH_PIN ) ;
WRITE ( PHOTOGRAPH_PIN , LOW ) ;
2013-06-06 17:49:25 -05:00
# endif
2012-11-06 05:06:41 -06:00
}
void setup_powerhold ( )
{
2013-06-06 17:49:25 -05:00
# if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
SET_OUTPUT ( SUICIDE_PIN ) ;
WRITE ( SUICIDE_PIN , HIGH ) ;
# endif
# if defined(PS_ON_PIN) && PS_ON_PIN > -1
SET_OUTPUT ( PS_ON_PIN ) ;
2013-10-29 12:44:56 -05:00
# if defined(PS_DEFAULT_OFF)
WRITE ( PS_ON_PIN , PS_ON_ASLEEP ) ;
# else
WRITE ( PS_ON_PIN , PS_ON_AWAKE ) ;
# endif
2013-06-06 17:49:25 -05:00
# endif
2012-11-06 05:06:41 -06:00
}
void suicide ( )
{
2013-06-06 17:49:25 -05:00
# if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
SET_OUTPUT ( SUICIDE_PIN ) ;
WRITE ( SUICIDE_PIN , LOW ) ;
# endif
}
void servo_init ( )
{
# if (NUM_SERVOS >= 1) && defined(SERVO0_PIN) && (SERVO0_PIN > -1)
servos [ 0 ] . attach ( SERVO0_PIN ) ;
# endif
# if (NUM_SERVOS >= 2) && defined(SERVO1_PIN) && (SERVO1_PIN > -1)
servos [ 1 ] . attach ( SERVO1_PIN ) ;
# endif
# if (NUM_SERVOS >= 3) && defined(SERVO2_PIN) && (SERVO2_PIN > -1)
servos [ 2 ] . attach ( SERVO2_PIN ) ;
# endif
# if (NUM_SERVOS >= 4) && defined(SERVO3_PIN) && (SERVO3_PIN > -1)
servos [ 3 ] . attach ( SERVO3_PIN ) ;
# endif
# if (NUM_SERVOS >= 5)
# error "TODO: enter initalisation code for more servos"
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 09:36:52 -05:00
// Set position of Servo Endstops that are defined
# ifdef SERVO_ENDSTOPS
for ( int8_t i = 0 ; i < 3 ; i + + )
{
if ( servo_endstops [ i ] > - 1 ) {
servos [ servo_endstops [ i ] ] . write ( servo_endstop_angles [ i * 2 + 1 ] ) ;
}
}
# endif
2013-09-29 11:20:06 -05:00
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
delay ( PROBE_SERVO_DEACTIVATION_DELAY ) ;
2013-12-08 14:35:57 -06:00
servos [ servo_endstops [ Z_AXIS ] ] . detach ( ) ;
2013-09-29 11:20:06 -05:00
# endif
2012-11-06 05:06:41 -06:00
}
void setup ( )
{
2013-06-06 17:49:25 -05:00
setup_killpin ( ) ;
2012-11-06 05:06:41 -06:00
setup_powerhold ( ) ;
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 ) ;
SERIAL_ECHOLNPGM ( VERSION_STRING ) ;
# ifdef STRING_VERSION_CONFIG_H
# ifdef STRING_CONFIG_H_AUTHOR
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_CONFIGURATION_VER ) ;
SERIAL_ECHOPGM ( STRING_VERSION_CONFIG_H ) ;
SERIAL_ECHOPGM ( MSG_AUTHOR ) ;
SERIAL_ECHOLNPGM ( STRING_CONFIG_H_AUTHOR ) ;
2012-11-21 13:36:30 -06:00
SERIAL_ECHOPGM ( " Compiled: " ) ;
SERIAL_ECHOLNPGM ( __DATE__ ) ;
2012-11-06 05:06:41 -06:00
# endif
# endif
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_FREE_MEMORY ) ;
SERIAL_ECHO ( freeMemory ( ) ) ;
SERIAL_ECHOPGM ( MSG_PLANNER_BUFFER_BYTES ) ;
SERIAL_ECHOLN ( ( int ) sizeof ( block_t ) * BLOCK_BUFFER_SIZE ) ;
for ( int8_t i = 0 ; i < BUFSIZE ; i + + )
{
fromsd [ i ] = false ;
}
2013-06-06 17:49:25 -05:00
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
// loads data from EEPROM if available else uses defaults (and resets step acceleration rate)
2013-06-06 17:49:25 -05:00
Config_RetrieveSettings ( ) ;
2012-11-06 05:06:41 -06:00
2013-06-06 17:49:25 -05:00
tp_init ( ) ; // Initialize temperature loop
2012-11-06 05:06:41 -06:00
plan_init ( ) ; // Initialize planner;
watchdog_init ( ) ;
st_init ( ) ; // Initialize stepper, this enables interrupts!
setup_photpin ( ) ;
2013-06-06 17:49:25 -05:00
servo_init ( ) ;
2012-12-03 05:52:00 -06:00
lcd_init ( ) ;
2013-07-14 03:28:26 -05:00
_delay_ms ( 1000 ) ; // wait 1sec to display the splash screen
2013-08-01 08:06:39 -05:00
2013-06-06 17:49:25 -05:00
# if defined(CONTROLLERFAN_PIN) && CONTROLLERFAN_PIN > -1
2013-03-26 15:43:04 -05:00
SET_OUTPUT ( CONTROLLERFAN_PIN ) ; //Set pin used for driver cooling fan
2013-08-01 08:06:39 -05:00
# endif
2014-02-05 03:47:12 -06:00
# ifdef DIGIPOT_I2C
digipot_i2c_init ( ) ;
# endif
2012-11-06 05:06:41 -06:00
}
void loop ( )
{
if ( buflen < ( BUFSIZE - 1 ) )
get_command ( ) ;
# ifdef SDSUPPORT
card . checkautostart ( false ) ;
# endif
if ( buflen )
{
# ifdef SDSUPPORT
if ( card . saving )
{
2013-06-06 17:49:25 -05:00
if ( strstr_P ( cmdbuffer [ bufindr ] , PSTR ( " M29 " ) ) = = NULL )
{
card . write_command ( cmdbuffer [ bufindr ] ) ;
2013-03-16 17:02:57 -05:00
if ( card . logging )
{
2013-03-16 17:11:58 -05:00
process_commands ( ) ;
2013-03-16 17:02:57 -05:00
}
else
{
2013-03-16 17:11:58 -05:00
SERIAL_PROTOCOLLNPGM ( MSG_OK ) ;
2013-03-16 17:02:57 -05:00
}
2013-06-06 17:49:25 -05:00
}
else
{
card . closefile ( ) ;
SERIAL_PROTOCOLLNPGM ( MSG_FILE_SAVED ) ;
}
2012-11-06 05:06:41 -06:00
}
else
{
2013-06-06 17:49:25 -05:00
process_commands ( ) ;
2012-11-06 05:06:41 -06:00
}
# else
process_commands ( ) ;
# endif //SDSUPPORT
buflen = ( buflen - 1 ) ;
bufindr = ( bufindr + 1 ) % BUFSIZE ;
}
//check heater every n milliseconds
manage_heater ( ) ;
manage_inactivity ( ) ;
checkHitEndstops ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
}
2013-06-06 17:49:25 -05:00
void get_command ( )
{
2012-11-06 05:06:41 -06:00
while ( MYSERIAL . available ( ) > 0 & & buflen < BUFSIZE ) {
serial_char = MYSERIAL . read ( ) ;
2013-06-06 17:49:25 -05:00
if ( serial_char = = ' \n ' | |
serial_char = = ' \r ' | |
( serial_char = = ' : ' & & comment_mode = = false ) | |
serial_count > = ( MAX_CMD_SIZE - 1 ) )
2012-11-06 05:06:41 -06:00
{
if ( ! serial_count ) { //if empty line
comment_mode = false ; //for new command
return ;
}
cmdbuffer [ bufindw ] [ serial_count ] = 0 ; //terminate string
if ( ! comment_mode ) {
comment_mode = false ; //for new command
fromsd [ bufindw ] = false ;
2012-11-28 03:30:34 -06:00
if ( strchr ( cmdbuffer [ bufindw ] , ' N ' ) ! = NULL )
2012-11-06 05:06:41 -06:00
{
strchr_pointer = strchr ( cmdbuffer [ bufindw ] , ' N ' ) ;
gcode_N = ( strtol ( & cmdbuffer [ bufindw ] [ strchr_pointer - cmdbuffer [ bufindw ] + 1 ] , NULL , 10 ) ) ;
2012-11-28 03:30:34 -06:00
if ( gcode_N ! = gcode_LastN + 1 & & ( strstr_P ( cmdbuffer [ bufindw ] , PSTR ( " M110 " ) ) = = NULL ) ) {
2012-11-06 05:06:41 -06:00
SERIAL_ERROR_START ;
SERIAL_ERRORPGM ( MSG_ERR_LINE_NO ) ;
SERIAL_ERRORLN ( gcode_LastN ) ;
//Serial.println(gcode_N);
FlushSerialRequestResend ( ) ;
serial_count = 0 ;
return ;
}
2012-11-28 03:30:34 -06:00
if ( strchr ( cmdbuffer [ bufindw ] , ' * ' ) ! = NULL )
2012-11-06 05:06:41 -06:00
{
byte checksum = 0 ;
byte count = 0 ;
while ( cmdbuffer [ bufindw ] [ count ] ! = ' * ' ) checksum = checksum ^ cmdbuffer [ bufindw ] [ count + + ] ;
strchr_pointer = strchr ( cmdbuffer [ bufindw ] , ' * ' ) ;
if ( ( int ) ( strtod ( & cmdbuffer [ bufindw ] [ strchr_pointer - cmdbuffer [ bufindw ] + 1 ] , NULL ) ) ! = checksum ) {
SERIAL_ERROR_START ;
SERIAL_ERRORPGM ( MSG_ERR_CHECKSUM_MISMATCH ) ;
SERIAL_ERRORLN ( gcode_LastN ) ;
FlushSerialRequestResend ( ) ;
serial_count = 0 ;
return ;
}
//if no errors, continue parsing
}
2013-06-06 17:49:25 -05:00
else
2012-11-06 05:06:41 -06:00
{
SERIAL_ERROR_START ;
SERIAL_ERRORPGM ( MSG_ERR_NO_CHECKSUM ) ;
SERIAL_ERRORLN ( gcode_LastN ) ;
FlushSerialRequestResend ( ) ;
serial_count = 0 ;
return ;
}
gcode_LastN = gcode_N ;
//if no errors, continue parsing
}
else // if we don't receive 'N' but still see '*'
{
2012-11-28 03:30:34 -06:00
if ( ( strchr ( cmdbuffer [ bufindw ] , ' * ' ) ! = NULL ) )
2012-11-06 05:06:41 -06:00
{
SERIAL_ERROR_START ;
SERIAL_ERRORPGM ( MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM ) ;
SERIAL_ERRORLN ( gcode_LastN ) ;
serial_count = 0 ;
return ;
}
}
2012-11-28 03:30:34 -06:00
if ( ( strchr ( cmdbuffer [ bufindw ] , ' G ' ) ! = NULL ) ) {
2012-11-06 05:06:41 -06:00
strchr_pointer = strchr ( cmdbuffer [ bufindw ] , ' G ' ) ;
switch ( ( int ) ( ( strtod ( & cmdbuffer [ bufindw ] [ strchr_pointer - cmdbuffer [ bufindw ] + 1 ] , NULL ) ) ) ) {
case 0 :
case 1 :
case 2 :
case 3 :
if ( Stopped = = false ) { // If printer is stopped by an error the G[0-3] codes are ignored.
2013-06-06 17:49:25 -05:00
# ifdef SDSUPPORT
2012-11-06 05:06:41 -06:00
if ( card . saving )
break ;
2013-06-06 17:49:25 -05:00
# endif //SDSUPPORT
SERIAL_PROTOCOLLNPGM ( MSG_OK ) ;
2012-11-06 05:06:41 -06:00
}
else {
SERIAL_ERRORLNPGM ( MSG_ERR_STOPPED ) ;
LCD_MESSAGEPGM ( MSG_STOPPED ) ;
}
break ;
default :
break ;
}
}
bufindw = ( bufindw + 1 ) % BUFSIZE ;
buflen + = 1 ;
}
serial_count = 0 ; //clear buffer
}
else
{
if ( serial_char = = ' ; ' ) comment_mode = true ;
if ( ! comment_mode ) cmdbuffer [ bufindw ] [ serial_count + + ] = serial_char ;
}
}
# ifdef SDSUPPORT
if ( ! card . sdprinting | | serial_count ! = 0 ) {
return ;
}
2013-12-08 14:35:57 -06:00
2013-10-22 02:54:13 -05:00
//'#' stops reading from sd to the buffer prematurely, so procedural macro calls are possible
2013-12-08 14:35:57 -06:00
// if it occures, stop_buffering is triggered and the buffer is ran dry.
2013-10-22 02:54:13 -05:00
// this character _can_ occure in serial com, due to checksums. however, no checksums are used in sd printing
2013-12-08 14:35:57 -06:00
2013-10-22 02:54:13 -05:00
static bool stop_buffering = false ;
if ( buflen = = 0 ) stop_buffering = false ;
2013-12-08 14:35:57 -06:00
while ( ! card . eof ( ) & & buflen < BUFSIZE & & ! stop_buffering ) {
2012-11-06 05:06:41 -06:00
int16_t n = card . get ( ) ;
2013-12-08 14:35:57 -06:00
serial_char = ( char ) n ;
2013-06-06 17:49:25 -05:00
if ( serial_char = = ' \n ' | |
serial_char = = ' \r ' | |
2013-10-22 03:34:51 -05:00
( serial_char = = ' # ' & & comment_mode = = false ) | |
2013-06-06 17:49:25 -05:00
( serial_char = = ' : ' & & comment_mode = = false ) | |
serial_count > = ( MAX_CMD_SIZE - 1 ) | | n = = - 1 )
2012-11-06 05:06:41 -06:00
{
if ( card . eof ( ) ) {
SERIAL_PROTOCOLLNPGM ( MSG_FILE_PRINTED ) ;
stoptime = millis ( ) ;
char time [ 30 ] ;
unsigned long t = ( stoptime - starttime ) / 1000 ;
2012-12-19 05:26:40 -06:00
int hours , minutes ;
minutes = ( t / 60 ) % 60 ;
hours = t / 60 / 60 ;
sprintf_P ( time , PSTR ( " %i hours %i minutes " ) , hours , minutes ) ;
2012-11-06 05:06:41 -06:00
SERIAL_ECHO_START ;
SERIAL_ECHOLN ( time ) ;
2012-12-03 05:52:00 -06:00
lcd_setstatus ( time ) ;
2012-11-06 05:06:41 -06:00
card . printingHasFinished ( ) ;
card . checkautostart ( true ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
}
2013-10-22 02:54:13 -05:00
if ( serial_char = = ' # ' )
stop_buffering = true ;
2013-12-08 14:35:57 -06:00
2012-11-06 05:06:41 -06:00
if ( ! serial_count )
{
comment_mode = false ; //for new command
return ; //if empty line
}
cmdbuffer [ bufindw ] [ serial_count ] = 0 ; //terminate string
// if(!comment_mode){
fromsd [ bufindw ] = true ;
buflen + = 1 ;
bufindw = ( bufindw + 1 ) % BUFSIZE ;
2013-06-06 17:49:25 -05:00
// }
2012-11-06 05:06:41 -06:00
comment_mode = false ; //for new command
serial_count = 0 ; //clear buffer
}
else
{
if ( serial_char = = ' ; ' ) comment_mode = true ;
if ( ! comment_mode ) cmdbuffer [ bufindw ] [ serial_count + + ] = serial_char ;
}
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
# endif //SDSUPPORT
}
2013-06-06 17:49:25 -05:00
float code_value ( )
{
return ( strtod ( & cmdbuffer [ bufindr ] [ strchr_pointer - cmdbuffer [ bufindr ] + 1 ] , NULL ) ) ;
2012-11-06 05:06:41 -06:00
}
2013-06-06 17:49:25 -05:00
long code_value_long ( )
{
return ( strtol ( & cmdbuffer [ bufindr ] [ strchr_pointer - cmdbuffer [ bufindr ] + 1 ] , NULL , 10 ) ) ;
2012-11-06 05:06:41 -06:00
}
bool code_seen ( char code )
{
strchr_pointer = strchr ( cmdbuffer [ bufindr ] , code ) ;
return ( strchr_pointer ! = NULL ) ; //Return True if a character was found
}
2013-06-06 17:49:25 -05:00
# define DEFINE_PGM_READ_ANY(type, reader) \
static inline type pgm_read_any ( const type * p ) \
{ return pgm_read_ # # reader # # _near ( p ) ; }
2012-11-06 05:06:41 -06:00
DEFINE_PGM_READ_ANY ( float , float ) ;
DEFINE_PGM_READ_ANY ( signed char , byte ) ;
2013-06-06 17:49:25 -05:00
# define XYZ_CONSTS_FROM_CONFIG(type, array, CONFIG) \
static const PROGMEM type array # # _P [ 3 ] = \
{ X_ # # CONFIG , Y_ # # CONFIG , Z_ # # CONFIG } ; \
static inline type array ( int axis ) \
2012-11-06 05:06:41 -06:00
{ return pgm_read_any ( & array # # _P [ axis ] ) ; }
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_retract_mm , HOME_RETRACT_MM ) ;
XYZ_CONSTS_FROM_CONFIG ( signed char , home_dir , HOME_DIR ) ;
2013-07-17 07:44:45 -05:00
# ifdef DUAL_X_CARRIAGE
# if EXTRUDERS == 1 || defined(COREXY) \
| | ! defined ( X2_ENABLE_PIN ) | | ! defined ( X2_STEP_PIN ) | | ! defined ( X2_DIR_PIN ) \
| | ! defined ( X2_HOME_POS ) | | ! defined ( X2_MIN_POS ) | | ! defined ( X2_MAX_POS ) \
| | ! defined ( X_MAX_PIN ) | | X_MAX_PIN < 0
# error "Missing or invalid definitions for DUAL_X_CARRIAGE mode."
# endif
# if X_HOME_DIR != -1 || X2_HOME_DIR != 1
# error "Please use canonical x-carriage assignment" // the x-carriages are defined by their homing directions
2013-12-08 14:35:57 -06:00
# endif
2013-08-01 08:06:39 -05:00
2013-08-07 09:10:26 -05:00
# define DXC_FULL_CONTROL_MODE 0
# define DXC_AUTO_PARK_MODE 1
# define DXC_DUPLICATION_MODE 2
static int dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE ;
2013-12-08 14:35:57 -06:00
2013-07-17 07:44:45 -05:00
static float x_home_pos ( int extruder ) {
if ( extruder = = 0 )
return base_home_pos ( X_AXIS ) + add_homeing [ X_AXIS ] ;
else
// In dual carriage mode the extruder offset provides an override of the
// second X-carriage offset when homed - otherwise X2_HOME_POS is used.
2013-08-01 08:06:39 -05:00
// This allow soft recalibration of the second extruder offset position without firmware reflash
2013-07-17 07:44:45 -05:00
// (through the M218 command).
2013-07-22 07:46:14 -05:00
return ( extruder_offset [ X_AXIS ] [ 1 ] > 0 ) ? extruder_offset [ X_AXIS ] [ 1 ] : X2_HOME_POS ;
2013-07-17 07:44:45 -05:00
}
static int x_home_dir ( int extruder ) {
return ( extruder = = 0 ) ? X_HOME_DIR : X2_HOME_DIR ;
}
2013-08-07 09:10:26 -05:00
static float inactive_extruder_x_pos = X2_MAX_POS ; // used in mode 0 & 1
static bool active_extruder_parked = false ; // used in mode 1 & 2
2013-12-08 14:35:57 -06:00
static float raised_parked_position [ NUM_AXIS ] ; // used in mode 1
static unsigned long delayed_move_time = 0 ; // used in mode 1
2013-08-07 09:10:26 -05:00
static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET ; // used in mode 2
static float duplicate_extruder_temp_offset = 0 ; // used in mode 2
bool extruder_duplication_enabled = false ; // used in mode 2
2014-02-05 03:47:12 -06:00
# endif //DUAL_X_CARRIAGE
2013-07-17 07:44:45 -05:00
2012-11-06 05:06:41 -06:00
static void axis_is_at_home ( int axis ) {
2013-07-17 07:44:45 -05:00
# ifdef DUAL_X_CARRIAGE
2013-08-07 09:10:26 -05:00
if ( axis = = X_AXIS ) {
if ( active_extruder ! = 0 ) {
current_position [ X_AXIS ] = x_home_pos ( active_extruder ) ;
min_pos [ X_AXIS ] = X2_MIN_POS ;
max_pos [ X_AXIS ] = max ( extruder_offset [ X_AXIS ] [ 1 ] , X2_MAX_POS ) ;
return ;
}
else if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE & & active_extruder = = 0 ) {
current_position [ X_AXIS ] = base_home_pos ( X_AXIS ) + add_homeing [ X_AXIS ] ;
2014-02-05 03:47:12 -06:00
min_pos [ X_AXIS ] = base_min_pos ( X_AXIS ) + add_homeing [ X_AXIS ] ;
max_pos [ X_AXIS ] = min ( base_max_pos ( X_AXIS ) + add_homeing [ X_AXIS ] ,
2013-08-07 09:10:26 -05:00
max ( extruder_offset [ X_AXIS ] [ 1 ] , X2_MAX_POS ) - duplicate_extruder_x_offset ) ;
return ;
}
2013-07-17 07:44:45 -05:00
}
2013-08-01 08:06:39 -05:00
# endif
2012-11-06 05:06:41 -06:00
current_position [ axis ] = base_home_pos ( axis ) + add_homeing [ axis ] ;
min_pos [ axis ] = base_min_pos ( axis ) + add_homeing [ axis ] ;
max_pos [ axis ] = base_max_pos ( axis ) + add_homeing [ axis ] ;
}
2013-09-29 11:20:06 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
2013-12-06 14:46:25 -06:00
# ifdef ACCURATE_BED_LEVELING
static void set_bed_level_equation_lsq ( double * plane_equation_coefficients )
{
vector_3 planeNormal = vector_3 ( - plane_equation_coefficients [ 0 ] , - plane_equation_coefficients [ 1 ] , 1 ) ;
planeNormal . debug ( " planeNormal " ) ;
plan_bed_level_matrix = matrix_3x3 : : create_look_at ( planeNormal ) ;
//bedLevel.debug("bedLevel");
2013-12-11 14:27:43 -06:00
//plan_bed_level_matrix.debug("bed level before");
2013-12-06 14:46:25 -06:00
//vector_3 uncorrected_position = plan_get_position_mm();
//uncorrected_position.debug("position before");
vector_3 corrected_position = plan_get_position ( ) ;
// corrected_position.debug("position after");
current_position [ X_AXIS ] = corrected_position . x ;
current_position [ Y_AXIS ] = corrected_position . y ;
current_position [ Z_AXIS ] = corrected_position . z ;
// but the bed at 0 so we don't go below it.
2014-01-16 14:13:46 -06:00
current_position [ Z_AXIS ] = zprobe_zoffset ; // in the lsq we reach here after raising the extruder due to the loop structure
2013-12-06 14:46:25 -06:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
}
# else
2013-09-29 11:20:06 -05:00
static void set_bed_level_equation ( float z_at_xLeft_yFront , float z_at_xRight_yFront , float z_at_xLeft_yBack ) {
plan_bed_level_matrix . set_to_identity ( ) ;
vector_3 xLeftyFront = vector_3 ( LEFT_PROBE_BED_POSITION , FRONT_PROBE_BED_POSITION , z_at_xLeft_yFront ) ;
vector_3 xLeftyBack = vector_3 ( LEFT_PROBE_BED_POSITION , BACK_PROBE_BED_POSITION , z_at_xLeft_yBack ) ;
vector_3 xRightyFront = vector_3 ( RIGHT_PROBE_BED_POSITION , FRONT_PROBE_BED_POSITION , z_at_xRight_yFront ) ;
vector_3 xPositive = ( xRightyFront - xLeftyFront ) . get_normal ( ) ;
vector_3 yPositive = ( xLeftyBack - xLeftyFront ) . get_normal ( ) ;
2013-12-06 14:32:21 -06:00
vector_3 planeNormal = vector_3 : : cross ( xPositive , yPositive ) . get_normal ( ) ;
2013-09-29 11:20:06 -05:00
//planeNormal.debug("planeNormal");
//yPositive.debug("yPositive");
2013-12-06 14:32:21 -06:00
plan_bed_level_matrix = matrix_3x3 : : create_look_at ( planeNormal ) ;
2013-09-29 11:20:06 -05:00
//bedLevel.debug("bedLevel");
//plan_bed_level_matrix.debug("bed level before");
//vector_3 uncorrected_position = plan_get_position_mm();
//uncorrected_position.debug("position before");
// and set our bed level equation to do the right thing
//plan_bed_level_matrix.debug("bed level after");
vector_3 corrected_position = plan_get_position ( ) ;
//corrected_position.debug("position after");
current_position [ X_AXIS ] = corrected_position . x ;
current_position [ Y_AXIS ] = corrected_position . y ;
current_position [ Z_AXIS ] = corrected_position . z ;
// but the bed at 0 so we don't go below it.
2014-01-16 14:13:46 -06:00
current_position [ Z_AXIS ] = zprobe_zoffset ;
2013-09-29 11:20:06 -05:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
}
2013-12-06 14:46:25 -06:00
# endif // ACCURATE_BED_LEVELING
2013-09-29 11:20:06 -05:00
static void run_z_probe ( ) {
plan_bed_level_matrix . set_to_identity ( ) ;
feedrate = homing_feedrate [ Z_AXIS ] ;
// move down until you find the bed
float zPosition = - 10 ;
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , zPosition , current_position [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
// we have to let the planner know where we are right now as it is not where we said to go.
zPosition = st_get_position_mm ( Z_AXIS ) ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , zPosition , current_position [ E_AXIS ] ) ;
// move up the retract distance
zPosition + = home_retract_mm ( Z_AXIS ) ;
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , zPosition , current_position [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
// move back down slowly to find bed
2014-02-05 03:47:12 -06:00
feedrate = homing_feedrate [ Z_AXIS ] / 4 ;
2013-09-29 11:20:06 -05:00
zPosition - = home_retract_mm ( Z_AXIS ) * 2 ;
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , zPosition , current_position [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
current_position [ Z_AXIS ] = st_get_position_mm ( Z_AXIS ) ;
// make sure the planner knows where we are as it may be a bit different than we last said to move to
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
}
static void do_blocking_move_to ( float x , float y , float z ) {
float oldFeedRate = feedrate ;
feedrate = XY_TRAVEL_SPEED ;
current_position [ X_AXIS ] = x ;
current_position [ Y_AXIS ] = y ;
current_position [ Z_AXIS ] = z ;
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
feedrate = oldFeedRate ;
}
static void do_blocking_move_relative ( float offset_x , float offset_y , float offset_z ) {
do_blocking_move_to ( current_position [ X_AXIS ] + offset_x , current_position [ Y_AXIS ] + offset_y , current_position [ Z_AXIS ] + offset_z ) ;
}
static void setup_for_endstop_move ( ) {
saved_feedrate = feedrate ;
saved_feedmultiply = feedmultiply ;
feedmultiply = 100 ;
previous_millis_cmd = millis ( ) ;
enable_endstops ( true ) ;
}
static void clean_up_after_endstop_move ( ) {
# ifdef ENDSTOPS_ONLY_FOR_HOMING
enable_endstops ( false ) ;
# endif
feedrate = saved_feedrate ;
feedmultiply = saved_feedmultiply ;
previous_millis_cmd = millis ( ) ;
}
static void engage_z_probe ( ) {
// Engage Z Servo endstop if enabled
# ifdef SERVO_ENDSTOPS
if ( servo_endstops [ Z_AXIS ] > - 1 ) {
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
servos [ servo_endstops [ Z_AXIS ] ] . attach ( 0 ) ;
# endif
servos [ servo_endstops [ Z_AXIS ] ] . write ( servo_endstop_angles [ Z_AXIS * 2 ] ) ;
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
delay ( PROBE_SERVO_DEACTIVATION_DELAY ) ;
servos [ servo_endstops [ Z_AXIS ] ] . detach ( ) ;
# endif
}
# endif
}
static void retract_z_probe ( ) {
// Retract Z Servo endstop if enabled
# ifdef SERVO_ENDSTOPS
if ( servo_endstops [ Z_AXIS ] > - 1 ) {
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
servos [ servo_endstops [ Z_AXIS ] ] . attach ( 0 ) ;
# endif
servos [ servo_endstops [ Z_AXIS ] ] . write ( servo_endstop_angles [ Z_AXIS * 2 + 1 ] ) ;
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
delay ( PROBE_SERVO_DEACTIVATION_DELAY ) ;
servos [ servo_endstops [ Z_AXIS ] ] . detach ( ) ;
# endif
}
# endif
}
# endif // #ifdef ENABLE_AUTO_BED_LEVELING
2012-11-06 05:06:41 -06:00
static void homeaxis ( int axis ) {
# define HOMEAXIS_DO(LETTER) \
( ( LETTER # # _MIN_PIN > - 1 & & LETTER # # _HOME_DIR = = - 1 ) | | ( LETTER # # _MAX_PIN > - 1 & & LETTER # # _HOME_DIR = = 1 ) )
2013-07-17 07:44:45 -05:00
2012-11-06 05:06:41 -06:00
if ( axis = = X_AXIS ? HOMEAXIS_DO ( X ) :
axis = = Y_AXIS ? HOMEAXIS_DO ( Y ) :
axis = = Z_AXIS ? HOMEAXIS_DO ( Z ) :
0 ) {
2013-07-17 07:44:45 -05:00
int axis_home_dir = home_dir ( axis ) ;
# ifdef DUAL_X_CARRIAGE
if ( axis = = X_AXIS )
axis_home_dir = x_home_dir ( active_extruder ) ;
# endif
2013-06-06 09:36:52 -05:00
2013-10-12 15:28:11 -05:00
current_position [ axis ] = 0 ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2014-02-05 03:47:12 -06:00
2013-11-27 18:37:35 -06:00
2013-06-06 09:36:52 -05:00
// Engage Servo endstop if enabled
2013-06-28 10:02:04 -05:00
# ifdef SERVO_ENDSTOPS
2013-10-12 15:28:11 -05:00
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
if ( axis = = Z_AXIS ) {
engage_z_probe ( ) ;
}
else
# endif
2013-09-11 16:09:37 -05:00
if ( servo_endstops [ axis ] > - 1 ) {
2013-06-28 10:02:04 -05:00
servos [ servo_endstops [ axis ] ] . write ( servo_endstop_angles [ axis * 2 ] ) ;
}
2013-06-06 09:36:52 -05:00
# endif
2013-08-01 08:06:39 -05:00
2013-07-19 22:07:50 -05:00
destination [ axis ] = 1.5 * max_length ( axis ) * axis_home_dir ;
2012-11-06 05:06:41 -06:00
feedrate = homing_feedrate [ axis ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
current_position [ axis ] = 0 ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2013-07-19 22:07:50 -05:00
destination [ axis ] = - home_retract_mm ( axis ) * axis_home_dir ;
2012-11-06 05:06:41 -06:00
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
2013-06-06 17:49:25 -05:00
2013-07-19 22:07:50 -05:00
destination [ axis ] = 2 * home_retract_mm ( axis ) * axis_home_dir ;
2013-07-17 18:14:07 -05:00
# ifdef DELTA
feedrate = homing_feedrate [ axis ] / 10 ;
# else
2013-06-06 17:49:25 -05:00
feedrate = homing_feedrate [ axis ] / 2 ;
2013-07-17 18:14:07 -05:00
# endif
2012-11-06 05:06:41 -06:00
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
2013-08-27 18:15:20 -05:00
# ifdef DELTA
// retrace by the amount specified in endstop_adj
if ( endstop_adj [ axis ] * axis_home_dir < 0 ) {
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
destination [ axis ] = endstop_adj [ axis ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
}
# endif
2013-06-06 17:49:25 -05:00
axis_is_at_home ( axis ) ;
2012-11-06 05:06:41 -06:00
destination [ axis ] = current_position [ axis ] ;
feedrate = 0.0 ;
endstops_hit_on_purpose ( ) ;
2013-11-27 18:37:35 -06:00
axis_known_position [ axis ] = true ;
2013-06-06 09:36:52 -05:00
// Retract Servo endstop if enabled
2013-06-28 10:02:04 -05:00
# ifdef SERVO_ENDSTOPS
2013-09-11 16:09:37 -05:00
if ( servo_endstops [ axis ] > - 1 ) {
2013-06-28 10:02:04 -05:00
servos [ servo_endstops [ axis ] ] . write ( servo_endstop_angles [ axis * 2 + 1 ] ) ;
}
2013-06-06 09:36:52 -05:00
# endif
2013-09-29 11:20:06 -05:00
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
if ( axis = = Z_AXIS ) retract_z_probe ( ) ;
# endif
2014-02-05 03:47:12 -06:00
2012-11-06 05:06:41 -06:00
}
}
# define HOMEAXIS(LETTER) homeaxis(LETTER##_AXIS)
void process_commands ( )
{
unsigned long codenum ; //throw away variable
char * starpos = NULL ;
2013-09-29 11:20:06 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
float x_tmp , y_tmp , z_tmp , real_z ;
# endif
2012-11-06 05:06:41 -06:00
if ( code_seen ( ' G ' ) )
{
switch ( ( int ) code_value ( ) )
{
case 0 : // G0 -> G1
case 1 : // G1
if ( Stopped = = false ) {
get_coordinates ( ) ; // For X Y Z E F
prepare_move ( ) ;
//ClearToSend();
return ;
}
//break;
case 2 : // G2 - CW ARC
if ( Stopped = = false ) {
get_arc_coordinates ( ) ;
prepare_arc_move ( true ) ;
return ;
}
case 3 : // G3 - CCW ARC
if ( Stopped = = false ) {
get_arc_coordinates ( ) ;
prepare_arc_move ( false ) ;
return ;
}
case 4 : // G4 dwell
LCD_MESSAGEPGM ( MSG_DWELL ) ;
codenum = 0 ;
if ( code_seen ( ' P ' ) ) codenum = code_value ( ) ; // milliseconds to wait
if ( code_seen ( ' S ' ) ) codenum = code_value ( ) * 1000 ; // seconds to wait
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
st_synchronize ( ) ;
codenum + = millis ( ) ; // keep track of when we started waiting
previous_millis_cmd = millis ( ) ;
while ( millis ( ) < codenum ) {
manage_heater ( ) ;
manage_inactivity ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
}
break ;
2013-06-06 17:49:25 -05:00
# ifdef FWRETRACT
2012-11-06 05:06:41 -06:00
case 10 : // G10 retract
2013-06-06 17:49:25 -05:00
if ( ! retracted )
2012-11-06 05:06:41 -06:00
{
destination [ X_AXIS ] = current_position [ X_AXIS ] ;
destination [ Y_AXIS ] = current_position [ Y_AXIS ] ;
2013-06-06 17:49:25 -05:00
destination [ Z_AXIS ] = current_position [ Z_AXIS ] ;
2012-11-06 05:06:41 -06:00
current_position [ Z_AXIS ] + = - retract_zlift ;
2013-06-06 17:49:25 -05:00
destination [ E_AXIS ] = current_position [ E_AXIS ] - retract_length ;
2012-11-06 05:06:41 -06:00
feedrate = retract_feedrate ;
retracted = true ;
prepare_move ( ) ;
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
break ;
2013-10-24 20:58:42 -05:00
case 11 : // G11 retract_recover
if ( retracted )
2012-11-06 05:06:41 -06:00
{
destination [ X_AXIS ] = current_position [ X_AXIS ] ;
destination [ Y_AXIS ] = current_position [ Y_AXIS ] ;
2013-06-06 17:49:25 -05:00
destination [ Z_AXIS ] = current_position [ Z_AXIS ] ;
2012-11-06 05:06:41 -06:00
current_position [ Z_AXIS ] + = retract_zlift ;
2014-02-05 03:47:12 -06:00
destination [ E_AXIS ] = current_position [ E_AXIS ] + retract_length + retract_recover_length ;
2012-11-06 05:06:41 -06:00
feedrate = retract_recover_feedrate ;
retracted = false ;
prepare_move ( ) ;
}
break ;
# endif //FWRETRACT
case 28 : //G28 Home all Axis one at a time
2013-09-29 11:20:06 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
plan_bed_level_matrix . set_to_identity ( ) ; //Reset the plane ("erase" all leveling data)
# endif //ENABLE_AUTO_BED_LEVELING
2012-11-06 05:06:41 -06:00
saved_feedrate = feedrate ;
saved_feedmultiply = feedmultiply ;
feedmultiply = 100 ;
previous_millis_cmd = millis ( ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
enable_endstops ( true ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
destination [ i ] = current_position [ i ] ;
}
2013-08-07 09:10:26 -05:00
feedrate = 0.0 ;
2013-06-09 23:10:00 -05:00
# ifdef DELTA
// A delta can only safely home all axis at the same time
// all axis have to home at the same time
// Move all carriages up together until the first endstop is hit.
current_position [ X_AXIS ] = 0 ;
current_position [ Y_AXIS ] = 0 ;
current_position [ Z_AXIS ] = 0 ;
2013-08-01 08:06:39 -05:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2013-06-09 23:10:00 -05:00
destination [ X_AXIS ] = 3 * Z_MAX_LENGTH ;
destination [ Y_AXIS ] = 3 * Z_MAX_LENGTH ;
destination [ Z_AXIS ] = 3 * Z_MAX_LENGTH ;
feedrate = 1.732 * homing_feedrate [ X_AXIS ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
endstops_hit_on_purpose ( ) ;
current_position [ X_AXIS ] = destination [ X_AXIS ] ;
current_position [ Y_AXIS ] = destination [ Y_AXIS ] ;
current_position [ Z_AXIS ] = destination [ Z_AXIS ] ;
2013-08-01 08:06:39 -05:00
2013-06-09 23:10:00 -05:00
// take care of back off and rehome now we are all at the top
HOMEAXIS ( X ) ;
HOMEAXIS ( Y ) ;
HOMEAXIS ( Z ) ;
calculate_delta ( current_position ) ;
plan_set_position ( delta [ X_AXIS ] , delta [ Y_AXIS ] , delta [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
# else // NOT DELTA
2013-07-19 22:07:50 -05:00
home_all_axis = ! ( ( code_seen ( axis_codes [ 0 ] ) ) | | ( code_seen ( axis_codes [ 1 ] ) ) | | ( code_seen ( axis_codes [ 2 ] ) ) ) ;
2013-06-09 23:10:00 -05:00
2012-11-06 05:06:41 -06:00
# if Z_HOME_DIR > 0 // If homing away from BED do Z first
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ Z_AXIS ] ) ) ) {
HOMEAXIS ( Z ) ;
}
# endif
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
# ifdef QUICK_HOME
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ X_AXIS ] ) & & code_seen ( axis_codes [ Y_AXIS ] ) ) ) //first diagonal move
{
2013-06-06 17:49:25 -05:00
current_position [ X_AXIS ] = 0 ; current_position [ Y_AXIS ] = 0 ;
2012-11-06 05:06:41 -06:00
2013-07-22 07:46:14 -05:00
# ifndef DUAL_X_CARRIAGE
2013-07-17 07:44:45 -05:00
int x_axis_home_dir = home_dir ( X_AXIS ) ;
# else
int x_axis_home_dir = x_home_dir ( active_extruder ) ;
2013-08-07 09:10:26 -05:00
extruder_duplication_enabled = false ;
2013-07-17 07:44:45 -05:00
# endif
2013-08-01 08:06:39 -05:00
2013-06-06 17:49:25 -05:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2013-07-17 07:44:45 -05:00
destination [ X_AXIS ] = 1.5 * max_length ( X_AXIS ) * x_axis_home_dir ; destination [ Y_AXIS ] = 1.5 * max_length ( Y_AXIS ) * home_dir ( Y_AXIS ) ;
2013-06-06 17:49:25 -05:00
feedrate = homing_feedrate [ X_AXIS ] ;
2012-11-06 05:06:41 -06:00
if ( homing_feedrate [ Y_AXIS ] < feedrate )
2013-06-06 17:49:25 -05:00
feedrate = homing_feedrate [ Y_AXIS ] ;
2012-11-06 05:06:41 -06:00
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
st_synchronize ( ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
axis_is_at_home ( X_AXIS ) ;
axis_is_at_home ( Y_AXIS ) ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
destination [ X_AXIS ] = current_position [ X_AXIS ] ;
destination [ Y_AXIS ] = current_position [ Y_AXIS ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
feedrate = 0.0 ;
st_synchronize ( ) ;
endstops_hit_on_purpose ( ) ;
2012-12-10 03:04:12 -06:00
current_position [ X_AXIS ] = destination [ X_AXIS ] ;
current_position [ Y_AXIS ] = destination [ Y_AXIS ] ;
current_position [ Z_AXIS ] = destination [ Z_AXIS ] ;
2012-11-06 05:06:41 -06:00
}
# endif
2013-06-06 17:49:25 -05:00
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ X_AXIS ] ) ) )
2012-11-06 05:06:41 -06:00
{
2013-07-17 07:44:45 -05:00
# ifdef DUAL_X_CARRIAGE
int tmp_extruder = active_extruder ;
2013-08-07 09:10:26 -05:00
extruder_duplication_enabled = false ;
2013-07-17 07:44:45 -05:00
active_extruder = ! active_extruder ;
HOMEAXIS ( X ) ;
2013-08-07 09:10:26 -05:00
inactive_extruder_x_pos = current_position [ X_AXIS ] ;
2013-07-17 07:44:45 -05:00
active_extruder = tmp_extruder ;
2012-11-06 05:06:41 -06:00
HOMEAXIS ( X ) ;
2013-08-07 09:10:26 -05:00
// reset state used by the different modes
memcpy ( raised_parked_position , current_position , sizeof ( raised_parked_position ) ) ;
delayed_move_time = 0 ;
2014-02-05 03:47:12 -06:00
active_extruder_parked = true ;
# else
2013-08-07 09:10:26 -05:00
HOMEAXIS ( X ) ;
2014-02-05 03:47:12 -06:00
# endif
2012-11-06 05:06:41 -06:00
}
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ Y_AXIS ] ) ) ) {
HOMEAXIS ( Y ) ;
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( axis_codes [ X_AXIS ] ) )
2012-11-06 05:06:41 -06:00
{
if ( code_value_long ( ) ! = 0 ) {
current_position [ X_AXIS ] = code_value ( ) + add_homeing [ 0 ] ;
}
}
if ( code_seen ( axis_codes [ Y_AXIS ] ) ) {
if ( code_value_long ( ) ! = 0 ) {
current_position [ Y_AXIS ] = code_value ( ) + add_homeing [ 1 ] ;
}
}
2014-02-05 03:47:12 -06:00
2013-11-27 18:37:35 -06:00
# if Z_HOME_DIR < 0 // If homing towards BED do Z last
# ifndef Z_SAFE_HOMING
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ Z_AXIS ] ) ) ) {
# if defined (Z_RAISE_BEFORE_HOMING) && (Z_RAISE_BEFORE_HOMING > 0)
destination [ Z_AXIS ] = Z_RAISE_BEFORE_HOMING * home_dir ( Z_AXIS ) * ( - 1 ) ; // Set destination away from bed
feedrate = max_feedrate [ Z_AXIS ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate , active_extruder ) ;
st_synchronize ( ) ;
# endif
HOMEAXIS ( Z ) ;
}
2014-02-05 03:47:12 -06:00
# else // Z Safe mode activated.
2013-11-27 18:37:35 -06:00
if ( home_all_axis ) {
destination [ X_AXIS ] = round ( Z_SAFE_HOMING_X_POINT - X_PROBE_OFFSET_FROM_EXTRUDER ) ;
destination [ Y_AXIS ] = round ( Z_SAFE_HOMING_Y_POINT - Y_PROBE_OFFSET_FROM_EXTRUDER ) ;
destination [ Z_AXIS ] = Z_RAISE_BEFORE_HOMING * home_dir ( Z_AXIS ) * ( - 1 ) ; // Set destination away from bed
feedrate = XY_TRAVEL_SPEED ;
current_position [ Z_AXIS ] = 0 ;
2014-02-05 03:47:12 -06:00
2013-11-27 18:37:35 -06:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate , active_extruder ) ;
st_synchronize ( ) ;
current_position [ X_AXIS ] = destination [ X_AXIS ] ;
current_position [ Y_AXIS ] = destination [ Y_AXIS ] ;
2012-11-06 05:06:41 -06:00
2013-11-27 18:37:35 -06:00
HOMEAXIS ( Z ) ;
}
// Let's see if X and Y are homed and probe is inside bed area.
if ( code_seen ( axis_codes [ Z_AXIS ] ) ) {
if ( ( axis_known_position [ X_AXIS ] ) & & ( axis_known_position [ Y_AXIS ] ) \
& & ( current_position [ X_AXIS ] + X_PROBE_OFFSET_FROM_EXTRUDER > = X_MIN_POS ) \
& & ( current_position [ X_AXIS ] + X_PROBE_OFFSET_FROM_EXTRUDER < = X_MAX_POS ) \
& & ( current_position [ Y_AXIS ] + Y_PROBE_OFFSET_FROM_EXTRUDER > = Y_MIN_POS ) \
& & ( current_position [ Y_AXIS ] + Y_PROBE_OFFSET_FROM_EXTRUDER < = Y_MAX_POS ) ) {
current_position [ Z_AXIS ] = 0 ;
2014-02-05 03:47:12 -06:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2013-11-27 18:37:35 -06:00
destination [ Z_AXIS ] = Z_RAISE_BEFORE_HOMING * home_dir ( Z_AXIS ) * ( - 1 ) ; // Set destination away from bed
feedrate = max_feedrate [ Z_AXIS ] ;
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate , active_extruder ) ;
st_synchronize ( ) ;
HOMEAXIS ( Z ) ;
} else if ( ! ( ( axis_known_position [ X_AXIS ] ) & & ( axis_known_position [ Y_AXIS ] ) ) ) {
LCD_MESSAGEPGM ( MSG_POSITION_UNKNOWN ) ;
SERIAL_ECHO_START ;
SERIAL_ECHOLNPGM ( MSG_POSITION_UNKNOWN ) ;
} else {
LCD_MESSAGEPGM ( MSG_ZPROBE_OUT ) ;
SERIAL_ECHO_START ;
SERIAL_ECHOLNPGM ( MSG_ZPROBE_OUT ) ;
}
}
# endif
# endif
2014-02-05 03:47:12 -06:00
2012-11-06 05:06:41 -06:00
if ( code_seen ( axis_codes [ Z_AXIS ] ) ) {
if ( code_value_long ( ) ! = 0 ) {
current_position [ Z_AXIS ] = code_value ( ) + add_homeing [ 2 ] ;
}
}
2013-10-12 15:28:11 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
2013-11-27 18:37:35 -06:00
if ( ( home_all_axis ) | | ( code_seen ( axis_codes [ Z_AXIS ] ) ) ) {
2014-01-16 14:13:46 -06:00
current_position [ Z_AXIS ] + = zprobe_zoffset ; //Add Z_Probe offset (the distance is negative)
2013-11-27 18:37:35 -06:00
}
2013-10-12 15:28:11 -05:00
# endif
2013-06-09 23:10:00 -05:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2013-07-17 07:44:45 -05:00
# endif // else DELTA
2013-08-01 08:06:39 -05:00
2012-11-06 05:06:41 -06:00
# ifdef ENDSTOPS_ONLY_FOR_HOMING
enable_endstops ( false ) ;
# endif
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
feedrate = saved_feedrate ;
feedmultiply = saved_feedmultiply ;
previous_millis_cmd = millis ( ) ;
endstops_hit_on_purpose ( ) ;
break ;
2013-09-29 11:20:06 -05:00
# ifdef ENABLE_AUTO_BED_LEVELING
case 29 : // G29 Detailed Z-Probe, probes the bed at 3 points.
{
# if Z_MIN_PIN == -1
# error "You must have a Z_MIN endstop in order to enable Auto Bed Leveling feature!!! Z_MIN_PIN must point to a valid hardware pin."
# endif
st_synchronize ( ) ;
// make sure the bed_level_rotation_matrix is identity or the planner will get it incorectly
//vector_3 corrected_position = plan_get_position_mm();
//corrected_position.debug("position before G29");
plan_bed_level_matrix . set_to_identity ( ) ;
vector_3 uncorrected_position = plan_get_position ( ) ;
//uncorrected_position.debug("position durring G29");
current_position [ X_AXIS ] = uncorrected_position . x ;
current_position [ Y_AXIS ] = uncorrected_position . y ;
current_position [ Z_AXIS ] = uncorrected_position . z ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
setup_for_endstop_move ( ) ;
feedrate = homing_feedrate [ Z_AXIS ] ;
2013-12-06 14:46:25 -06:00
# ifdef ACCURATE_BED_LEVELING
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
int xGridSpacing = ( RIGHT_PROBE_BED_POSITION - LEFT_PROBE_BED_POSITION ) / ( ACCURATE_BED_LEVELING_POINTS - 1 ) ;
int yGridSpacing = ( BACK_PROBE_BED_POSITION - FRONT_PROBE_BED_POSITION ) / ( ACCURATE_BED_LEVELING_POINTS - 1 ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06: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
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
// "A" matrix of the linear system of equations
double eqnAMatrix [ ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS * 3 ] ;
// "B" vector of Z points
double eqnBVector [ ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS ] ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
int probePointCounter = 0 ;
2013-12-13 03:31:19 -06:00
bool zig = true ;
2014-02-05 03:47:12 -06:00
2013-12-13 03:31:19 -06:00
for ( int yProbe = FRONT_PROBE_BED_POSITION ; yProbe < = BACK_PROBE_BED_POSITION ; yProbe + = yGridSpacing )
2013-12-06 14:46:25 -06:00
{
2013-12-13 03:31:19 -06:00
int xProbe , xInc ;
if ( zig )
{
xProbe = LEFT_PROBE_BED_POSITION ;
//xEnd = RIGHT_PROBE_BED_POSITION;
xInc = xGridSpacing ;
zig = false ;
} else // zag
{
xProbe = RIGHT_PROBE_BED_POSITION ;
//xEnd = LEFT_PROBE_BED_POSITION;
xInc = - xGridSpacing ;
zig = true ;
}
2014-02-05 03:47:12 -06:00
2013-12-13 03:31:19 -06:00
for ( int xCount = 0 ; xCount < ACCURATE_BED_LEVELING_POINTS ; xCount + + )
2013-12-06 14:46:25 -06:00
{
if ( probePointCounter = = 0 )
{
// raise before probing
do_blocking_move_to ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , Z_RAISE_BEFORE_PROBING ) ;
} else
2014-02-05 03:47:12 -06:00
{
2013-12-06 14:46:25 -06:00
// raise extruder
do_blocking_move_to ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] + Z_RAISE_BETWEEN_PROBINGS ) ;
}
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
do_blocking_move_to ( xProbe - X_PROBE_OFFSET_FROM_EXTRUDER , yProbe - Y_PROBE_OFFSET_FROM_EXTRUDER , current_position [ Z_AXIS ] ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
engage_z_probe ( ) ; // Engage Z Servo endstop if available
run_z_probe ( ) ;
eqnBVector [ probePointCounter ] = current_position [ Z_AXIS ] ;
retract_z_probe ( ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
SERIAL_PROTOCOLPGM ( " Bed x: " ) ;
SERIAL_PROTOCOL ( xProbe ) ;
SERIAL_PROTOCOLPGM ( " y: " ) ;
SERIAL_PROTOCOL ( yProbe ) ;
SERIAL_PROTOCOLPGM ( " z: " ) ;
SERIAL_PROTOCOL ( current_position [ Z_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " \n " ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
eqnAMatrix [ probePointCounter + 0 * ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS ] = xProbe ;
eqnAMatrix [ probePointCounter + 1 * ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS ] = yProbe ;
eqnAMatrix [ probePointCounter + 2 * ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS ] = 1 ;
probePointCounter + + ;
2013-12-13 03:31:19 -06:00
xProbe + = xInc ;
2013-12-06 14:46:25 -06:00
}
}
clean_up_after_endstop_move ( ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
// solve lsq problem
double * plane_equation_coefficients = qr_solve ( ACCURATE_BED_LEVELING_POINTS * ACCURATE_BED_LEVELING_POINTS , 3 , eqnAMatrix , eqnBVector ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
SERIAL_PROTOCOLPGM ( " Eqn coefficients: a: " ) ;
SERIAL_PROTOCOL ( plane_equation_coefficients [ 0 ] ) ;
SERIAL_PROTOCOLPGM ( " b: " ) ;
SERIAL_PROTOCOL ( plane_equation_coefficients [ 1 ] ) ;
SERIAL_PROTOCOLPGM ( " d: " ) ;
SERIAL_PROTOCOLLN ( plane_equation_coefficients [ 2 ] ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
set_bed_level_equation_lsq ( plane_equation_coefficients ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
free ( plane_equation_coefficients ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
# else // ACCURATE_BED_LEVELING not defined
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
// prob 1
do_blocking_move_to ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , Z_RAISE_BEFORE_PROBING ) ;
do_blocking_move_to ( LEFT_PROBE_BED_POSITION - X_PROBE_OFFSET_FROM_EXTRUDER , BACK_PROBE_BED_POSITION - Y_PROBE_OFFSET_FROM_EXTRUDER , current_position [ Z_AXIS ] ) ;
engage_z_probe ( ) ; // Engage Z Servo endstop if available
run_z_probe ( ) ;
float z_at_xLeft_yBack = current_position [ Z_AXIS ] ;
2013-11-27 18:37:35 -06:00
retract_z_probe ( ) ;
2013-09-29 11:20:06 -05:00
SERIAL_PROTOCOLPGM ( " Bed x: " ) ;
SERIAL_PROTOCOL ( LEFT_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " y: " ) ;
SERIAL_PROTOCOL ( BACK_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " z: " ) ;
SERIAL_PROTOCOL ( current_position [ Z_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " \n " ) ;
// prob 2
do_blocking_move_to ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] + Z_RAISE_BETWEEN_PROBINGS ) ;
do_blocking_move_to ( LEFT_PROBE_BED_POSITION - X_PROBE_OFFSET_FROM_EXTRUDER , FRONT_PROBE_BED_POSITION - Y_PROBE_OFFSET_FROM_EXTRUDER , current_position [ Z_AXIS ] ) ;
2013-11-27 18:37:35 -06:00
engage_z_probe ( ) ; // Engage Z Servo endstop if available
2013-09-29 11:20:06 -05:00
run_z_probe ( ) ;
float z_at_xLeft_yFront = current_position [ Z_AXIS ] ;
2013-11-27 18:37:35 -06:00
retract_z_probe ( ) ;
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
SERIAL_PROTOCOLPGM ( " Bed x: " ) ;
SERIAL_PROTOCOL ( LEFT_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " y: " ) ;
SERIAL_PROTOCOL ( FRONT_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " z: " ) ;
SERIAL_PROTOCOL ( current_position [ Z_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " \n " ) ;
// prob 3
do_blocking_move_to ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] + Z_RAISE_BETWEEN_PROBINGS ) ;
// the current position will be updated by the blocking move so the head will not lower on this next call.
do_blocking_move_to ( RIGHT_PROBE_BED_POSITION - X_PROBE_OFFSET_FROM_EXTRUDER , FRONT_PROBE_BED_POSITION - Y_PROBE_OFFSET_FROM_EXTRUDER , current_position [ Z_AXIS ] ) ;
2013-11-27 18:37:35 -06:00
engage_z_probe ( ) ; // Engage Z Servo endstop if available
2013-09-29 11:20:06 -05:00
run_z_probe ( ) ;
float z_at_xRight_yFront = current_position [ Z_AXIS ] ;
2013-11-27 18:37:35 -06:00
retract_z_probe ( ) ; // Retract Z Servo endstop if available
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
SERIAL_PROTOCOLPGM ( " Bed x: " ) ;
SERIAL_PROTOCOL ( RIGHT_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " y: " ) ;
SERIAL_PROTOCOL ( FRONT_PROBE_BED_POSITION ) ;
SERIAL_PROTOCOLPGM ( " z: " ) ;
SERIAL_PROTOCOL ( current_position [ Z_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " \n " ) ;
clean_up_after_endstop_move ( ) ;
set_bed_level_equation ( z_at_xLeft_yFront , z_at_xRight_yFront , z_at_xLeft_yBack ) ;
2014-02-05 03:47:12 -06:00
2013-12-06 14:46:25 -06:00
# endif // ACCURATE_BED_LEVELING
2014-02-05 03:47:12 -06:00
st_synchronize ( ) ;
2013-09-29 11:20:06 -05:00
// The following code correct the Z height difference from z-probe position and hotend tip position.
2014-02-05 03:47:12 -06:00
// The Z height on homing is measured by Z-Probe, but the probe is quite far from the hotend.
2013-09-29 11:20:06 -05:00
// When the bed is uneven, this height must be corrected.
real_z = float ( st_get_position ( Z_AXIS ) ) / axis_steps_per_unit [ Z_AXIS ] ; //get the real Z (since the auto bed leveling is already correcting the plane)
x_tmp = current_position [ X_AXIS ] + X_PROBE_OFFSET_FROM_EXTRUDER ;
y_tmp = current_position [ Y_AXIS ] + Y_PROBE_OFFSET_FROM_EXTRUDER ;
z_tmp = current_position [ Z_AXIS ] ;
apply_rotation_xyz ( plan_bed_level_matrix , x_tmp , y_tmp , z_tmp ) ; //Apply the correction sending the probe offset
current_position [ Z_AXIS ] = z_tmp - real_z + current_position [ Z_AXIS ] ; //The difference is added to current position and sent to planner.
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
}
break ;
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
case 30 : // G30 Single Z Probe
{
engage_z_probe ( ) ; // Engage Z Servo endstop if available
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
st_synchronize ( ) ;
// TODO: make sure the bed_level_rotation_matrix is identity or the planner will get set incorectly
setup_for_endstop_move ( ) ;
feedrate = homing_feedrate [ Z_AXIS ] ;
run_z_probe ( ) ;
SERIAL_PROTOCOLPGM ( " Bed Position 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 ( " \n " ) ;
clean_up_after_endstop_move ( ) ;
retract_z_probe ( ) ; // Retract Z Servo endstop if available
}
break ;
# endif // ENABLE_AUTO_BED_LEVELING
2012-11-06 05:06:41 -06:00
case 90 : // G90
relative_mode = false ;
break ;
case 91 : // G91
relative_mode = true ;
break ;
case 92 : // G92
if ( ! code_seen ( axis_codes [ E_AXIS ] ) )
st_synchronize ( ) ;
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
2013-06-06 17:49:25 -05:00
if ( code_seen ( axis_codes [ i ] ) ) {
2012-11-06 05:06:41 -06:00
if ( i = = E_AXIS ) {
2013-06-06 17:49:25 -05:00
current_position [ i ] = code_value ( ) ;
2012-11-06 05:06:41 -06:00
plan_set_e_position ( current_position [ E_AXIS ] ) ;
}
else {
2013-06-06 17:49:25 -05:00
current_position [ i ] = code_value ( ) + add_homeing [ i ] ;
2012-11-06 05:06:41 -06:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
}
}
}
break ;
}
}
else if ( code_seen ( ' M ' ) )
{
2013-06-06 17:49:25 -05:00
switch ( ( int ) code_value ( ) )
2012-11-06 05:06:41 -06:00
{
2012-12-12 04:32:33 -06:00
# ifdef ULTIPANEL
2012-11-06 05:06:41 -06: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
{
LCD_MESSAGEPGM ( MSG_USERWAIT ) ;
codenum = 0 ;
if ( code_seen ( ' P ' ) ) codenum = code_value ( ) ; // milliseconds to wait
if ( code_seen ( ' S ' ) ) codenum = code_value ( ) * 1000 ; // seconds to wait
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
st_synchronize ( ) ;
previous_millis_cmd = millis ( ) ;
if ( codenum > 0 ) {
codenum + = millis ( ) ; // keep track of when we started waiting
2013-06-06 17:49:25 -05:00
while ( millis ( ) < codenum & & ! lcd_clicked ( ) ) {
2012-11-06 05:06:41 -06:00
manage_heater ( ) ;
manage_inactivity ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
}
} else {
2013-06-06 17:49:25 -05:00
while ( ! lcd_clicked ( ) ) {
2012-11-06 05:06:41 -06:00
manage_heater ( ) ;
manage_inactivity ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
}
}
2012-12-21 09:14:47 -06:00
LCD_MESSAGEPGM ( MSG_RESUMING ) ;
2012-11-06 05:06:41 -06:00
}
break ;
# endif
case 17 :
LCD_MESSAGEPGM ( MSG_NO_MOVE ) ;
2013-06-06 17:49:25 -05:00
enable_x ( ) ;
enable_y ( ) ;
enable_z ( ) ;
enable_e0 ( ) ;
enable_e1 ( ) ;
enable_e2 ( ) ;
2012-11-06 05:06:41 -06:00
break ;
# ifdef SDSUPPORT
case 20 : // M20 - list SD card
SERIAL_PROTOCOLLNPGM ( MSG_BEGIN_FILE_LIST ) ;
card . ls ( ) ;
SERIAL_PROTOCOLLNPGM ( MSG_END_FILE_LIST ) ;
break ;
case 21 : // M21 - init SD card
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
card . initsd ( ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
break ;
case 22 : //M22 - release SD card
card . release ( ) ;
break ;
case 23 : //M23 - Select file
starpos = ( strchr ( strchr_pointer + 4 , ' * ' ) ) ;
if ( starpos ! = NULL )
* ( starpos - 1 ) = ' \0 ' ;
card . openFile ( strchr_pointer + 4 , true ) ;
break ;
case 24 : //M24 - Start SD print
card . startFileprint ( ) ;
starttime = millis ( ) ;
break ;
case 25 : //M25 - Pause SD print
card . pauseSDPrint ( ) ;
break ;
case 26 : //M26 - Set SD index
if ( card . cardOK & & code_seen ( ' S ' ) ) {
card . setIndex ( code_value_long ( ) ) ;
}
break ;
case 27 : //M27 - Get SD status
card . getStatus ( ) ;
break ;
case 28 : //M28 - Start SD write
starpos = ( strchr ( strchr_pointer + 4 , ' * ' ) ) ;
if ( starpos ! = NULL ) {
char * npos = strchr ( cmdbuffer [ bufindr ] , ' N ' ) ;
strchr_pointer = strchr ( npos , ' ' ) + 1 ;
* ( starpos - 1 ) = ' \0 ' ;
}
card . openFile ( strchr_pointer + 4 , false ) ;
break ;
case 29 : //M29 - Stop SD write
//processed in write to file routine above
//card,saving = false;
break ;
2013-06-06 17:49:25 -05:00
case 30 : //M30 <filename> Delete File
if ( card . cardOK ) {
card . closefile ( ) ;
starpos = ( strchr ( strchr_pointer + 4 , ' * ' ) ) ;
if ( starpos ! = NULL ) {
char * npos = strchr ( cmdbuffer [ bufindr ] , ' N ' ) ;
strchr_pointer = strchr ( npos , ' ' ) + 1 ;
* ( starpos - 1 ) = ' \0 ' ;
}
card . removeFile ( strchr_pointer + 4 ) ;
}
break ;
2014-02-05 03:47:12 -06:00
case 32 : //M32 - Select file and start SD print
2013-10-22 03:02:18 -05:00
{
2013-07-14 15:39:59 -05:00
if ( card . sdprinting ) {
st_synchronize ( ) ;
2013-10-22 03:02:18 -05:00
2013-07-14 15:39:59 -05:00
}
2014-02-05 03:47:12 -06:00
starpos = ( strchr ( strchr_pointer + 4 , ' * ' ) ) ;
2013-10-22 03:02:18 -05:00
char * namestartpos = ( strchr ( strchr_pointer + 4 , ' ! ' ) ) ; //find ! to indicate filename string start.
if ( namestartpos = = NULL )
{
namestartpos = strchr_pointer + 4 ; //default name position, 4 letters after the M
}
else
namestartpos + + ; //to skip the '!'
2014-02-05 03:47:12 -06:00
2013-07-14 15:39:59 -05:00
if ( starpos ! = NULL )
* ( starpos - 1 ) = ' \0 ' ;
2014-02-05 03:47:12 -06:00
2013-10-22 03:02:18 -05:00
bool call_procedure = ( code_seen ( ' P ' ) ) ;
2014-02-05 03:47:12 -06:00
if ( strchr_pointer > namestartpos )
2013-10-22 03:02:18 -05:00
call_procedure = false ; //false alert, 'P' found within filename
2014-02-05 03:47:12 -06:00
if ( card . cardOK )
2013-10-22 03:02:18 -05:00
{
card . openFile ( namestartpos , true , ! call_procedure ) ;
if ( code_seen ( ' S ' ) )
if ( strchr_pointer < namestartpos ) //only if "S" is occuring _before_ the filename
card . setIndex ( code_value_long ( ) ) ;
card . startFileprint ( ) ;
if ( ! call_procedure )
starttime = millis ( ) ; //procedure calls count as normal print time.
}
} break ;
2013-03-16 17:02:57 -05:00
case 928 : //M928 - Start SD write
starpos = ( strchr ( strchr_pointer + 5 , ' * ' ) ) ;
if ( starpos ! = NULL ) {
char * npos = strchr ( cmdbuffer [ bufindr ] , ' N ' ) ;
strchr_pointer = strchr ( npos , ' ' ) + 1 ;
* ( starpos - 1 ) = ' \0 ' ;
}
card . openLogFile ( strchr_pointer + 5 ) ;
break ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
# endif //SDSUPPORT
case 31 : //M31 take time since the start of the SD print or an M109 command
{
stoptime = millis ( ) ;
char time [ 30 ] ;
unsigned long t = ( stoptime - starttime ) / 1000 ;
int sec , min ;
min = t / 60 ;
sec = t % 60 ;
2012-11-28 03:30:34 -06:00
sprintf_P ( time , PSTR ( " %i min, %i sec " ) , min , sec ) ;
2012-11-06 05:06:41 -06:00
SERIAL_ECHO_START ;
SERIAL_ECHOLN ( time ) ;
2012-12-03 05:52:00 -06:00
lcd_setstatus ( time ) ;
2012-11-06 05:06:41 -06:00
autotempShutdown ( ) ;
}
break ;
2013-01-31 11:11:13 -06:00
case 42 : //M42 -Change pin status via gcode
2012-11-06 05:06:41 -06:00
if ( code_seen ( ' S ' ) )
{
int pin_status = code_value ( ) ;
2012-12-11 07:53:53 -06:00
int pin_number = LED_PIN ;
2012-11-06 05:06:41 -06:00
if ( code_seen ( ' P ' ) & & pin_status > = 0 & & pin_status < = 255 )
2012-12-11 07:53:53 -06:00
pin_number = code_value ( ) ;
for ( int8_t i = 0 ; i < ( int8_t ) sizeof ( sensitive_pins ) ; i + + )
2012-11-06 05:06:41 -06:00
{
2012-12-11 07:53:53 -06:00
if ( sensitive_pins [ i ] = = pin_number )
2012-11-06 05:06:41 -06:00
{
2012-12-11 07:53:53 -06:00
pin_number = - 1 ;
break ;
2012-11-06 05:06:41 -06:00
}
}
2013-06-06 17:49:25 -05:00
# if defined(FAN_PIN) && FAN_PIN > -1
if ( pin_number = = FAN_PIN )
fanSpeed = pin_status ;
# endif
2012-12-11 07:53:53 -06:00
if ( pin_number > - 1 )
{
pinMode ( pin_number , OUTPUT ) ;
digitalWrite ( pin_number , pin_status ) ;
analogWrite ( pin_number , pin_status ) ;
}
2012-11-06 05:06:41 -06:00
}
break ;
case 104 : // M104
if ( setTargetedHotend ( 104 ) ) {
break ;
}
if ( code_seen ( ' S ' ) ) setTargetHotend ( code_value ( ) , tmp_extruder ) ;
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE & & tmp_extruder = = 0 )
setTargetHotend1 ( code_value ( ) = = 0.0 ? 0.0 : code_value ( ) + duplicate_extruder_temp_offset ) ;
2014-02-05 03:47:12 -06:00
# endif
2012-11-06 05:06:41 -06:00
setWatch ( ) ;
break ;
case 140 : // M140 set bed temp
if ( code_seen ( ' S ' ) ) setTargetBed ( code_value ( ) ) ;
break ;
case 105 : // M105
if ( setTargetedHotend ( 105 ) ) {
break ;
2013-06-06 17:49:25 -05:00
}
# if defined(TEMP_0_PIN) && TEMP_0_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( " ok T: " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL_F ( degHotend ( tmp_extruder ) , 1 ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( " / " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL_F ( degTargetHotend ( tmp_extruder ) , 1 ) ;
# if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
SERIAL_PROTOCOLPGM ( " B: " ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL_F ( degBed ( ) , 1 ) ;
SERIAL_PROTOCOLPGM ( " / " ) ;
SERIAL_PROTOCOL_F ( degTargetBed ( ) , 1 ) ;
# endif //TEMP_BED_PIN
2013-05-29 11:06:12 -05:00
for ( int8_t cur_extruder = 0 ; cur_extruder < EXTRUDERS ; + + cur_extruder ) {
SERIAL_PROTOCOLPGM ( " T " ) ;
SERIAL_PROTOCOL ( cur_extruder ) ;
SERIAL_PROTOCOLPGM ( " : " ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOL_F ( degHotend ( cur_extruder ) , 1 ) ;
2013-05-29 11:06:12 -05:00
SERIAL_PROTOCOLPGM ( " / " ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOL_F ( degTargetHotend ( cur_extruder ) , 1 ) ;
2013-05-29 11:06:12 -05:00
}
2013-07-23 16:34:42 -05:00
# else
2012-11-06 05:06:41 -06:00
SERIAL_ERROR_START ;
SERIAL_ERRORLNPGM ( MSG_ERR_NO_THERMISTORS ) ;
# endif
SERIAL_PROTOCOLPGM ( " @: " ) ;
2014-02-03 13:46:09 -06:00
# ifdef EXTRUDER_WATTS
SERIAL_PROTOCOL ( ( EXTRUDER_WATTS * getHeaterPower ( tmp_extruder ) ) / 127 ) ;
SERIAL_PROTOCOLPGM ( " W " ) ;
# else
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( getHeaterPower ( tmp_extruder ) ) ;
2014-02-03 13:46:09 -06:00
# endif
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( " B@: " ) ;
2014-02-03 13:46:09 -06:00
# ifdef BED_WATTS
SERIAL_PROTOCOL ( ( BED_WATTS * getHeaterPower ( - 1 ) ) / 127 ) ;
SERIAL_PROTOCOLPGM ( " W " ) ;
# else
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( getHeaterPower ( - 1 ) ) ;
2014-02-03 13:46:09 -06:00
# endif
2012-11-06 05:06:41 -06:00
2013-10-12 08:41:23 -05:00
# ifdef SHOW_TEMP_ADC_VALUES
# if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
SERIAL_PROTOCOLPGM ( " ADC B: " ) ;
SERIAL_PROTOCOL_F ( degBed ( ) , 1 ) ;
SERIAL_PROTOCOLPGM ( " C-> " ) ;
SERIAL_PROTOCOL_F ( rawBedTemp ( ) / OVERSAMPLENR , 0 ) ;
# endif
for ( int8_t cur_extruder = 0 ; cur_extruder < EXTRUDERS ; + + cur_extruder ) {
SERIAL_PROTOCOLPGM ( " T " ) ;
SERIAL_PROTOCOL ( cur_extruder ) ;
SERIAL_PROTOCOLPGM ( " : " ) ;
SERIAL_PROTOCOL_F ( degHotend ( cur_extruder ) , 1 ) ;
SERIAL_PROTOCOLPGM ( " C-> " ) ;
SERIAL_PROTOCOL_F ( rawHotendTemp ( cur_extruder ) / OVERSAMPLENR , 0 ) ;
}
# endif
2014-02-05 03:47:12 -06:00
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLLN ( " " ) ;
return ;
break ;
2013-06-06 17:49:25 -05:00
case 109 :
2012-11-06 05:06:41 -06:00
{ // M109 - Wait for extruder heater to reach target.
if ( setTargetedHotend ( 109 ) ) {
break ;
}
2013-06-06 17:49:25 -05:00
LCD_MESSAGEPGM ( MSG_HEATING ) ;
2012-11-06 05:06:41 -06:00
# ifdef AUTOTEMP
autotemp_enabled = false ;
# endif
2013-08-01 08:06:39 -05:00
if ( code_seen ( ' S ' ) ) {
2013-07-14 14:10:24 -05:00
setTargetHotend ( code_value ( ) , tmp_extruder ) ;
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE & & tmp_extruder = = 0 )
setTargetHotend1 ( code_value ( ) = = 0.0 ? 0.0 : code_value ( ) + duplicate_extruder_temp_offset ) ;
2014-02-05 03:47:12 -06:00
# endif
2013-07-14 14:10:24 -05:00
CooldownNoWait = true ;
} else if ( code_seen ( ' R ' ) ) {
setTargetHotend ( code_value ( ) , tmp_extruder ) ;
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE & & tmp_extruder = = 0 )
setTargetHotend1 ( code_value ( ) = = 0.0 ? 0.0 : code_value ( ) + duplicate_extruder_temp_offset ) ;
2014-02-05 03:47:12 -06:00
# endif
2013-07-14 14:10:24 -05:00
CooldownNoWait = false ;
}
2012-11-06 05:06:41 -06:00
# ifdef AUTOTEMP
if ( code_seen ( ' S ' ) ) autotemp_min = code_value ( ) ;
if ( code_seen ( ' B ' ) ) autotemp_max = code_value ( ) ;
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' F ' ) )
2012-11-06 05:06:41 -06:00
{
autotemp_factor = code_value ( ) ;
autotemp_enabled = true ;
}
# endif
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
setWatch ( ) ;
2013-06-06 17:49:25 -05:00
codenum = millis ( ) ;
2012-11-06 05:06:41 -06:00
/* See if we are heating up or cooling down */
2013-07-14 14:10:24 -05:00
target_direction = isHeatingHotend ( tmp_extruder ) ; // true if heating, false if cooling
2012-11-06 05:06:41 -06:00
# ifdef TEMP_RESIDENCY_TIME
long residencyStart ;
residencyStart = - 1 ;
2013-06-06 17:49:25 -05:00
/* continue to loop until we have reached the target temp
2012-11-06 05:06:41 -06:00
_and_ until TEMP_RESIDENCY_TIME hasn ' t passed since we reached it */
while ( ( residencyStart = = - 1 ) | |
( residencyStart > = 0 & & ( ( ( unsigned int ) ( millis ( ) - residencyStart ) ) < ( TEMP_RESIDENCY_TIME * 1000UL ) ) ) ) {
# else
while ( target_direction ? ( isHeatingHotend ( tmp_extruder ) ) : ( isCoolingHotend ( tmp_extruder ) & & ( CooldownNoWait = = false ) ) ) {
# endif //TEMP_RESIDENCY_TIME
if ( ( millis ( ) - codenum ) > 1000UL )
{ //Print Temp Reading and remaining time every 1 second while heating up/cooling down
SERIAL_PROTOCOLPGM ( " T: " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL_F ( degHotend ( tmp_extruder ) , 1 ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( " E: " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( ( int ) tmp_extruder ) ;
2012-11-06 05:06:41 -06:00
# ifdef TEMP_RESIDENCY_TIME
SERIAL_PROTOCOLPGM ( " W: " ) ;
if ( residencyStart > - 1 )
{
codenum = ( ( TEMP_RESIDENCY_TIME * 1000UL ) - ( millis ( ) - residencyStart ) ) / 1000UL ;
SERIAL_PROTOCOLLN ( codenum ) ;
}
2013-06-06 17:49:25 -05:00
else
2012-11-06 05:06:41 -06:00
{
SERIAL_PROTOCOLLN ( " ? " ) ;
}
# else
SERIAL_PROTOCOLLN ( " " ) ;
# endif
codenum = millis ( ) ;
}
manage_heater ( ) ;
manage_inactivity ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
# ifdef TEMP_RESIDENCY_TIME
/* start/restart the TEMP_RESIDENCY_TIME timer whenever we reach target temp for the first time
or when current temp falls outside the hysteresis after target temp was reached */
if ( ( residencyStart = = - 1 & & target_direction & & ( degHotend ( tmp_extruder ) > = ( degTargetHotend ( tmp_extruder ) - TEMP_WINDOW ) ) ) | |
( residencyStart = = - 1 & & ! target_direction & & ( degHotend ( tmp_extruder ) < = ( degTargetHotend ( tmp_extruder ) + TEMP_WINDOW ) ) ) | |
2013-06-06 17:49:25 -05:00
( residencyStart > - 1 & & labs ( degHotend ( tmp_extruder ) - degTargetHotend ( tmp_extruder ) ) > TEMP_HYSTERESIS ) )
2012-11-06 05:06:41 -06:00
{
residencyStart = millis ( ) ;
}
# endif //TEMP_RESIDENCY_TIME
}
LCD_MESSAGEPGM ( MSG_HEATING_COMPLETE ) ;
starttime = millis ( ) ;
previous_millis_cmd = millis ( ) ;
}
break ;
case 190 : // M190 - Wait for bed heater to reach target.
2013-06-06 17:49:25 -05:00
# if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
2012-11-06 05:06:41 -06:00
LCD_MESSAGEPGM ( MSG_BED_HEATING ) ;
2013-08-01 08:06:39 -05:00
if ( code_seen ( ' S ' ) ) {
2013-07-14 14:10:24 -05:00
setTargetBed ( code_value ( ) ) ;
CooldownNoWait = true ;
} else if ( code_seen ( ' R ' ) ) {
setTargetBed ( code_value ( ) ) ;
CooldownNoWait = false ;
}
2013-06-06 17:49:25 -05:00
codenum = millis ( ) ;
2013-08-01 08:06:39 -05:00
2013-07-14 14:10:24 -05:00
target_direction = isHeatingBed ( ) ; // true if heating, false if cooling
2013-08-01 08:06:39 -05:00
2013-07-14 14:10:24 -05:00
while ( target_direction ? ( isHeatingBed ( ) ) : ( isCoolingBed ( ) & & ( CooldownNoWait = = false ) ) )
2012-11-06 05:06:41 -06:00
{
if ( ( millis ( ) - codenum ) > 1000 ) //Print Temp Reading every 1 second while heating up.
{
float tt = degHotend ( active_extruder ) ;
SERIAL_PROTOCOLPGM ( " T: " ) ;
SERIAL_PROTOCOL ( tt ) ;
SERIAL_PROTOCOLPGM ( " E: " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( ( int ) active_extruder ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( " B: " ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL_F ( degBed ( ) , 1 ) ;
SERIAL_PROTOCOLLN ( " " ) ;
codenum = millis ( ) ;
2012-11-06 05:06:41 -06:00
}
manage_heater ( ) ;
manage_inactivity ( ) ;
2012-12-03 05:52:00 -06:00
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
}
LCD_MESSAGEPGM ( MSG_BED_DONE ) ;
previous_millis_cmd = millis ( ) ;
# endif
break ;
2013-06-06 17:49:25 -05:00
# if defined(FAN_PIN) && FAN_PIN > -1
2012-11-06 05:06:41 -06:00
case 106 : //M106 Fan On
if ( code_seen ( ' S ' ) ) {
2012-12-03 05:13:20 -06:00
fanSpeed = constrain ( code_value ( ) , 0 , 255 ) ;
2012-11-06 05:06:41 -06:00
}
else {
2013-06-06 17:49:25 -05:00
fanSpeed = 255 ;
2012-11-06 05:06:41 -06:00
}
break ;
case 107 : //M107 Fan Off
2012-12-03 05:13:20 -06:00
fanSpeed = 0 ;
2012-11-06 05:06:41 -06:00
break ;
# endif //FAN_PIN
2013-06-06 17:49:25 -05:00
# ifdef BARICUDA
// PWM for HEATER_1_PIN
# if defined(HEATER_1_PIN) && HEATER_1_PIN > -1
case 126 : //M126 valve open
if ( code_seen ( ' S ' ) ) {
ValvePressure = constrain ( code_value ( ) , 0 , 255 ) ;
}
else {
ValvePressure = 255 ;
}
break ;
case 127 : //M127 valve closed
ValvePressure = 0 ;
break ;
# endif //HEATER_1_PIN
// PWM for HEATER_2_PIN
# if defined(HEATER_2_PIN) && HEATER_2_PIN > -1
case 128 : //M128 valve open
if ( code_seen ( ' S ' ) ) {
EtoPPressure = constrain ( code_value ( ) , 0 , 255 ) ;
}
else {
EtoPPressure = 255 ;
}
break ;
case 129 : //M129 valve closed
EtoPPressure = 0 ;
break ;
# endif //HEATER_2_PIN
# endif
2012-11-06 05:06:41 -06:00
2013-06-06 17:49:25 -05:00
# if defined(PS_ON_PIN) && PS_ON_PIN > -1
2013-03-05 07:52:51 -06:00
case 80 : // M80 - Turn on Power Supply
2012-11-06 05:06:41 -06:00
SET_OUTPUT ( PS_ON_PIN ) ; //GND
2013-01-07 07:33:30 -06:00
WRITE ( PS_ON_PIN , PS_ON_AWAKE ) ;
2013-11-04 05:04:04 -06: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...
# if defined SUICIDE_PIN && SUICIDE_PIN > -1
SET_OUTPUT ( SUICIDE_PIN ) ;
WRITE ( SUICIDE_PIN , HIGH ) ;
# endif
2014-02-05 03:47:12 -06:00
2013-03-05 07:52:51 -06:00
# ifdef ULTIPANEL
powersupply = true ;
LCD_MESSAGEPGM ( WELCOME_MSG ) ;
lcd_update ( ) ;
# endif
2012-11-06 05:06:41 -06:00
break ;
# endif
2013-08-01 08:06:39 -05:00
2013-03-05 07:52:51 -06:00
case 81 : // M81 - Turn off Power Supply
2013-03-05 08:03:48 -06:00
disable_heater ( ) ;
st_synchronize ( ) ;
disable_e0 ( ) ;
disable_e1 ( ) ;
disable_e2 ( ) ;
finishAndDisableSteppers ( ) ;
fanSpeed = 0 ;
delay ( 1000 ) ; // Wait a little before to switch off
2013-06-06 17:49:25 -05:00
# if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
2012-11-06 05:06:41 -06:00
st_synchronize ( ) ;
suicide ( ) ;
2013-06-06 17:49:25 -05:00
# elif defined(PS_ON_PIN) && PS_ON_PIN > -1
SET_OUTPUT ( PS_ON_PIN ) ;
2013-01-07 07:33:30 -06:00
WRITE ( PS_ON_PIN , PS_ON_ASLEEP ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-03-05 07:52:51 -06:00
# ifdef ULTIPANEL
powersupply = false ;
LCD_MESSAGEPGM ( MACHINE_NAME " " MSG_OFF " . " ) ;
lcd_update ( ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-20 16:59:56 -05:00
break ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
case 82 :
axis_relative_modes [ 3 ] = false ;
break ;
case 83 :
axis_relative_modes [ 3 ] = true ;
break ;
case 18 : //compatibility
case 84 : // M84
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) ) {
stepper_inactive_time = code_value ( ) * 1000 ;
2012-11-06 05:06:41 -06:00
}
else
2013-06-06 17:49:25 -05:00
{
2012-11-06 05:06:41 -06:00
bool all_axis = ! ( ( code_seen ( axis_codes [ 0 ] ) ) | | ( code_seen ( axis_codes [ 1 ] ) ) | | ( code_seen ( axis_codes [ 2 ] ) ) | | ( code_seen ( axis_codes [ 3 ] ) ) ) ;
if ( all_axis )
{
st_synchronize ( ) ;
disable_e0 ( ) ;
disable_e1 ( ) ;
disable_e2 ( ) ;
finishAndDisableSteppers ( ) ;
}
else
{
st_synchronize ( ) ;
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 ( ) ;
}
2013-06-06 17:49:25 -05:00
# endif
2012-11-06 05:06:41 -06:00
}
}
break ;
case 85 : // M85
code_seen ( ' S ' ) ;
2013-06-06 17:49:25 -05:00
max_inactive_time = code_value ( ) * 1000 ;
2012-11-06 05:06:41 -06:00
break ;
case 92 : // M92
2013-06-06 17:49:25 -05:00
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + )
2012-11-06 05:06:41 -06:00
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( axis_codes [ i ] ) )
2012-11-06 05:06:41 -06:00
{
if ( i = = 3 ) { // E
float value = code_value ( ) ;
if ( value < 20.0 ) {
float factor = axis_steps_per_unit [ i ] / value ; // increase e constants if M92 E14 is given for netfab.
max_e_jerk * = factor ;
max_feedrate [ i ] * = factor ;
axis_steps_per_sqr_second [ i ] * = factor ;
}
axis_steps_per_unit [ i ] = value ;
}
else {
axis_steps_per_unit [ i ] = code_value ( ) ;
}
}
}
break ;
case 115 : // M115
SERIAL_PROTOCOLPGM ( MSG_M115_REPORT ) ;
break ;
case 117 : // M117 display message
2012-12-12 02:35:32 -06:00
starpos = ( strchr ( strchr_pointer + 5 , ' * ' ) ) ;
if ( starpos ! = NULL )
* ( starpos - 1 ) = ' \0 ' ;
lcd_setstatus ( strchr_pointer + 5 ) ;
2012-11-06 05:06:41 -06:00
break ;
case 114 : // M114
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 ] ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOLPGM ( " E: " ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL ( current_position [ E_AXIS ] ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_COUNT_X ) ;
SERIAL_PROTOCOL ( float ( st_get_position ( X_AXIS ) ) / axis_steps_per_unit [ X_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " Y: " ) ;
SERIAL_PROTOCOL ( float ( st_get_position ( Y_AXIS ) ) / axis_steps_per_unit [ Y_AXIS ] ) ;
SERIAL_PROTOCOLPGM ( " Z: " ) ;
SERIAL_PROTOCOL ( float ( st_get_position ( Z_AXIS ) ) / axis_steps_per_unit [ Z_AXIS ] ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLLN ( " " ) ;
break ;
case 120 : // M120
enable_endstops ( false ) ;
break ;
case 121 : // M121
enable_endstops ( true ) ;
break ;
case 119 : // M119
SERIAL_PROTOCOLLN ( MSG_M119_REPORT ) ;
2013-06-06 17:49:25 -05:00
# if defined(X_MIN_PIN) && X_MIN_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_X_MIN ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( X_MIN_PIN ) ^ X_MIN_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
# if defined(X_MAX_PIN) && X_MAX_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_X_MAX ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( X_MAX_PIN ) ^ X_MAX_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
# if defined(Y_MIN_PIN) && Y_MIN_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_Y_MIN ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( Y_MIN_PIN ) ^ Y_MIN_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
# if defined(Y_MAX_PIN) && Y_MAX_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_Y_MAX ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( Y_MAX_PIN ) ^ Y_MAX_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
# if defined(Z_MIN_PIN) && Z_MIN_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_Z_MIN ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( Z_MIN_PIN ) ^ Z_MIN_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
# if defined(Z_MAX_PIN) && Z_MAX_PIN > -1
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLPGM ( MSG_Z_MAX ) ;
2013-08-01 08:06:39 -05:00
SERIAL_PROTOCOLLN ( ( ( READ ( Z_MAX_PIN ) ^ Z_MAX_ENDSTOP_INVERTING ) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN ) ) ;
2012-11-06 05:06:41 -06:00
# endif
break ;
//TODO: update for all axis, use for loop
2014-02-05 03:47:12 -06:00
# ifdef BLINKM
2013-09-10 04:18:29 -05:00
case 150 : // M150
{
byte red ;
byte grn ;
byte blu ;
2014-02-05 03:47:12 -06:00
2013-09-10 04:18:29 -05:00
if ( code_seen ( ' R ' ) ) red = code_value ( ) ;
if ( code_seen ( ' U ' ) ) grn = code_value ( ) ;
if ( code_seen ( ' B ' ) ) blu = code_value ( ) ;
2014-02-05 03:47:12 -06:00
SendColors ( red , grn , blu ) ;
2013-09-10 04:18:29 -05:00
}
break ;
2013-09-20 02:57:42 -05:00
# endif //BLINKM
2014-02-01 20:49:25 -06:00
case 200 : // M200 D<millimeters> set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
2014-01-31 02:54:19 -06:00
{
2014-02-01 20:49:25 -06:00
float area = .0 ;
float radius = .0 ;
if ( code_seen ( ' D ' ) ) {
radius = ( float ) code_value ( ) * .5 ;
2014-01-31 02:54:19 -06:00
if ( radius = = 0 ) {
area = 1 ;
} else {
area = M_PI * pow ( radius , 2 ) ;
}
} else {
//reserved for setting filament diameter via UFID or filament measuring device
break ;
}
tmp_extruder = active_extruder ;
if ( code_seen ( ' T ' ) ) {
tmp_extruder = code_value ( ) ;
if ( tmp_extruder > = EXTRUDERS ) {
SERIAL_ECHO_START ;
SERIAL_ECHO ( MSG_M200_INVALID_EXTRUDER ) ;
}
SERIAL_ECHOLN ( tmp_extruder ) ;
break ;
}
2014-01-31 10:43:11 -06:00
volumetric_multiplier [ tmp_extruder ] = 1 / area ;
2014-01-31 02:54:19 -06:00
}
break ;
2012-11-06 05:06:41 -06:00
case 201 : // M201
2013-06-06 17:49:25 -05:00
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + )
2012-11-06 05:06:41 -06:00
{
if ( code_seen ( axis_codes [ i ] ) )
{
max_acceleration_units_per_sq_second [ i ] = code_value ( ) ;
}
}
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05: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)
2013-06-06 17:49:25 -05:00
reset_acceleration_rates ( ) ;
2012-11-06 05:06:41 -06:00
break ;
#if 0 // Not used for Sprinter/grbl gen6
case 202 : // M202
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
if ( code_seen ( axis_codes [ i ] ) ) axis_travel_steps_per_sqr_second [ i ] = code_value ( ) * axis_steps_per_unit [ i ] ;
}
break ;
# endif
case 203 : // M203 max feedrate mm/sec
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
if ( code_seen ( axis_codes [ i ] ) ) max_feedrate [ i ] = code_value ( ) ;
}
break ;
case 204 : // M204 acclereration S normal moves T filmanent only moves
{
if ( code_seen ( ' S ' ) ) acceleration = code_value ( ) ;
if ( code_seen ( ' T ' ) ) retract_acceleration = code_value ( ) ;
}
break ;
case 205 : //M205 advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk
{
if ( code_seen ( ' S ' ) ) minimumfeedrate = code_value ( ) ;
if ( code_seen ( ' T ' ) ) mintravelfeedrate = code_value ( ) ;
if ( code_seen ( ' B ' ) ) minsegmenttime = code_value ( ) ;
if ( code_seen ( ' X ' ) ) max_xy_jerk = code_value ( ) ;
if ( code_seen ( ' Z ' ) ) max_z_jerk = code_value ( ) ;
if ( code_seen ( ' E ' ) ) max_e_jerk = code_value ( ) ;
}
break ;
case 206 : // M206 additional homeing offset
2013-06-06 17:49:25 -05:00
for ( int8_t i = 0 ; i < 3 ; i + + )
2012-11-06 05:06:41 -06:00
{
if ( code_seen ( axis_codes [ i ] ) ) add_homeing [ i ] = code_value ( ) ;
}
break ;
2013-08-27 18:15:20 -05:00
# ifdef DELTA
case 666 : // M666 set delta endstop adjustemnt
for ( int8_t i = 0 ; i < 3 ; i + + )
{
if ( code_seen ( axis_codes [ i ] ) ) endstop_adj [ i ] = code_value ( ) ;
}
break ;
# endif
2012-11-06 05:06:41 -06:00
# ifdef FWRETRACT
case 207 : //M207 - set retract length S[positive mm] F[feedrate mm/sec] Z[additional zlift/hop]
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) )
2012-11-06 05:06:41 -06:00
{
retract_length = code_value ( ) ;
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' F ' ) )
2012-11-06 05:06:41 -06:00
{
retract_feedrate = code_value ( ) ;
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' Z ' ) )
2012-11-06 05:06:41 -06:00
{
retract_zlift = code_value ( ) ;
}
} break ;
case 208 : // M208 - set retract recover length S[positive mm surplus to the M207 S*] F[feedrate mm/sec]
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) )
2012-11-06 05:06:41 -06:00
{
retract_recover_length = code_value ( ) ;
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' F ' ) )
2012-11-06 05:06:41 -06:00
{
retract_recover_feedrate = code_value ( ) ;
}
} break ;
case 209 : // M209 - S<1=true/0=false> enable automatic retract detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) )
2012-11-06 05:06:41 -06:00
{
int t = code_value ( ) ;
switch ( t )
{
case 0 : autoretract_enabled = false ; retracted = false ; break ;
case 1 : autoretract_enabled = true ; retracted = false ; break ;
2013-06-06 17:49:25 -05:00
default :
2012-11-06 05:06:41 -06:00
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_UNKNOWN_COMMAND ) ;
SERIAL_ECHO ( cmdbuffer [ bufindr ] ) ;
SERIAL_ECHOLNPGM ( " \" " ) ;
}
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
} break ;
2013-03-26 15:43:04 -05:00
# endif // FWRETRACT
2013-02-27 05:32:07 -06:00
# if EXTRUDERS > 1
2013-02-04 22:05:45 -06:00
case 218 : // M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
{
if ( setTargetedHotend ( 218 ) ) {
break ;
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' X ' ) )
2013-02-04 22:05:45 -06:00
{
extruder_offset [ X_AXIS ] [ tmp_extruder ] = code_value ( ) ;
}
if ( code_seen ( ' Y ' ) )
{
extruder_offset [ Y_AXIS ] [ tmp_extruder ] = code_value ( ) ;
}
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
if ( code_seen ( ' Z ' ) )
{
extruder_offset [ Z_AXIS ] [ tmp_extruder ] = code_value ( ) ;
}
2014-02-05 03:47:12 -06:00
# endif
2013-02-04 22:05:45 -06:00
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_HOTEND_OFFSET ) ;
2013-06-06 17:49:25 -05:00
for ( tmp_extruder = 0 ; tmp_extruder < EXTRUDERS ; tmp_extruder + + )
2013-02-04 22:05:45 -06:00
{
SERIAL_ECHO ( " " ) ;
SERIAL_ECHO ( extruder_offset [ X_AXIS ] [ tmp_extruder ] ) ;
SERIAL_ECHO ( " , " ) ;
SERIAL_ECHO ( extruder_offset [ Y_AXIS ] [ tmp_extruder ] ) ;
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
SERIAL_ECHO ( " , " ) ;
SERIAL_ECHO ( extruder_offset [ Z_AXIS ] [ tmp_extruder ] ) ;
# endif
2013-02-04 22:05:45 -06:00
}
SERIAL_ECHOLN ( " " ) ;
2013-03-26 15:43:04 -05:00
} break ;
2013-02-27 05:32:07 -06:00
# endif
2012-11-06 05:06:41 -06:00
case 220 : // M220 S<factor in percent>- set speed factor override percentage
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) )
2012-11-06 05:06:41 -06:00
{
2012-12-05 12:32:02 -06:00
feedmultiply = code_value ( ) ;
2012-11-06 05:06:41 -06:00
}
}
break ;
case 221 : // M221 S<factor in percent>- set extrude factor override percentage
{
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' S ' ) )
2012-11-06 05:06:41 -06:00
{
extrudemultiply = code_value ( ) ;
}
}
break ;
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
case 226 : // M226 P<pin number> S<pin state>- Wait until the specified pin reaches the state required
{
if ( code_seen ( ' P ' ) ) {
int pin_number = code_value ( ) ; // pin number
int pin_state = - 1 ; // required pin state - default is inverted
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
if ( code_seen ( ' S ' ) ) pin_state = code_value ( ) ; // required pin state
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
if ( pin_state > = - 1 & & pin_state < = 1 ) {
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
for ( int8_t i = 0 ; i < ( int8_t ) sizeof ( sensitive_pins ) ; i + + )
{
if ( sensitive_pins [ i ] = = pin_number )
{
pin_number = - 1 ;
break ;
}
}
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
if ( pin_number > - 1 )
{
st_synchronize ( ) ;
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
pinMode ( pin_number , INPUT ) ;
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
int target ;
switch ( pin_state ) {
case 1 :
target = HIGH ;
break ;
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
case 0 :
target = LOW ;
break ;
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
case - 1 :
target = ! digitalRead ( pin_number ) ;
break ;
}
2014-02-05 03:47:12 -06:00
2013-11-08 18:55:23 -06:00
while ( digitalRead ( pin_number ) ! = target ) {
manage_heater ( ) ;
manage_inactivity ( ) ;
lcd_update ( ) ;
}
}
}
}
}
2014-02-05 03:47:12 -06:00
break ;
2013-08-01 08:06:39 -05:00
2013-06-06 17:49:25 -05:00
# if NUM_SERVOS > 0
case 280 : // M280 - set servo position absolute. P: servo index, S: angle or microseconds
{
int servo_index = - 1 ;
int servo_position = 0 ;
if ( code_seen ( ' P ' ) )
servo_index = code_value ( ) ;
if ( code_seen ( ' S ' ) ) {
servo_position = code_value ( ) ;
if ( ( servo_index > = 0 ) & & ( servo_index < NUM_SERVOS ) ) {
2013-09-29 11:20:06 -05:00
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
servos [ servo_index ] . attach ( 0 ) ;
# endif
2013-06-06 17:49:25 -05:00
servos [ servo_index ] . write ( servo_position ) ;
2013-09-29 11:20:06 -05:00
# if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
delay ( PROBE_SERVO_DEACTIVATION_DELAY ) ;
servos [ servo_index ] . detach ( ) ;
# endif
2013-06-06 17:49:25 -05:00
}
else {
SERIAL_ECHO_START ;
SERIAL_ECHO ( " Servo " ) ;
SERIAL_ECHO ( servo_index ) ;
SERIAL_ECHOLN ( " out of range " ) ;
}
}
else if ( servo_index > = 0 ) {
SERIAL_PROTOCOL ( MSG_OK ) ;
SERIAL_PROTOCOL ( " Servo " ) ;
SERIAL_PROTOCOL ( servo_index ) ;
SERIAL_PROTOCOL ( " : " ) ;
SERIAL_PROTOCOL ( servos [ servo_index ] . read ( ) ) ;
SERIAL_PROTOCOLLN ( " " ) ;
}
}
break ;
# endif // NUM_SERVOS > 0
2014-02-03 01:45:03 -06:00
# if (LARGE_FLASH == true && ( BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)))
2013-03-24 23:35:05 -05:00
case 300 : // M300
{
2013-05-02 11:55:15 -05:00
int beepS = code_seen ( ' S ' ) ? code_value ( ) : 110 ;
int beepP = code_seen ( ' P ' ) ? code_value ( ) : 1000 ;
if ( beepS > 0 )
{
2013-06-06 17:49:25 -05:00
# if BEEPER > 0
tone ( BEEPER , beepS ) ;
delay ( beepP ) ;
noTone ( BEEPER ) ;
# elif defined(ULTRALCD)
2014-02-03 01:45:03 -06:00
lcd_buzz ( beepS , beepP ) ;
# elif defined(LCD_USE_I2C_BUZZER)
lcd_buzz ( beepP , beepS ) ;
2013-06-06 17:49:25 -05:00
# endif
2013-05-02 11:55:15 -05:00
}
else
{
delay ( beepP ) ;
}
2013-03-24 23:35:05 -05:00
}
break ;
# endif // M300
2012-11-06 05:06:41 -06:00
# ifdef PIDTEMP
case 301 : // M301
{
if ( code_seen ( ' P ' ) ) Kp = code_value ( ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
if ( code_seen ( ' I ' ) ) Ki = scalePID_i ( code_value ( ) ) ;
if ( code_seen ( ' D ' ) ) Kd = scalePID_d ( code_value ( ) ) ;
2012-11-06 05:06:41 -06:00
# ifdef PID_ADD_EXTRUSION_RATE
if ( code_seen ( ' C ' ) ) Kc = code_value ( ) ;
# endif
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
updatePID ( ) ;
SERIAL_PROTOCOL ( MSG_OK ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( " p: " ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL ( Kp ) ;
SERIAL_PROTOCOL ( " i: " ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
SERIAL_PROTOCOL ( unscalePID_i ( Ki ) ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL ( " d: " ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
SERIAL_PROTOCOL ( unscalePID_d ( Kd ) ) ;
2012-11-06 05:06:41 -06:00
# ifdef PID_ADD_EXTRUSION_RATE
SERIAL_PROTOCOL ( " c: " ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
//Kc does not have scaling applied above, or in resetting defaults
SERIAL_PROTOCOL ( Kc ) ;
2012-11-06 05:06:41 -06:00
# endif
SERIAL_PROTOCOLLN ( " " ) ;
}
break ;
# endif //PIDTEMP
# ifdef PIDTEMPBED
case 304 : // M304
{
if ( code_seen ( ' P ' ) ) bedKp = code_value ( ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
if ( code_seen ( ' I ' ) ) bedKi = scalePID_i ( code_value ( ) ) ;
if ( code_seen ( ' D ' ) ) bedKd = scalePID_d ( code_value ( ) ) ;
2013-04-06 12:18:39 -05:00
2012-11-06 05:06:41 -06:00
updatePID ( ) ;
SERIAL_PROTOCOL ( MSG_OK ) ;
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOL ( " p: " ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL ( bedKp ) ;
SERIAL_PROTOCOL ( " i: " ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
SERIAL_PROTOCOL ( unscalePID_i ( bedKi ) ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOL ( " d: " ) ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 09:05:11 -05:00
SERIAL_PROTOCOL ( unscalePID_d ( bedKd ) ) ;
2012-11-06 05:06:41 -06:00
SERIAL_PROTOCOLLN ( " " ) ;
}
break ;
# endif //PIDTEMP
case 240 : // M240 Triggers a camera by emulating a Canon RC-1 : http://www.doc-diy.net/photo/rc-1_hacked/
{
2013-06-06 17:49:25 -05:00
# if defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1
2012-11-06 05:06:41 -06: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 ) ;
}
# endif
}
break ;
2013-07-14 03:28:26 -05:00
# ifdef DOGLCD
case 250 : // M250 Set LCD contrast value: C<value> (value 0..63)
{
if ( code_seen ( ' C ' ) ) {
lcd_setcontrast ( ( ( int ) code_value ( ) ) & 63 ) ;
}
SERIAL_PROTOCOLPGM ( " lcd contrast value: " ) ;
SERIAL_PROTOCOL ( lcd_contrast ) ;
SERIAL_PROTOCOLLN ( " " ) ;
}
break ;
# endif
2013-06-06 17:49:25 -05:00
# ifdef PREVENT_DANGEROUS_EXTRUDE
case 302 : // allow cold extrudes, or set the minimum extrude temperature
2012-11-06 05:06:41 -06:00
{
2013-06-06 17:49:25 -05:00
float temp = .0 ;
if ( code_seen ( ' S ' ) ) temp = code_value ( ) ;
set_extrude_min_temp ( temp ) ;
2012-11-06 05:06:41 -06:00
}
break ;
2013-06-06 17:49:25 -05:00
# endif
2012-11-06 05:06:41 -06:00
case 303 : // M303 PID autotune
{
float temp = 150.0 ;
int e = 0 ;
int c = 5 ;
if ( code_seen ( ' E ' ) ) e = code_value ( ) ;
2013-06-06 17:49:25 -05:00
if ( e < 0 )
temp = 70 ;
2012-11-06 05:06:41 -06:00
if ( code_seen ( ' S ' ) ) temp = code_value ( ) ;
if ( code_seen ( ' C ' ) ) c = code_value ( ) ;
PID_autotune ( temp , e , c ) ;
}
break ;
case 400 : // M400 finish all moves
{
st_synchronize ( ) ;
}
break ;
2013-09-29 11:20:06 -05:00
# if defined(ENABLE_AUTO_BED_LEVELING) && defined(SERVO_ENDSTOPS)
case 401 :
{
engage_z_probe ( ) ; // Engage Z Servo endstop if available
}
break ;
2014-02-05 03:47:12 -06:00
2013-09-29 11:20:06 -05:00
case 402 :
{
retract_z_probe ( ) ; // Retract Z Servo endstop if enabled
}
break ;
2014-02-05 03:47:12 -06:00
# endif
2012-12-11 03:21:44 -06:00
case 500 : // M500 Store settings in EEPROM
2012-11-06 05:06:41 -06:00
{
2012-11-07 03:02:45 -06:00
Config_StoreSettings ( ) ;
2012-11-06 05:06:41 -06:00
}
break ;
2012-12-11 03:21:44 -06:00
case 501 : // M501 Read settings from EEPROM
2012-11-06 05:06:41 -06:00
{
2012-11-07 03:02:45 -06:00
Config_RetrieveSettings ( ) ;
2012-11-06 05:06:41 -06:00
}
break ;
2012-12-11 03:21:44 -06:00
case 502 : // M502 Revert to default settings
2012-11-06 05:06:41 -06:00
{
2012-11-07 03:02:45 -06:00
Config_ResetDefault ( ) ;
2012-11-06 05:06:41 -06:00
}
break ;
2012-12-11 03:21:44 -06:00
case 503 : // M503 print settings currently in memory
2012-11-06 05:06:41 -06:00
{
2012-11-07 03:02:45 -06:00
Config_PrintSettings ( ) ;
2012-11-06 05:06:41 -06:00
}
2013-02-04 22:05:45 -06:00
break ;
# ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
case 540 :
{
if ( code_seen ( ' S ' ) ) abort_on_endstop_hit = code_value ( ) > 0 ;
}
break ;
2013-01-08 04:53:18 -06:00
# endif
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
# ifdef FILAMENTCHANGEENABLE
case 600 : //Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
{
float target [ 4 ] ;
float lastpos [ 4 ] ;
target [ X_AXIS ] = current_position [ X_AXIS ] ;
target [ Y_AXIS ] = current_position [ Y_AXIS ] ;
target [ Z_AXIS ] = current_position [ Z_AXIS ] ;
target [ E_AXIS ] = current_position [ E_AXIS ] ;
lastpos [ X_AXIS ] = current_position [ X_AXIS ] ;
lastpos [ Y_AXIS ] = current_position [ Y_AXIS ] ;
lastpos [ Z_AXIS ] = current_position [ Z_AXIS ] ;
lastpos [ E_AXIS ] = current_position [ E_AXIS ] ;
//retract by E
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' E ' ) )
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
{
target [ E_AXIS ] + = code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_FIRSTRETRACT
target [ E_AXIS ] + = FILAMENTCHANGE_FIRSTRETRACT ;
# endif
}
plan_buffer_line ( target [ X_AXIS ] , target [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
//lift Z
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' Z ' ) )
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
{
target [ Z_AXIS ] + = code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_ZADD
target [ Z_AXIS ] + = FILAMENTCHANGE_ZADD ;
# endif
}
plan_buffer_line ( target [ X_AXIS ] , target [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
//move xy
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' X ' ) )
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
{
target [ X_AXIS ] + = code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_XPOS
target [ X_AXIS ] = FILAMENTCHANGE_XPOS ;
# endif
}
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' Y ' ) )
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
{
target [ Y_AXIS ] = code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_YPOS
target [ Y_AXIS ] = FILAMENTCHANGE_YPOS ;
# endif
}
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
plan_buffer_line ( target [ X_AXIS ] , target [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
if ( code_seen ( ' L ' ) )
{
target [ E_AXIS ] + = code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_FINALRETRACT
target [ E_AXIS ] + = FILAMENTCHANGE_FINALRETRACT ;
# endif
}
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
plan_buffer_line ( target [ X_AXIS ] , target [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
//finish moves
st_synchronize ( ) ;
//disable extruder steppers so filament can be removed
disable_e0 ( ) ;
disable_e1 ( ) ;
disable_e2 ( ) ;
delay ( 100 ) ;
LCD_ALERTMESSAGEPGM ( MSG_FILAMENTCHANGE ) ;
uint8_t cnt = 0 ;
2013-06-06 17:49:25 -05:00
while ( ! lcd_clicked ( ) ) {
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
cnt + + ;
manage_heater ( ) ;
manage_inactivity ( ) ;
lcd_update ( ) ;
if ( cnt = = 0 )
{
2013-06-06 17:49:25 -05:00
# if BEEPER > 0
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
SET_OUTPUT ( BEEPER ) ;
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
WRITE ( BEEPER , HIGH ) ;
delay ( 3 ) ;
WRITE ( BEEPER , LOW ) ;
delay ( 3 ) ;
2013-08-01 08:06:39 -05:00
# else
2014-02-03 01:45:03 -06:00
# if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
lcd_buzz ( 1000 / 6 , 100 ) ;
# else
lcd_buzz ( LCD_FEEDBACK_FREQUENCY_DURATION_MS , LCD_FEEDBACK_FREQUENCY_HZ ) ;
# endif
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
# endif
2013-06-06 17:49:25 -05:00
}
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
}
2013-06-06 17:49:25 -05:00
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
//return to normal
2013-06-06 17:49:25 -05:00
if ( code_seen ( ' L ' ) )
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 06:21:34 -06:00
{
target [ E_AXIS ] + = - code_value ( ) ;
}
else
{
# ifdef FILAMENTCHANGE_FINALRETRACT
target [ E_AXIS ] + = ( - 1 ) * FILAMENTCHANGE_FINALRETRACT ;
# endif
}
current_position [ E_AXIS ] = target [ E_AXIS ] ; //the long retract of L is compensated by manual filament feeding
plan_set_e_position ( current_position [ E_AXIS ] ) ;
plan_buffer_line ( target [ X_AXIS ] , target [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ; //should do nothing
plan_buffer_line ( lastpos [ X_AXIS ] , lastpos [ Y_AXIS ] , target [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ; //move xy back
plan_buffer_line ( lastpos [ X_AXIS ] , lastpos [ Y_AXIS ] , lastpos [ Z_AXIS ] , target [ E_AXIS ] , feedrate / 60 , active_extruder ) ; //move z back
plan_buffer_line ( lastpos [ X_AXIS ] , lastpos [ Y_AXIS ] , lastpos [ Z_AXIS ] , lastpos [ E_AXIS ] , feedrate / 60 , active_extruder ) ; //final untretract
}
break ;
2013-06-06 17:49:25 -05:00
# endif //FILAMENTCHANGEENABLE
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
case 605 : // 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
2014-02-05 03:47:12 -06:00
// millimeters x-offset and an optional differential hotend temperature of
2013-08-07 09:10:26 -05: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.
{
st_synchronize ( ) ;
2014-02-05 03:47:12 -06:00
2013-08-07 09:10:26 -05:00
if ( code_seen ( ' S ' ) )
dual_x_carriage_mode = code_value ( ) ;
if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE )
{
if ( code_seen ( ' X ' ) )
duplicate_extruder_x_offset = max ( code_value ( ) , X2_MIN_POS - x_home_pos ( 0 ) ) ;
if ( code_seen ( ' R ' ) )
duplicate_extruder_temp_offset = code_value ( ) ;
2014-02-05 03:47:12 -06:00
2013-08-07 09:10:26 -05:00
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_HOTEND_OFFSET ) ;
SERIAL_ECHO ( " " ) ;
SERIAL_ECHO ( extruder_offset [ X_AXIS ] [ 0 ] ) ;
SERIAL_ECHO ( " , " ) ;
SERIAL_ECHO ( extruder_offset [ Y_AXIS ] [ 0 ] ) ;
SERIAL_ECHO ( " " ) ;
SERIAL_ECHO ( duplicate_extruder_x_offset ) ;
SERIAL_ECHO ( " , " ) ;
SERIAL_ECHOLN ( extruder_offset [ Y_AXIS ] [ 1 ] ) ;
}
else if ( dual_x_carriage_mode ! = DXC_FULL_CONTROL_MODE & & dual_x_carriage_mode ! = DXC_AUTO_PARK_MODE )
{
dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE ;
}
2014-02-05 03:47:12 -06:00
2013-08-07 09:10:26 -05:00
active_extruder_parked = false ;
extruder_duplication_enabled = false ;
delayed_move_time = 0 ;
}
break ;
2014-02-05 03:47:12 -06:00
# endif //DUAL_X_CARRIAGE
2013-08-07 09:10:26 -05:00
2012-12-11 03:21:44 -06:00
case 907 : // M907 Set digital trimpot motor current using axis codes.
2012-11-21 13:36:30 -06:00
{
2013-06-06 17:49:25 -05:00
# if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1
for ( int i = 0 ; i < NUM_AXIS ; i + + ) if ( code_seen ( axis_codes [ i ] ) ) digipot_current ( i , code_value ( ) ) ;
2012-11-21 13:36:30 -06:00
if ( code_seen ( ' B ' ) ) digipot_current ( 4 , code_value ( ) ) ;
if ( code_seen ( ' S ' ) ) for ( int i = 0 ; i < = 4 ; i + + ) digipot_current ( i , code_value ( ) ) ;
# endif
2014-01-06 04:05:02 -06:00
# ifdef MOTOR_CURRENT_PWM_XY_PIN
if ( code_seen ( ' X ' ) ) digipot_current ( 0 , code_value ( ) ) ;
# endif
# ifdef MOTOR_CURRENT_PWM_Z_PIN
if ( code_seen ( ' Z ' ) ) digipot_current ( 1 , code_value ( ) ) ;
# endif
# ifdef MOTOR_CURRENT_PWM_E_PIN
if ( code_seen ( ' E ' ) ) digipot_current ( 2 , code_value ( ) ) ;
# endif
2014-02-05 03:47:12 -06:00
# ifdef DIGIPOT_I2C
// this one uses actual amps in floating point
for ( int i = 0 ; i < NUM_AXIS ; i + + ) if ( code_seen ( axis_codes [ i ] ) ) digipot_i2c_set_current ( i , code_value ( ) ) ;
// for each additional extruder (named B,C,D,E..., channels 4,5,6,7...)
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 ( ) ) ;
# endif
2012-11-21 13:36:30 -06:00
}
2013-06-06 17:49:25 -05:00
break ;
2012-12-11 03:21:44 -06:00
case 908 : // M908 Control digital trimpot directly.
2012-11-21 13:36:30 -06:00
{
2013-06-06 17:49:25 -05:00
# if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1
2012-11-21 13:36:30 -06:00
uint8_t channel , current ;
if ( code_seen ( ' P ' ) ) channel = code_value ( ) ;
if ( code_seen ( ' S ' ) ) current = code_value ( ) ;
digitalPotWrite ( channel , current ) ;
# endif
}
break ;
2012-12-11 03:21:44 -06:00
case 350 : // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
2012-11-21 13:36:30 -06:00
{
2013-06-06 17:49:25 -05:00
# if defined(X_MS1_PIN) && X_MS1_PIN > -1
if ( code_seen ( ' S ' ) ) for ( int i = 0 ; i < = 4 ; i + + ) microstep_mode ( i , code_value ( ) ) ;
for ( int i = 0 ; i < NUM_AXIS ; i + + ) if ( code_seen ( axis_codes [ i ] ) ) microstep_mode ( i , ( uint8_t ) code_value ( ) ) ;
2012-11-21 13:36:30 -06:00
if ( code_seen ( ' B ' ) ) microstep_mode ( 4 , code_value ( ) ) ;
microstep_readings ( ) ;
# endif
}
break ;
2012-12-11 03:21:44 -06:00
case 351 : // M351 Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
2012-11-21 13:36:30 -06:00
{
2013-06-06 17:49:25 -05:00
# if defined(X_MS1_PIN) && X_MS1_PIN > -1
2012-11-21 13:36:30 -06:00
if ( code_seen ( ' S ' ) ) switch ( ( int ) code_value ( ) )
{
case 1 :
2013-06-06 17:49:25 -05:00
for ( int i = 0 ; i < NUM_AXIS ; i + + ) if ( code_seen ( axis_codes [ i ] ) ) microstep_ms ( i , code_value ( ) , - 1 ) ;
2012-11-21 13:36:30 -06:00
if ( code_seen ( ' B ' ) ) microstep_ms ( 4 , code_value ( ) , - 1 ) ;
break ;
case 2 :
2013-06-06 17:49:25 -05:00
for ( int i = 0 ; i < NUM_AXIS ; i + + ) if ( code_seen ( axis_codes [ i ] ) ) microstep_ms ( i , - 1 , code_value ( ) ) ;
2012-11-21 13:36:30 -06:00
if ( code_seen ( ' B ' ) ) microstep_ms ( 4 , - 1 , code_value ( ) ) ;
break ;
}
microstep_readings ( ) ;
# endif
}
break ;
2012-12-11 03:21:44 -06:00
case 999 : // M999: Restart after being stopped
2012-11-06 05:06:41 -06:00
Stopped = false ;
2012-12-12 04:47:03 -06:00
lcd_reset_alert_level ( ) ;
2012-11-06 05:06:41 -06:00
gcode_LastN = Stopped_gcode_LastN ;
FlushSerialRequestResend ( ) ;
break ;
}
}
2013-06-06 17:49:25 -05:00
else if ( code_seen ( ' T ' ) )
2012-11-06 05:06:41 -06:00
{
tmp_extruder = code_value ( ) ;
if ( tmp_extruder > = EXTRUDERS ) {
SERIAL_ECHO_START ;
SERIAL_ECHO ( " T " ) ;
SERIAL_ECHO ( tmp_extruder ) ;
SERIAL_ECHOLN ( MSG_INVALID_EXTRUDER ) ;
}
else {
2013-02-04 22:05:45 -06:00
boolean make_move = false ;
if ( code_seen ( ' F ' ) ) {
make_move = true ;
next_feedrate = code_value ( ) ;
if ( next_feedrate > 0.0 ) {
feedrate = next_feedrate ;
}
}
2013-02-27 05:32:07 -06:00
# if EXTRUDERS > 1
2013-02-04 22:05:45 -06:00
if ( tmp_extruder ! = active_extruder ) {
// Save current position to return to after applying extruder offset
memcpy ( destination , current_position , sizeof ( destination ) ) ;
2013-07-17 07:44:45 -05:00
# ifdef DUAL_X_CARRIAGE
2014-02-05 03:47:12 -06:00
if ( dual_x_carriage_mode = = DXC_AUTO_PARK_MODE & & Stopped = = false & &
2013-08-07 09:10:26 -05:00
( delayed_move_time ! = 0 | | current_position [ X_AXIS ] ! = x_home_pos ( active_extruder ) ) )
{
// Park old head: 1) raise 2) move to park position 3) lower
2014-02-05 03:47:12 -06:00
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] + TOOLCHANGE_PARK_ZLIFT ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , max_feedrate [ Z_AXIS ] , active_extruder ) ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( x_home_pos ( active_extruder ) , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] + TOOLCHANGE_PARK_ZLIFT ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , max_feedrate [ X_AXIS ] , active_extruder ) ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( x_home_pos ( active_extruder ) , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , max_feedrate [ Z_AXIS ] , active_extruder ) ;
st_synchronize ( ) ;
}
2014-02-05 03:47:12 -06:00
2013-08-07 09:10:26 -05:00
// apply Y & Z extruder offset (x offset is already used in determining home pos)
2013-07-17 07:44:45 -05:00
current_position [ Y_AXIS ] = current_position [ Y_AXIS ] -
extruder_offset [ Y_AXIS ] [ active_extruder ] +
extruder_offset [ Y_AXIS ] [ tmp_extruder ] ;
2013-08-07 09:10:26 -05:00
current_position [ Z_AXIS ] = current_position [ Z_AXIS ] -
extruder_offset [ Z_AXIS ] [ active_extruder ] +
extruder_offset [ Z_AXIS ] [ tmp_extruder ] ;
2014-02-05 03:47:12 -06:00
2013-08-07 09:10:26 -05:00
active_extruder = tmp_extruder ;
2013-07-17 07:44:45 -05:00
2013-08-07 09:10:26 -05:00
// This function resets the max/min values - the current position may be overwritten below.
axis_is_at_home ( X_AXIS ) ;
2013-07-17 07:44:45 -05:00
2013-08-07 09:10:26 -05:00
if ( dual_x_carriage_mode = = DXC_FULL_CONTROL_MODE )
{
2014-02-05 03:47:12 -06:00
current_position [ X_AXIS ] = inactive_extruder_x_pos ;
2013-08-07 09:10:26 -05:00
inactive_extruder_x_pos = destination [ X_AXIS ] ;
}
else if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE )
{
active_extruder_parked = ( active_extruder = = 0 ) ; // this triggers the second extruder to move into the duplication position
if ( active_extruder = = 0 | | active_extruder_parked )
2014-02-05 03:47:12 -06:00
current_position [ X_AXIS ] = inactive_extruder_x_pos ;
2013-08-07 09:10:26 -05:00
else
2014-02-05 03:47:12 -06:00
current_position [ X_AXIS ] = destination [ X_AXIS ] + duplicate_extruder_x_offset ;
2013-08-07 09:10:26 -05:00
inactive_extruder_x_pos = destination [ X_AXIS ] ;
2014-02-05 03:47:12 -06:00
extruder_duplication_enabled = false ;
2013-08-07 09:10:26 -05:00
}
else
{
// 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 ;
active_extruder_parked = true ;
delayed_move_time = 0 ;
}
2014-02-05 03:47:12 -06:00
# else
2013-02-04 22:05:45 -06:00
// Offset extruder (only by XY)
int i ;
for ( i = 0 ; i < 2 ; i + + ) {
2013-06-06 17:49:25 -05:00
current_position [ i ] = current_position [ i ] -
2013-02-04 22:05:45 -06:00
extruder_offset [ i ] [ active_extruder ] +
extruder_offset [ i ] [ tmp_extruder ] ;
}
// Set the new active extruder and position
active_extruder = tmp_extruder ;
2013-07-17 07:44:45 -05:00
# endif //else DUAL_X_CARRIAGE
2013-02-04 22:05:45 -06:00
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
// Move to the old position if 'F' was in the parameters
if ( make_move & & Stopped = = false ) {
prepare_move ( ) ;
}
2013-03-26 15:43:04 -05:00
}
2013-02-27 05:32:07 -06:00
# endif
2012-11-06 05:06:41 -06:00
SERIAL_ECHO_START ;
SERIAL_ECHO ( MSG_ACTIVE_EXTRUDER ) ;
SERIAL_PROTOCOLLN ( ( int ) active_extruder ) ;
}
}
else
{
SERIAL_ECHO_START ;
SERIAL_ECHOPGM ( MSG_UNKNOWN_COMMAND ) ;
SERIAL_ECHO ( cmdbuffer [ bufindr ] ) ;
SERIAL_ECHOLNPGM ( " \" " ) ;
}
ClearToSend ( ) ;
}
void FlushSerialRequestResend ( )
{
//char cmdbuffer[bufindr][100]="Resend:";
MYSERIAL . flush ( ) ;
SERIAL_PROTOCOLPGM ( MSG_RESEND ) ;
SERIAL_PROTOCOLLN ( gcode_LastN + 1 ) ;
ClearToSend ( ) ;
}
void ClearToSend ( )
{
previous_millis_cmd = millis ( ) ;
# ifdef SDSUPPORT
if ( fromsd [ bufindr ] )
return ;
# endif //SDSUPPORT
2013-06-06 17:49:25 -05:00
SERIAL_PROTOCOLLNPGM ( MSG_OK ) ;
2012-11-06 05:06:41 -06:00
}
void get_coordinates ( )
{
bool seen [ 4 ] = { false , false , false , false } ;
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
2013-06-06 17:49:25 -05:00
if ( code_seen ( axis_codes [ i ] ) )
2012-11-06 05:06:41 -06:00
{
destination [ i ] = ( float ) code_value ( ) + ( axis_relative_modes [ i ] | | relative_mode ) * current_position [ i ] ;
seen [ i ] = true ;
}
else destination [ i ] = current_position [ i ] ; //Are these else lines really needed?
}
if ( code_seen ( ' F ' ) ) {
next_feedrate = code_value ( ) ;
if ( next_feedrate > 0.0 ) feedrate = next_feedrate ;
}
# ifdef FWRETRACT
if ( autoretract_enabled )
if ( ! ( seen [ X_AXIS ] | | seen [ Y_AXIS ] | | seen [ Z_AXIS ] ) & & seen [ E_AXIS ] )
{
float echange = destination [ E_AXIS ] - current_position [ E_AXIS ] ;
if ( echange < - MIN_RETRACT ) //retract
{
2013-06-06 17:49:25 -05:00
if ( ! retracted )
2012-11-06 05:06:41 -06:00
{
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
destination [ Z_AXIS ] + = retract_zlift ; //not sure why chaninging current_position negatively does not work.
//if slicer retracted by echange=-1mm and you want to retract 3mm, corrrectede=-2mm additionally
float correctede = - echange - retract_length ;
//to generate the additional steps, not the destination is changed, but inversely the current position
2013-06-06 17:49:25 -05:00
current_position [ E_AXIS ] + = - correctede ;
2012-11-06 05:06:41 -06:00
feedrate = retract_feedrate ;
retracted = true ;
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
}
2013-06-06 17:49:25 -05:00
else
2012-11-06 05:06:41 -06:00
if ( echange > MIN_RETRACT ) //retract_recover
{
2013-06-06 17:49:25 -05:00
if ( retracted )
2012-11-06 05:06:41 -06:00
{
//current_position[Z_AXIS]+=-retract_zlift;
//if slicer retracted_recovered by echange=+1mm and you want to retract_recover 3mm, corrrectede=2mm additionally
float correctede = - echange + 1 * retract_length + retract_recover_length ; //total unretract=retract_length+retract_recover_length[surplus]
current_position [ E_AXIS ] + = correctede ; //to generate the additional steps, not the destination is changed, but inversely the current position
feedrate = retract_recover_feedrate ;
retracted = false ;
}
}
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
}
# endif //FWRETRACT
}
void get_arc_coordinates ( )
{
# ifdef SF_ARC_FIX
bool relative_mode_backup = relative_mode ;
relative_mode = true ;
# endif
get_coordinates ( ) ;
# ifdef SF_ARC_FIX
relative_mode = relative_mode_backup ;
# endif
if ( code_seen ( ' I ' ) ) {
offset [ 0 ] = code_value ( ) ;
2013-06-06 17:49:25 -05:00
}
2012-11-06 05:06:41 -06:00
else {
offset [ 0 ] = 0.0 ;
}
if ( code_seen ( ' J ' ) ) {
offset [ 1 ] = code_value ( ) ;
}
else {
offset [ 1 ] = 0.0 ;
}
}
void clamp_to_software_endstops ( float target [ 3 ] )
{
if ( min_software_endstops ) {
if ( target [ X_AXIS ] < min_pos [ X_AXIS ] ) target [ X_AXIS ] = min_pos [ X_AXIS ] ;
if ( target [ Y_AXIS ] < min_pos [ Y_AXIS ] ) target [ Y_AXIS ] = min_pos [ Y_AXIS ] ;
if ( target [ Z_AXIS ] < min_pos [ Z_AXIS ] ) target [ Z_AXIS ] = min_pos [ Z_AXIS ] ;
}
if ( max_software_endstops ) {
if ( target [ X_AXIS ] > max_pos [ X_AXIS ] ) target [ X_AXIS ] = max_pos [ X_AXIS ] ;
if ( target [ Y_AXIS ] > max_pos [ Y_AXIS ] ) target [ Y_AXIS ] = max_pos [ Y_AXIS ] ;
if ( target [ Z_AXIS ] > max_pos [ Z_AXIS ] ) target [ Z_AXIS ] = max_pos [ Z_AXIS ] ;
}
}
2013-06-08 17:51:58 -05:00
# ifdef DELTA
2012-12-10 03:04:12 -06:00
void calculate_delta ( float cartesian [ 3 ] )
{
2013-07-30 07:09:21 -05:00
delta [ X_AXIS ] = sqrt ( DELTA_DIAGONAL_ROD_2
2012-12-10 03:04:12 -06:00
- sq ( DELTA_TOWER1_X - cartesian [ X_AXIS ] )
- sq ( DELTA_TOWER1_Y - cartesian [ Y_AXIS ] )
) + cartesian [ Z_AXIS ] ;
2013-07-30 07:09:21 -05:00
delta [ Y_AXIS ] = sqrt ( DELTA_DIAGONAL_ROD_2
2012-12-10 03:04:12 -06:00
- sq ( DELTA_TOWER2_X - cartesian [ X_AXIS ] )
- sq ( DELTA_TOWER2_Y - cartesian [ Y_AXIS ] )
) + cartesian [ Z_AXIS ] ;
2013-07-30 07:09:21 -05:00
delta [ Z_AXIS ] = sqrt ( DELTA_DIAGONAL_ROD_2
2012-12-10 03:04:12 -06:00
- sq ( DELTA_TOWER3_X - cartesian [ X_AXIS ] )
- sq ( DELTA_TOWER3_Y - cartesian [ Y_AXIS ] )
) + cartesian [ Z_AXIS ] ;
/*
SERIAL_ECHOPGM ( " cartesian x= " ) ; SERIAL_ECHO ( cartesian [ X_AXIS ] ) ;
SERIAL_ECHOPGM ( " y= " ) ; SERIAL_ECHO ( cartesian [ Y_AXIS ] ) ;
SERIAL_ECHOPGM ( " z= " ) ; SERIAL_ECHOLN ( cartesian [ Z_AXIS ] ) ;
SERIAL_ECHOPGM ( " delta x= " ) ; SERIAL_ECHO ( delta [ X_AXIS ] ) ;
SERIAL_ECHOPGM ( " y= " ) ; SERIAL_ECHO ( delta [ Y_AXIS ] ) ;
SERIAL_ECHOPGM ( " z= " ) ; SERIAL_ECHOLN ( delta [ Z_AXIS ] ) ;
*/
}
2013-06-08 17:51:58 -05:00
# endif
2012-12-10 03:04:12 -06:00
2012-11-06 05:06:41 -06:00
void prepare_move ( )
{
clamp_to_software_endstops ( destination ) ;
2013-06-06 17:49:25 -05:00
previous_millis_cmd = millis ( ) ;
2013-06-08 17:51:58 -05:00
# ifdef DELTA
2012-12-10 03:04:12 -06:00
float difference [ NUM_AXIS ] ;
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
difference [ i ] = destination [ i ] - current_position [ i ] ;
2012-11-06 05:06:41 -06:00
}
2012-12-10 03:04:12 -06:00
float cartesian_mm = sqrt ( sq ( difference [ X_AXIS ] ) +
sq ( difference [ Y_AXIS ] ) +
sq ( difference [ Z_AXIS ] ) ) ;
if ( cartesian_mm < 0.000001 ) { cartesian_mm = abs ( difference [ E_AXIS ] ) ; }
if ( cartesian_mm < 0.000001 ) { return ; }
float seconds = 6000 * cartesian_mm / feedrate / feedmultiply ;
int steps = max ( 1 , int ( DELTA_SEGMENTS_PER_SECOND * seconds ) ) ;
// SERIAL_ECHOPGM("mm="); SERIAL_ECHO(cartesian_mm);
// SERIAL_ECHOPGM(" seconds="); SERIAL_ECHO(seconds);
// SERIAL_ECHOPGM(" steps="); SERIAL_ECHOLN(steps);
for ( int s = 1 ; s < = steps ; s + + ) {
float fraction = float ( s ) / float ( steps ) ;
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
destination [ i ] = current_position [ i ] + difference [ i ] * fraction ;
}
calculate_delta ( destination ) ;
plan_buffer_line ( delta [ X_AXIS ] , delta [ Y_AXIS ] , delta [ Z_AXIS ] ,
destination [ E_AXIS ] , feedrate * feedmultiply / 60 / 100.0 ,
active_extruder ) ;
2012-11-06 05:06:41 -06:00
}
2013-06-08 17:51:58 -05:00
# else
2013-08-07 09:10:26 -05:00
# ifdef DUAL_X_CARRIAGE
if ( active_extruder_parked )
{
if ( dual_x_carriage_mode = = DXC_DUPLICATION_MODE & & active_extruder = = 0 )
{
// move duplicate extruder into correct duplication position.
plan_set_position ( inactive_extruder_x_pos , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( current_position [ X_AXIS ] + duplicate_extruder_x_offset , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , max_feedrate [ X_AXIS ] , 1 ) ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
st_synchronize ( ) ;
extruder_duplication_enabled = true ;
active_extruder_parked = false ;
2014-02-05 03:47:12 -06:00
}
2013-08-07 09:10:26 -05:00
else if ( dual_x_carriage_mode = = DXC_AUTO_PARK_MODE ) // handle unparking of head
{
if ( current_position [ E_AXIS ] = = destination [ E_AXIS ] )
{
// this is a travel move - skit it but keep track of current position (so that it can later
// be used as start of first non-travel move)
if ( delayed_move_time ! = 0xFFFFFFFFUL )
{
2014-02-05 03:47:12 -06:00
memcpy ( current_position , destination , sizeof ( current_position ) ) ;
2013-08-07 09:10:26 -05:00
if ( destination [ Z_AXIS ] > raised_parked_position [ Z_AXIS ] )
raised_parked_position [ Z_AXIS ] = destination [ Z_AXIS ] ;
delayed_move_time = millis ( ) ;
return ;
}
}
delayed_move_time = 0 ;
// unpark extruder: 1) raise, 2) move into starting XY position, 3) lower
plan_buffer_line ( raised_parked_position [ X_AXIS ] , raised_parked_position [ Y_AXIS ] , raised_parked_position [ Z_AXIS ] , current_position [ E_AXIS ] , max_feedrate [ Z_AXIS ] , active_extruder ) ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , raised_parked_position [ Z_AXIS ] ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , min ( max_feedrate [ X_AXIS ] , max_feedrate [ Y_AXIS ] ) , active_extruder ) ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] ,
2013-08-07 09:10:26 -05:00
current_position [ E_AXIS ] , max_feedrate [ Z_AXIS ] , active_extruder ) ;
active_extruder_parked = false ;
}
}
# endif //DUAL_X_CARRIAGE
2012-11-06 05:06:41 -06:00
// Do not use feedmultiply for E or Z only moves
if ( ( current_position [ X_AXIS ] = = destination [ X_AXIS ] ) & & ( current_position [ Y_AXIS ] = = destination [ Y_AXIS ] ) ) {
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate / 60 , active_extruder ) ;
}
else {
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] , destination [ E_AXIS ] , feedrate * feedmultiply / 60 / 100.0 , active_extruder ) ;
}
2013-08-07 09:10:26 -05:00
# endif //else DELTA
2012-11-06 05:06:41 -06:00
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
current_position [ i ] = destination [ i ] ;
}
}
void prepare_arc_move ( char isclockwise ) {
float r = hypot ( offset [ X_AXIS ] , offset [ Y_AXIS ] ) ; // Compute arc radius for mc_arc
// Trace the arc
mc_arc ( current_position , destination , offset , X_AXIS , Y_AXIS , Z_AXIS , feedrate * feedmultiply / 60 / 100.0 , r , isclockwise , active_extruder ) ;
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06: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.
for ( int8_t i = 0 ; i < NUM_AXIS ; i + + ) {
current_position [ i ] = destination [ i ] ;
}
previous_millis_cmd = millis ( ) ;
}
2013-06-06 17:49:25 -05:00
# if defined(CONTROLLERFAN_PIN) && CONTROLLERFAN_PIN > -1
# if defined(FAN_PIN)
2013-08-01 08:06:39 -05:00
# if CONTROLLERFAN_PIN == FAN_PIN
2013-06-06 17:49:25 -05:00
# error "You cannot set CONTROLLERFAN_PIN equal to FAN_PIN"
# endif
2013-08-01 08:06:39 -05:00
# endif
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
unsigned long lastMotor = 0 ; //Save the time for when a motor was turned on last
unsigned long lastMotorCheck = 0 ;
void controllerFan ( )
{
if ( ( millis ( ) - lastMotorCheck ) > = 2500 ) //Not a time critical function, so we only check every 2500ms
{
lastMotorCheck = millis ( ) ;
2013-06-06 17:49:25 -05:00
2013-11-27 19:23:06 -06:00
if ( ! READ ( X_ENABLE_PIN ) | | ! READ ( Y_ENABLE_PIN ) | | ! READ ( Z_ENABLE_PIN ) | | ( soft_pwm_bed > 0 )
2012-11-06 05:06:41 -06:00
# if EXTRUDERS > 2
| | ! READ ( E2_ENABLE_PIN )
# endif
# if EXTRUDER > 1
2013-07-17 07:44:45 -05:00
# if defined(X2_ENABLE_PIN) && X2_ENABLE_PIN > -1
| | ! READ ( X2_ENABLE_PIN )
# endif
2013-06-06 17:49:25 -05:00
| | ! READ ( E1_ENABLE_PIN )
2012-11-06 05:06:41 -06:00
# endif
2013-06-06 17:49:25 -05:00
| | ! READ ( E0_ENABLE_PIN ) ) //If any of the drivers are enabled...
2012-11-06 05:06:41 -06:00
{
lastMotor = millis ( ) ; //... set time to NOW so the fan will turn on
}
2013-08-01 08:06:39 -05:00
if ( ( millis ( ) - lastMotor ) > = ( CONTROLLERFAN_SECS * 1000UL ) | | lastMotor = = 0 ) //If the last time any driver was enabled, is longer since than CONTROLLERSEC...
2012-11-06 05:06:41 -06:00
{
2013-08-01 08:06:39 -05:00
digitalWrite ( CONTROLLERFAN_PIN , 0 ) ;
analogWrite ( CONTROLLERFAN_PIN , 0 ) ;
2012-11-06 05:06:41 -06:00
}
else
{
2013-06-06 17:49:25 -05:00
// allows digital or PWM fan output to be used (see M42 handling)
digitalWrite ( CONTROLLERFAN_PIN , CONTROLLERFAN_SPEED ) ;
2013-08-01 08:06:39 -05:00
analogWrite ( CONTROLLERFAN_PIN , CONTROLLERFAN_SPEED ) ;
2012-11-06 05:06:41 -06:00
}
}
}
# endif
2013-10-20 05:12:35 -05:00
# ifdef TEMP_STAT_LEDS
static bool blue_led = false ;
static bool red_led = false ;
static uint32_t stat_update = 0 ;
void handle_status_leds ( void ) {
float max_temp = 0.0 ;
if ( millis ( ) > stat_update ) {
stat_update + = 500 ; // Update every 0.5s
for ( int8_t cur_extruder = 0 ; cur_extruder < EXTRUDERS ; + + cur_extruder ) {
max_temp = max ( max_temp , degHotend ( cur_extruder ) ) ;
max_temp = max ( max_temp , degTargetHotend ( cur_extruder ) ) ;
}
# if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
max_temp = max ( max_temp , degTargetBed ( ) ) ;
max_temp = max ( max_temp , degBed ( ) ) ;
# endif
if ( ( max_temp > 55.0 ) & & ( red_led = = false ) ) {
digitalWrite ( STAT_LED_RED , 1 ) ;
digitalWrite ( STAT_LED_BLUE , 0 ) ;
red_led = true ;
blue_led = false ;
}
if ( ( max_temp < 54.0 ) & & ( blue_led = = false ) ) {
digitalWrite ( STAT_LED_RED , 0 ) ;
digitalWrite ( STAT_LED_BLUE , 1 ) ;
red_led = false ;
blue_led = true ;
}
}
}
# endif
2013-06-06 17:49:25 -05:00
void manage_inactivity ( )
2013-03-26 15:43:04 -05:00
{
2013-06-06 17:49:25 -05:00
if ( ( millis ( ) - previous_millis_cmd ) > max_inactive_time )
if ( max_inactive_time )
kill ( ) ;
2012-11-06 05:06:41 -06:00
if ( stepper_inactive_time ) {
2013-06-06 17:49:25 -05:00
if ( ( millis ( ) - previous_millis_cmd ) > stepper_inactive_time )
2012-11-06 05:06:41 -06:00
{
if ( blocks_queued ( ) = = false ) {
disable_x ( ) ;
disable_y ( ) ;
disable_z ( ) ;
disable_e0 ( ) ;
disable_e1 ( ) ;
disable_e2 ( ) ;
}
}
}
2013-06-06 17:49:25 -05:00
# if defined(KILL_PIN) && KILL_PIN > -1
2012-11-06 05:06:41 -06:00
if ( 0 = = READ ( KILL_PIN ) )
kill ( ) ;
# endif
2013-06-06 17:49:25 -05:00
# if defined(CONTROLLERFAN_PIN) && CONTROLLERFAN_PIN > -1
2012-11-06 05:06:41 -06:00
controllerFan ( ) ; //Check if fan should be turned on to cool stepper drivers down
# endif
# ifdef EXTRUDER_RUNOUT_PREVENT
2013-06-06 17:49:25 -05:00
if ( ( millis ( ) - previous_millis_cmd ) > EXTRUDER_RUNOUT_SECONDS * 1000 )
2012-11-06 05:06:41 -06:00
if ( degHotend ( active_extruder ) > EXTRUDER_RUNOUT_MINTEMP )
{
bool oldstatus = READ ( E0_ENABLE_PIN ) ;
enable_e0 ( ) ;
float oldepos = current_position [ E_AXIS ] ;
float oldedes = destination [ E_AXIS ] ;
2014-02-05 03:47:12 -06:00
plan_buffer_line ( destination [ X_AXIS ] , destination [ Y_AXIS ] , destination [ Z_AXIS ] ,
destination [ E_AXIS ] + EXTRUDER_RUNOUT_EXTRUDE * EXTRUDER_RUNOUT_ESTEPS / axis_steps_per_unit [ E_AXIS ] ,
2012-11-06 05:06:41 -06:00
EXTRUDER_RUNOUT_SPEED / 60. * EXTRUDER_RUNOUT_ESTEPS / axis_steps_per_unit [ E_AXIS ] , active_extruder ) ;
current_position [ E_AXIS ] = oldepos ;
destination [ E_AXIS ] = oldedes ;
plan_set_e_position ( oldepos ) ;
2014-01-20 00:06:45 -06:00
previous_millis_cmd = millis ( ) ;
2012-11-06 05:06:41 -06:00
st_synchronize ( ) ;
WRITE ( E0_ENABLE_PIN , oldstatus ) ;
}
# endif
2013-08-07 09:10:26 -05:00
# if defined(DUAL_X_CARRIAGE)
// handle delayed move timeout
if ( delayed_move_time ! = 0 & & ( millis ( ) - delayed_move_time ) > 1000 & & Stopped = = false )
{
// travel moves have been received so enact them
delayed_move_time = 0xFFFFFFFFUL ; // force moves to be done
memcpy ( destination , current_position , sizeof ( destination ) ) ;
2014-02-05 03:47:12 -06:00
prepare_move ( ) ;
2013-08-07 09:10:26 -05:00
}
2013-10-20 05:12:35 -05:00
# endif
# ifdef TEMP_STAT_LEDS
handle_status_leds ( ) ;
# endif
2012-11-06 05:06:41 -06:00
check_axes_activity ( ) ;
}
void kill ( )
{
cli ( ) ; // Stop interrupts
disable_heater ( ) ;
disable_x ( ) ;
disable_y ( ) ;
disable_z ( ) ;
disable_e0 ( ) ;
disable_e1 ( ) ;
disable_e2 ( ) ;
2013-06-06 17:49:25 -05:00
# if defined(PS_ON_PIN) && PS_ON_PIN > -1
pinMode ( PS_ON_PIN , INPUT ) ;
2013-08-01 08:06:39 -05:00
# endif
2012-11-06 05:06:41 -06:00
SERIAL_ERROR_START ;
SERIAL_ERRORLNPGM ( MSG_ERR_KILLED ) ;
LCD_ALERTMESSAGEPGM ( MSG_KILLED ) ;
suicide ( ) ;
2012-11-12 08:35:28 -06:00
while ( 1 ) { /* Intentionally left empty */ } // Wait for reset
2012-11-06 05:06:41 -06:00
}
void Stop ( )
{
disable_heater ( ) ;
if ( Stopped = = false ) {
Stopped = true ;
Stopped_gcode_LastN = gcode_LastN ; // Save last g_code for restart
SERIAL_ERROR_START ;
SERIAL_ERRORLNPGM ( MSG_ERR_STOPPED ) ;
LCD_MESSAGEPGM ( MSG_STOPPED ) ;
}
}
bool IsStopped ( ) { return Stopped ; } ;
# ifdef FAST_PWM_FAN
void setPwmFrequency ( uint8_t pin , int val )
{
val & = 0x07 ;
switch ( digitalPinToTimer ( pin ) )
{
2013-06-06 17:49:25 -05:00
2012-11-06 05:06:41 -06:00
# if defined(TCCR0A)
case TIMER0A :
case TIMER0B :
2012-12-11 03:21:44 -06:00
// TCCR0B &= ~(_BV(CS00) | _BV(CS01) | _BV(CS02));
2012-11-06 05:06:41 -06:00
// TCCR0B |= val;
break ;
# endif
# if defined(TCCR1A)
case TIMER1A :
case TIMER1B :
2012-12-11 03:21:44 -06:00
// TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
2012-11-06 05:06:41 -06:00
// TCCR1B |= val;
break ;
# endif
# if defined(TCCR2)
case TIMER2 :
case TIMER2 :
2012-12-11 03:21:44 -06:00
TCCR2 & = ~ ( _BV ( CS10 ) | _BV ( CS11 ) | _BV ( CS12 ) ) ;
2012-11-06 05:06:41 -06:00
TCCR2 | = val ;
break ;
# endif
# if defined(TCCR2A)
case TIMER2A :
case TIMER2B :
2012-12-11 03:21:44 -06:00
TCCR2B & = ~ ( _BV ( CS20 ) | _BV ( CS21 ) | _BV ( CS22 ) ) ;
2012-11-06 05:06:41 -06:00
TCCR2B | = val ;
break ;
# endif
# if defined(TCCR3A)
case TIMER3A :
case TIMER3B :
case TIMER3C :
2012-12-11 03:21:44 -06:00
TCCR3B & = ~ ( _BV ( CS30 ) | _BV ( CS31 ) | _BV ( CS32 ) ) ;
2012-11-06 05:06:41 -06:00
TCCR3B | = val ;
break ;
# endif
2013-06-06 17:49:25 -05:00
# if defined(TCCR4A)
2012-11-06 05:06:41 -06:00
case TIMER4A :
case TIMER4B :
case TIMER4C :
2012-12-11 03:21:44 -06:00
TCCR4B & = ~ ( _BV ( CS40 ) | _BV ( CS41 ) | _BV ( CS42 ) ) ;
2012-11-06 05:06:41 -06:00
TCCR4B | = val ;
break ;
# endif
2013-06-06 17:49:25 -05:00
# if defined(TCCR5A)
2012-11-06 05:06:41 -06:00
case TIMER5A :
case TIMER5B :
case TIMER5C :
2012-12-11 03:21:44 -06:00
TCCR5B & = ~ ( _BV ( CS50 ) | _BV ( CS51 ) | _BV ( CS52 ) ) ;
2012-11-06 05:06:41 -06:00
TCCR5B | = val ;
break ;
# endif
}
}
# endif //FAST_PWM_FAN
bool setTargetedHotend ( int code ) {
tmp_extruder = active_extruder ;
if ( code_seen ( ' T ' ) ) {
tmp_extruder = code_value ( ) ;
if ( tmp_extruder > = EXTRUDERS ) {
SERIAL_ECHO_START ;
switch ( code ) {
case 104 :
SERIAL_ECHO ( MSG_M104_INVALID_EXTRUDER ) ;
break ;
case 105 :
SERIAL_ECHO ( MSG_M105_INVALID_EXTRUDER ) ;
break ;
case 109 :
SERIAL_ECHO ( MSG_M109_INVALID_EXTRUDER ) ;
break ;
2013-02-04 22:05:45 -06:00
case 218 :
SERIAL_ECHO ( MSG_M218_INVALID_EXTRUDER ) ;
break ;
2012-11-06 05:06:41 -06:00
}
SERIAL_ECHOLN ( tmp_extruder ) ;
return true ;
}
}
return false ;
}
2013-06-06 17:49:25 -05:00