Move gcode handlers into inline functions
This commit is contained in:
Scott Lahteine
parent
94fd8c7555
commit
cdc38aa783
1 changed files with 3204 additions and 2659 deletions
|
|
@ -30,6 +30,9 @@
|
|||
#include "Marlin.h"
|
||||
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
#if Z_MIN_PIN == -1
|
||||
#error "You must have a Z_MIN endstop to enable Auto Bed Leveling feature. Z_MIN_PIN must point to a valid hardware pin."
|
||||
#endif
|
||||
#include "vector_3.h"
|
||||
#ifdef AUTO_BED_LEVELING_GRID
|
||||
#include "qr_solve.h"
|
||||
|
|
@ -124,6 +127,8 @@
|
|||
// M115 - Capabilities string
|
||||
// M117 - display message
|
||||
// M119 - Output Endstop status to serial port
|
||||
// M120 - Enable endstop detection
|
||||
// M121 - Disable endstop detection
|
||||
// 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)
|
||||
|
|
@ -739,7 +744,7 @@ void get_command()
|
|||
if(strchr(cmdbuffer[bufindw], 'N') != NULL)
|
||||
{
|
||||
strchr_pointer = strchr(cmdbuffer[bufindw], 'N');
|
||||
gcode_N = (strtol(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL, 10));
|
||||
gcode_N = (strtol(strchr_pointer + 1, NULL, 10));
|
||||
if(gcode_N != gcode_LastN+1 && (strstr_P(cmdbuffer[bufindw], PSTR("M110")) == NULL) ) {
|
||||
SERIAL_ERROR_START;
|
||||
SERIAL_ERRORPGM(MSG_ERR_LINE_NO);
|
||||
|
|
@ -757,7 +762,7 @@ void get_command()
|
|||
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) {
|
||||
if( (int)(strtod(strchr_pointer + 1, NULL)) != checksum) {
|
||||
SERIAL_ERROR_START;
|
||||
SERIAL_ERRORPGM(MSG_ERR_CHECKSUM_MISMATCH);
|
||||
SERIAL_ERRORLN(gcode_LastN);
|
||||
|
|
@ -793,7 +798,7 @@ void get_command()
|
|||
}
|
||||
if((strchr(cmdbuffer[bufindw], 'G') != NULL)){
|
||||
strchr_pointer = strchr(cmdbuffer[bufindw], 'G');
|
||||
switch((int)((strtod(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL)))){
|
||||
switch((int)((strtod(strchr_pointer + 1, NULL)))){
|
||||
case 0:
|
||||
case 1:
|
||||
case 2:
|
||||
|
|
@ -892,12 +897,12 @@ void get_command()
|
|||
|
||||
float code_value()
|
||||
{
|
||||
return (strtod(&cmdbuffer[bufindr][strchr_pointer - cmdbuffer[bufindr] + 1], NULL));
|
||||
return (strtod(strchr_pointer + 1, NULL));
|
||||
}
|
||||
|
||||
long code_value_long()
|
||||
{
|
||||
return (strtol(&cmdbuffer[bufindr][strchr_pointer - cmdbuffer[bufindr] + 1], NULL, 10));
|
||||
return (strtol(strchr_pointer + 1, NULL, 10));
|
||||
}
|
||||
|
||||
bool code_seen(char code)
|
||||
|
|
@ -1416,26 +1421,24 @@ static void dock_sled(bool dock, int offset=0) {
|
|||
}
|
||||
#endif
|
||||
|
||||
void process_commands()
|
||||
{
|
||||
unsigned long codenum; //throw away variable
|
||||
char *starpos = NULL;
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
float x_tmp, y_tmp, z_tmp, real_z;
|
||||
#endif
|
||||
if(code_seen('G'))
|
||||
{
|
||||
switch((int)code_value())
|
||||
{
|
||||
case 0: // G0 -> G1
|
||||
case 1: // G1
|
||||
if(Stopped == false) {
|
||||
/**
|
||||
*
|
||||
* G-Code Handler functions
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* G0, G1: Coordinated movement of X Y Z E axes
|
||||
*/
|
||||
inline void gcode_G0_G1() {
|
||||
if (!Stopped) {
|
||||
get_coordinates(); // For X Y Z E F
|
||||
#ifdef FWRETRACT
|
||||
if (autoretract_enabled)
|
||||
if (!(code_seen('X') || code_seen('Y') || code_seen('Z')) && code_seen('E')) {
|
||||
float echange = destination[E_AXIS] - current_position[E_AXIS];
|
||||
if((echange<-MIN_RETRACT && !retracted[active_extruder]) || (echange>MIN_RETRACT && retracted[active_extruder])) { //move appears to be an attempt to retract or recover
|
||||
// Is this move an attempt to retract or recover?
|
||||
if ((echange < -MIN_RETRACT && !retracted[active_extruder]) || (echange > MIN_RETRACT && retracted[active_extruder])) {
|
||||
current_position[E_AXIS] = destination[E_AXIS]; // hide the slicer-generated retract/recover from calculations
|
||||
plan_set_e_position(current_position[E_AXIS]); // AND from the planner
|
||||
retract(!retracted[active_extruder]);
|
||||
|
|
@ -1446,57 +1449,68 @@ void process_commands()
|
|||
prepare_move();
|
||||
//ClearToSend();
|
||||
}
|
||||
break;
|
||||
#ifndef SCARA //disable arc support
|
||||
case 2: // G2 - CW ARC
|
||||
if(Stopped == false) {
|
||||
get_arc_coordinates();
|
||||
prepare_arc_move(true);
|
||||
}
|
||||
break;
|
||||
case 3: // G3 - CCW ARC
|
||||
if(Stopped == false) {
|
||||
|
||||
/**
|
||||
* G2: Clockwise Arc
|
||||
* G3: Counterclockwise Arc
|
||||
*/
|
||||
inline void gcode_G2_G3(bool clockwise) {
|
||||
if (!Stopped) {
|
||||
get_arc_coordinates();
|
||||
prepare_arc_move(false);
|
||||
prepare_arc_move(clockwise);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 4: // G4 dwell
|
||||
}
|
||||
|
||||
/**
|
||||
* G4: Dwell S<seconds> or P<milliseconds>
|
||||
*/
|
||||
inline void gcode_G4() {
|
||||
unsigned long codenum;
|
||||
|
||||
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
|
||||
|
||||
if (code_seen('P')) codenum = code_value_long(); // milliseconds to wait
|
||||
if (code_seen('S')) codenum = code_value_long() * 1000; // seconds to wait
|
||||
|
||||
st_synchronize();
|
||||
codenum += millis(); // keep track of when we started waiting
|
||||
previous_millis_cmd = millis();
|
||||
codenum += previous_millis_cmd; // keep track of when we started waiting
|
||||
while(millis() < codenum) {
|
||||
manage_heater();
|
||||
manage_inactivity();
|
||||
lcd_update();
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef FWRETRACT
|
||||
case 10: // G10 retract
|
||||
|
||||
/**
|
||||
* G10 - Retract filament according to settings of M207
|
||||
* G11 - Recover filament according to settings of M208
|
||||
*/
|
||||
inline void gcode_G10_G11(bool doRetract=false) {
|
||||
#if EXTRUDERS > 1
|
||||
if (doRetract) {
|
||||
retracted_swap[active_extruder] = (code_seen('S') && code_value_long() == 1); // checks for swap retract argument
|
||||
retract(true,retracted_swap[active_extruder]);
|
||||
#else
|
||||
retract(true);
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
case 11: // G11 retract_recover
|
||||
retract(doRetract
|
||||
#if EXTRUDERS > 1
|
||||
retract(false,retracted_swap[active_extruder]);
|
||||
#else
|
||||
retract(false);
|
||||
, retracted_swap[active_extruder]
|
||||
#endif
|
||||
break;
|
||||
);
|
||||
}
|
||||
|
||||
#endif //FWRETRACT
|
||||
case 28: //G28 Home all Axis one at a time
|
||||
|
||||
/**
|
||||
* G28: Home all axes, one at a time
|
||||
*/
|
||||
inline void gcode_G28() {
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
plan_bed_level_matrix.set_to_identity(); //Reset the plane ("erase" all leveling data)
|
||||
#endif //ENABLE_AUTO_BED_LEVELING
|
||||
#endif
|
||||
|
||||
saved_feedrate = feedrate;
|
||||
saved_feedmultiply = feedmultiply;
|
||||
|
|
@ -1505,9 +1519,8 @@ void process_commands()
|
|||
|
||||
enable_endstops(true);
|
||||
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
destination[i] = current_position[i];
|
||||
}
|
||||
for (int i = X_AXIS; i <= Z_AXIS; i++) destination[i] = current_position[i];
|
||||
|
||||
feedrate = 0.0;
|
||||
|
||||
#ifdef DELTA
|
||||
|
|
@ -1515,22 +1528,17 @@ void process_commands()
|
|||
// 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;
|
||||
for (int i = X_AXIS; i <= Z_AXIS; i++) current_position[i] = 0;
|
||||
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
|
||||
destination[X_AXIS] = 3 * Z_MAX_LENGTH;
|
||||
destination[Y_AXIS] = 3 * Z_MAX_LENGTH;
|
||||
destination[Z_AXIS] = 3 * Z_MAX_LENGTH;
|
||||
for (int i = X_AXIS; i <= Z_AXIS; i++) destination[i] = 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];
|
||||
// Destination reached
|
||||
for (int i = X_AXIS; i <= Z_AXIS; i++) current_position[i] = destination[i];
|
||||
|
||||
// take care of back off and rehome now we are all at the top
|
||||
HOMEAXIS(X);
|
||||
|
|
@ -1542,18 +1550,17 @@ void process_commands()
|
|||
|
||||
#else // NOT DELTA
|
||||
|
||||
home_all_axis = !((code_seen(axis_codes[X_AXIS])) || (code_seen(axis_codes[Y_AXIS])) || (code_seen(axis_codes[Z_AXIS])));
|
||||
home_all_axis = !(code_seen(axis_codes[X_AXIS]) || code_seen(axis_codes[Y_AXIS]) || code_seen(axis_codes[Z_AXIS]));
|
||||
|
||||
#if Z_HOME_DIR > 0 // If homing away from BED do Z first
|
||||
if((home_all_axis) || (code_seen(axis_codes[Z_AXIS]))) {
|
||||
if (home_all_axis || code_seen(axis_codes[Z_AXIS])) {
|
||||
HOMEAXIS(Z);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef QUICK_HOME
|
||||
if((home_all_axis)||( code_seen(axis_codes[X_AXIS]) && code_seen(axis_codes[Y_AXIS])) ) //first diagonal move
|
||||
{
|
||||
current_position[X_AXIS] = 0;current_position[Y_AXIS] = 0;
|
||||
if (home_all_axis || code_seen(axis_codes[X_AXIS] && code_seen(axis_codes[Y_AXIS]))) { //first diagonal move
|
||||
current_position[X_AXIS] = current_position[Y_AXIS] = 0;
|
||||
|
||||
#ifndef DUAL_X_CARRIAGE
|
||||
int x_axis_home_dir = home_dir(X_AXIS);
|
||||
|
|
@ -1563,10 +1570,10 @@ void process_commands()
|
|||
#endif
|
||||
|
||||
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
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);
|
||||
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);
|
||||
feedrate = homing_feedrate[X_AXIS];
|
||||
if(homing_feedrate[Y_AXIS]<feedrate)
|
||||
feedrate = homing_feedrate[Y_AXIS];
|
||||
if (homing_feedrate[Y_AXIS] < feedrate) feedrate = homing_feedrate[Y_AXIS];
|
||||
if (max_length(X_AXIS) > max_length(Y_AXIS)) {
|
||||
feedrate *= sqrt(pow(max_length(Y_AXIS) / max_length(X_AXIS), 2) + 1);
|
||||
} else {
|
||||
|
|
@ -1591,10 +1598,9 @@ void process_commands()
|
|||
current_position[Z_AXIS] = destination[Z_AXIS];
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#endif //QUICK_HOME
|
||||
|
||||
if((home_all_axis) || (code_seen(axis_codes[X_AXIS])))
|
||||
{
|
||||
if ((home_all_axis) || (code_seen(axis_codes[X_AXIS]))) {
|
||||
#ifdef DUAL_X_CARRIAGE
|
||||
int tmp_extruder = active_extruder;
|
||||
extruder_duplication_enabled = false;
|
||||
|
|
@ -1612,47 +1618,46 @@ void process_commands()
|
|||
#endif
|
||||
}
|
||||
|
||||
if((home_all_axis) || (code_seen(axis_codes[Y_AXIS]))) {
|
||||
HOMEAXIS(Y);
|
||||
}
|
||||
if (home_all_axis || code_seen(axis_codes[Y_AXIS])) HOMEAXIS(Y);
|
||||
|
||||
if(code_seen(axis_codes[X_AXIS]))
|
||||
{
|
||||
if (code_seen(axis_codes[X_AXIS])) {
|
||||
if (code_value_long() != 0) {
|
||||
#ifdef SCARA
|
||||
current_position[X_AXIS]=code_value();
|
||||
#else
|
||||
current_position[X_AXIS]=code_value()+add_homing[X_AXIS];
|
||||
current_position[X_AXIS] = code_value()
|
||||
#ifndef SCARA
|
||||
+ add_homing[X_AXIS]
|
||||
#endif
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
if(code_seen(axis_codes[Y_AXIS])) {
|
||||
if(code_value_long() != 0) {
|
||||
#ifdef SCARA
|
||||
current_position[Y_AXIS]=code_value();
|
||||
#else
|
||||
current_position[Y_AXIS]=code_value()+add_homing[Y_AXIS];
|
||||
if (code_seen(axis_codes[Y_AXIS]) && code_value_long() != 0) {
|
||||
current_position[Y_AXIS] = code_value()
|
||||
#ifndef SCARA
|
||||
+ add_homing[Y_AXIS]
|
||||
#endif
|
||||
}
|
||||
;
|
||||
}
|
||||
|
||||
#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
|
||||
|
||||
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); // 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);
|
||||
}
|
||||
#else // Z Safe mode activated.
|
||||
|
||||
#else // Z_SAFE_HOMING
|
||||
|
||||
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
|
||||
destination[Z_AXIS] = -Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS); // Set destination away from bed
|
||||
feedrate = XY_TRAVEL_SPEED / 60;
|
||||
current_position[Z_AXIS] = 0;
|
||||
|
||||
|
|
@ -1664,54 +1669,58 @@ void process_commands()
|
|||
|
||||
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_MIN_POS - X_PROBE_OFFSET_FROM_EXTRUDER) \
|
||||
&& (current_position[X_AXIS] <= X_MAX_POS - X_PROBE_OFFSET_FROM_EXTRUDER) \
|
||||
&& (current_position[Y_AXIS] >= Y_MIN_POS - Y_PROBE_OFFSET_FROM_EXTRUDER) \
|
||||
&& (current_position[Y_AXIS] <= Y_MAX_POS - Y_PROBE_OFFSET_FROM_EXTRUDER)) {
|
||||
|
||||
if (axis_known_position[X_AXIS] && axis_known_position[Y_AXIS]) {
|
||||
|
||||
float cpx = current_position[X_AXIS], cpy = current_position[Y_AXIS];
|
||||
if ( cpx >= X_MIN_POS - X_PROBE_OFFSET_FROM_EXTRUDER
|
||||
&& cpx <= X_MAX_POS - X_PROBE_OFFSET_FROM_EXTRUDER
|
||||
&& cpy >= Y_MIN_POS - Y_PROBE_OFFSET_FROM_EXTRUDER
|
||||
&& cpy <= Y_MAX_POS - Y_PROBE_OFFSET_FROM_EXTRUDER) {
|
||||
current_position[Z_AXIS] = 0;
|
||||
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
destination[Z_AXIS] = Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS) * (-1); // Set destination away from bed
|
||||
plan_set_position(cpx, cpy, current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
destination[Z_AXIS] = -Z_RAISE_BEFORE_HOMING * home_dir(Z_AXIS); // 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 {
|
||||
}
|
||||
else {
|
||||
LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
else {
|
||||
LCD_MESSAGEPGM(MSG_POSITION_UNKNOWN);
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // Z_SAFE_HOMING
|
||||
|
||||
#endif // Z_HOME_DIR < 0
|
||||
|
||||
|
||||
|
||||
if(code_seen(axis_codes[Z_AXIS])) {
|
||||
if(code_value_long() != 0) {
|
||||
if (code_seen(axis_codes[Z_AXIS]) && code_value_long() != 0)
|
||||
current_position[Z_AXIS] = code_value() + add_homing[Z_AXIS];
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
if((home_all_axis) || (code_seen(axis_codes[Z_AXIS]))) {
|
||||
if (home_all_axis || code_seen(axis_codes[Z_AXIS]))
|
||||
current_position[Z_AXIS] += zprobe_zoffset; //Add Z_Probe offset (the distance is negative)
|
||||
}
|
||||
#endif
|
||||
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
|
||||
#endif // else DELTA
|
||||
|
||||
#ifdef SCARA
|
||||
calculate_delta(current_position);
|
||||
plan_set_position(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS]);
|
||||
#endif // SCARA
|
||||
#endif
|
||||
|
||||
#ifdef ENDSTOPS_ONLY_FOR_HOMING
|
||||
enable_endstops(false);
|
||||
|
|
@ -1721,15 +1730,14 @@ void process_commands()
|
|||
feedmultiply = saved_feedmultiply;
|
||||
previous_millis_cmd = millis();
|
||||
endstops_hit_on_purpose();
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
|
||||
#if Z_MIN_PIN == -1
|
||||
#error "You must have a Z_MIN endstop in order to enable Auto Bed Leveling!!! Z_MIN_PIN must point to a valid hardware pin."
|
||||
#endif
|
||||
|
||||
/**
|
||||
* G29: Detailed Z-Probe, probes the bed at 3 or more points.
|
||||
* Will fail if the printer has not been homed with G28.
|
||||
*
|
||||
* Enhanced G29 Auto Bed Leveling Probe Routine
|
||||
*
|
||||
* Parameters With AUTO_BED_LEVELING_GRID:
|
||||
|
|
@ -1757,22 +1765,21 @@ void process_commands()
|
|||
*
|
||||
*/
|
||||
|
||||
case 29: // G29 Detailed Z-Probe, probes the bed at 3 or more points.
|
||||
{
|
||||
// Use one of these defines to specify the origin
|
||||
// for a topographical map to be printed for your bed.
|
||||
#define ORIGIN_BACK_LEFT 1
|
||||
#define ORIGIN_FRONT_RIGHT 2
|
||||
#define ORIGIN_BACK_RIGHT 3
|
||||
#define ORIGIN_FRONT_LEFT 4
|
||||
#define TOPO_ORIGIN ORIGIN_FRONT_LEFT
|
||||
enum { OriginBackLeft, OriginFrontLeft, OriginBackRight, OriginFrontRight };
|
||||
#define TOPO_ORIGIN OriginFrontLeft
|
||||
|
||||
inline void gcode_G29() {
|
||||
|
||||
float x_tmp, y_tmp, z_tmp, real_z;
|
||||
|
||||
// Prevent user from running a G29 without first homing in X and Y
|
||||
if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS])) {
|
||||
if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) {
|
||||
LCD_MESSAGEPGM(MSG_POSITION_UNKNOWN);
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_POSITION_UNKNOWN);
|
||||
break; // abort G29, since we don't know where we are
|
||||
return;
|
||||
}
|
||||
|
||||
bool enhanced_g29 = code_seen('E') || code_seen('e');
|
||||
|
|
@ -1788,7 +1795,7 @@ void process_commands()
|
|||
verbose_level = code_value();
|
||||
if (verbose_level < 0 || verbose_level > 4) {
|
||||
SERIAL_PROTOCOLPGM("?(V)erbose Level is implausible (0-4).\n");
|
||||
break;
|
||||
return;
|
||||
}
|
||||
if (verbose_level > 0) {
|
||||
SERIAL_PROTOCOLPGM("G29 Enhanced Auto Bed Leveling Code V1.25:\n");
|
||||
|
|
@ -1800,7 +1807,7 @@ void process_commands()
|
|||
int auto_bed_leveling_grid_points = code_seen('P') ? code_value_long() : AUTO_BED_LEVELING_GRID_POINTS;
|
||||
if (auto_bed_leveling_grid_points < 2 || auto_bed_leveling_grid_points > AUTO_BED_LEVELING_GRID_POINTS) {
|
||||
SERIAL_PROTOCOLPGM("?Number of probed (P)oints is implausible (2 minimum).\n");
|
||||
break;
|
||||
return;
|
||||
}
|
||||
|
||||
// Define the possible boundaries for probing based on the set limits.
|
||||
|
|
@ -1846,16 +1853,17 @@ void process_commands()
|
|||
SERIAL_PROTOCOLPGM("?Probe (B)ack position out of range.\n");
|
||||
back_probe_bed_position = back_out_b ? max_probe_y : front_probe_bed_position + MIN_PROBE_EDGE;
|
||||
}
|
||||
break;
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif // AUTO_BED_LEVELING_GRID
|
||||
|
||||
#ifdef Z_PROBE_SLED
|
||||
dock_sled(false); // engage (un-dock) the probe
|
||||
#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");
|
||||
|
|
@ -1871,8 +1879,8 @@ void process_commands()
|
|||
feedrate = homing_feedrate[Z_AXIS];
|
||||
|
||||
#ifdef AUTO_BED_LEVELING_GRID
|
||||
// probe at the points of a lattice grid
|
||||
|
||||
// probe at the points of a lattice grid
|
||||
int xGridSpacing = (right_probe_bed_position - left_probe_bed_position) / (auto_bed_leveling_grid_points - 1);
|
||||
int yGridSpacing = (back_probe_bed_position - front_probe_bed_position) / (auto_bed_leveling_grid_points - 1);
|
||||
|
||||
|
|
@ -1905,8 +1913,8 @@ void process_commands()
|
|||
|
||||
for (int xCount = 0; xCount < auto_bed_leveling_grid_points; xCount++) {
|
||||
// raise extruder
|
||||
float z_before = probePointCounter == 0 ? Z_RAISE_BEFORE_PROBING : current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS,
|
||||
measured_z;
|
||||
float measured_z,
|
||||
z_before = probePointCounter == 0 ? Z_RAISE_BEFORE_PROBING : current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS;
|
||||
|
||||
// Enhanced G29 - Do not retract servo between probes
|
||||
ProbeAction act;
|
||||
|
|
@ -1963,24 +1971,24 @@ void process_commands()
|
|||
int xx, yy;
|
||||
|
||||
SERIAL_PROTOCOLPGM(" \nBed Height Topography: \n");
|
||||
#if TOPO_ORIGIN == ORIGIN_FRONT_LEFT
|
||||
#if TOPO_ORIGIN == OriginFrontLeft
|
||||
for (yy = auto_bed_leveling_grid_points - 1; yy >= 0; yy--)
|
||||
#else
|
||||
for (yy = 0; yy < auto_bed_leveling_grid_points; yy++)
|
||||
#endif
|
||||
{
|
||||
#if TOPO_ORIGIN == ORIGIN_BACK_RIGHT
|
||||
#if TOPO_ORIGIN == OriginBackRight
|
||||
for (xx = auto_bed_leveling_grid_points - 1; xx >= 0; xx--)
|
||||
#else
|
||||
for (xx = 0; xx < auto_bed_leveling_grid_points; xx++)
|
||||
#endif
|
||||
{
|
||||
int ind =
|
||||
#if TOPO_ORIGIN == ORIGIN_BACK_RIGHT || TOPO_ORIGIN == ORIGIN_FRONT_LEFT
|
||||
#if TOPO_ORIGIN == OriginBackRight || TOPO_ORIGIN == OriginFrontLeft
|
||||
yy * auto_bed_leveling_grid_points + xx
|
||||
#elif TOPO_ORIGIN == ORIGIN_BACK_LEFT
|
||||
#elif TOPO_ORIGIN == OriginBackLeft
|
||||
xx * auto_bed_leveling_grid_points + yy
|
||||
#elif TOPO_ORIGIN == ORIGIN_FRONT_RIGHT
|
||||
#elif TOPO_ORIGIN == OriginFrontRight
|
||||
abl2 - xx * auto_bed_leveling_grid_points - yy - 1
|
||||
#endif
|
||||
;
|
||||
|
|
@ -2043,11 +2051,10 @@ void process_commands()
|
|||
dock_sled(true, -SLED_DOCKING_OFFSET); // dock the probe, correcting for over-travel
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
#ifndef Z_PROBE_SLED
|
||||
case 30: // G30 Single Z Probe
|
||||
{
|
||||
|
||||
inline void gcode_G30() {
|
||||
engage_z_probe(); // Engage Z Servo endstop if available
|
||||
st_synchronize();
|
||||
// TODO: make sure the bed_level_rotation_matrix is identity or the planner will get set incorectly
|
||||
|
|
@ -2068,62 +2075,48 @@ void process_commands()
|
|||
clean_up_after_endstop_move();
|
||||
retract_z_probe(); // Retract Z Servo endstop if available
|
||||
}
|
||||
break;
|
||||
#else
|
||||
case 31: // dock the sled
|
||||
dock_sled(true);
|
||||
break;
|
||||
case 32: // undock the sled
|
||||
dock_sled(false);
|
||||
break;
|
||||
#endif // Z_PROBE_SLED
|
||||
|
||||
#endif //!Z_PROBE_SLED
|
||||
|
||||
#endif //ENABLE_AUTO_BED_LEVELING
|
||||
case 90: // G90
|
||||
relative_mode = false;
|
||||
break;
|
||||
case 91: // G91
|
||||
relative_mode = true;
|
||||
break;
|
||||
case 92: // G92
|
||||
|
||||
/**
|
||||
* G92: Set current position to given X Y Z E
|
||||
*/
|
||||
inline void gcode_G92() {
|
||||
if (!code_seen(axis_codes[E_AXIS]))
|
||||
st_synchronize();
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
|
||||
for (int i=0;i<NUM_AXIS;i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
if (i == E_AXIS) {
|
||||
current_position[i] = code_value();
|
||||
plan_set_e_position(current_position[E_AXIS]);
|
||||
}
|
||||
else {
|
||||
current_position[i] = code_value() +
|
||||
#ifdef SCARA
|
||||
if (i == X_AXIS || i == Y_AXIS) {
|
||||
current_position[i] = code_value();
|
||||
}
|
||||
else {
|
||||
current_position[i] = code_value()+add_homing[i];
|
||||
}
|
||||
((i != X_AXIS && i != Y_AXIS) ? add_homing[i] : 0)
|
||||
#else
|
||||
current_position[i] = code_value()+add_homing[i];
|
||||
add_homing[i]
|
||||
#endif
|
||||
;
|
||||
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'))
|
||||
{
|
||||
switch( (int)code_value() )
|
||||
{
|
||||
#ifdef ULTIPANEL
|
||||
case 0: // M0 - Unconditional stop - Wait for user button press on LCD
|
||||
case 1: // M1 - Conditional stop - Wait for user button press on LCD
|
||||
{
|
||||
|
||||
/**
|
||||
* M0: // M0 - Unconditional stop - Wait for user button press on LCD
|
||||
* M1: // M1 - Conditional stop - Wait for user button press on LCD
|
||||
*/
|
||||
inline void gcode_M0_M1() {
|
||||
char *src = strchr_pointer + 2;
|
||||
|
||||
codenum = 0;
|
||||
|
||||
unsigned long codenum = 0;
|
||||
bool hasP = false, hasS = false;
|
||||
if (code_seen('P')) {
|
||||
codenum = code_value(); // milliseconds to wait
|
||||
|
|
@ -2133,29 +2126,28 @@ void process_commands()
|
|||
codenum = code_value() * 1000; // seconds to wait
|
||||
hasS = codenum > 0;
|
||||
}
|
||||
starpos = strchr(src, '*');
|
||||
char* starpos = strchr(src, '*');
|
||||
if (starpos != NULL) *(starpos) = '\0';
|
||||
while (*src == ' ') ++src;
|
||||
if (!hasP && !hasS && *src != '\0') {
|
||||
if (!hasP && !hasS && *src != '\0')
|
||||
lcd_setstatus(src);
|
||||
} else {
|
||||
else
|
||||
LCD_MESSAGEPGM(MSG_USERWAIT);
|
||||
}
|
||||
|
||||
lcd_ignore_click();
|
||||
st_synchronize();
|
||||
previous_millis_cmd = millis();
|
||||
if (codenum > 0) {
|
||||
codenum += millis(); // keep track of when we started waiting
|
||||
codenum += previous_millis_cmd; // keep track of when we started waiting
|
||||
while(millis() < codenum && !lcd_clicked()) {
|
||||
manage_heater();
|
||||
manage_inactivity();
|
||||
lcd_update();
|
||||
}
|
||||
lcd_ignore_click(false);
|
||||
}else{
|
||||
if (!lcd_detected())
|
||||
break;
|
||||
}
|
||||
else {
|
||||
if (!lcd_detected()) return;
|
||||
while (!lcd_clicked()) {
|
||||
manage_heater();
|
||||
manage_inactivity();
|
||||
|
|
@ -2167,9 +2159,13 @@ void process_commands()
|
|||
else
|
||||
LCD_MESSAGEPGM(WELCOME_MSG);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 17:
|
||||
|
||||
#endif // ULTIPANEL
|
||||
|
||||
/**
|
||||
* M17: Enable power on all stepper motors
|
||||
*/
|
||||
inline void gcode_M17() {
|
||||
LCD_MESSAGEPGM(MSG_NO_MOVE);
|
||||
enable_x();
|
||||
enable_y();
|
||||
|
|
@ -2178,186 +2174,238 @@ void process_commands()
|
|||
enable_e1();
|
||||
enable_e2();
|
||||
enable_e3();
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
case 20: // M20 - list SD card
|
||||
|
||||
/**
|
||||
* M20: List SD card to serial output
|
||||
*/
|
||||
inline void gcode_M20() {
|
||||
SERIAL_PROTOCOLLNPGM(MSG_BEGIN_FILE_LIST);
|
||||
card.ls();
|
||||
SERIAL_PROTOCOLLNPGM(MSG_END_FILE_LIST);
|
||||
break;
|
||||
case 21: // M21 - init SD card
|
||||
}
|
||||
|
||||
/**
|
||||
* M21: Init SD Card
|
||||
*/
|
||||
inline void gcode_M21() {
|
||||
card.initsd();
|
||||
}
|
||||
|
||||
break;
|
||||
case 22: //M22 - release SD card
|
||||
/**
|
||||
* M22: Release SD Card
|
||||
*/
|
||||
inline void gcode_M22() {
|
||||
card.release();
|
||||
}
|
||||
|
||||
break;
|
||||
case 23: //M23 - Select file
|
||||
starpos = (strchr(strchr_pointer + 4,'*'));
|
||||
if(starpos!=NULL)
|
||||
*(starpos)='\0';
|
||||
card.openFile(strchr_pointer + 4,true);
|
||||
break;
|
||||
case 24: //M24 - Start SD print
|
||||
/**
|
||||
* M23: Select a file
|
||||
*/
|
||||
inline void gcode_M23() {
|
||||
char* codepos = strchr_pointer + 4;
|
||||
char* starpos = strchr(codepos, '*');
|
||||
if (starpos) *starpos = '\0';
|
||||
card.openFile(codepos, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* M24: Start SD Print
|
||||
*/
|
||||
inline void gcode_M24() {
|
||||
card.startFileprint();
|
||||
starttime = millis();
|
||||
break;
|
||||
case 25: //M25 - Pause SD print
|
||||
}
|
||||
|
||||
/**
|
||||
* M25: Pause SD Print
|
||||
*/
|
||||
inline void gcode_M25() {
|
||||
card.pauseSDPrint();
|
||||
break;
|
||||
case 26: //M26 - Set SD index
|
||||
if(card.cardOK && code_seen('S')) {
|
||||
}
|
||||
|
||||
/**
|
||||
* M26: Set SD Card file index
|
||||
*/
|
||||
inline void gcode_M26() {
|
||||
if (card.cardOK && code_seen('S'))
|
||||
card.setIndex(code_value_long());
|
||||
}
|
||||
break;
|
||||
case 27: //M27 - Get SD status
|
||||
|
||||
/**
|
||||
* M27: Get SD Card status
|
||||
*/
|
||||
inline void gcode_M27() {
|
||||
card.getStatus();
|
||||
break;
|
||||
case 28: //M28 - Start SD write
|
||||
starpos = (strchr(strchr_pointer + 4,'*'));
|
||||
if(starpos != NULL){
|
||||
}
|
||||
|
||||
/**
|
||||
* M28: Start SD Write
|
||||
*/
|
||||
inline void gcode_M28() {
|
||||
char* codepos = strchr_pointer + 4;
|
||||
char* starpos = strchr(strchr_pointer + 4, '*');
|
||||
if (starpos) {
|
||||
char* npos = strchr(cmdbuffer[bufindr], 'N');
|
||||
strchr_pointer = strchr(npos, ' ') + 1;
|
||||
*(starpos) = '\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;
|
||||
case 30: //M30 <filename> Delete File
|
||||
}
|
||||
|
||||
/**
|
||||
* M29: Stop SD Write
|
||||
* Processed in write to file routine above
|
||||
*/
|
||||
inline void gcode_M29() {
|
||||
// card.saving = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* M30 <filename>: Delete SD Card file
|
||||
*/
|
||||
inline void gcode_M30() {
|
||||
if (card.cardOK) {
|
||||
card.closefile();
|
||||
starpos = (strchr(strchr_pointer + 4,'*'));
|
||||
if(starpos != NULL){
|
||||
char* starpos = strchr(strchr_pointer + 4, '*');
|
||||
if (starpos) {
|
||||
char* npos = strchr(cmdbuffer[bufindr], 'N');
|
||||
strchr_pointer = strchr(npos, ' ') + 1;
|
||||
*(starpos) = '\0';
|
||||
}
|
||||
card.removeFile(strchr_pointer + 4);
|
||||
}
|
||||
break;
|
||||
case 32: //M32 - Select file and start SD print
|
||||
{
|
||||
if(card.sdprinting) {
|
||||
st_synchronize();
|
||||
|
||||
}
|
||||
starpos = (strchr(strchr_pointer + 4,'*'));
|
||||
|
||||
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 '!'
|
||||
#endif
|
||||
|
||||
if(starpos!=NULL)
|
||||
*(starpos)='\0';
|
||||
|
||||
bool call_procedure=(code_seen('P'));
|
||||
|
||||
if(strchr_pointer>namestartpos)
|
||||
call_procedure=false; //false alert, 'P' found within filename
|
||||
|
||||
if( card.cardOK )
|
||||
{
|
||||
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;
|
||||
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) = '\0';
|
||||
}
|
||||
card.openLogFile(strchr_pointer+5);
|
||||
break;
|
||||
|
||||
#endif //SDSUPPORT
|
||||
|
||||
case 31: //M31 take time since the start of the SD print or an M109 command
|
||||
{
|
||||
/**
|
||||
* M31: Get the time since the start of SD Print (or last M109)
|
||||
*/
|
||||
inline void gcode_M31() {
|
||||
stoptime = millis();
|
||||
char time[30];
|
||||
unsigned long t = (stoptime - starttime) / 1000;
|
||||
int sec,min;
|
||||
min=t/60;
|
||||
sec=t%60;
|
||||
int min = t / 60, sec = t % 60;
|
||||
char time[30];
|
||||
sprintf_P(time, PSTR("%i min, %i sec"), min, sec);
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLN(time);
|
||||
lcd_setstatus(time);
|
||||
autotempShutdown();
|
||||
}
|
||||
break;
|
||||
case 42: //M42 -Change pin status via gcode
|
||||
if (code_seen('S'))
|
||||
{
|
||||
int pin_status = code_value();
|
||||
int pin_number = LED_PIN;
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
|
||||
/**
|
||||
* M32: Select file and start SD Print
|
||||
*/
|
||||
inline void gcode_M32() {
|
||||
if (card.sdprinting)
|
||||
st_synchronize();
|
||||
|
||||
char* codepos = strchr_pointer + 4;
|
||||
|
||||
char* namestartpos = strchr(codepos, '!'); //find ! to indicate filename string start.
|
||||
if (! namestartpos)
|
||||
namestartpos = codepos; //default name position, 4 letters after the M
|
||||
else
|
||||
namestartpos++; //to skip the '!'
|
||||
|
||||
char* starpos = strchr(codepos, '*');
|
||||
if (starpos) *(starpos) = '\0';
|
||||
|
||||
bool call_procedure = code_seen('P') && (strchr_pointer < namestartpos);
|
||||
|
||||
if (card.cardOK) {
|
||||
card.openFile(namestartpos, true, !call_procedure);
|
||||
|
||||
if (code_seen('S') && strchr_pointer < namestartpos) // "S" (must occur _before_ the filename!)
|
||||
card.setIndex(code_value_long());
|
||||
|
||||
card.startFileprint();
|
||||
if (!call_procedure)
|
||||
starttime = millis(); //procedure calls count as normal print time.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* M928: Start SD Write
|
||||
*/
|
||||
inline void gcode_M928() {
|
||||
char* starpos = strchr(strchr_pointer + 5, '*');
|
||||
if (starpos) {
|
||||
char* npos = strchr(cmdbuffer[bufindr], 'N');
|
||||
strchr_pointer = strchr(npos, ' ') + 1;
|
||||
*(starpos) = '\0';
|
||||
}
|
||||
card.openLogFile(strchr_pointer + 5);
|
||||
}
|
||||
|
||||
#endif // SDSUPPORT
|
||||
|
||||
/**
|
||||
* M42: Change pin status via GCode
|
||||
*/
|
||||
inline void gcode_M42() {
|
||||
if (code_seen('S')) {
|
||||
int pin_status = code_value(),
|
||||
pin_number = LED_PIN;
|
||||
|
||||
if (code_seen('P') && pin_status >= 0 && pin_status <= 255)
|
||||
pin_number = code_value();
|
||||
for(int8_t i = 0; i < (int8_t)(sizeof(sensitive_pins)/sizeof(int)); i++)
|
||||
{
|
||||
if (sensitive_pins[i] == pin_number)
|
||||
{
|
||||
|
||||
for (int8_t i = 0; i < (int8_t)(sizeof(sensitive_pins) / sizeof(*sensitive_pins)); i++) {
|
||||
if (sensitive_pins[i] == pin_number) {
|
||||
pin_number = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(FAN_PIN) && FAN_PIN > -1
|
||||
if (pin_number == FAN_PIN)
|
||||
fanSpeed = pin_status;
|
||||
if (pin_number == FAN_PIN) fanSpeed = pin_status;
|
||||
#endif
|
||||
if (pin_number > -1)
|
||||
{
|
||||
|
||||
if (pin_number > -1) {
|
||||
pinMode(pin_number, OUTPUT);
|
||||
digitalWrite(pin_number, pin_status);
|
||||
analogWrite(pin_number, pin_status);
|
||||
}
|
||||
} // code_seen('S')
|
||||
}
|
||||
break;
|
||||
|
||||
// M48 Z-Probe repeatability measurement function.
|
||||
//
|
||||
// Usage: M48 <n #_samples> <X X_position_for_samples> <Y Y_position_for_samples> <V Verbose_Level> <Engage_probe_for_each_reading> <L legs_of_movement_prior_to_doing_probe>
|
||||
//
|
||||
// This function assumes the bed has been homed. Specificaly, that a G28 command
|
||||
// as been issued prior to invoking the M48 Z-Probe repeatability measurement function.
|
||||
// Any information generated by a prior G29 Bed leveling command will be lost and need to be
|
||||
// regenerated.
|
||||
//
|
||||
// The number of samples will default to 10 if not specified. You can use upper or lower case
|
||||
// letters for any of the options EXCEPT n. n must be in lower case because Marlin uses a capital
|
||||
// N for its communication protocol and will get horribly confused if you send it a capital N.
|
||||
//
|
||||
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
#ifdef Z_PROBE_REPEATABILITY_TEST
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && defined(Z_PROBE_REPEATABILITY_TEST)
|
||||
|
||||
case 48: // M48 Z-Probe repeatability
|
||||
{
|
||||
#if Z_MIN_PIN == -1
|
||||
#error "You must have a Z_MIN endstop in order to enable calculation of Z-Probe repeatability."
|
||||
#endif
|
||||
|
||||
double sum=0.0;
|
||||
double mean=0.0;
|
||||
double sigma=0.0;
|
||||
double sample_set[50];
|
||||
/**
|
||||
* M48: Z-Probe repeatability measurement function.
|
||||
*
|
||||
* Usage:
|
||||
* M48 <n#> <X#> <Y#> <V#> <E> <L#>
|
||||
* n = Number of samples (4-50, default 10)
|
||||
* X = Sample X position
|
||||
* Y = Sample Y position
|
||||
* V = Verbose level (0-4, default=1)
|
||||
* E = Engage probe for each reading
|
||||
* L = Number of legs of movement before probe
|
||||
*
|
||||
* This function assumes the bed has been homed. Specificaly, that a G28 command
|
||||
* as been issued prior to invoking the M48 Z-Probe repeatability measurement function.
|
||||
* Any information generated by a prior G29 Bed leveling command will be lost and need to be
|
||||
* regenerated.
|
||||
*
|
||||
* The number of samples will default to 10 if not specified. You can use upper or lower case
|
||||
* letters for any of the options EXCEPT n. n must be in lower case because Marlin uses a capital
|
||||
* N for its communication protocol and will get horribly confused if you send it a capital N.
|
||||
*/
|
||||
inline void gcode_M48() {
|
||||
|
||||
double sum = 0.0, mean = 0.0, sigma = 0.0, sample_set[50];
|
||||
int verbose_level = 1, n = 0, j, n_samples = 10, n_legs = 0, engage_probe_for_each_reading = 0;
|
||||
double X_current, Y_current, Z_current;
|
||||
double X_probe_location, Y_probe_location, Z_start_location, ext_position;
|
||||
|
|
@ -2365,8 +2413,8 @@ void process_commands()
|
|||
if (code_seen('V') || code_seen('v')) {
|
||||
verbose_level = code_value();
|
||||
if (verbose_level < 0 || verbose_level > 4 ) {
|
||||
SERIAL_PROTOCOLPGM("?Verbose Level not plausable.\n");
|
||||
goto Sigma_Exit;
|
||||
SERIAL_PROTOCOLPGM("?Verbose Level not plausible (0-4).\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2378,8 +2426,8 @@ void process_commands()
|
|||
if (code_seen('n')) {
|
||||
n_samples = code_value();
|
||||
if (n_samples < 4 || n_samples > 50) {
|
||||
SERIAL_PROTOCOLPGM("?Specified sample size not plausable.\n");
|
||||
goto Sigma_Exit;
|
||||
SERIAL_PROTOCOLPGM("?Specified sample size not plausible (4-50).\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2396,7 +2444,7 @@ void process_commands()
|
|||
X_probe_location = code_value() - X_PROBE_OFFSET_FROM_EXTRUDER;
|
||||
if (X_probe_location < X_MIN_POS || X_probe_location > X_MAX_POS) {
|
||||
SERIAL_PROTOCOLPGM("?Specified X position out of range.\n");
|
||||
goto Sigma_Exit;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2404,17 +2452,16 @@ void process_commands()
|
|||
Y_probe_location = code_value() - Y_PROBE_OFFSET_FROM_EXTRUDER;
|
||||
if (Y_probe_location < Y_MIN_POS || Y_probe_location > Y_MAX_POS) {
|
||||
SERIAL_PROTOCOLPGM("?Specified Y position out of range.\n");
|
||||
goto Sigma_Exit;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (code_seen('L') || code_seen('l')) {
|
||||
n_legs = code_value();
|
||||
if ( n_legs==1 )
|
||||
n_legs = 2;
|
||||
if (n_legs == 1) n_legs = 2;
|
||||
if (n_legs < 0 || n_legs > 15) {
|
||||
SERIAL_PROTOCOLPGM("?Specified number of legs in movement not plausable.\n");
|
||||
goto Sigma_Exit;
|
||||
SERIAL_PROTOCOLPGM("?Specified number of legs in movement not plausible (0-15).\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2469,8 +2516,7 @@ void process_commands()
|
|||
st_synchronize();
|
||||
current_position[Z_AXIS] = Z_current = st_get_position_mm(Z_AXIS);
|
||||
|
||||
if (engage_probe_for_each_reading)
|
||||
retract_z_probe();
|
||||
if (engage_probe_for_each_reading) retract_z_probe();
|
||||
|
||||
for (n=0; n < n_samples; n++) {
|
||||
|
||||
|
|
@ -2478,39 +2524,29 @@ void process_commands()
|
|||
|
||||
if (n_legs) {
|
||||
double radius=0.0, theta=0.0, x_sweep, y_sweep;
|
||||
int rotational_direction, l;
|
||||
|
||||
rotational_direction = (unsigned long) millis() & 0x0001; // clockwise or counter clockwise
|
||||
int l;
|
||||
int rotational_direction = (unsigned long) millis() & 0x0001; // clockwise or counter clockwise
|
||||
radius = (unsigned long)millis() % (long)(X_MAX_LENGTH / 4); // limit how far out to go
|
||||
theta = (float) ((unsigned long) millis() % (long) 360) / (360./(2*3.1415926)); // turn into radians
|
||||
theta = (float)((unsigned long)millis() % 360L) / (360. / (2 * 3.1415926)); // turn into radians
|
||||
|
||||
//SERIAL_ECHOPAIR("starting radius: ",radius);
|
||||
//SERIAL_ECHOPAIR(" theta: ",theta);
|
||||
//SERIAL_ECHOPAIR(" direction: ",rotational_direction);
|
||||
//SERIAL_PROTOCOLLNPGM("");
|
||||
|
||||
float dir = rotational_direction ? 1 : -1;
|
||||
for (l = 0; l < n_legs - 1; l++) {
|
||||
if (rotational_direction==1)
|
||||
theta += (float) ((unsigned long) millis() % (long) 20) / (360.0/(2*3.1415926)); // turn into radians
|
||||
else
|
||||
theta -= (float) ((unsigned long) millis() % (long) 20) / (360.0/(2*3.1415926)); // turn into radians
|
||||
theta += dir * (float)((unsigned long)millis() % 20L) / (360.0/(2*3.1415926)); // turn into radians
|
||||
|
||||
radius += (float) ( ((long) ((unsigned long) millis() % (long) 10)) - 5);
|
||||
if ( radius<0.0 )
|
||||
radius = -radius;
|
||||
radius += (float)(((long)((unsigned long) millis() % 10L)) - 5L);
|
||||
if (radius < 0.0) radius = -radius;
|
||||
|
||||
X_current = X_probe_location + cos(theta) * radius;
|
||||
Y_current = Y_probe_location + sin(theta) * radius;
|
||||
|
||||
if ( X_current<X_MIN_POS) // Make sure our X & Y are sane
|
||||
X_current = X_MIN_POS;
|
||||
if ( X_current>X_MAX_POS)
|
||||
X_current = X_MAX_POS;
|
||||
|
||||
if ( Y_current<Y_MIN_POS) // Make sure our X & Y are sane
|
||||
Y_current = Y_MIN_POS;
|
||||
if ( Y_current>Y_MAX_POS)
|
||||
Y_current = Y_MAX_POS;
|
||||
// Make sure our X & Y are sane
|
||||
X_current = constrain(X_current, X_MIN_POS, X_MAX_POS);
|
||||
Y_current = constrain(Y_current, Y_MIN_POS, Y_MAX_POS);
|
||||
|
||||
if (verbose_level > 3) {
|
||||
SERIAL_ECHOPAIR("x: ", X_current);
|
||||
|
|
@ -2537,19 +2573,15 @@ void process_commands()
|
|||
// Get the current mean for the data points we have so far
|
||||
//
|
||||
sum = 0.0;
|
||||
for( j=0; j<=n; j++) {
|
||||
sum = sum + sample_set[j];
|
||||
}
|
||||
for (j=0; j<=n; j++) sum += sample_set[j];
|
||||
mean = sum / (double (n+1));
|
||||
|
||||
//
|
||||
// Now, use that mean to calculate the standard deviation for the
|
||||
// data points we have so far
|
||||
//
|
||||
|
||||
sum = 0.0;
|
||||
for( j=0; j<=n; j++) {
|
||||
sum = sum + (sample_set[j]-mean) * (sample_set[j]-mean);
|
||||
}
|
||||
for (j=0; j<=n; j++) sum += (sample_set[j]-mean) * (sample_set[j]-mean);
|
||||
sigma = sqrt( sum / (double (n+1)) );
|
||||
|
||||
if (verbose_level > 1) {
|
||||
|
|
@ -2563,7 +2595,6 @@ void process_commands()
|
|||
if (verbose_level > 2) {
|
||||
SERIAL_PROTOCOL(" mean: ");
|
||||
SERIAL_PROTOCOL_F(mean,6);
|
||||
|
||||
SERIAL_PROTOCOL(" sigma: ");
|
||||
SERIAL_PROTOCOL_F(sigma,6);
|
||||
}
|
||||
|
|
@ -2597,34 +2628,30 @@ void process_commands()
|
|||
SERIAL_PROTOCOLPGM("Standard Deviation: ");
|
||||
SERIAL_PROTOCOL_F(sigma, 6);
|
||||
SERIAL_PROTOCOLPGM("\n\n");
|
||||
|
||||
Sigma_Exit:
|
||||
break;
|
||||
}
|
||||
#endif // Z_PROBE_REPEATABILITY_TEST
|
||||
#endif // ENABLE_AUTO_BED_LEVELING
|
||||
|
||||
case 104: // M104
|
||||
if(setTargetedHotend(104)){
|
||||
break;
|
||||
}
|
||||
#endif // ENABLE_AUTO_BED_LEVELING && Z_PROBE_REPEATABILITY_TEST
|
||||
|
||||
/**
|
||||
* M104: Set hot end temperature
|
||||
*/
|
||||
inline void gcode_M104() {
|
||||
if (setTargetedHotend(104)) return;
|
||||
|
||||
if (code_seen('S')) setTargetHotend(code_value(), tmp_extruder);
|
||||
#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);
|
||||
#endif
|
||||
setWatch();
|
||||
break;
|
||||
case 112: // M112 -Emergency Stop
|
||||
kill();
|
||||
break;
|
||||
case 140: // M140 set bed temp
|
||||
if (code_seen('S')) setTargetBed(code_value());
|
||||
break;
|
||||
case 105 : // M105
|
||||
if(setTargetedHotend(105)){
|
||||
break;
|
||||
}
|
||||
|
||||
/**
|
||||
* M105: Read hot end and bed temperature
|
||||
*/
|
||||
inline void gcode_M105() {
|
||||
if (setTargetedHotend(105)) return;
|
||||
|
||||
#if defined(TEMP_0_PIN) && TEMP_0_PIN > -1
|
||||
SERIAL_PROTOCOLPGM("ok T:");
|
||||
SERIAL_PROTOCOL_F(degHotend(tmp_extruder),1);
|
||||
|
|
@ -2683,44 +2710,49 @@ Sigma_Exit:
|
|||
#endif
|
||||
|
||||
SERIAL_PROTOCOLLN("");
|
||||
return;
|
||||
break;
|
||||
case 109:
|
||||
{// M109 - Wait for extruder heater to reach target.
|
||||
if(setTargetedHotend(109)){
|
||||
break;
|
||||
}
|
||||
|
||||
#if defined(FAN_PIN) && FAN_PIN > -1
|
||||
|
||||
/**
|
||||
* M106: Set Fan Speed
|
||||
*/
|
||||
inline void gcode_M106() { fanSpeed = code_seen('S') ? constrain(code_value(), 0, 255) : 255; }
|
||||
|
||||
/**
|
||||
* M107: Fan Off
|
||||
*/
|
||||
inline void gcode_M107() { fanSpeed = 0; }
|
||||
|
||||
#endif //FAN_PIN
|
||||
|
||||
/**
|
||||
* M109: Wait for extruder(s) to reach temperature
|
||||
*/
|
||||
inline void gcode_M109() {
|
||||
if (setTargetedHotend(109)) return;
|
||||
|
||||
LCD_MESSAGEPGM(MSG_HEATING);
|
||||
#ifdef AUTOTEMP
|
||||
autotemp_enabled=false;
|
||||
#endif
|
||||
if (code_seen('S')) {
|
||||
|
||||
CooldownNoWait = code_seen('S');
|
||||
if (CooldownNoWait || code_seen('R')) {
|
||||
setTargetHotend(code_value(), tmp_extruder);
|
||||
#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);
|
||||
#endif
|
||||
CooldownNoWait = true;
|
||||
} else if (code_seen('R')) {
|
||||
setTargetHotend(code_value(), tmp_extruder);
|
||||
#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);
|
||||
#endif
|
||||
CooldownNoWait = false;
|
||||
}
|
||||
|
||||
#ifdef AUTOTEMP
|
||||
autotemp_enabled = code_seen('F');
|
||||
if (autotemp_enabled) autotemp_factor = code_value();
|
||||
if (code_seen('S')) autotemp_min = code_value();
|
||||
if (code_seen('B')) autotemp_max = code_value();
|
||||
if (code_seen('F'))
|
||||
{
|
||||
autotemp_factor=code_value();
|
||||
autotemp_enabled=true;
|
||||
}
|
||||
#endif
|
||||
|
||||
setWatch();
|
||||
codenum = millis();
|
||||
|
||||
unsigned long timetemp = millis();
|
||||
|
||||
/* See if we are heating up or cooling down */
|
||||
target_direction = isHeatingHotend(tmp_extruder); // true if heating, false if cooling
|
||||
|
|
@ -2728,43 +2760,41 @@ Sigma_Exit:
|
|||
cancel_heatup = false;
|
||||
|
||||
#ifdef TEMP_RESIDENCY_TIME
|
||||
long residencyStart;
|
||||
residencyStart = -1;
|
||||
long residencyStart = -1;
|
||||
/* continue to loop until we have reached the target temp
|
||||
_and_ until TEMP_RESIDENCY_TIME hasn't passed since we reached it */
|
||||
while((!cancel_heatup)&&((residencyStart == -1) ||
|
||||
(residencyStart >= 0 && (((unsigned int) (millis() - residencyStart)) < (TEMP_RESIDENCY_TIME * 1000UL)))) ) {
|
||||
(residencyStart >= 0 && (((unsigned int) (millis() - residencyStart)) < (TEMP_RESIDENCY_TIME * 1000UL)))) )
|
||||
#else
|
||||
while ( target_direction ? (isHeatingHotend(tmp_extruder)) : (isCoolingHotend(tmp_extruder)&&(CooldownNoWait==false)) ) {
|
||||
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
|
||||
|
||||
{ // while loop
|
||||
if (millis() > timetemp + 1000UL) { //Print temp & remaining time every 1s while waiting
|
||||
SERIAL_PROTOCOLPGM("T:");
|
||||
SERIAL_PROTOCOL_F(degHotend(tmp_extruder),1);
|
||||
SERIAL_PROTOCOLPGM(" E:");
|
||||
SERIAL_PROTOCOL((int)tmp_extruder);
|
||||
#ifdef TEMP_RESIDENCY_TIME
|
||||
SERIAL_PROTOCOLPGM(" W:");
|
||||
if(residencyStart > -1)
|
||||
{
|
||||
codenum = ((TEMP_RESIDENCY_TIME * 1000UL) - (millis() - residencyStart)) / 1000UL;
|
||||
SERIAL_PROTOCOLLN( codenum );
|
||||
if (residencyStart > -1) {
|
||||
timetemp = ((TEMP_RESIDENCY_TIME * 1000UL) - (millis() - residencyStart)) / 1000UL;
|
||||
SERIAL_PROTOCOLLN( timetemp );
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
SERIAL_PROTOCOLLN( "?" );
|
||||
}
|
||||
#else
|
||||
SERIAL_PROTOCOLLN("");
|
||||
#endif
|
||||
codenum = millis();
|
||||
timetemp = millis();
|
||||
}
|
||||
manage_heater();
|
||||
manage_inactivity();
|
||||
lcd_update();
|
||||
#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 */
|
||||
// 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))) ||
|
||||
(residencyStart > -1 && labs(degHotend(tmp_extruder) - degTargetHotend(tmp_extruder)) > TEMP_HYSTERESIS) )
|
||||
|
|
@ -2773,30 +2803,32 @@ Sigma_Exit:
|
|||
}
|
||||
#endif //TEMP_RESIDENCY_TIME
|
||||
}
|
||||
|
||||
LCD_MESSAGEPGM(MSG_HEATING_COMPLETE);
|
||||
starttime=millis();
|
||||
previous_millis_cmd = millis();
|
||||
starttime = previous_millis_cmd = millis();
|
||||
}
|
||||
break;
|
||||
case 190: // M190 - Wait for bed heater to reach target.
|
||||
|
||||
#if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
|
||||
|
||||
/**
|
||||
* M190: Sxxx Wait for bed current temp to reach target temp. Waits only when heating
|
||||
* Rxxx Wait for bed current temp to reach target temp. Waits when heating and cooling
|
||||
*/
|
||||
inline void gcode_M190() {
|
||||
LCD_MESSAGEPGM(MSG_BED_HEATING);
|
||||
if (code_seen('S')) {
|
||||
CooldownNoWait = code_seen('S');
|
||||
if (CooldownNoWait || code_seen('R'))
|
||||
setTargetBed(code_value());
|
||||
CooldownNoWait = true;
|
||||
} else if (code_seen('R')) {
|
||||
setTargetBed(code_value());
|
||||
CooldownNoWait = false;
|
||||
}
|
||||
codenum = millis();
|
||||
|
||||
unsigned long timetemp = millis();
|
||||
|
||||
cancel_heatup = false;
|
||||
target_direction = isHeatingBed(); // true if heating, false if cooling
|
||||
|
||||
while ( (target_direction)&&(!cancel_heatup) ? (isHeatingBed()) : (isCoolingBed()&&(CooldownNoWait==false)) )
|
||||
{
|
||||
if(( millis() - codenum) > 1000 ) //Print Temp Reading every 1 second while heating up.
|
||||
{
|
||||
while ( (target_direction)&&(!cancel_heatup) ? (isHeatingBed()) : (isCoolingBed()&&(CooldownNoWait==false)) ) {
|
||||
unsigned long ms = millis();
|
||||
if (ms > timetemp + 1000UL) { //Print Temp Reading every 1 second while heating up.
|
||||
timetemp = ms;
|
||||
float tt = degHotend(active_extruder);
|
||||
SERIAL_PROTOCOLPGM("T:");
|
||||
SERIAL_PROTOCOL(tt);
|
||||
|
|
@ -2805,7 +2837,6 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOLPGM(" B:");
|
||||
SERIAL_PROTOCOL_F(degBed(), 1);
|
||||
SERIAL_PROTOCOLLN("");
|
||||
codenum = millis();
|
||||
}
|
||||
manage_heater();
|
||||
manage_inactivity();
|
||||
|
|
@ -2813,62 +2844,62 @@ Sigma_Exit:
|
|||
}
|
||||
LCD_MESSAGEPGM(MSG_BED_DONE);
|
||||
previous_millis_cmd = millis();
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
|
||||
#if defined(FAN_PIN) && FAN_PIN > -1
|
||||
case 106: //M106 Fan On
|
||||
if (code_seen('S')){
|
||||
fanSpeed=constrain(code_value(),0,255);
|
||||
#endif // TEMP_BED_PIN > -1
|
||||
|
||||
/**
|
||||
* M112: Emergency Stop
|
||||
*/
|
||||
inline void gcode_M112() {
|
||||
kill();
|
||||
}
|
||||
else {
|
||||
fanSpeed=255;
|
||||
}
|
||||
break;
|
||||
case 107: //M107 Fan Off
|
||||
fanSpeed = 0;
|
||||
break;
|
||||
#endif //FAN_PIN
|
||||
|
||||
#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
|
||||
#if defined(HEATER_1_PIN) && HEATER_1_PIN > -1
|
||||
/**
|
||||
* M126: Heater 1 valve open
|
||||
*/
|
||||
inline void gcode_M126() { ValvePressure = code_seen('S') ? constrain(code_value(), 0, 255) : 255; }
|
||||
/**
|
||||
* M127: Heater 1 valve close
|
||||
*/
|
||||
inline void gcode_M127() { ValvePressure = 0; }
|
||||
#endif
|
||||
|
||||
#if defined(HEATER_2_PIN) && HEATER_2_PIN > -1
|
||||
/**
|
||||
* M128: Heater 2 valve open
|
||||
*/
|
||||
inline void gcode_M128() { EtoPPressure = code_seen('S') ? constrain(code_value(), 0, 255) : 255; }
|
||||
/**
|
||||
* M129: Heater 2 valve close
|
||||
*/
|
||||
inline void gcode_M129() { EtoPPressure = 0; }
|
||||
#endif
|
||||
|
||||
#endif //BARICUDA
|
||||
|
||||
/**
|
||||
* M140: Set bed temperature
|
||||
*/
|
||||
inline void gcode_M140() {
|
||||
if (code_seen('S')) setTargetBed(code_value());
|
||||
}
|
||||
|
||||
#if defined(PS_ON_PIN) && PS_ON_PIN > -1
|
||||
case 80: // M80 - Turn on Power Supply
|
||||
|
||||
/**
|
||||
* M80: Turn on Power Supply
|
||||
*/
|
||||
inline void gcode_M80() {
|
||||
OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE); //GND
|
||||
|
||||
// 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
|
||||
#if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
|
||||
OUT_WRITE(SUICIDE_PIN, HIGH);
|
||||
#endif
|
||||
|
||||
|
|
@ -2877,10 +2908,14 @@ Sigma_Exit:
|
|||
LCD_MESSAGEPGM(WELCOME_MSG);
|
||||
lcd_update();
|
||||
#endif
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
case 81: // M81 - Turn off Power Supply
|
||||
#endif // PS_ON_PIN
|
||||
|
||||
/**
|
||||
* M81: Turn off Power Supply
|
||||
*/
|
||||
inline void gcode_M81() {
|
||||
disable_heater();
|
||||
st_synchronize();
|
||||
disable_e0();
|
||||
|
|
@ -2889,7 +2924,7 @@ Sigma_Exit:
|
|||
disable_e3();
|
||||
finishAndDisableSteppers();
|
||||
fanSpeed = 0;
|
||||
delay(1000); // Wait a little before to switch off
|
||||
delay(1000); // Wait 1 second before switching off
|
||||
#if defined(SUICIDE_PIN) && SUICIDE_PIN > -1
|
||||
st_synchronize();
|
||||
suicide();
|
||||
|
|
@ -2901,24 +2936,28 @@ Sigma_Exit:
|
|||
LCD_MESSAGEPGM(MACHINE_NAME " " MSG_OFF ".");
|
||||
lcd_update();
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
|
||||
case 82:
|
||||
axis_relative_modes[3] = false;
|
||||
break;
|
||||
case 83:
|
||||
axis_relative_modes[3] = true;
|
||||
break;
|
||||
case 18: //compatibility
|
||||
case 84: // M84
|
||||
/**
|
||||
* M82: Set E codes absolute (default)
|
||||
*/
|
||||
inline void gcode_M82() { axis_relative_modes[E_AXIS] = false; }
|
||||
|
||||
/**
|
||||
* M82: Set E codes relative while in Absolute Coordinates (G90) mode
|
||||
*/
|
||||
inline void gcode_M83() { axis_relative_modes[E_AXIS] = true; }
|
||||
|
||||
/**
|
||||
* M18, M84: Disable all stepper motors
|
||||
*/
|
||||
inline void gcode_M18_M84() {
|
||||
if (code_seen('S')) {
|
||||
stepper_inactive_time = code_value() * 1000;
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
bool all_axis = !((code_seen(axis_codes[X_AXIS])) || (code_seen(axis_codes[Y_AXIS])) || (code_seen(axis_codes[Z_AXIS]))|| (code_seen(axis_codes[E_AXIS])));
|
||||
if(all_axis)
|
||||
{
|
||||
if (all_axis) {
|
||||
st_synchronize();
|
||||
disable_e0();
|
||||
disable_e1();
|
||||
|
|
@ -2926,8 +2965,7 @@ Sigma_Exit:
|
|||
disable_e3();
|
||||
finishAndDisableSteppers();
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
st_synchronize();
|
||||
if (code_seen('X')) disable_x();
|
||||
if (code_seen('Y')) disable_y();
|
||||
|
|
@ -2942,18 +2980,22 @@ Sigma_Exit:
|
|||
#endif
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 85: // M85
|
||||
if(code_seen('S')) {
|
||||
max_inactive_time = code_value() * 1000;
|
||||
}
|
||||
break;
|
||||
case 92: // M92
|
||||
for(int8_t i=0; i < NUM_AXIS; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i]))
|
||||
{
|
||||
if(i == 3) { // E
|
||||
|
||||
/**
|
||||
* M85: Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
|
||||
*/
|
||||
inline void gcode_M85() {
|
||||
if (code_seen('S')) max_inactive_time = code_value() * 1000;
|
||||
}
|
||||
|
||||
/**
|
||||
* M92: Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
|
||||
*/
|
||||
inline void gcode_M92() {
|
||||
for(int8_t i=0; i < NUM_AXIS; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
if (i == E_AXIS) {
|
||||
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.
|
||||
|
|
@ -2968,17 +3010,12 @@ Sigma_Exit:
|
|||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 115: // M115
|
||||
SERIAL_PROTOCOLPGM(MSG_M115_REPORT);
|
||||
break;
|
||||
case 117: // M117 display message
|
||||
starpos = (strchr(strchr_pointer + 5,'*'));
|
||||
if(starpos!=NULL)
|
||||
*(starpos)='\0';
|
||||
lcd_setstatus(strchr_pointer + 5);
|
||||
break;
|
||||
case 114: // M114
|
||||
}
|
||||
|
||||
/**
|
||||
* M114: Output current position to serial port
|
||||
*/
|
||||
inline void gcode_M114() {
|
||||
SERIAL_PROTOCOLPGM("X:");
|
||||
SERIAL_PROTOCOL(current_position[X_AXIS]);
|
||||
SERIAL_PROTOCOLPGM(" Y:");
|
||||
|
|
@ -2996,6 +3033,7 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOL(float(st_get_position(Z_AXIS))/axis_steps_per_unit[Z_AXIS]);
|
||||
|
||||
SERIAL_PROTOCOLLN("");
|
||||
|
||||
#ifdef SCARA
|
||||
SERIAL_PROTOCOLPGM("SCARA Theta:");
|
||||
SERIAL_PROTOCOL(delta[X_AXIS]);
|
||||
|
|
@ -3016,14 +3054,29 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOLLN("");
|
||||
SERIAL_PROTOCOLLN("");
|
||||
#endif
|
||||
break;
|
||||
case 120: // M120
|
||||
enable_endstops(false) ;
|
||||
break;
|
||||
case 121: // M121
|
||||
enable_endstops(true) ;
|
||||
break;
|
||||
case 119: // M119
|
||||
}
|
||||
|
||||
/**
|
||||
* M115: Capabilities string
|
||||
*/
|
||||
inline void gcode_M115() {
|
||||
SERIAL_PROTOCOLPGM(MSG_M115_REPORT);
|
||||
}
|
||||
|
||||
/**
|
||||
* M117: Set LCD Status Message
|
||||
*/
|
||||
inline void gcode_M117() {
|
||||
char* codepos = strchr_pointer + 5;
|
||||
char* starpos = strchr(codepos, '*');
|
||||
if (starpos) *starpos = '\0';
|
||||
lcd_setstatus(codepos);
|
||||
}
|
||||
|
||||
/**
|
||||
* M119: Output endstop states to serial output
|
||||
*/
|
||||
inline void gcode_M119() {
|
||||
SERIAL_PROTOCOLLN(MSG_M119_REPORT);
|
||||
#if defined(X_MIN_PIN) && X_MIN_PIN > -1
|
||||
SERIAL_PROTOCOLPGM(MSG_X_MIN);
|
||||
|
|
@ -3049,33 +3102,46 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOLPGM(MSG_Z_MAX);
|
||||
SERIAL_PROTOCOLLN(((READ(Z_MAX_PIN)^Z_MAX_ENDSTOP_INVERTING)?MSG_ENDSTOP_HIT:MSG_ENDSTOP_OPEN));
|
||||
#endif
|
||||
break;
|
||||
//TODO: update for all axis, use for loop
|
||||
#ifdef BLINKM
|
||||
case 150: // M150
|
||||
{
|
||||
byte red;
|
||||
byte grn;
|
||||
byte blu;
|
||||
|
||||
if(code_seen('R')) red = code_value();
|
||||
if(code_seen('U')) grn = code_value();
|
||||
if(code_seen('B')) blu = code_value();
|
||||
|
||||
SendColors(red,grn,blu);
|
||||
}
|
||||
break;
|
||||
#endif //BLINKM
|
||||
case 200: // M200 D<millimeters> set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
|
||||
{
|
||||
|
||||
/**
|
||||
* M120: Enable endstops
|
||||
*/
|
||||
inline void gcode_M120() { enable_endstops(false); }
|
||||
|
||||
/**
|
||||
* M121: Disable endstops
|
||||
*/
|
||||
inline void gcode_M121() { enable_endstops(true); }
|
||||
|
||||
#ifdef BLINKM
|
||||
|
||||
/**
|
||||
* M150: Set Status LED Color - Use R-U-B for R-G-B
|
||||
*/
|
||||
inline void gcode_M150() {
|
||||
SendColors(
|
||||
code_seen('R') ? (byte)code_value() : 0,
|
||||
code_seen('U') ? (byte)code_value() : 0,
|
||||
code_seen('B') ? (byte)code_value() : 0
|
||||
);
|
||||
}
|
||||
|
||||
#endif // BLINKM
|
||||
|
||||
/**
|
||||
* M200: Set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
|
||||
* T<extruder>
|
||||
* D<millimeters>
|
||||
*/
|
||||
inline void gcode_M200() {
|
||||
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);
|
||||
break;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3092,44 +3158,71 @@ Sigma_Exit:
|
|||
for (int i=0; i<EXTRUDERS; i++)
|
||||
if (! filament_size[i]) filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
//reserved for setting filament diameter via UFID or filament measuring device
|
||||
break;
|
||||
return;
|
||||
}
|
||||
calculate_volumetric_multipliers();
|
||||
}
|
||||
break;
|
||||
case 201: // M201
|
||||
for(int8_t i=0; i < NUM_AXIS; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i]))
|
||||
{
|
||||
|
||||
/**
|
||||
* M201: Set max acceleration in units/s^2 for print moves (M201 X1000 Y1000)
|
||||
*/
|
||||
inline void gcode_M201() {
|
||||
for (int8_t i=0; i < NUM_AXIS; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
max_acceleration_units_per_sq_second[i] = code_value();
|
||||
}
|
||||
}
|
||||
// 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)
|
||||
reset_acceleration_rates();
|
||||
break;
|
||||
}
|
||||
|
||||
#if 0 // Not used for Sprinter/grbl gen6
|
||||
case 202: // M202
|
||||
inline void gcode_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
|
||||
{
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* M203: Set maximum feedrate that your machine can sustain (M203 X200 Y200 Z300 E10000) in mm/sec
|
||||
*/
|
||||
inline void gcode_M203() {
|
||||
for (int8_t i=0; i < NUM_AXIS; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
max_feedrate[i] = code_value();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* M204: Set Default Acceleration and/or Default Filament Acceleration in mm/sec^2 (M204 S3000 T7000)
|
||||
*
|
||||
* S = normal moves
|
||||
* T = filament only moves
|
||||
*
|
||||
* Also sets minimum segment time in ms (B20000) to prevent buffer under-runs and M20 minimum feedrate
|
||||
*/
|
||||
inline void gcode_M204() {
|
||||
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
|
||||
{
|
||||
|
||||
/**
|
||||
* M205: Set Advanced Settings
|
||||
*
|
||||
* S = Min Feed Rate (mm/s)
|
||||
* T = Min Travel Feed Rate (mm/s)
|
||||
* B = Min Segment Time (µs)
|
||||
* X = Max XY Jerk (mm/s/s)
|
||||
* Z = Max Z Jerk (mm/s/s)
|
||||
* E = Max E Jerk (mm/s/s)
|
||||
*/
|
||||
inline void gcode_M205() {
|
||||
if (code_seen('S')) minimumfeedrate = code_value();
|
||||
if (code_seen('T')) mintravelfeedrate = code_value();
|
||||
if (code_seen('B')) minsegmenttime = code_value();
|
||||
|
|
@ -3137,118 +3230,112 @@ Sigma_Exit:
|
|||
if (code_seen('Z')) max_z_jerk = code_value();
|
||||
if (code_seen('E')) max_e_jerk = code_value();
|
||||
}
|
||||
break;
|
||||
case 206: // M206 additional homing offset
|
||||
for(int8_t i=0; i < 3; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i])) add_homing[i] = code_value();
|
||||
|
||||
/**
|
||||
* M206: Set Additional Homing Offset (X Y Z). SCARA aliases T=X, P=Y
|
||||
*/
|
||||
inline void gcode_M206() {
|
||||
for (int8_t i=X_AXIS; i <= Z_AXIS; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
add_homing[i] = code_value();
|
||||
}
|
||||
}
|
||||
#ifdef SCARA
|
||||
if(code_seen('T')) // Theta
|
||||
{
|
||||
add_homing[X_AXIS] = code_value() ;
|
||||
}
|
||||
if(code_seen('P')) // Psi
|
||||
{
|
||||
add_homing[Y_AXIS] = code_value() ;
|
||||
}
|
||||
if (code_seen('T')) add_homing[X_AXIS] = code_value(); // Theta
|
||||
if (code_seen('P')) add_homing[Y_AXIS] = code_value(); // Psi
|
||||
#endif
|
||||
break;
|
||||
#ifdef DELTA
|
||||
case 665: // M665 set delta configurations L<diagonal_rod> R<delta_radius> S<segments_per_sec>
|
||||
if(code_seen('L')) {
|
||||
delta_diagonal_rod= code_value();
|
||||
}
|
||||
if(code_seen('R')) {
|
||||
delta_radius= code_value();
|
||||
}
|
||||
if(code_seen('S')) {
|
||||
delta_segments_per_second= code_value();
|
||||
}
|
||||
|
||||
#ifdef DELTA
|
||||
/**
|
||||
* M665: Set delta configurations
|
||||
*
|
||||
* L = diagonal rod
|
||||
* R = delta radius
|
||||
* S = segments per second
|
||||
*/
|
||||
inline void gcode_M665() {
|
||||
if (code_seen('L')) delta_diagonal_rod = code_value();
|
||||
if (code_seen('R')) delta_radius = code_value();
|
||||
if (code_seen('S')) delta_segments_per_second = code_value();
|
||||
recalc_delta_settings(delta_radius, delta_diagonal_rod);
|
||||
break;
|
||||
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
|
||||
/**
|
||||
* M666: Set delta endstop adjustment
|
||||
*/
|
||||
inline void gcode_M666() {
|
||||
for (int8_t i = 0; i < 3; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
endstop_adj[i] = code_value();
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif // DELTA
|
||||
|
||||
#ifdef FWRETRACT
|
||||
case 207: //M207 - set retract length S[positive mm] F[feedrate mm/min] Z[additional zlift/hop]
|
||||
{
|
||||
if(code_seen('S'))
|
||||
{
|
||||
retract_length = code_value() ;
|
||||
|
||||
/**
|
||||
* M207: Set retract length S[positive mm] F[feedrate mm/min] Z[additional zlift/hop]
|
||||
*/
|
||||
inline void gcode_M207() {
|
||||
if (code_seen('S')) retract_length = code_value();
|
||||
if (code_seen('F')) retract_feedrate = code_value() / 60;
|
||||
if (code_seen('Z')) retract_zlift = code_value();
|
||||
}
|
||||
if(code_seen('F'))
|
||||
{
|
||||
retract_feedrate = code_value()/60 ;
|
||||
|
||||
/**
|
||||
* M208: Set retract recover length S[positive mm surplus to the M207 S*] F[feedrate mm/min]
|
||||
*/
|
||||
inline void gcode_M208() {
|
||||
if (code_seen('S')) retract_recover_length = code_value();
|
||||
if (code_seen('F')) retract_recover_feedrate = code_value() / 60;
|
||||
}
|
||||
if(code_seen('Z'))
|
||||
{
|
||||
retract_zlift = code_value() ;
|
||||
}
|
||||
}break;
|
||||
case 208: // M208 - set retract recover length S[positive mm surplus to the M207 S*] F[feedrate mm/min]
|
||||
{
|
||||
if(code_seen('S'))
|
||||
{
|
||||
retract_recover_length = code_value() ;
|
||||
}
|
||||
if(code_seen('F'))
|
||||
{
|
||||
retract_recover_feedrate = code_value()/60 ;
|
||||
}
|
||||
}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.
|
||||
{
|
||||
if(code_seen('S'))
|
||||
{
|
||||
|
||||
/**
|
||||
* M209: Enable automatic retract (M209 S1)
|
||||
* detect if the slicer did not support G10/11: every normal extrude-only move will be classified as retract depending on the direction.
|
||||
*/
|
||||
inline void gcode_M209() {
|
||||
if (code_seen('S')) {
|
||||
int t = code_value();
|
||||
switch(t)
|
||||
{
|
||||
switch(t) {
|
||||
case 0:
|
||||
autoretract_enabled = false;
|
||||
break;
|
||||
case 1:
|
||||
{
|
||||
autoretract_enabled = (t == 1);
|
||||
for (int i=0; i<EXTRUDERS; i++) retracted[i] = false;
|
||||
}break;
|
||||
autoretract_enabled = true;
|
||||
break;
|
||||
default:
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOPGM(MSG_UNKNOWN_COMMAND);
|
||||
SERIAL_ECHO(cmdbuffer[bufindr]);
|
||||
SERIAL_ECHOLNPGM("\"");
|
||||
return;
|
||||
}
|
||||
for (int i=0; i<EXTRUDERS; i++) retracted[i] = false;
|
||||
}
|
||||
}
|
||||
|
||||
}break;
|
||||
#endif // FWRETRACT
|
||||
|
||||
#if EXTRUDERS > 1
|
||||
case 218: // M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
|
||||
{
|
||||
if(setTargetedHotend(218)){
|
||||
break;
|
||||
}
|
||||
if(code_seen('X'))
|
||||
{
|
||||
extruder_offset[X_AXIS][tmp_extruder] = code_value();
|
||||
}
|
||||
if(code_seen('Y'))
|
||||
{
|
||||
extruder_offset[Y_AXIS][tmp_extruder] = code_value();
|
||||
}
|
||||
|
||||
/**
|
||||
* M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
|
||||
*/
|
||||
inline void gcode_M218() {
|
||||
if (setTargetedHotend(218)) return;
|
||||
|
||||
if (code_seen('X')) extruder_offset[X_AXIS][tmp_extruder] = code_value();
|
||||
if (code_seen('Y')) extruder_offset[Y_AXIS][tmp_extruder] = code_value();
|
||||
|
||||
#ifdef DUAL_X_CARRIAGE
|
||||
if(code_seen('Z'))
|
||||
{
|
||||
extruder_offset[Z_AXIS][tmp_extruder] = code_value();
|
||||
}
|
||||
if (code_seen('Z')) extruder_offset[Z_AXIS][tmp_extruder] = code_value();
|
||||
#endif
|
||||
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
|
||||
for(tmp_extruder = 0; tmp_extruder < EXTRUDERS; tmp_extruder++)
|
||||
{
|
||||
for (tmp_extruder = 0; tmp_extruder < EXTRUDERS; tmp_extruder++) {
|
||||
SERIAL_ECHO(" ");
|
||||
SERIAL_ECHO(extruder_offset[X_AXIS][tmp_extruder]);
|
||||
SERIAL_ECHO(",");
|
||||
|
|
@ -3259,57 +3346,52 @@ Sigma_Exit:
|
|||
#endif
|
||||
}
|
||||
SERIAL_EOL;
|
||||
}break;
|
||||
#endif
|
||||
case 220: // M220 S<factor in percent>- set speed factor override percentage
|
||||
{
|
||||
if(code_seen('S'))
|
||||
{
|
||||
feedmultiply = code_value() ;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 221: // M221 S<factor in percent>- set extrude factor override percentage
|
||||
{
|
||||
if(code_seen('S'))
|
||||
{
|
||||
int tmp_code = code_value();
|
||||
if (code_seen('T'))
|
||||
{
|
||||
if(setTargetedHotend(221)){
|
||||
break;
|
||||
}
|
||||
extruder_multiply[tmp_extruder] = tmp_code;
|
||||
}
|
||||
else
|
||||
{
|
||||
extrudemultiply = tmp_code ;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 226: // M226 P<pin number> S<pin state>- Wait until the specified pin reaches the state required
|
||||
{
|
||||
#endif // EXTRUDERS > 1
|
||||
|
||||
/**
|
||||
* M220: Set speed percentage factor, aka "Feed Rate" (M220 S95)
|
||||
*/
|
||||
inline void gcode_M220() {
|
||||
if (code_seen('S')) feedmultiply = code_value();
|
||||
}
|
||||
|
||||
/**
|
||||
* M221: Set extrusion percentage (M221 T0 S95)
|
||||
*/
|
||||
inline void gcode_M221() {
|
||||
if (code_seen('S')) {
|
||||
int sval = code_value();
|
||||
if (code_seen('T')) {
|
||||
if (setTargetedHotend(221)) return;
|
||||
extruder_multiply[tmp_extruder] = sval;
|
||||
}
|
||||
else {
|
||||
extrudemultiply = sval;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* M226: Wait until the specified pin reaches the state required (M226 P<pin> S<state>)
|
||||
*/
|
||||
inline void gcode_M226() {
|
||||
if (code_seen('P')) {
|
||||
int pin_number = code_value(); // pin number
|
||||
int pin_state = -1; // required pin state - default is inverted
|
||||
int pin_number = code_value();
|
||||
|
||||
if(code_seen('S')) pin_state = code_value(); // required pin state
|
||||
int pin_state = code_seen('S') ? code_value() : -1; // required pin state - default is inverted
|
||||
|
||||
if (pin_state >= -1 && pin_state <= 1) {
|
||||
|
||||
for(int8_t i = 0; i < (int8_t)(sizeof(sensitive_pins)/sizeof(int)); i++)
|
||||
{
|
||||
if (sensitive_pins[i] == pin_number)
|
||||
{
|
||||
for (int8_t i = 0; i < (int8_t)(sizeof(sensitive_pins)/sizeof(*sensitive_pins)); i++) {
|
||||
if (sensitive_pins[i] == pin_number) {
|
||||
pin_number = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (pin_number > -1)
|
||||
{
|
||||
if (pin_number > -1) {
|
||||
int target = LOW;
|
||||
|
||||
st_synchronize();
|
||||
|
|
@ -3335,23 +3417,24 @@ Sigma_Exit:
|
|||
manage_inactivity();
|
||||
lcd_update();
|
||||
}
|
||||
|
||||
} // pin_number > -1
|
||||
} // pin_state -1 0 1
|
||||
} // code_seen('P')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
#if NUM_SERVOS > 0
|
||||
case 280: // M280 - set servo position absolute. P: servo index, S: angle or microseconds
|
||||
{
|
||||
int servo_index = -1;
|
||||
|
||||
/**
|
||||
* M280: Set servo position absolute. P: servo index, S: angle or microseconds
|
||||
*/
|
||||
inline void gcode_M280() {
|
||||
int servo_index = code_seen('P') ? code_value() : -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)) {
|
||||
#if defined (ENABLE_AUTO_BED_LEVELING) && (PROBE_SERVO_DEACTIVATION_DELAY > 0)
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && PROBE_SERVO_DEACTIVATION_DELAY > 0
|
||||
servos[servo_index].attach(0);
|
||||
#endif
|
||||
servos[servo_index].write(servo_position);
|
||||
|
|
@ -3376,16 +3459,18 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
#endif // NUM_SERVOS > 0
|
||||
|
||||
#if (LARGE_FLASH == true && ( BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)))
|
||||
case 300: // M300
|
||||
{
|
||||
#if defined(LARGE_FLASH) && (BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER))
|
||||
|
||||
/**
|
||||
* M300: Play beep sound S<frequency Hz> P<duration ms>
|
||||
*/
|
||||
inline void gcode_M300() {
|
||||
int beepS = code_seen('S') ? code_value() : 110;
|
||||
int beepP = code_seen('P') ? code_value() : 1000;
|
||||
if (beepS > 0)
|
||||
{
|
||||
if (beepS > 0) {
|
||||
#if BEEPER > 0
|
||||
tone(BEEPER, beepS);
|
||||
delay(beepP);
|
||||
|
|
@ -3396,28 +3481,25 @@ Sigma_Exit:
|
|||
lcd_buzz(beepP, beepS);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
delay(beepP);
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif // M300
|
||||
|
||||
#endif // LARGE_FLASH && (BEEPER>0 || ULTRALCD || LCD_USE_I2C_BUZZER)
|
||||
|
||||
#ifdef PIDTEMP
|
||||
case 301: // M301
|
||||
{
|
||||
|
||||
/**
|
||||
* M301: Set PID parameters P I D (and optionally C)
|
||||
*/
|
||||
inline void gcode_M301() {
|
||||
|
||||
// multi-extruder PID patch: M301 updates or prints a single extruder's PID values
|
||||
// default behaviour (omitting E parameter) is to update for extruder 0 only
|
||||
int e = 0; // extruder being updated
|
||||
if (code_seen('E'))
|
||||
{
|
||||
e = (int)code_value();
|
||||
}
|
||||
if (e < EXTRUDERS) // catch bad input value
|
||||
{
|
||||
int e = code_seen('E') ? code_value() : 0; // extruder being updated
|
||||
|
||||
if (e < EXTRUDERS) { // catch bad input value
|
||||
if (code_seen('P')) PID_PARAM(Kp, e) = code_value();
|
||||
if (code_seen('I')) PID_PARAM(Ki, e) = scalePID_i(code_value());
|
||||
if (code_seen('D')) PID_PARAM(Kd, e) = scalePID_d(code_value());
|
||||
|
|
@ -3443,20 +3525,18 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOL(PID_PARAM(Kc, e));
|
||||
#endif
|
||||
SERIAL_PROTOCOLLN("");
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
#endif // PIDTEMP
|
||||
|
||||
#ifdef PIDTEMPBED
|
||||
case 304: // M304
|
||||
{
|
||||
|
||||
inline void gcode_M304() {
|
||||
if (code_seen('P')) bedKp = code_value();
|
||||
if (code_seen('I')) bedKi = scalePID_i(code_value());
|
||||
if (code_seen('D')) bedKd = scalePID_d(code_value());
|
||||
|
|
@ -3471,19 +3551,24 @@ Sigma_Exit:
|
|||
SERIAL_PROTOCOL(unscalePID_d(bedKd));
|
||||
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/
|
||||
{
|
||||
|
||||
#endif // PIDTEMPBED
|
||||
|
||||
#if defined(CHDK) || (defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1)
|
||||
|
||||
/**
|
||||
* M240: Trigger a camera by emulating a Canon RC-1
|
||||
* See http://www.doc-diy.net/photo/rc-1_hacked/
|
||||
*/
|
||||
inline void gcode_M240() {
|
||||
#ifdef CHDK
|
||||
|
||||
OUT_WRITE(CHDK, HIGH);
|
||||
chdkHigh = millis();
|
||||
chdkActive = true;
|
||||
|
||||
#else
|
||||
#elif defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1
|
||||
|
||||
#if defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1
|
||||
const uint8_t NUM_PULSES = 16;
|
||||
const float PULSE_LENGTH = 0.01524;
|
||||
for (int i = 0; i < NUM_PULSES; i++) {
|
||||
|
|
@ -3499,204 +3584,269 @@ Sigma_Exit:
|
|||
WRITE(PHOTOGRAPH_PIN, LOW);
|
||||
_delay_ms(PULSE_LENGTH);
|
||||
}
|
||||
#endif
|
||||
#endif //chdk end if
|
||||
|
||||
#endif // !CHDK && PHOTOGRAPH_PIN > -1
|
||||
}
|
||||
break;
|
||||
|
||||
#endif // CHDK || PHOTOGRAPH_PIN
|
||||
|
||||
#ifdef DOGLCD
|
||||
case 250: // M250 Set LCD contrast value: C<value> (value 0..63)
|
||||
{
|
||||
if (code_seen('C')) {
|
||||
lcd_setcontrast( ((int)code_value())&63 );
|
||||
}
|
||||
|
||||
/**
|
||||
* M250: Read and optionally set the LCD contrast
|
||||
*/
|
||||
inline void gcode_M250() {
|
||||
if (code_seen('C')) lcd_setcontrast(code_value_long() & 0x3F);
|
||||
SERIAL_PROTOCOLPGM("lcd contrast value: ");
|
||||
SERIAL_PROTOCOL(lcd_contrast);
|
||||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
#endif // DOGLCD
|
||||
|
||||
#ifdef PREVENT_DANGEROUS_EXTRUDE
|
||||
case 302: // allow cold extrudes, or set the minimum extrude temperature
|
||||
{
|
||||
float temp = .0;
|
||||
if (code_seen('S')) temp=code_value();
|
||||
set_extrude_min_temp(temp);
|
||||
|
||||
/**
|
||||
* M302: Allow cold extrudes, or set the minimum extrude S<temperature>.
|
||||
*/
|
||||
inline void gcode_M302() {
|
||||
set_extrude_min_temp(code_seen('S') ? code_value() : 0);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case 303: // M303 PID autotune
|
||||
{
|
||||
float temp = 150.0;
|
||||
int e=0;
|
||||
int c=5;
|
||||
if (code_seen('E')) e=code_value();
|
||||
if (e<0)
|
||||
temp=70;
|
||||
if (code_seen('S')) temp=code_value();
|
||||
if (code_seen('C')) c=code_value();
|
||||
|
||||
#endif // PREVENT_DANGEROUS_EXTRUDE
|
||||
|
||||
/**
|
||||
* M303: PID relay autotune
|
||||
* S<temperature> sets the target temperature. (default target temperature = 150C)
|
||||
* E<extruder> (-1 for the bed)
|
||||
* C<cycles>
|
||||
*/
|
||||
inline void gcode_M303() {
|
||||
int e = code_seen('E') ? code_value_long() : 0;
|
||||
int c = code_seen('C') ? code_value_long() : 5;
|
||||
float temp = code_seen('S') ? code_value() : (e < 0 ? 70.0 : 150.0);
|
||||
PID_autotune(temp, e, c);
|
||||
}
|
||||
break;
|
||||
|
||||
#ifdef SCARA
|
||||
case 360: // M360 SCARA Theta pos1
|
||||
|
||||
/**
|
||||
* M360: SCARA calibration: Move to cal-position ThetaA (0 deg calibration)
|
||||
*/
|
||||
inline bool gcode_M360() {
|
||||
SERIAL_ECHOLN(" Cal: Theta 0 ");
|
||||
//SoftEndsEnabled = false; // Ignore soft endstops during calibration
|
||||
//SERIAL_ECHOLN(" Soft endstops disabled ");
|
||||
if(Stopped == false) {
|
||||
if (! Stopped) {
|
||||
//get_coordinates(); // For X Y Z E F
|
||||
delta[X_AXIS] = 0;
|
||||
delta[Y_AXIS] = 120;
|
||||
calculate_SCARA_forward_Transform(delta);
|
||||
destination[X_AXIS] = delta[X_AXIS]/axis_scaling[X_AXIS];
|
||||
destination[Y_AXIS] = delta[Y_AXIS]/axis_scaling[Y_AXIS];
|
||||
|
||||
prepare_move();
|
||||
//ClearToSend();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
|
||||
case 361: // SCARA Theta pos2
|
||||
/**
|
||||
* M361: SCARA calibration: Move to cal-position ThetaB (90 deg calibration - steps per degree)
|
||||
*/
|
||||
inline bool gcode_M361() {
|
||||
SERIAL_ECHOLN(" Cal: Theta 90 ");
|
||||
//SoftEndsEnabled = false; // Ignore soft endstops during calibration
|
||||
//SERIAL_ECHOLN(" Soft endstops disabled ");
|
||||
if(Stopped == false) {
|
||||
if (! Stopped) {
|
||||
//get_coordinates(); // For X Y Z E F
|
||||
delta[X_AXIS] = 90;
|
||||
delta[Y_AXIS] = 130;
|
||||
calculate_SCARA_forward_Transform(delta);
|
||||
destination[X_AXIS] = delta[X_AXIS]/axis_scaling[X_AXIS];
|
||||
destination[Y_AXIS] = delta[Y_AXIS]/axis_scaling[Y_AXIS];
|
||||
|
||||
prepare_move();
|
||||
//ClearToSend();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case 362: // SCARA Psi pos1
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* M362: SCARA calibration: Move to cal-position PsiA (0 deg calibration)
|
||||
*/
|
||||
inline bool gcode_M362() {
|
||||
SERIAL_ECHOLN(" Cal: Psi 0 ");
|
||||
//SoftEndsEnabled = false; // Ignore soft endstops during calibration
|
||||
//SERIAL_ECHOLN(" Soft endstops disabled ");
|
||||
if(Stopped == false) {
|
||||
if (! Stopped) {
|
||||
//get_coordinates(); // For X Y Z E F
|
||||
delta[X_AXIS] = 60;
|
||||
delta[Y_AXIS] = 180;
|
||||
calculate_SCARA_forward_Transform(delta);
|
||||
destination[X_AXIS] = delta[X_AXIS]/axis_scaling[X_AXIS];
|
||||
destination[Y_AXIS] = delta[Y_AXIS]/axis_scaling[Y_AXIS];
|
||||
|
||||
prepare_move();
|
||||
//ClearToSend();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case 363: // SCARA Psi pos2
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* M363: SCARA calibration: Move to cal-position PsiB (90 deg calibration - steps per degree)
|
||||
*/
|
||||
inline bool gcode_M363() {
|
||||
SERIAL_ECHOLN(" Cal: Psi 90 ");
|
||||
//SoftEndsEnabled = false; // Ignore soft endstops during calibration
|
||||
//SERIAL_ECHOLN(" Soft endstops disabled ");
|
||||
if(Stopped == false) {
|
||||
if (! Stopped) {
|
||||
//get_coordinates(); // For X Y Z E F
|
||||
delta[X_AXIS] = 50;
|
||||
delta[Y_AXIS] = 90;
|
||||
calculate_SCARA_forward_Transform(delta);
|
||||
destination[X_AXIS] = delta[X_AXIS]/axis_scaling[X_AXIS];
|
||||
destination[Y_AXIS] = delta[Y_AXIS]/axis_scaling[Y_AXIS];
|
||||
|
||||
prepare_move();
|
||||
//ClearToSend();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case 364: // SCARA Psi pos3 (90 deg to Theta)
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* M364: SCARA calibration: Move to cal-position PSIC (90 deg to Theta calibration position)
|
||||
*/
|
||||
inline bool gcode_M364() {
|
||||
SERIAL_ECHOLN(" Cal: Theta-Psi 90 ");
|
||||
// SoftEndsEnabled = false; // Ignore soft endstops during calibration
|
||||
//SERIAL_ECHOLN(" Soft endstops disabled ");
|
||||
if(Stopped == false) {
|
||||
if (! Stopped) {
|
||||
//get_coordinates(); // For X Y Z E F
|
||||
delta[X_AXIS] = 45;
|
||||
delta[Y_AXIS] = 135;
|
||||
calculate_SCARA_forward_Transform(delta);
|
||||
destination[X_AXIS] = delta[X_AXIS] / axis_scaling[X_AXIS];
|
||||
destination[Y_AXIS] = delta[Y_AXIS] / axis_scaling[Y_AXIS];
|
||||
|
||||
prepare_move();
|
||||
//ClearToSend();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case 365: // M364 Set SCARA scaling for X Y Z
|
||||
for(int8_t i=0; i < 3; i++)
|
||||
{
|
||||
if(code_seen(axis_codes[i]))
|
||||
{
|
||||
|
||||
/**
|
||||
* M365: SCARA calibration: Scaling factor, X, Y, Z axis
|
||||
*/
|
||||
inline void gcode_M365() {
|
||||
for (int8_t i = X_AXIS; i <= Z_AXIS; i++) {
|
||||
if (code_seen(axis_codes[i])) {
|
||||
axis_scaling[i] = code_value();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
#endif // SCARA
|
||||
|
||||
#ifdef EXT_SOLENOID
|
||||
case 380:
|
||||
enable_solenoid_on_active_extruder();
|
||||
break;
|
||||
|
||||
case 381:
|
||||
disable_all_solenoids();
|
||||
void enable_solenoid(uint8_t num) {
|
||||
switch(num) {
|
||||
case 0:
|
||||
OUT_WRITE(SOL0_PIN, HIGH);
|
||||
break;
|
||||
#if defined(SOL1_PIN) && SOL1_PIN > -1
|
||||
case 1:
|
||||
OUT_WRITE(SOL1_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(SOL2_PIN) && SOL2_PIN > -1
|
||||
case 2:
|
||||
OUT_WRITE(SOL2_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(SOL3_PIN) && SOL3_PIN > -1
|
||||
case 3:
|
||||
OUT_WRITE(SOL3_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void enable_solenoid_on_active_extruder() { enable_solenoid(active_extruder); }
|
||||
|
||||
void disable_all_solenoids() {
|
||||
OUT_WRITE(SOL0_PIN, LOW);
|
||||
OUT_WRITE(SOL1_PIN, LOW);
|
||||
OUT_WRITE(SOL2_PIN, LOW);
|
||||
OUT_WRITE(SOL3_PIN, LOW);
|
||||
}
|
||||
|
||||
/**
|
||||
* M380: Enable solenoid on the active extruder
|
||||
*/
|
||||
inline void gcode_M380() { enable_solenoid_on_active_extruder(); }
|
||||
|
||||
/**
|
||||
* M381: Disable all solenoids
|
||||
*/
|
||||
inline void gcode_M381() { disable_all_solenoids(); }
|
||||
|
||||
#endif // EXT_SOLENOID
|
||||
|
||||
case 400: // M400 finish all moves
|
||||
{
|
||||
st_synchronize();
|
||||
}
|
||||
break;
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && defined(SERVO_ENDSTOPS) && not defined(Z_PROBE_SLED)
|
||||
case 401:
|
||||
{
|
||||
engage_z_probe(); // Engage Z Servo endstop if available
|
||||
}
|
||||
break;
|
||||
/**
|
||||
* M400: Finish all moves
|
||||
*/
|
||||
inline void gcode_M400() { st_synchronize(); }
|
||||
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && defined(SERVO_ENDSTOPS) && not defined(Z_PROBE_SLED)
|
||||
|
||||
/**
|
||||
* M401: Engage Z Servo endstop if available
|
||||
*/
|
||||
inline void gcode_M401() { engage_z_probe(); }
|
||||
/**
|
||||
* M402: Retract Z Servo endstop if enabled
|
||||
*/
|
||||
inline void gcode_M402() { retract_z_probe(); }
|
||||
|
||||
case 402:
|
||||
{
|
||||
retract_z_probe(); // Retract Z Servo endstop if enabled
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef FILAMENT_SENSOR
|
||||
case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or display nominal filament width
|
||||
{
|
||||
#if (FILWIDTH_PIN > -1)
|
||||
if(code_seen('N')) filament_width_nominal=code_value();
|
||||
|
||||
/**
|
||||
* M404: Display or set the nominal filament width (3mm, 1.75mm ) N<3.0>
|
||||
*/
|
||||
inline void gcode_M404() {
|
||||
#if FILWIDTH_PIN > -1
|
||||
if (code_seen('N')) {
|
||||
filament_width_nominal = code_value();
|
||||
}
|
||||
else {
|
||||
SERIAL_PROTOCOLPGM("Filament dia (nominal mm):");
|
||||
SERIAL_PROTOCOLLN(filament_width_nominal);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
case 405: //M405 Turn on filament sensor for control
|
||||
{
|
||||
|
||||
|
||||
/**
|
||||
* M405: Turn on filament sensor for control
|
||||
*/
|
||||
inline void gcode_M405() {
|
||||
if (code_seen('D')) meas_delay_cm = code_value();
|
||||
if (meas_delay_cm > MAX_MEASUREMENT_DELAY) meas_delay_cm = MAX_MEASUREMENT_DELAY;
|
||||
|
||||
if(meas_delay_cm> MAX_MEASUREMENT_DELAY)
|
||||
meas_delay_cm = MAX_MEASUREMENT_DELAY;
|
||||
|
||||
if(delay_index2 == -1) //initialize the ring buffer if it has not been done since startup
|
||||
{
|
||||
if (delay_index2 == -1) { //initialize the ring buffer if it has not been done since startup
|
||||
int temp_ratio = widthFil_to_size_ratio();
|
||||
|
||||
for (delay_index1=0; delay_index1<(MAX_MEASUREMENT_DELAY+1); ++delay_index1 ){
|
||||
for (delay_index1 = 0; delay_index1 < MAX_MEASUREMENT_DELAY + 1; ++delay_index1)
|
||||
measurement_delay[delay_index1] = temp_ratio - 100; //subtract 100 to scale within a signed byte
|
||||
}
|
||||
delay_index1=0;
|
||||
delay_index2=0;
|
||||
|
||||
delay_index1 = delay_index2 = 0;
|
||||
}
|
||||
|
||||
filament_sensor = true;
|
||||
|
|
@ -3706,73 +3856,74 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
//SERIAL_PROTOCOLPGM("Extrusion ratio(%):");
|
||||
//SERIAL_PROTOCOL(extrudemultiply);
|
||||
}
|
||||
break;
|
||||
|
||||
case 406: //M406 Turn off filament sensor for control
|
||||
{
|
||||
filament_sensor = false ;
|
||||
}
|
||||
break;
|
||||
|
||||
case 407: //M407 Display measured filament diameter
|
||||
{
|
||||
|
||||
|
||||
/**
|
||||
* M406: Turn off filament sensor for control
|
||||
*/
|
||||
inline void gcode_M406() { filament_sensor = false; }
|
||||
|
||||
/**
|
||||
* M407: Get measured filament diameter on serial output
|
||||
*/
|
||||
inline void gcode_M407() {
|
||||
SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
|
||||
SERIAL_PROTOCOLLN(filament_width_meas);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
#endif // FILAMENT_SENSOR
|
||||
|
||||
|
||||
|
||||
|
||||
case 500: // M500 Store settings in EEPROM
|
||||
{
|
||||
/**
|
||||
* M500: Store settings in EEPROM
|
||||
*/
|
||||
inline void gcode_M500() {
|
||||
Config_StoreSettings();
|
||||
}
|
||||
break;
|
||||
case 501: // M501 Read settings from EEPROM
|
||||
{
|
||||
|
||||
/**
|
||||
* M501: Read settings from EEPROM
|
||||
*/
|
||||
inline void gcode_M501() {
|
||||
Config_RetrieveSettings();
|
||||
}
|
||||
break;
|
||||
case 502: // M502 Revert to default settings
|
||||
{
|
||||
|
||||
/**
|
||||
* M502: Revert to default settings
|
||||
*/
|
||||
inline void gcode_M502() {
|
||||
Config_ResetDefault();
|
||||
}
|
||||
break;
|
||||
case 503: // M503 print settings currently in memory
|
||||
{
|
||||
|
||||
/**
|
||||
* M503: print settings currently in memory
|
||||
*/
|
||||
inline void gcode_M503() {
|
||||
Config_PrintSettings(code_seen('S') && code_value == 0);
|
||||
}
|
||||
break;
|
||||
|
||||
#ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
|
||||
case 540:
|
||||
{
|
||||
if(code_seen('S')) abort_on_endstop_hit = code_value() > 0;
|
||||
|
||||
/**
|
||||
* M540: Set whether SD card print should abort on endstop hit (M540 S<0|1>)
|
||||
*/
|
||||
inline void gcode_M540() {
|
||||
if (code_seen('S')) abort_on_endstop_hit = (code_value() > 0);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
#endif // ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
|
||||
|
||||
#ifdef CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
|
||||
case CUSTOM_M_CODE_SET_Z_PROBE_OFFSET:
|
||||
{
|
||||
|
||||
inline void gcode_SET_Z_PROBE_OFFSET() {
|
||||
float value;
|
||||
if (code_seen('Z'))
|
||||
{
|
||||
if (code_seen('Z')) {
|
||||
value = code_value();
|
||||
if ((Z_PROBE_OFFSET_RANGE_MIN <= value) && (value <= Z_PROBE_OFFSET_RANGE_MAX))
|
||||
{
|
||||
if (Z_PROBE_OFFSET_RANGE_MIN <= value && value <= Z_PROBE_OFFSET_RANGE_MAX) {
|
||||
zprobe_zoffset = -value; // compare w/ line 278 of ConfigurationStore.cpp
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_ZPROBE_ZOFFSET " " MSG_OK);
|
||||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET);
|
||||
SERIAL_ECHOPGM(MSG_Z_MIN);
|
||||
|
|
@ -3782,20 +3933,22 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_ZPROBE_ZOFFSET " : ");
|
||||
SERIAL_ECHO(-zprobe_zoffset);
|
||||
SERIAL_PROTOCOLLN("");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
#endif // CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
|
||||
|
||||
#ifdef FILAMENTCHANGEENABLE
|
||||
case 600: //Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
|
||||
{
|
||||
|
||||
/**
|
||||
* M600: Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
|
||||
*/
|
||||
inline void gcode_M600() {
|
||||
float target[NUM_AXIS], lastpos[NUM_AXIS], fr60 = feedrate / 60;
|
||||
for (int i=0; i<NUM_AXIS; i++)
|
||||
target[i] = lastpos[i] = current_position[i];
|
||||
|
|
@ -3808,65 +3961,38 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
#endif
|
||||
|
||||
//retract by E
|
||||
if(code_seen('E'))
|
||||
{
|
||||
target[E_AXIS]+= code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (code_seen('E')) target[E_AXIS] += code_value();
|
||||
#ifdef FILAMENTCHANGE_FIRSTRETRACT
|
||||
target[E_AXIS]+= FILAMENTCHANGE_FIRSTRETRACT ;
|
||||
else target[E_AXIS] += FILAMENTCHANGE_FIRSTRETRACT;
|
||||
#endif
|
||||
}
|
||||
|
||||
RUNPLAN;
|
||||
|
||||
//lift Z
|
||||
if(code_seen('Z'))
|
||||
{
|
||||
target[Z_AXIS]+= code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (code_seen('Z')) target[Z_AXIS] += code_value();
|
||||
#ifdef FILAMENTCHANGE_ZADD
|
||||
target[Z_AXIS]+= FILAMENTCHANGE_ZADD ;
|
||||
else target[Z_AXIS] += FILAMENTCHANGE_ZADD;
|
||||
#endif
|
||||
}
|
||||
|
||||
RUNPLAN;
|
||||
|
||||
//move xy
|
||||
if(code_seen('X'))
|
||||
{
|
||||
target[X_AXIS]= code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (code_seen('X')) target[X_AXIS] = code_value();
|
||||
#ifdef FILAMENTCHANGE_XPOS
|
||||
target[X_AXIS]= FILAMENTCHANGE_XPOS ;
|
||||
else target[X_AXIS] = FILAMENTCHANGE_XPOS;
|
||||
#endif
|
||||
}
|
||||
if(code_seen('Y'))
|
||||
{
|
||||
target[Y_AXIS]= code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
if (code_seen('Y')) target[Y_AXIS] = code_value();
|
||||
#ifdef FILAMENTCHANGE_YPOS
|
||||
target[Y_AXIS]= FILAMENTCHANGE_YPOS ;
|
||||
else target[Y_AXIS] = FILAMENTCHANGE_YPOS;
|
||||
#endif
|
||||
}
|
||||
|
||||
RUNPLAN;
|
||||
|
||||
if(code_seen('L'))
|
||||
{
|
||||
target[E_AXIS]+= code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (code_seen('L')) target[E_AXIS] += code_value();
|
||||
#ifdef FILAMENTCHANGE_FINALRETRACT
|
||||
target[E_AXIS]+= FILAMENTCHANGE_FINALRETRACT ;
|
||||
else target[E_AXIS] += FILAMENTCHANGE_FINALRETRACT;
|
||||
#endif
|
||||
}
|
||||
|
||||
RUNPLAN;
|
||||
|
||||
|
|
@ -3885,8 +4011,7 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
manage_heater();
|
||||
manage_inactivity(true);
|
||||
lcd_update();
|
||||
if(cnt==0)
|
||||
{
|
||||
if (cnt == 0) {
|
||||
#if BEEPER > 0
|
||||
OUT_WRITE(BEEPER,HIGH);
|
||||
delay(3);
|
||||
|
|
@ -3900,25 +4025,19 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
} // while(!lcd_clicked)
|
||||
|
||||
//return to normal
|
||||
if(code_seen('L'))
|
||||
{
|
||||
target[E_AXIS]+= -code_value();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (code_seen('L')) target[E_AXIS] -= code_value();
|
||||
#ifdef FILAMENTCHANGE_FINALRETRACT
|
||||
target[E_AXIS]+=(-1)*FILAMENTCHANGE_FINALRETRACT ;
|
||||
else target[E_AXIS] -= 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]);
|
||||
|
||||
RUNPLAN; //should do nothing
|
||||
|
||||
//reset LCD alert message
|
||||
lcd_reset_alert_level();
|
||||
|
||||
#ifdef DELTA
|
||||
|
|
@ -3931,32 +4050,30 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
plan_buffer_line(lastpos[X_AXIS], lastpos[Y_AXIS], lastpos[Z_AXIS], lastpos[E_AXIS], fr60, active_extruder); //final untretract
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
#endif // FILAMENTCHANGEENABLE
|
||||
|
||||
#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
|
||||
// millimeters x-offset and an optional differential hotend temperature of
|
||||
// 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.
|
||||
{
|
||||
|
||||
/**
|
||||
* M605: Set dual x-carriage movement mode
|
||||
*
|
||||
* M605 S0: Full control mode. The slicer has full control over x-carriage movement
|
||||
* M605 S1: Auto-park mode. The inactive head will auto park/unpark without slicer involvement
|
||||
* M605 S2 [Xnnn] [Rmmm]: Duplication mode. The second extruder will duplicate the first with nnn
|
||||
* millimeters x-offset and an optional differential hotend temperature of
|
||||
* mmm degrees. E.g., with "M605 S2 X100 R2" the second extruder will duplicate
|
||||
* the first with a spacing of 100mm in the x direction and 2 degrees hotter.
|
||||
*
|
||||
* Note: the X axis should be homed after changing dual x-carriage mode.
|
||||
*/
|
||||
inline void gcode_M605() {
|
||||
st_synchronize();
|
||||
|
||||
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();
|
||||
|
||||
if (code_seen('S')) dual_x_carriage_mode = code_value();
|
||||
switch(dual_x_carriage_mode) {
|
||||
case 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();
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
|
||||
SERIAL_ECHO(" ");
|
||||
|
|
@ -3967,23 +4084,28 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
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)
|
||||
{
|
||||
break;
|
||||
case DXC_FULL_CONTROL_MODE:
|
||||
case DXC_AUTO_PARK_MODE:
|
||||
break;
|
||||
default:
|
||||
dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE;
|
||||
break;
|
||||
}
|
||||
|
||||
active_extruder_parked = false;
|
||||
extruder_duplication_enabled = false;
|
||||
delayed_move_time = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
#endif // DUAL_X_CARRIAGE
|
||||
|
||||
case 907: // M907 Set digital trimpot motor current using axis codes.
|
||||
{
|
||||
/**
|
||||
* M907: Set digital trimpot motor current using axis codes X, Y, Z, E, B, S
|
||||
*/
|
||||
inline void gcode_M907() {
|
||||
#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());
|
||||
for (int i=0;i<NUM_AXIS;i++)
|
||||
if (code_seen(axis_codes[i])) digipot_current(i, code_value());
|
||||
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
|
||||
|
|
@ -4003,19 +4125,23 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
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
|
||||
}
|
||||
break;
|
||||
case 908: // M908 Control digital trimpot directly.
|
||||
{
|
||||
|
||||
#if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1
|
||||
uint8_t channel,current;
|
||||
if(code_seen('P')) channel=code_value();
|
||||
if(code_seen('S')) current=code_value();
|
||||
digitalPotWrite(channel, current);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* M908: Control digital trimpot directly (M908 P<pin> S<current>)
|
||||
*/
|
||||
inline void gcode_M908() {
|
||||
digitalPotWrite(
|
||||
code_seen('P') ? code_value() : 0,
|
||||
code_seen('S') ? code_value() : 0
|
||||
);
|
||||
}
|
||||
break;
|
||||
case 350: // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
|
||||
{
|
||||
|
||||
#endif // DIGIPOTSS_PIN
|
||||
|
||||
// M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
|
||||
inline void gcode_M350() {
|
||||
#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());
|
||||
|
|
@ -4023,12 +4149,14 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
microstep_readings();
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
case 351: // M351 Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
|
||||
{
|
||||
|
||||
/**
|
||||
* M351: Toggle MS1 MS2 pins directly with axis codes X Y Z E B
|
||||
* S# determines MS1 or MS2, X# sets the pin high/low.
|
||||
*/
|
||||
inline void gcode_M351() {
|
||||
#if defined(X_MS1_PIN) && X_MS1_PIN > -1
|
||||
if(code_seen('S')) switch((int)code_value())
|
||||
{
|
||||
if (code_seen('S')) switch((int)code_value()) {
|
||||
case 1:
|
||||
for(int i=0;i<NUM_AXIS;i++) if (code_seen(axis_codes[i])) microstep_ms(i, code_value(), -1);
|
||||
if (code_seen('B')) microstep_ms(4, code_value(), -1);
|
||||
|
|
@ -4041,18 +4169,18 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
microstep_readings();
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
case 999: // M999: Restart after being stopped
|
||||
|
||||
/**
|
||||
* M999: Restart after being stopped
|
||||
*/
|
||||
inline void gcode_M999() {
|
||||
Stopped = false;
|
||||
lcd_reset_alert_level();
|
||||
gcode_LastN = Stopped_gcode_LastN;
|
||||
FlushSerialRequestResend();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else if(code_seen('T'))
|
||||
{
|
||||
inline void gcode_T() {
|
||||
tmp_extruder = code_value();
|
||||
if (tmp_extruder >= EXTRUDERS) {
|
||||
SERIAL_ECHO_START;
|
||||
|
|
@ -4065,9 +4193,7 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
if (code_seen('F')) {
|
||||
make_move = true;
|
||||
next_feedrate = code_value();
|
||||
if(next_feedrate > 0.0) {
|
||||
feedrate = next_feedrate;
|
||||
}
|
||||
if (next_feedrate > 0.0) feedrate = next_feedrate;
|
||||
}
|
||||
#if EXTRUDERS > 1
|
||||
if (tmp_extruder != active_extruder) {
|
||||
|
|
@ -4075,8 +4201,7 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
memcpy(destination, current_position, sizeof(destination));
|
||||
#ifdef DUAL_X_CARRIAGE
|
||||
if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && Stopped == false &&
|
||||
(delayed_move_time != 0 || current_position[X_AXIS] != x_home_pos(active_extruder)))
|
||||
{
|
||||
(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
|
||||
plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT,
|
||||
current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder);
|
||||
|
|
@ -4100,13 +4225,11 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
// This function resets the max/min values - the current position may be overwritten below.
|
||||
axis_is_at_home(X_AXIS);
|
||||
|
||||
if (dual_x_carriage_mode == DXC_FULL_CONTROL_MODE)
|
||||
{
|
||||
if (dual_x_carriage_mode == DXC_FULL_CONTROL_MODE) {
|
||||
current_position[X_AXIS] = inactive_extruder_x_pos;
|
||||
inactive_extruder_x_pos = destination[X_AXIS];
|
||||
}
|
||||
else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE)
|
||||
{
|
||||
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)
|
||||
current_position[X_AXIS] = inactive_extruder_x_pos;
|
||||
|
|
@ -4115,39 +4238,29 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
inactive_extruder_x_pos = destination[X_AXIS];
|
||||
extruder_duplication_enabled = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
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;
|
||||
}
|
||||
#else
|
||||
#else // !DUAL_X_CARRIAGE
|
||||
// Offset extruder (only by XY)
|
||||
int i;
|
||||
for(i = 0; i < 2; i++) {
|
||||
current_position[i] = current_position[i] -
|
||||
extruder_offset[i][active_extruder] +
|
||||
extruder_offset[i][tmp_extruder];
|
||||
}
|
||||
for (int i=X_AXIS; i<=Y_AXIS; i++)
|
||||
current_position[i] += extruder_offset[i][tmp_extruder] - extruder_offset[i][active_extruder];
|
||||
// Set the new active extruder and position
|
||||
active_extruder = tmp_extruder;
|
||||
#endif //else DUAL_X_CARRIAGE
|
||||
#endif // !DUAL_X_CARRIAGE
|
||||
#ifdef DELTA
|
||||
|
||||
calculate_delta(current_position); // change cartesian kinematic to delta kinematic;
|
||||
//sent position to plan_set_position();
|
||||
plan_set_position(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS],current_position[E_AXIS]);
|
||||
|
||||
#else
|
||||
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
|
||||
|
||||
#endif
|
||||
// Move to the old position if 'F' was in the parameters
|
||||
if(make_move && Stopped == false) {
|
||||
prepare_move();
|
||||
}
|
||||
if (make_move && !Stopped) prepare_move();
|
||||
}
|
||||
|
||||
#ifdef EXT_SOLENOID
|
||||
|
|
@ -4156,15 +4269,487 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp
|
|||
enable_solenoid_on_active_extruder();
|
||||
#endif // EXT_SOLENOID
|
||||
|
||||
#endif
|
||||
#endif // EXTRUDERS > 1
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHO(MSG_ACTIVE_EXTRUDER);
|
||||
SERIAL_PROTOCOLLN((int)active_extruder);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
/**
|
||||
* Process Commands and dispatch them to handlers
|
||||
*/
|
||||
void process_commands() {
|
||||
if (code_seen('G')) {
|
||||
|
||||
int gCode = code_value_long();
|
||||
|
||||
switch(gCode) {
|
||||
|
||||
// G0, G1
|
||||
case 0:
|
||||
case 1:
|
||||
gcode_G0_G1();
|
||||
break;
|
||||
|
||||
// G2, G3
|
||||
#ifndef SCARA
|
||||
case 2: // G2 - CW ARC
|
||||
case 3: // G3 - CCW ARC
|
||||
gcode_G2_G3(gCode == 2);
|
||||
break;
|
||||
#endif
|
||||
|
||||
// G4 Dwell
|
||||
case 4:
|
||||
gcode_G4();
|
||||
break;
|
||||
|
||||
#ifdef FWRETRACT
|
||||
|
||||
case 10: // G10: retract
|
||||
case 11: // G11: retract_recover
|
||||
gcode_G10_G11(gCode == 10);
|
||||
break;
|
||||
|
||||
#endif //FWRETRACT
|
||||
|
||||
case 28: // G28: Home all axes, one at a time
|
||||
gcode_G28();
|
||||
break;
|
||||
|
||||
#ifdef ENABLE_AUTO_BED_LEVELING
|
||||
|
||||
case 29: // G29 Detailed Z-Probe, probes the bed at 3 or more points.
|
||||
gcode_G29();
|
||||
break;
|
||||
|
||||
#ifndef Z_PROBE_SLED
|
||||
|
||||
case 30: // G30 Single Z Probe
|
||||
gcode_G30();
|
||||
break;
|
||||
|
||||
#else // Z_PROBE_SLED
|
||||
|
||||
case 31: // G31: dock the sled
|
||||
case 32: // G32: undock the sled
|
||||
dock_sled(gCode == 31);
|
||||
break;
|
||||
|
||||
#endif // Z_PROBE_SLED
|
||||
|
||||
#endif // ENABLE_AUTO_BED_LEVELING
|
||||
|
||||
case 90: // G90
|
||||
relative_mode = false;
|
||||
break;
|
||||
case 91: // G91
|
||||
relative_mode = true;
|
||||
break;
|
||||
|
||||
case 92: // G92
|
||||
gcode_G92();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else if (code_seen('M')) {
|
||||
switch( (int)code_value() ) {
|
||||
#ifdef ULTIPANEL
|
||||
case 0: // M0 - Unconditional stop - Wait for user button press on LCD
|
||||
case 1: // M1 - Conditional stop - Wait for user button press on LCD
|
||||
gcode_M0_M1();
|
||||
break;
|
||||
#endif // ULTIPANEL
|
||||
|
||||
case 17:
|
||||
gcode_M17();
|
||||
break;
|
||||
|
||||
#ifdef SDSUPPORT
|
||||
|
||||
case 20: // M20 - list SD card
|
||||
gcode_M20(); break;
|
||||
case 21: // M21 - init SD card
|
||||
gcode_M21(); break;
|
||||
case 22: //M22 - release SD card
|
||||
gcode_M22(); break;
|
||||
case 23: //M23 - Select file
|
||||
gcode_M23(); break;
|
||||
case 24: //M24 - Start SD print
|
||||
gcode_M24(); break;
|
||||
case 25: //M25 - Pause SD print
|
||||
gcode_M25(); break;
|
||||
case 26: //M26 - Set SD index
|
||||
gcode_M26(); break;
|
||||
case 27: //M27 - Get SD status
|
||||
gcode_M27(); break;
|
||||
case 28: //M28 - Start SD write
|
||||
gcode_M28(); break;
|
||||
case 29: //M29 - Stop SD write
|
||||
gcode_M29(); break;
|
||||
case 30: //M30 <filename> Delete File
|
||||
gcode_M30(); break;
|
||||
case 32: //M32 - Select file and start SD print
|
||||
gcode_M32(); break;
|
||||
case 928: //M928 - Start SD write
|
||||
gcode_M928(); break;
|
||||
|
||||
#endif //SDSUPPORT
|
||||
|
||||
case 31: //M31 take time since the start of the SD print or an M109 command
|
||||
gcode_M31();
|
||||
break;
|
||||
|
||||
case 42: //M42 -Change pin status via gcode
|
||||
gcode_M42();
|
||||
break;
|
||||
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && defined(Z_PROBE_REPEATABILITY_TEST)
|
||||
case 48: // M48 Z-Probe repeatability
|
||||
gcode_M48();
|
||||
break;
|
||||
#endif // ENABLE_AUTO_BED_LEVELING && Z_PROBE_REPEATABILITY_TEST
|
||||
|
||||
case 104: // M104
|
||||
gcode_M104();
|
||||
break;
|
||||
|
||||
case 112: // M112 Emergency Stop
|
||||
gcode_M112();
|
||||
break;
|
||||
|
||||
case 140: // M140 Set bed temp
|
||||
gcode_M140();
|
||||
break;
|
||||
|
||||
case 105: // M105 Read current temperature
|
||||
gcode_M105();
|
||||
return;
|
||||
break;
|
||||
|
||||
case 109: // M109 Wait for temperature
|
||||
gcode_M109();
|
||||
break;
|
||||
|
||||
#if defined(TEMP_BED_PIN) && TEMP_BED_PIN > -1
|
||||
case 190: // M190 - Wait for bed heater to reach target.
|
||||
gcode_M190();
|
||||
break;
|
||||
#endif //TEMP_BED_PIN
|
||||
|
||||
#if defined(FAN_PIN) && FAN_PIN > -1
|
||||
case 106: //M106 Fan On
|
||||
gcode_M106();
|
||||
break;
|
||||
case 107: //M107 Fan Off
|
||||
gcode_M107();
|
||||
break;
|
||||
#endif //FAN_PIN
|
||||
|
||||
#ifdef BARICUDA
|
||||
// PWM for HEATER_1_PIN
|
||||
#if defined(HEATER_1_PIN) && HEATER_1_PIN > -1
|
||||
case 126: // M126 valve open
|
||||
gcode_M126();
|
||||
break;
|
||||
case 127: // M127 valve closed
|
||||
gcode_M127();
|
||||
break;
|
||||
#endif //HEATER_1_PIN
|
||||
|
||||
// PWM for HEATER_2_PIN
|
||||
#if defined(HEATER_2_PIN) && HEATER_2_PIN > -1
|
||||
case 128: // M128 valve open
|
||||
gcode_M128();
|
||||
break;
|
||||
case 129: // M129 valve closed
|
||||
gcode_M129();
|
||||
break;
|
||||
#endif //HEATER_2_PIN
|
||||
#endif //BARICUDA
|
||||
|
||||
#if defined(PS_ON_PIN) && PS_ON_PIN > -1
|
||||
|
||||
case 80: // M80 - Turn on Power Supply
|
||||
gcode_M80();
|
||||
break;
|
||||
|
||||
#endif // PS_ON_PIN
|
||||
|
||||
case 81: // M81 - Turn off Power Supply
|
||||
gcode_M81();
|
||||
break;
|
||||
|
||||
case 82:
|
||||
gcode_M82();
|
||||
break;
|
||||
case 83:
|
||||
gcode_M83();
|
||||
break;
|
||||
case 18: //compatibility
|
||||
case 84: // M84
|
||||
gcode_M18_M84();
|
||||
break;
|
||||
case 85: // M85
|
||||
gcode_M85();
|
||||
break;
|
||||
case 92: // M92
|
||||
gcode_M92();
|
||||
break;
|
||||
case 115: // M115
|
||||
gcode_M115();
|
||||
break;
|
||||
case 117: // M117 display message
|
||||
gcode_M117();
|
||||
break;
|
||||
case 114: // M114
|
||||
gcode_M114();
|
||||
break;
|
||||
case 120: // M120
|
||||
gcode_M120();
|
||||
break;
|
||||
case 121: // M121
|
||||
gcode_M121();
|
||||
break;
|
||||
case 119: // M119
|
||||
gcode_M119();
|
||||
break;
|
||||
//TODO: update for all axis, use for loop
|
||||
|
||||
#ifdef BLINKM
|
||||
|
||||
case 150: // M150
|
||||
gcode_M150();
|
||||
break;
|
||||
|
||||
#endif //BLINKM
|
||||
|
||||
case 200: // M200 D<millimeters> set filament diameter and set E axis units to cubic millimeters (use S0 to set back to millimeters).
|
||||
gcode_M200();
|
||||
break;
|
||||
case 201: // M201
|
||||
gcode_M201();
|
||||
break;
|
||||
#if 0 // Not used for Sprinter/grbl gen6
|
||||
case 202: // M202
|
||||
gcode_M202();
|
||||
break;
|
||||
#endif
|
||||
case 203: // M203 max feedrate mm/sec
|
||||
gcode_M203();
|
||||
break;
|
||||
case 204: // M204 acclereration S normal moves T filmanent only moves
|
||||
gcode_M204();
|
||||
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
|
||||
gcode_M205();
|
||||
break;
|
||||
case 206: // M206 additional homing offset
|
||||
gcode_M206();
|
||||
break;
|
||||
|
||||
#ifdef DELTA
|
||||
case 665: // M665 set delta configurations L<diagonal_rod> R<delta_radius> S<segments_per_sec>
|
||||
gcode_M665();
|
||||
break;
|
||||
case 666: // M666 set delta endstop adjustment
|
||||
gcode_M666();
|
||||
break;
|
||||
#endif // DELTA
|
||||
|
||||
#ifdef FWRETRACT
|
||||
case 207: //M207 - set retract length S[positive mm] F[feedrate mm/min] Z[additional zlift/hop]
|
||||
gcode_M207();
|
||||
break;
|
||||
case 208: // M208 - set retract recover length S[positive mm surplus to the M207 S*] F[feedrate mm/min]
|
||||
gcode_M208();
|
||||
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.
|
||||
gcode_M209();
|
||||
break;
|
||||
#endif // FWRETRACT
|
||||
|
||||
#if EXTRUDERS > 1
|
||||
case 218: // M218 - set hotend offset (in mm), T<extruder_number> X<offset_on_X> Y<offset_on_Y>
|
||||
gcode_M218();
|
||||
break;
|
||||
#endif
|
||||
|
||||
case 220: // M220 S<factor in percent>- set speed factor override percentage
|
||||
gcode_M220();
|
||||
break;
|
||||
|
||||
case 221: // M221 S<factor in percent>- set extrude factor override percentage
|
||||
gcode_M221();
|
||||
break;
|
||||
|
||||
case 226: // M226 P<pin number> S<pin state>- Wait until the specified pin reaches the state required
|
||||
gcode_M226();
|
||||
break;
|
||||
|
||||
#if NUM_SERVOS > 0
|
||||
case 280: // M280 - set servo position absolute. P: servo index, S: angle or microseconds
|
||||
gcode_M280();
|
||||
break;
|
||||
#endif // NUM_SERVOS > 0
|
||||
|
||||
#if defined(LARGE_FLASH) && (BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER))
|
||||
case 300: // M300 - Play beep tone
|
||||
gcode_M300();
|
||||
break;
|
||||
#endif // LARGE_FLASH && (BEEPER>0 || ULTRALCD || LCD_USE_I2C_BUZZER)
|
||||
|
||||
#ifdef PIDTEMP
|
||||
case 301: // M301
|
||||
gcode_M301();
|
||||
break;
|
||||
#endif // PIDTEMP
|
||||
|
||||
#ifdef PIDTEMPBED
|
||||
case 304: // M304
|
||||
gcode_M304();
|
||||
break;
|
||||
#endif // PIDTEMPBED
|
||||
|
||||
#if defined(CHDK) || (defined(PHOTOGRAPH_PIN) && PHOTOGRAPH_PIN > -1)
|
||||
case 240: // M240 Triggers a camera by emulating a Canon RC-1 : http://www.doc-diy.net/photo/rc-1_hacked/
|
||||
gcode_M240();
|
||||
break;
|
||||
#endif // CHDK || PHOTOGRAPH_PIN
|
||||
|
||||
#ifdef DOGLCD
|
||||
case 250: // M250 Set LCD contrast value: C<value> (value 0..63)
|
||||
gcode_M250();
|
||||
break;
|
||||
#endif // DOGLCD
|
||||
|
||||
#ifdef PREVENT_DANGEROUS_EXTRUDE
|
||||
case 302: // allow cold extrudes, or set the minimum extrude temperature
|
||||
gcode_M302();
|
||||
break;
|
||||
#endif // PREVENT_DANGEROUS_EXTRUDE
|
||||
|
||||
case 303: // M303 PID autotune
|
||||
gcode_M303();
|
||||
break;
|
||||
|
||||
#ifdef SCARA
|
||||
case 360: // M360 SCARA Theta pos1
|
||||
if (gcode_M360()) return;
|
||||
break;
|
||||
case 361: // M361 SCARA Theta pos2
|
||||
if (gcode_M361()) return;
|
||||
break;
|
||||
case 362: // M362 SCARA Psi pos1
|
||||
if (gcode_M362()) return;
|
||||
break;
|
||||
case 363: // M363 SCARA Psi pos2
|
||||
if (gcode_M363()) return;
|
||||
break;
|
||||
case 364: // M364 SCARA Psi pos3 (90 deg to Theta)
|
||||
if (gcode_M364()) return;
|
||||
break;
|
||||
case 365: // M365 Set SCARA scaling for X Y Z
|
||||
gcode_M365();
|
||||
break;
|
||||
#endif // SCARA
|
||||
|
||||
case 400: // M400 finish all moves
|
||||
gcode_M400();
|
||||
break;
|
||||
|
||||
#if defined(ENABLE_AUTO_BED_LEVELING) && defined(SERVO_ENDSTOPS) && not defined(Z_PROBE_SLED)
|
||||
case 401:
|
||||
gcode_M401();
|
||||
break;
|
||||
case 402:
|
||||
gcode_M402();
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef FILAMENT_SENSOR
|
||||
case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or display nominal filament width
|
||||
gcode_M404();
|
||||
break;
|
||||
case 405: //M405 Turn on filament sensor for control
|
||||
gcode_M405();
|
||||
break;
|
||||
case 406: //M406 Turn off filament sensor for control
|
||||
gcode_M406();
|
||||
break;
|
||||
case 407: //M407 Display measured filament diameter
|
||||
gcode_M407();
|
||||
break;
|
||||
#endif // FILAMENT_SENSOR
|
||||
|
||||
case 500: // M500 Store settings in EEPROM
|
||||
gcode_M500();
|
||||
break;
|
||||
case 501: // M501 Read settings from EEPROM
|
||||
gcode_M501();
|
||||
break;
|
||||
case 502: // M502 Revert to default settings
|
||||
gcode_M502();
|
||||
break;
|
||||
case 503: // M503 print settings currently in memory
|
||||
gcode_M503();
|
||||
break;
|
||||
|
||||
#ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
|
||||
case 540:
|
||||
gcode_M540();
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
|
||||
case CUSTOM_M_CODE_SET_Z_PROBE_OFFSET:
|
||||
gcode_SET_Z_PROBE_OFFSET();
|
||||
break;
|
||||
#endif // CUSTOM_M_CODE_SET_Z_PROBE_OFFSET
|
||||
|
||||
#ifdef FILAMENTCHANGEENABLE
|
||||
case 600: //Pause for filament change X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
|
||||
gcode_M600();
|
||||
break;
|
||||
#endif // FILAMENTCHANGEENABLE
|
||||
|
||||
#ifdef DUAL_X_CARRIAGE
|
||||
case 605:
|
||||
gcode_M605();
|
||||
break;
|
||||
#endif // DUAL_X_CARRIAGE
|
||||
|
||||
case 907: // M907 Set digital trimpot motor current using axis codes.
|
||||
gcode_M907();
|
||||
break;
|
||||
|
||||
#if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1
|
||||
case 908: // M908 Control digital trimpot directly.
|
||||
gcode_M908();
|
||||
break;
|
||||
#endif // DIGIPOTSS_PIN
|
||||
|
||||
case 350: // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
|
||||
gcode_M350();
|
||||
break;
|
||||
|
||||
case 351: // M351 Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
|
||||
gcode_M351();
|
||||
break;
|
||||
|
||||
case 999: // M999: Restart after being Stopped
|
||||
gcode_M999();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else if (code_seen('T')) {
|
||||
gcode_T();
|
||||
}
|
||||
|
||||
else {
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOPGM(MSG_UNKNOWN_COMMAND);
|
||||
SERIAL_ECHO(cmdbuffer[bufindr]);
|
||||
|
|
@ -4875,43 +5460,3 @@ void calculate_volumetric_multipliers() {
|
|||
for (int i=0; i<EXTRUDERS; i++)
|
||||
volumetric_multiplier[i] = calculate_volumetric_multiplier(filament_size[i]);
|
||||
}
|
||||
|
||||
#ifdef EXT_SOLENOID
|
||||
|
||||
void enable_solenoid(uint8_t num) {
|
||||
switch(num) {
|
||||
case 0:
|
||||
OUT_WRITE(SOL0_PIN, HIGH);
|
||||
break;
|
||||
#if defined(SOL1_PIN) && SOL1_PIN > -1
|
||||
case 1:
|
||||
OUT_WRITE(SOL1_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(SOL2_PIN) && SOL2_PIN > -1
|
||||
case 2:
|
||||
OUT_WRITE(SOL2_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
#if defined(SOL3_PIN) && SOL3_PIN > -1
|
||||
case 3:
|
||||
OUT_WRITE(SOL3_PIN, HIGH);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
SERIAL_ECHO_START;
|
||||
SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void enable_solenoid_on_active_extruder() { enable_solenoid(active_extruder); }
|
||||
|
||||
void disable_all_solenoids() {
|
||||
OUT_WRITE(SOL0_PIN, LOW);
|
||||
OUT_WRITE(SOL1_PIN, LOW);
|
||||
OUT_WRITE(SOL2_PIN, LOW);
|
||||
OUT_WRITE(SOL3_PIN, LOW);
|
||||
}
|
||||
|
||||
#endif //EXT_SOLENOID
|
||||
|
|
|
|||
Reference in a new issue