andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Apply three more commits

pull/1/head
Scott Lahteine 10 years ago
parent
e7aae314de
commit
ccddc280be
14 changed files with 340 additions and 374 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      Marlin/Marlin.h
  2. 361
      Marlin/Marlin_main.cpp
  3. 10
      Marlin/cardreader.cpp
  4. 2
      Marlin/cardreader.h
  5. 2
      Marlin/dogm_lcd_implementation.h
  6. 4
      Marlin/example_configurations/Hephestos/Configuration.h
  7. 4
      Marlin/example_configurations/WITBOX/Configuration.h
  8. 26
      Marlin/planner.cpp
  9. 2
      Marlin/planner.h
  10. 6
      Marlin/stepper.cpp
  11. 48
      Marlin/temperature.cpp
  12. 69
      Marlin/ultralcd.cpp
  13. 3
      Marlin/ultralcd.h
  14. 29
      Marlin/ultralcd_implementation_hitachi_HD44780.h

16
Marlin/Marlin.h
View File

@ -31,6 +31,10 @@
#define TEST(n,b) (((n)&BIT(b))!=0) #define TEST(n,b) (((n)&BIT(b))!=0)
#define RADIANS(d) ((d)*M_PI/180.0) #define RADIANS(d) ((d)*M_PI/180.0)
#define DEGREES(r) ((d)*180.0/M_PI) #define DEGREES(r) ((d)*180.0/M_PI)
#define NOLESS(v,n) do{ if (v < n) v = n; }while(0)
#define NOMORE(v,n) do{ if (v > n) v = n; }while(0)
typedef unsigned long millis_t;
// Arduino < 1.0.0 does not define this, so we need to do it ourselves // Arduino < 1.0.0 does not define this, so we need to do it ourselves
#ifndef analogInputToDigitalPin #ifndef analogInputToDigitalPin
@ -223,14 +227,14 @@ extern bool Running;
inline bool IsRunning() { return Running; } inline bool IsRunning() { return Running; }
inline bool IsStopped() { return !Running; } inline bool IsStopped() { return !Running; }
bool enquecommand(const char *cmd); //put a single ASCII command at the end of the current buffer or return false when it is full bool enqueuecommand(const char *cmd); //put a single ASCII command at the end of the current buffer or return false when it is full
void enquecommands_P(const char *cmd); //put one or many ASCII commands at the end of the current buffer, read from flash void enqueuecommands_P(const char *cmd); //put one or many ASCII commands at the end of the current buffer, read from flash
void prepare_arc_move(char isclockwise); void prepare_arc_move(char isclockwise);
void clamp_to_software_endstops(float target[3]); void clamp_to_software_endstops(float target[3]);
extern unsigned long previous_millis_cmd; extern millis_t previous_cmd_ms;
inline void refresh_cmd_timeout() { previous_millis_cmd = millis(); } inline void refresh_cmd_timeout() { previous_cmd_ms = millis(); }
#ifdef FAST_PWM_FAN #ifdef FAST_PWM_FAN
void setPwmFrequency(uint8_t pin, int val); void setPwmFrequency(uint8_t pin, int val);
@ -305,8 +309,8 @@ extern int fanSpeed;
extern float retract_recover_length, retract_recover_length_swap, retract_recover_feedrate; extern float retract_recover_length, retract_recover_length_swap, retract_recover_feedrate;
#endif #endif
extern unsigned long starttime; extern millis_t starttime;
extern unsigned long stoptime; extern millis_t stoptime;
// Handling multiple extruders pins // Handling multiple extruders pins
extern uint8_t active_extruder; extern uint8_t active_extruder;

361
Marlin/Marlin_main.cpp
View File

@ -244,11 +244,11 @@ static char *strchr_pointer; ///< A pointer to find chars in the command string
const char* queued_commands_P= NULL; /* pointer to the current line in the active sequence of commands, or NULL when none */ const char* queued_commands_P= NULL; /* pointer to the current line in the active sequence of commands, or NULL when none */
const int sensitive_pins[] = SENSITIVE_PINS; ///< Sensitive pin list for M42 const int sensitive_pins[] = SENSITIVE_PINS; ///< Sensitive pin list for M42
// Inactivity shutdown // Inactivity shutdown
unsigned long previous_millis_cmd = 0; millis_t previous_cmd_ms = 0;
static unsigned long max_inactive_time = 0; static millis_t max_inactive_time = 0;
static unsigned long stepper_inactive_time = DEFAULT_STEPPER_DEACTIVE_TIME*1000l; static millis_t stepper_inactive_time = DEFAULT_STEPPER_DEACTIVE_TIME * 1000L;
unsigned long starttime = 0; ///< Print job start time millis_t starttime = 0; ///< Print job start time
unsigned long stoptime = 0; ///< Print job stop time millis_t stoptime = 0; ///< Print job stop time
static uint8_t target_extruder; static uint8_t target_extruder;
bool CooldownNoWait = true; bool CooldownNoWait = true;
bool target_direction; bool target_direction;
@ -425,7 +425,7 @@ static bool drain_queued_commands_P() {
char c; char c;
while((c = cmd[i]) && c != '\n') i++; // find the end of this gcode command while((c = cmd[i]) && c != '\n') i++; // find the end of this gcode command
cmd[i] = '\0'; cmd[i] = '\0';
if (enquecommand(cmd)) { // buffer was not full (else we will retry later) if (enqueuecommand(cmd)) { // buffer was not full (else we will retry later)
if (c) if (c)
queued_commands_P += i + 1; // move to next command queued_commands_P += i + 1; // move to next command
else else
@ -437,7 +437,7 @@ static bool drain_queued_commands_P() {
//Record one or many commands to run from program memory. //Record one or many commands to run from program memory.
//Aborts the current queue, if any. //Aborts the current queue, if any.
//Note: drain_queued_commands_P() must be called repeatedly to drain the commands afterwards //Note: drain_queued_commands_P() must be called repeatedly to drain the commands afterwards
void enquecommands_P(const char* pgcode) { void enqueuecommands_P(const char* pgcode) {
queued_commands_P = pgcode; queued_commands_P = pgcode;
drain_queued_commands_P(); // first command executed asap (when possible) drain_queued_commands_P(); // first command executed asap (when possible)
} }
@ -446,7 +446,7 @@ void enquecommands_P(const char* pgcode) {
//that is really done in a non-safe way. //that is really done in a non-safe way.
//needs overworking someday //needs overworking someday
//Returns false if it failed to do so //Returns false if it failed to do so
bool enquecommand(const char *cmd) bool enqueuecommand(const char *cmd)
{ {
if(*cmd==';') if(*cmd==';')
return false; return false;
@ -666,33 +666,30 @@ void loop() {
lcd_update(); lcd_update();
} }
void get_command() void get_command() {
{
if (drain_queued_commands_P()) // priority is given to non-serial commands
return;
while( MYSERIAL.available() > 0 && buflen < BUFSIZE) { if (drain_queued_commands_P()) return; // priority is given to non-serial commands
while (MYSERIAL.available() > 0 && buflen < BUFSIZE) {
serial_char = MYSERIAL.read(); serial_char = MYSERIAL.read();
if(serial_char == '\n' || if (serial_char == '\n' || serial_char == '\r' ||
serial_char == '\r' || serial_count >= (MAX_CMD_SIZE - 1)
serial_count >= (MAX_CMD_SIZE - 1) ) ) {
{
// end of line == end of comment // end of line == end of comment
comment_mode = false; comment_mode = false;
if(!serial_count) { if (!serial_count) return; // shortcut for empty lines
// short cut for empty lines
return; cmdbuffer[bufindw][serial_count] = 0; // terminate string
}
cmdbuffer[bufindw][serial_count] = 0; //terminate string
#ifdef SDSUPPORT #ifdef SDSUPPORT
fromsd[bufindw] = false; fromsd[bufindw] = false;
#endif //!SDSUPPORT #endif
if(strchr(cmdbuffer[bufindw], 'N') != NULL)
{ if (strchr(cmdbuffer[bufindw], 'N') != NULL) {
strchr_pointer = strchr(cmdbuffer[bufindw], 'N'); strchr_pointer = strchr(cmdbuffer[bufindw], 'N');
gcode_N = (strtol(strchr_pointer + 1, NULL, 10)); gcode_N = (strtol(strchr_pointer + 1, NULL, 10));
if(gcode_N != gcode_LastN+1 && (strstr_P(cmdbuffer[bufindw], PSTR("M110")) == NULL) ) { if (gcode_N != gcode_LastN + 1 && strstr_P(cmdbuffer[bufindw], PSTR("M110")) == NULL) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORPGM(MSG_ERR_LINE_NO); SERIAL_ERRORPGM(MSG_ERR_LINE_NO);
SERIAL_ERRORLN(gcode_LastN); SERIAL_ERRORLN(gcode_LastN);
@ -702,14 +699,13 @@ void get_command()
return; return;
} }
if(strchr(cmdbuffer[bufindw], '*') != NULL) if (strchr(cmdbuffer[bufindw], '*') != NULL) {
{
byte checksum = 0; byte checksum = 0;
byte count = 0; byte count = 0;
while(cmdbuffer[bufindw][count] != '*') checksum = checksum^cmdbuffer[bufindw][count++]; while (cmdbuffer[bufindw][count] != '*') checksum ^= cmdbuffer[bufindw][count++];
strchr_pointer = strchr(cmdbuffer[bufindw], '*'); strchr_pointer = strchr(cmdbuffer[bufindw], '*');
if(strtol(strchr_pointer + 1, NULL, 10) != checksum) { if (strtol(strchr_pointer + 1, NULL, 10) != checksum) {
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORPGM(MSG_ERR_CHECKSUM_MISMATCH); SERIAL_ERRORPGM(MSG_ERR_CHECKSUM_MISMATCH);
SERIAL_ERRORLN(gcode_LastN); SERIAL_ERRORLN(gcode_LastN);
@ -719,8 +715,7 @@ void get_command()
} }
//if no errors, continue parsing //if no errors, continue parsing
} }
else else {
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORPGM(MSG_ERR_NO_CHECKSUM); SERIAL_ERRORPGM(MSG_ERR_NO_CHECKSUM);
SERIAL_ERRORLN(gcode_LastN); SERIAL_ERRORLN(gcode_LastN);
@ -732,10 +727,8 @@ void get_command()
gcode_LastN = gcode_N; gcode_LastN = gcode_N;
//if no errors, continue parsing //if no errors, continue parsing
} }
else // if we don't receive 'N' but still see '*' else { // if we don't receive 'N' but still see '*'
{ if ((strchr(cmdbuffer[bufindw], '*') != NULL)) {
if((strchr(cmdbuffer[bufindw], '*') != NULL))
{
SERIAL_ERROR_START; SERIAL_ERROR_START;
SERIAL_ERRORPGM(MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM); SERIAL_ERRORPGM(MSG_ERR_NO_LINENUMBER_WITH_CHECKSUM);
SERIAL_ERRORLN(gcode_LastN); SERIAL_ERRORLN(gcode_LastN);
@ -743,9 +736,10 @@ void get_command()
return; return;
} }
} }
if((strchr(cmdbuffer[bufindw], 'G') != NULL)){
if (strchr(cmdbuffer[bufindw], 'G') != NULL) {
strchr_pointer = strchr(cmdbuffer[bufindw], 'G'); strchr_pointer = strchr(cmdbuffer[bufindw], 'G');
switch(strtol(strchr_pointer + 1, NULL, 10)){ switch (strtol(strchr_pointer + 1, NULL, 10)) {
case 0: case 0:
case 1: case 1:
case 2: case 2:
@ -758,96 +752,83 @@ void get_command()
default: default:
break; break;
} }
} }
//If command was e-stop process now // If command was e-stop process now
if(strcmp(cmdbuffer[bufindw], "M112") == 0) if (strcmp(cmdbuffer[bufindw], "M112") == 0) kill();
kill();
bufindw = (bufindw + 1)%BUFSIZE; bufindw = (bufindw + 1) % BUFSIZE;
buflen += 1; buflen += 1;
serial_count = 0; //clear buffer serial_count = 0; //clear buffer
} }
else if(serial_char == '\\') { //Handle escapes else if (serial_char == '\\') { // Handle escapes
if (MYSERIAL.available() > 0 && buflen < BUFSIZE) {
if(MYSERIAL.available() > 0 && buflen < BUFSIZE) {
// if we have one more character, copy it over // if we have one more character, copy it over
serial_char = MYSERIAL.read(); serial_char = MYSERIAL.read();
cmdbuffer[bufindw][serial_count++] = serial_char; cmdbuffer[bufindw][serial_count++] = serial_char;
} }
// otherwise do nothing
//otherwise do nothing
} }
else { // its not a newline, carriage return or escape char else { // its not a newline, carriage return or escape char
if(serial_char == ';') comment_mode = true; if (serial_char == ';') comment_mode = true;
if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char; if (!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
} }
} }
#ifdef SDSUPPORT #ifdef SDSUPPORT
if(!card.sdprinting || serial_count!=0){
return;
}
//'#' stops reading from SD to the buffer prematurely, so procedural macro calls are possible if (!card.sdprinting || serial_count) return;
// '#' stops reading from SD to the buffer prematurely, so procedural macro calls are possible
// if it occurs, stop_buffering is triggered and the buffer is ran dry. // if it occurs, stop_buffering is triggered and the buffer is ran dry.
// this character _can_ occur in serial com, due to checksums. however, no checksums are used in SD printing // this character _can_ occur in serial com, due to checksums. however, no checksums are used in SD printing
static bool stop_buffering=false; static bool stop_buffering = false;
if(buflen==0) stop_buffering=false; if (buflen == 0) stop_buffering = false;
while( !card.eof() && buflen < BUFSIZE && !stop_buffering) { while (!card.eof() && buflen < BUFSIZE && !stop_buffering) {
int16_t n=card.get(); int16_t n = card.get();
serial_char = (char)n; serial_char = (char)n;
if(serial_char == '\n' || if (serial_char == '\n' || serial_char == '\r' ||
serial_char == '\r' || ((serial_char == '#' || serial_char == ':') && !comment_mode) ||
(serial_char == '#' && comment_mode == false) || serial_count >= (MAX_CMD_SIZE - 1) || n == -1
(serial_char == ':' && comment_mode == false) || ) {
serial_count >= (MAX_CMD_SIZE - 1)||n==-1) if (card.eof()) {
{
if(card.eof()){
SERIAL_PROTOCOLLNPGM(MSG_FILE_PRINTED); SERIAL_PROTOCOLLNPGM(MSG_FILE_PRINTED);
stoptime=millis(); stoptime = millis();
char time[30]; char time[30];
unsigned long t=(stoptime-starttime)/1000; millis_t t = (stoptime - starttime) / 1000;
int hours, minutes; int hours = t / 60 / 60, minutes = (t / 60) % 60;
minutes=(t/60)%60; sprintf_P(time, PSTR("%i " MSG_END_HOUR " %i " MSG_END_MINUTE), hours, minutes);
hours=t/60/60;
sprintf_P(time, PSTR("%i "MSG_END_HOUR" %i "MSG_END_MINUTE),hours, minutes);
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOLN(time); SERIAL_ECHOLN(time);
lcd_setstatus(time, true); lcd_setstatus(time, true);
card.printingHasFinished(); card.printingHasFinished();
card.checkautostart(true); card.checkautostart(true);
} }
if(serial_char=='#') if (serial_char == '#') stop_buffering = true;
stop_buffering=true;
if(!serial_count) if (!serial_count) {
{
comment_mode = false; //for new command comment_mode = false; //for new command
return; //if empty line return; //if empty line
} }
cmdbuffer[bufindw][serial_count] = 0; //terminate string cmdbuffer[bufindw][serial_count] = 0; //terminate string
// if(!comment_mode){ // if (!comment_mode) {
fromsd[bufindw] = true; fromsd[bufindw] = true;
buflen += 1; buflen += 1;
bufindw = (bufindw + 1)%BUFSIZE; bufindw = (bufindw + 1)%BUFSIZE;
// } // }
comment_mode = false; //for new command comment_mode = false; //for new command
serial_count = 0; //clear buffer serial_count = 0; //clear buffer
} }
else else {
{ if (serial_char == ';') comment_mode = true;
if(serial_char == ';') comment_mode = true; if (!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
} }
} }
#endif //SDSUPPORT #endif // SDSUPPORT
} }
float code_has_value() { float code_has_value() {
@ -923,7 +904,7 @@ XYZ_CONSTS_FROM_CONFIG(signed char, home_dir, HOME_DIR);
static float inactive_extruder_x_pos = X2_MAX_POS; // used in mode 0 & 1 static float inactive_extruder_x_pos = X2_MAX_POS; // used in mode 0 & 1
static bool active_extruder_parked = false; // used in mode 1 & 2 static bool active_extruder_parked = false; // used in mode 1 & 2
static float raised_parked_position[NUM_AXIS]; // used in mode 1 static float raised_parked_position[NUM_AXIS]; // used in mode 1
static unsigned long delayed_move_time = 0; // used in mode 1 static millis_t delayed_move_time = 0; // used in mode 1
static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2 static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2
static float duplicate_extruder_temp_offset = 0; // used in mode 2 static float duplicate_extruder_temp_offset = 0; // used in mode 2
bool extruder_duplication_enabled = false; // used in mode 2 bool extruder_duplication_enabled = false; // used in mode 2
@ -1111,7 +1092,7 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
// move down slowly until you find the bed // move down slowly until you find the bed
feedrate = homing_feedrate[Z_AXIS] / 4; feedrate = homing_feedrate[Z_AXIS] / 4;
destination[Z_AXIS] = -10; destination[Z_AXIS] = -10;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
st_synchronize(); st_synchronize();
endstops_hit_on_purpose(); // clear endstop hit flags endstops_hit_on_purpose(); // clear endstop hit flags
@ -1157,7 +1138,8 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
} }
/** /**
* * Plan a move to (X, Y, Z) and set the current_position
* The final current_position may not be the one that was requested
*/ */
static void do_blocking_move_to(float x, float y, float z) { static void do_blocking_move_to(float x, float y, float z) {
float oldFeedRate = feedrate; float oldFeedRate = feedrate;
@ -1169,7 +1151,7 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
destination[X_AXIS] = x; destination[X_AXIS] = x;
destination[Y_AXIS] = y; destination[Y_AXIS] = y;
destination[Z_AXIS] = z; destination[Z_AXIS] = z;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
st_synchronize(); st_synchronize();
#else #else
@ -1233,17 +1215,17 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
destination[X_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_X; destination[X_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_X;
destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_Y; destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_Y;
destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_Z; destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_DEPLOY_Z;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Home X to touch the belt // Home X to touch the belt
feedrate = homing_feedrate[X_AXIS]/10; feedrate = homing_feedrate[X_AXIS]/10;
destination[X_AXIS] = 0; destination[X_AXIS] = 0;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Home Y for safety // Home Y for safety
feedrate = homing_feedrate[X_AXIS]/2; feedrate = homing_feedrate[X_AXIS]/2;
destination[Y_AXIS] = 0; destination[Y_AXIS] = 0;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
st_synchronize(); st_synchronize();
@ -1275,7 +1257,7 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
if (servo_endstops[Z_AXIS] >= 0) { if (servo_endstops[Z_AXIS] >= 0) {
#if Z_RAISE_AFTER_PROBING > 0 #if Z_RAISE_AFTER_PROBING > 0
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING); do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING); // this also updates current_position
st_synchronize(); st_synchronize();
#endif #endif
@ -1296,29 +1278,29 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
// Move up for safety // Move up for safety
feedrate = homing_feedrate[X_AXIS]; feedrate = homing_feedrate[X_AXIS];
destination[Z_AXIS] = current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING; destination[Z_AXIS] = current_position[Z_AXIS] + Z_RAISE_AFTER_PROBING;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Move to the start position to initiate retraction // Move to the start position to initiate retraction
destination[X_AXIS] = Z_PROBE_ALLEN_KEY_STOW_X; destination[X_AXIS] = Z_PROBE_ALLEN_KEY_STOW_X;
destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_STOW_Y; destination[Y_AXIS] = Z_PROBE_ALLEN_KEY_STOW_Y;
destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_STOW_Z; destination[Z_AXIS] = Z_PROBE_ALLEN_KEY_STOW_Z;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Move the nozzle down to push the probe into retracted position // Move the nozzle down to push the probe into retracted position
feedrate = homing_feedrate[Z_AXIS]/10; feedrate = homing_feedrate[Z_AXIS]/10;
destination[Z_AXIS] = current_position[Z_AXIS] - Z_PROBE_ALLEN_KEY_STOW_DEPTH; destination[Z_AXIS] = current_position[Z_AXIS] - Z_PROBE_ALLEN_KEY_STOW_DEPTH;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Move up for safety // Move up for safety
feedrate = homing_feedrate[Z_AXIS]/2; feedrate = homing_feedrate[Z_AXIS]/2;
destination[Z_AXIS] = current_position[Z_AXIS] + Z_PROBE_ALLEN_KEY_STOW_DEPTH * 2; destination[Z_AXIS] = current_position[Z_AXIS] + Z_PROBE_ALLEN_KEY_STOW_DEPTH * 2;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
// Home XY for safety // Home XY for safety
feedrate = homing_feedrate[X_AXIS]/2; feedrate = homing_feedrate[X_AXIS]/2;
destination[X_AXIS] = 0; destination[X_AXIS] = 0;
destination[Y_AXIS] = 0; destination[Y_AXIS] = 0;
prepare_move_raw(); prepare_move_raw(); // this will also set_current_to_destination
st_synchronize(); st_synchronize();
@ -1352,8 +1334,8 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
// Probe bed height at position (x,y), returns the measured z value // Probe bed height at position (x,y), returns the measured z value
static float probe_pt(float x, float y, float z_before, ProbeAction retract_action=ProbeDeployAndStow, int verbose_level=1) { static float probe_pt(float x, float y, float z_before, ProbeAction retract_action=ProbeDeployAndStow, int verbose_level=1) {
// move to right place // move to right place
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z_before); do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], z_before); // this also updates current_position
do_blocking_move_to(x - X_PROBE_OFFSET_FROM_EXTRUDER, y - Y_PROBE_OFFSET_FROM_EXTRUDER, current_position[Z_AXIS]); do_blocking_move_to(x - X_PROBE_OFFSET_FROM_EXTRUDER, y - Y_PROBE_OFFSET_FROM_EXTRUDER, current_position[Z_AXIS]); // this also updates current_position
#if !defined(Z_PROBE_SLED) && !defined(Z_PROBE_ALLEN_KEY) #if !defined(Z_PROBE_SLED) && !defined(Z_PROBE_ALLEN_KEY)
if (retract_action & ProbeDeploy) deploy_z_probe(); if (retract_action & ProbeDeploy) deploy_z_probe();
@ -1364,7 +1346,7 @@ inline void set_destination_to_current() { memcpy(destination, current_position,
#if Z_RAISE_BETWEEN_PROBINGS > 0 #if Z_RAISE_BETWEEN_PROBINGS > 0
if (retract_action == ProbeStay) { if (retract_action == ProbeStay) {
do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS); do_blocking_move_to(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + Z_RAISE_BETWEEN_PROBINGS); // this also updates current_position
st_synchronize(); st_synchronize();
} }
#endif #endif
@ -1643,12 +1625,12 @@ static void homeaxis(AxisEnum axis) {
} }
if (dock) { if (dock) {
do_blocking_move_to(X_MAX_POS + SLED_DOCKING_OFFSET + offset, current_position[Y_AXIS], current_position[Z_AXIS]); do_blocking_move_to(X_MAX_POS + SLED_DOCKING_OFFSET + offset, current_position[Y_AXIS], current_position[Z_AXIS]); // this also updates current_position
digitalWrite(SERVO0_PIN, LOW); // turn off magnet digitalWrite(SERVO0_PIN, LOW); // turn off magnet
} else { } else {
float z_loc = current_position[Z_AXIS]; float z_loc = current_position[Z_AXIS];
if (z_loc < Z_RAISE_BEFORE_PROBING + 5) z_loc = Z_RAISE_BEFORE_PROBING; if (z_loc < Z_RAISE_BEFORE_PROBING + 5) z_loc = Z_RAISE_BEFORE_PROBING;
do_blocking_move_to(X_MAX_POS + SLED_DOCKING_OFFSET + offset, Y_PROBE_OFFSET_FROM_EXTRUDER, z_loc); do_blocking_move_to(X_MAX_POS + SLED_DOCKING_OFFSET + offset, Y_PROBE_OFFSET_FROM_EXTRUDER, z_loc); // this also updates current_position
digitalWrite(SERVO0_PIN, HIGH); // turn on magnet digitalWrite(SERVO0_PIN, HIGH); // turn on magnet
} }
} }
@ -1700,7 +1682,7 @@ inline void gcode_G2_G3(bool clockwise) {
* G4: Dwell S<seconds> or P<milliseconds> * G4: Dwell S<seconds> or P<milliseconds>
*/ */
inline void gcode_G4() { inline void gcode_G4() {
unsigned long codenum = 0; millis_t codenum = 0;
LCD_MESSAGEPGM(MSG_DWELL); LCD_MESSAGEPGM(MSG_DWELL);
@ -1709,7 +1691,7 @@ inline void gcode_G4() {
st_synchronize(); st_synchronize();
refresh_cmd_timeout(); refresh_cmd_timeout();
codenum += previous_millis_cmd; // keep track of when we started waiting codenum += previous_cmd_ms; // keep track of when we started waiting
while (millis() < codenum) { while (millis() < codenum) {
manage_heater(); manage_heater();
manage_inactivity(); manage_inactivity();
@ -2096,7 +2078,7 @@ inline void gcode_G28() {
case MeshStart: case MeshStart:
mbl.reset(); mbl.reset();
probe_point = 0; probe_point = 0;
enquecommands_P(PSTR("G28\nG29 S2")); enqueuecommands_P(PSTR("G28\nG29 S2"));
break; break;
case MeshNext: case MeshNext:
@ -2135,7 +2117,7 @@ inline void gcode_G28() {
SERIAL_PROTOCOLLNPGM("Mesh probing done."); SERIAL_PROTOCOLLNPGM("Mesh probing done.");
probe_point = -1; probe_point = -1;
mbl.active = 1; mbl.active = 1;
enquecommands_P(PSTR("G28")); enqueuecommands_P(PSTR("G28"));
} }
break; break;
@ -2517,7 +2499,7 @@ inline void gcode_G28() {
#endif #endif
#ifdef Z_PROBE_END_SCRIPT #ifdef Z_PROBE_END_SCRIPT
enquecommands_P(PSTR(Z_PROBE_END_SCRIPT)); enqueuecommands_P(PSTR(Z_PROBE_END_SCRIPT));
st_synchronize(); st_synchronize();
#endif #endif
} }
@ -2579,7 +2561,7 @@ inline void gcode_G92() {
inline void gcode_M0_M1() { inline void gcode_M0_M1() {
char *src = strchr_pointer + 2; char *src = strchr_pointer + 2;
unsigned long codenum = 0; millis_t codenum = 0;
bool hasP = false, hasS = false; bool hasP = false, hasS = false;
if (code_seen('P')) { if (code_seen('P')) {
codenum = code_value_short(); // milliseconds to wait codenum = code_value_short(); // milliseconds to wait
@ -2605,7 +2587,7 @@ inline void gcode_G92() {
st_synchronize(); st_synchronize();
refresh_cmd_timeout(); refresh_cmd_timeout();
if (codenum > 0) { if (codenum > 0) {
codenum += previous_millis_cmd; // keep track of when we started waiting codenum += previous_cmd_ms; // keep track of when we started waiting
while(millis() < codenum && !lcd_clicked()) { while(millis() < codenum && !lcd_clicked()) {
manage_heater(); manage_heater();
manage_inactivity(); manage_inactivity();
@ -2747,7 +2729,7 @@ inline void gcode_M17() {
*/ */
inline void gcode_M31() { inline void gcode_M31() {
stoptime = millis(); stoptime = millis();
unsigned long t = (stoptime - starttime) / 1000; millis_t t = (stoptime - starttime) / 1000;
int min = t / 60, sec = t % 60; int min = t / 60, sec = t % 60;
char time[30]; char time[30];
sprintf_P(time, PSTR("%i min, %i sec"), min, sec); sprintf_P(time, PSTR("%i min, %i sec"), min, sec);
@ -2980,11 +2962,11 @@ inline void gcode_M42() {
if (deploy_probe_for_each_reading) stow_z_probe(); if (deploy_probe_for_each_reading) stow_z_probe();
for (uint8_t n=0; n < n_samples; n++) { for (uint8_t n=0; n < n_samples; n++) {
// Make sure we are at the probe location
do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // Make sure we are at the probe location do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // this also updates current_position
if (n_legs) { if (n_legs) {
unsigned long ms = millis(); millis_t ms = millis();
double radius = ms % (X_MAX_LENGTH / 4), // limit how far out to go double radius = ms % (X_MAX_LENGTH / 4), // limit how far out to go
theta = RADIANS(ms % 360L); theta = RADIANS(ms % 360L);
float dir = (ms & 0x0001) ? 1 : -1; // clockwise or counter clockwise float dir = (ms & 0x0001) ? 1 : -1; // clockwise or counter clockwise
@ -3011,11 +2993,12 @@ inline void gcode_M42() {
SERIAL_EOL; SERIAL_EOL;
} }
do_blocking_move_to(X_current, Y_current, Z_current); do_blocking_move_to(X_current, Y_current, Z_current); // this also updates current_position
} // n_legs loop } // n_legs loop
do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // Go back to the probe location // Go back to the probe location
do_blocking_move_to(X_probe_location, Y_probe_location, Z_start_location); // this also updates current_position
} // n_legs } // n_legs
@ -3221,7 +3204,7 @@ inline void gcode_M109() {
setWatch(); setWatch();
unsigned long timetemp = millis(); millis_t temp_ms = millis();
/* See if we are heating up or cooling down */ /* See if we are heating up or cooling down */
target_direction = isHeatingHotend(target_extruder); // true if heating, false if cooling target_direction = isHeatingHotend(target_extruder); // true if heating, false if cooling
@ -3229,26 +3212,26 @@ inline void gcode_M109() {
cancel_heatup = false; cancel_heatup = false;
#ifdef TEMP_RESIDENCY_TIME #ifdef TEMP_RESIDENCY_TIME
long residencyStart = -1; long residency_start_ms = -1;
/* continue to loop until we have reached the target temp /* continue to loop until we have reached the target temp
_and_ until TEMP_RESIDENCY_TIME hasn't passed since we reached it */ _and_ until TEMP_RESIDENCY_TIME hasn't passed since we reached it */
while((!cancel_heatup)&&((residencyStart == -1) || while((!cancel_heatup)&&((residency_start_ms == -1) ||
(residencyStart >= 0 && (((unsigned int) (millis() - residencyStart)) < (TEMP_RESIDENCY_TIME * 1000UL)))) ) (residency_start_ms >= 0 && (((unsigned int) (millis() - residency_start_ms)) < (TEMP_RESIDENCY_TIME * 1000UL)))) )
#else #else
while ( target_direction ? (isHeatingHotend(target_extruder)) : (isCoolingHotend(target_extruder)&&(CooldownNoWait==false)) ) while ( target_direction ? (isHeatingHotend(target_extruder)) : (isCoolingHotend(target_extruder)&&(CooldownNoWait==false)) )
#endif //TEMP_RESIDENCY_TIME #endif //TEMP_RESIDENCY_TIME
{ // while loop { // while loop
if (millis() > timetemp + 1000UL) { //Print temp & remaining time every 1s while waiting if (millis() > temp_ms + 1000UL) { //Print temp & remaining time every 1s while waiting
SERIAL_PROTOCOLPGM("T:"); SERIAL_PROTOCOLPGM("T:");
SERIAL_PROTOCOL_F(degHotend(target_extruder),1); SERIAL_PROTOCOL_F(degHotend(target_extruder),1);
SERIAL_PROTOCOLPGM(" E:"); SERIAL_PROTOCOLPGM(" E:");
SERIAL_PROTOCOL((int)target_extruder); SERIAL_PROTOCOL((int)target_extruder);
#ifdef TEMP_RESIDENCY_TIME #ifdef TEMP_RESIDENCY_TIME
SERIAL_PROTOCOLPGM(" W:"); SERIAL_PROTOCOLPGM(" W:");
if (residencyStart > -1) { if (residency_start_ms > -1) {
timetemp = ((TEMP_RESIDENCY_TIME * 1000UL) - (millis() - residencyStart)) / 1000UL; temp_ms = ((TEMP_RESIDENCY_TIME * 1000UL) - (millis() - residency_start_ms)) / 1000UL;
SERIAL_PROTOCOLLN( timetemp ); SERIAL_PROTOCOLLN(temp_ms);
} }
else { else {
SERIAL_PROTOCOLLNPGM("?"); SERIAL_PROTOCOLLNPGM("?");
@ -3256,7 +3239,7 @@ inline void gcode_M109() {
#else #else
SERIAL_EOL; SERIAL_EOL;
#endif #endif
timetemp = millis(); temp_ms = millis();
} }
manage_heater(); manage_heater();
manage_inactivity(); manage_inactivity();
@ -3264,18 +3247,18 @@ inline void gcode_M109() {
#ifdef TEMP_RESIDENCY_TIME #ifdef TEMP_RESIDENCY_TIME
// start/restart the TEMP_RESIDENCY_TIME timer whenever we reach target temp for the first 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 // or when current temp falls outside the hysteresis after target temp was reached
if ((residencyStart == -1 && target_direction && (degHotend(target_extruder) >= (degTargetHotend(target_extruder)-TEMP_WINDOW))) || if ((residency_start_ms == -1 && target_direction && (degHotend(target_extruder) >= (degTargetHotend(target_extruder)-TEMP_WINDOW))) ||
(residencyStart == -1 && !target_direction && (degHotend(target_extruder) <= (degTargetHotend(target_extruder)+TEMP_WINDOW))) || (residency_start_ms == -1 && !target_direction && (degHotend(target_extruder) <= (degTargetHotend(target_extruder)+TEMP_WINDOW))) ||
(residencyStart > -1 && labs(degHotend(target_extruder) - degTargetHotend(target_extruder)) > TEMP_HYSTERESIS) ) (residency_start_ms > -1 && labs(degHotend(target_extruder) - degTargetHotend(target_extruder)) > TEMP_HYSTERESIS) )
{ {
residencyStart = millis(); residency_start_ms = millis();
} }
#endif //TEMP_RESIDENCY_TIME #endif //TEMP_RESIDENCY_TIME
} }
LCD_MESSAGEPGM(MSG_HEATING_COMPLETE); LCD_MESSAGEPGM(MSG_HEATING_COMPLETE);
refresh_cmd_timeout(); refresh_cmd_timeout();
starttime = previous_millis_cmd; starttime = previous_cmd_ms;
} }
#if HAS_TEMP_BED #if HAS_TEMP_BED
@ -3290,15 +3273,15 @@ inline void gcode_M109() {
if (CooldownNoWait || code_seen('R')) if (CooldownNoWait || code_seen('R'))
setTargetBed(code_value()); setTargetBed(code_value());
unsigned long timetemp = millis(); millis_t temp_ms = millis();
cancel_heatup = false; cancel_heatup = false;
target_direction = isHeatingBed(); // true if heating, false if cooling target_direction = isHeatingBed(); // true if heating, false if cooling
while ( (target_direction)&&(!cancel_heatup) ? (isHeatingBed()) : (isCoolingBed()&&(CooldownNoWait==false)) ) { while ( (target_direction)&&(!cancel_heatup) ? (isHeatingBed()) : (isCoolingBed()&&(CooldownNoWait==false)) ) {
unsigned long ms = millis(); millis_t ms = millis();
if (ms > timetemp + 1000UL) { //Print Temp Reading every 1 second while heating up. if (ms > temp_ms + 1000UL) { //Print Temp Reading every 1 second while heating up.
timetemp = ms; temp_ms = ms;
float tt = degHotend(active_extruder); float tt = degHotend(active_extruder);
SERIAL_PROTOCOLPGM("T:"); SERIAL_PROTOCOLPGM("T:");
SERIAL_PROTOCOL(tt); SERIAL_PROTOCOL(tt);
@ -3974,14 +3957,14 @@ inline void gcode_M226() {
#endif // NUM_SERVOS > 0 #endif // NUM_SERVOS > 0
#if defined(LARGE_FLASH) && (BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)) #if BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)
/** /**
* M300: Play beep sound S<frequency Hz> P<duration ms> * M300: Play beep sound S<frequency Hz> P<duration ms>
*/ */
inline void gcode_M300() { inline void gcode_M300() {
int beepS = code_seen('S') ? code_value() : 110; uint16_t beepS = code_seen('S') ? code_value_short() : 110;
int beepP = code_seen('P') ? code_value() : 1000; uint32_t beepP = code_seen('P') ? code_value_long() : 1000;
if (beepS > 0) { if (beepS > 0) {
#if BEEPER > 0 #if BEEPER > 0
tone(BEEPER, beepS); tone(BEEPER, beepS);
@ -3998,7 +3981,7 @@ inline void gcode_M226() {
} }
} }
#endif // LARGE_FLASH && (BEEPER>0 || ULTRALCD || LCD_USE_I2C_BUZZER) #endif // BEEPER>0 || ULTRALCD || LCD_USE_I2C_BUZZER
#ifdef PIDTEMP #ifdef PIDTEMP
@ -4472,24 +4455,10 @@ inline void gcode_M503() {
LCD_ALERTMESSAGEPGM(MSG_FILAMENTCHANGE); LCD_ALERTMESSAGEPGM(MSG_FILAMENTCHANGE);
uint8_t cnt = 0; uint8_t cnt = 0;
while (!lcd_clicked()) { while (!lcd_clicked()) {
cnt++; if (++cnt == 0) lcd_quick_feedback(); // every 256th frame till the lcd is clicked
manage_heater(); manage_heater();
manage_inactivity(true); manage_inactivity(true);
lcd_update(); lcd_update();
if (cnt == 0) {
#if BEEPER > 0
OUT_WRITE(BEEPER,HIGH);
delay(3);
WRITE(BEEPER,LOW);
delay(3);
#else
#if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
lcd_buzz(1000/6, 100);
#else
lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#endif
#endif
}
} // while(!lcd_clicked) } // while(!lcd_clicked)
//return to normal //return to normal
@ -5078,11 +5047,11 @@ void process_commands() {
break; break;
#endif // NUM_SERVOS > 0 #endif // NUM_SERVOS > 0
#if defined(LARGE_FLASH) && (BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)) #if BEEPER > 0 || defined(ULTRALCD) || defined(LCD_USE_I2C_BUZZER)
case 300: // M300 - Play beep tone case 300: // M300 - Play beep tone
gcode_M300(); gcode_M300();
break; break;
#endif // LARGE_FLASH && (BEEPER>0 || ULTRALCD || LCD_USE_I2C_BUZZER) #endif // BEEPER > 0 || ULTRALCD || LCD_USE_I2C_BUZZER
#ifdef PIDTEMP #ifdef PIDTEMP
case 301: // M301 case 301: // M301
@ -5289,25 +5258,23 @@ void get_arc_coordinates() {
offset[1] = code_seen('J') ? code_value() : 0; offset[1] = code_seen('J') ? code_value() : 0;
} }
void clamp_to_software_endstops(float target[3]) void clamp_to_software_endstops(float target[3]) {
{
if (min_software_endstops) { if (min_software_endstops) {
if (target[X_AXIS] < min_pos[X_AXIS]) target[X_AXIS] = min_pos[X_AXIS]; NOLESS(target[X_AXIS], min_pos[X_AXIS]);
if (target[Y_AXIS] < min_pos[Y_AXIS]) target[Y_AXIS] = min_pos[Y_AXIS]; NOLESS(target[Y_AXIS], min_pos[Y_AXIS]);
float negative_z_offset = 0; float negative_z_offset = 0;
#ifdef ENABLE_AUTO_BED_LEVELING #ifdef ENABLE_AUTO_BED_LEVELING
if (Z_PROBE_OFFSET_FROM_EXTRUDER < 0) negative_z_offset = negative_z_offset + Z_PROBE_OFFSET_FROM_EXTRUDER; if (Z_PROBE_OFFSET_FROM_EXTRUDER < 0) negative_z_offset += Z_PROBE_OFFSET_FROM_EXTRUDER;
if (home_offset[Z_AXIS] < 0) negative_z_offset = negative_z_offset + home_offset[Z_AXIS]; if (home_offset[Z_AXIS] < 0) negative_z_offset += home_offset[Z_AXIS];
#endif #endif
NOLESS(target[Z_AXIS], min_pos[Z_AXIS] + negative_z_offset);
if (target[Z_AXIS] < min_pos[Z_AXIS]+negative_z_offset) target[Z_AXIS] = min_pos[Z_AXIS]+negative_z_offset;
} }
if (max_software_endstops) { if (max_software_endstops) {
if (target[X_AXIS] > max_pos[X_AXIS]) target[X_AXIS] = max_pos[X_AXIS]; NOMORE(target[X_AXIS], max_pos[X_AXIS]);
if (target[Y_AXIS] > max_pos[Y_AXIS]) target[Y_AXIS] = max_pos[Y_AXIS]; NOMORE(target[Y_AXIS], max_pos[Y_AXIS]);
if (target[Z_AXIS] > max_pos[Z_AXIS]) target[Z_AXIS] = max_pos[Z_AXIS]; NOMORE(target[Z_AXIS], max_pos[Z_AXIS]);
} }
} }
@ -5522,7 +5489,7 @@ void prepare_move() {
//SERIAL_ECHOPGM("delta[Y_AXIS]="); SERIAL_ECHOLN(delta[Y_AXIS]); //SERIAL_ECHOPGM("delta[Y_AXIS]="); SERIAL_ECHOLN(delta[Y_AXIS]);
//SERIAL_ECHOPGM("delta[Z_AXIS]="); SERIAL_ECHOLN(delta[Z_AXIS]); //SERIAL_ECHOPGM("delta[Z_AXIS]="); SERIAL_ECHOLN(delta[Z_AXIS]);
plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], feedrate*feedmultiply/60/100.0, active_extruder); plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], feedrate/60*feedmultiply/100.0, active_extruder);
} }
#endif // SCARA #endif // SCARA
@ -5549,7 +5516,7 @@ void prepare_move() {
#ifdef ENABLE_AUTO_BED_LEVELING #ifdef ENABLE_AUTO_BED_LEVELING
adjust_delta(destination); adjust_delta(destination);
#endif #endif
plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], feedrate*feedmultiply/60/100.0, active_extruder); plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], destination[E_AXIS], feedrate/60*feedmultiply/100.0, active_extruder);
} }
#endif // DELTA #endif // DELTA
@ -5573,7 +5540,7 @@ void prepare_move() {
// (so it can be used as the start of the next non-travel move) // (so it can be used as the start of the next non-travel move)
if (delayed_move_time != 0xFFFFFFFFUL) { if (delayed_move_time != 0xFFFFFFFFUL) {
set_current_to_destination(); set_current_to_destination();
if (destination[Z_AXIS] > raised_parked_position[Z_AXIS]) raised_parked_position[Z_AXIS] = destination[Z_AXIS]; NOLESS(raised_parked_position[Z_AXIS], destination[Z_AXIS]);
delayed_move_time = millis(); delayed_move_time = millis();
return; return;
} }
@ -5621,11 +5588,11 @@ void prepare_arc_move(char isclockwise) {
#if HAS_CONTROLLERFAN #if HAS_CONTROLLERFAN
unsigned long lastMotor = 0; // Last time a motor was turned on millis_t lastMotor = 0; // Last time a motor was turned on
unsigned long lastMotorCheck = 0; // Last time the state was checked millis_t lastMotorCheck = 0; // Last time the state was checked
void controllerFan() { void controllerFan() {
uint32_t ms = millis(); millis_t ms = millis();
if (ms >= lastMotorCheck + 2500) { // Not a time critical function, so we only check every 2500ms if (ms >= lastMotorCheck + 2500) { // Not a time critical function, so we only check every 2500ms
lastMotorCheck = ms; lastMotorCheck = ms;
if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON || soft_pwm_bed > 0 if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON || soft_pwm_bed > 0
@ -5732,36 +5699,28 @@ void calculate_delta(float cartesian[3]){
#endif #endif
#ifdef TEMP_STAT_LEDS #ifdef TEMP_STAT_LEDS
static bool blue_led = false;
static bool red_led = false;
static uint32_t stat_update = 0;
void handle_status_leds(void) { static bool red_led = false;
static millis_t next_status_led_update_ms = 0;
void handle_status_leds(void) {
float max_temp = 0.0; float max_temp = 0.0;
if(millis() > stat_update) { if (millis() > next_status_led_update_ms) {
stat_update += 500; // Update every 0.5s next_status_led_update_ms += 500; // Update every 0.5s
for (int8_t cur_extruder = 0; cur_extruder < EXTRUDERS; ++cur_extruder) { for (int8_t cur_extruder = 0; cur_extruder < EXTRUDERS; ++cur_extruder)
max_temp = max(max_temp, degHotend(cur_extruder)); max_temp = max(max(max_temp, degHotend(cur_extruder)), degTargetHotend(cur_extruder));
max_temp = max(max_temp, degTargetHotend(cur_extruder));
}
#if HAS_TEMP_BED #if HAS_TEMP_BED
max_temp = max(max_temp, degTargetBed()); max_temp = max(max(max_temp, degTargetBed()), degBed());
max_temp = max(max_temp, degBed());
#endif #endif
if((max_temp > 55.0) && (red_led == false)) { bool new_led = (max_temp > 55.0) ? true : (max_temp < 54.0) ? false : red_led;
digitalWrite(STAT_LED_RED, 1); if (new_led != red_led) {
digitalWrite(STAT_LED_BLUE, 0); red_led = new_led;
red_led = true; digitalWrite(STAT_LED_RED, new_led ? HIGH : LOW);
blue_led = false; digitalWrite(STAT_LED_BLUE, new_led ? LOW : HIGH);
} }
if((max_temp < 54.0) && (blue_led == false)) {
digitalWrite(STAT_LED_RED, 0);
digitalWrite(STAT_LED_BLUE, 1);
red_led = false;
blue_led = true;
} }
} }
}
#endif #endif
void enable_all_steppers() { void enable_all_steppers() {
@ -5805,11 +5764,11 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
if (buflen < BUFSIZE - 1) get_command(); if (buflen < BUFSIZE - 1) get_command();
unsigned long ms = millis(); millis_t ms = millis();
if (max_inactive_time && ms > previous_millis_cmd + max_inactive_time) kill(); if (max_inactive_time && ms > previous_cmd_ms + max_inactive_time) kill();
if (stepper_inactive_time && ms > previous_millis_cmd + stepper_inactive_time if (stepper_inactive_time && ms > previous_cmd_ms + stepper_inactive_time
&& !ignore_stepper_queue && !blocks_queued()) && !ignore_stepper_queue && !blocks_queued())
disable_all_steppers(); disable_all_steppers();
@ -5845,7 +5804,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
const int HOME_DEBOUNCE_DELAY = 750; const int HOME_DEBOUNCE_DELAY = 750;
if (!READ(HOME_PIN)) { if (!READ(HOME_PIN)) {
if (!homeDebounceCount) { if (!homeDebounceCount) {
enquecommands_P(PSTR("G28")); enqueuecommands_P(PSTR("G28"));
LCD_ALERTMESSAGEPGM(MSG_AUTO_HOME); LCD_ALERTMESSAGEPGM(MSG_AUTO_HOME);
} }
if (homeDebounceCount < HOME_DEBOUNCE_DELAY) if (homeDebounceCount < HOME_DEBOUNCE_DELAY)
@ -5860,7 +5819,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
#endif #endif
#ifdef EXTRUDER_RUNOUT_PREVENT #ifdef EXTRUDER_RUNOUT_PREVENT
if (ms > previous_millis_cmd + EXTRUDER_RUNOUT_SECONDS * 1000) if (ms > previous_cmd_ms + EXTRUDER_RUNOUT_SECONDS * 1000)
if (degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP) { if (degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP) {
bool oldstatus; bool oldstatus;
switch(active_extruder) { switch(active_extruder) {
@ -5894,7 +5853,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
current_position[E_AXIS] = oldepos; current_position[E_AXIS] = oldepos;
destination[E_AXIS] = oldedes; destination[E_AXIS] = oldedes;
plan_set_e_position(oldepos); plan_set_e_position(oldepos);
previous_millis_cmd = ms; // refresh_cmd_timeout() previous_cmd_ms = ms; // refresh_cmd_timeout()
st_synchronize(); st_synchronize();
switch(active_extruder) { switch(active_extruder) {
case 0: case 0:
@ -5964,7 +5923,7 @@ void kill()
{ {
if filrunoutEnqued == false { if filrunoutEnqued == false {
filrunoutEnqued = true; filrunoutEnqued = true;
enquecommand("M600"); enqueuecommand("M600");
} }
} }
#endif #endif

10
Marlin/cardreader.cpp
View File

@ -25,7 +25,7 @@ CardReader::CardReader() {
OUT_WRITE(SDPOWER, HIGH); OUT_WRITE(SDPOWER, HIGH);
#endif //SDPOWER #endif //SDPOWER
autostart_atmillis = millis() + 5000; next_autostart_ms = millis() + 5000;
} }
char *createFilename(char *buffer, const dir_t &p) { //buffer > 12characters char *createFilename(char *buffer, const dir_t &p) { //buffer > 12characters
@ -397,7 +397,7 @@ void CardReader::write_command(char *buf) {
} }
void CardReader::checkautostart(bool force) { void CardReader::checkautostart(bool force) {
if (!force && (!autostart_stilltocheck || autostart_atmillis < millis())) if (!force && (!autostart_stilltocheck || next_autostart_ms < millis()))
return; return;
autostart_stilltocheck = false; autostart_stilltocheck = false;
@ -421,8 +421,8 @@ void CardReader::checkautostart(bool force) {
if (p.name[9] != '~' && strncmp((char*)p.name, autoname, 5) == 0) { if (p.name[9] != '~' && strncmp((char*)p.name, autoname, 5) == 0) {
char cmd[30]; char cmd[30];
sprintf_P(cmd, PSTR("M23 %s"), autoname); sprintf_P(cmd, PSTR("M23 %s"), autoname);
enquecommand(cmd); enqueuecommand(cmd);
enquecommands_P(PSTR("M24")); enqueuecommands_P(PSTR("M24"));
found = true; found = true;
} }
} }
@ -508,7 +508,7 @@ void CardReader::printingHasFinished() {
sdprinting = false; sdprinting = false;
if (SD_FINISHED_STEPPERRELEASE) { if (SD_FINISHED_STEPPERRELEASE) {
//finishAndDisableSteppers(); //finishAndDisableSteppers();
enquecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND)); enqueuecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
} }
autotempShutdown(); autotempShutdown();
} }

2
Marlin/cardreader.h
View File

@ -62,7 +62,7 @@ private:
uint32_t filespos[SD_PROCEDURE_DEPTH]; uint32_t filespos[SD_PROCEDURE_DEPTH];
char filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH]; char filenames[SD_PROCEDURE_DEPTH][MAXPATHNAMELENGTH];
uint32_t filesize; uint32_t filesize;
unsigned long autostart_atmillis; millis_t next_autostart_ms;
uint32_t sdpos; uint32_t sdpos;
bool autostart_stilltocheck; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware. bool autostart_stilltocheck; //the sd start is delayed, because otherwise the serial cannot answer fast enought to make contact with the hostsoftware.

2
Marlin/dogm_lcd_implementation.h
View File

@ -350,7 +350,7 @@ static void lcd_implementation_status_screen() {
#ifndef FILAMENT_LCD_DISPLAY #ifndef FILAMENT_LCD_DISPLAY
lcd_print(lcd_status_message); lcd_print(lcd_status_message);
#else #else
if (millis() < message_millis + 5000) { //Display both Status message line and Filament display on the last line if (millis() < previous_lcd_status_ms + 5000) { //Display both Status message line and Filament display on the last line
lcd_print(lcd_status_message); lcd_print(lcd_status_message);
} }
else { else {

4
Marlin/example_configurations/Hephestos/Configuration.h
View File

@ -58,9 +58,7 @@ Here are some standard links for getting your machine calibrated:
// The following define selects which electronics board you have. // The following define selects which electronics board you have.
// Please choose the name from boards.h that matches your setup // Please choose the name from boards.h that matches your setup
#ifndef MOTHERBOARD #define MOTHERBOARD BOARD_HEPHESTOS
#define MOTHERBOARD BOARD_HEPHESTOS
#endif
// Optional custom name for your RepStrap or other custom machine // Optional custom name for your RepStrap or other custom machine
// Displayed in the LCD "Ready" message // Displayed in the LCD "Ready" message

4
Marlin/example_configurations/WITBOX/Configuration.h
View File

@ -58,9 +58,7 @@ Here are some standard links for getting your machine calibrated:
// The following define selects which electronics board you have. // The following define selects which electronics board you have.
// Please choose the name from boards.h that matches your setup // Please choose the name from boards.h that matches your setup
#ifndef MOTHERBOARD #define MOTHERBOARD BOARD_WITBOX
#define MOTHERBOARD BOARD_WITBOX
#endif
// Optional custom name for your RepStrap or other custom machine // Optional custom name for your RepStrap or other custom machine
// Displayed in the LCD "Ready" message // Displayed in the LCD "Ready" message

26
Marlin/planner.cpp
View File

@ -60,13 +60,13 @@
#ifdef MESH_BED_LEVELING #ifdef MESH_BED_LEVELING
#include "mesh_bed_leveling.h" #include "mesh_bed_leveling.h"
#endif // MESH_BED_LEVELING #endif
//=========================================================================== //===========================================================================
//============================= public variables ============================ //============================= public variables ============================
//=========================================================================== //===========================================================================
unsigned long minsegmenttime; millis_t minsegmenttime;
float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute float max_feedrate[NUM_AXIS]; // Max speeds in mm per minute
float axis_steps_per_unit[NUM_AXIS]; float axis_steps_per_unit[NUM_AXIS];
unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software
@ -159,8 +159,8 @@ void calculate_trapezoid_for_block(block_t *block, float entry_factor, float exi
unsigned long final_rate = ceil(block->nominal_rate * exit_factor); // (step/min) unsigned long final_rate = ceil(block->nominal_rate * exit_factor); // (step/min)
// Limit minimal step rate (Otherwise the timer will overflow.) // Limit minimal step rate (Otherwise the timer will overflow.)
if (initial_rate < 120) initial_rate = 120; NOLESS(initial_rate, 120);
if (final_rate < 120) final_rate = 120; NOLESS(final_rate, 120);
long acceleration = block->acceleration_st; long acceleration = block->acceleration_st;
int32_t accelerate_steps = ceil(estimate_acceleration_distance(initial_rate, block->nominal_rate, acceleration)); int32_t accelerate_steps = ceil(estimate_acceleration_distance(initial_rate, block->nominal_rate, acceleration));
@ -382,9 +382,11 @@ void plan_init() {
} }
float t = autotemp_min + high * autotemp_factor; float t = autotemp_min + high * autotemp_factor;
if (t < autotemp_min) t = autotemp_min; t = constrain(t, autotemp_min, autotemp_max);
if (t > autotemp_max) t = autotemp_max; if (oldt > t) {
if (oldt > t) t = AUTOTEMP_OLDWEIGHT * oldt + (1 - AUTOTEMP_OLDWEIGHT) * t; t *= (1 - AUTOTEMP_OLDWEIGHT);
t += AUTOTEMP_OLDWEIGHT * oldt;
}
oldt = t; oldt = t;
setTargetHotend0(t); setTargetHotend0(t);
} }
@ -426,7 +428,7 @@ void check_axes_activity() {
#if HAS_FAN #if HAS_FAN
#ifdef FAN_KICKSTART_TIME #ifdef FAN_KICKSTART_TIME
static unsigned long fan_kick_end; static millis_t fan_kick_end;
if (tail_fan_speed) { if (tail_fan_speed) {
if (fan_kick_end == 0) { if (fan_kick_end == 0) {
// Just starting up fan - run at full power. // Just starting up fan - run at full power.
@ -651,10 +653,10 @@ float junction_deviation = 0.1;
} }
} }
if (block->steps[E_AXIS]) { if (block->steps[E_AXIS])
if (feed_rate < minimumfeedrate) feed_rate = minimumfeedrate; NOLESS(feed_rate, minimumfeedrate);
} else
else if (feed_rate < mintravelfeedrate) feed_rate = mintravelfeedrate; NOLESS(feed_rate, mintravelfeedrate);
/** /**
* This part of the code calculates the total length of the movement. * This part of the code calculates the total length of the movement.

2
Marlin/planner.h
View File

@ -115,7 +115,7 @@ FORCE_INLINE uint8_t movesplanned() { return BLOCK_MOD(block_buffer_head - block
void plan_set_e_position(const float &e); void plan_set_e_position(const float &e);
extern unsigned long minsegmenttime; extern millis_t minsegmenttime;
extern float max_feedrate[NUM_AXIS]; // set the max speeds extern float max_feedrate[NUM_AXIS]; // set the max speeds
extern float axis_steps_per_unit[NUM_AXIS]; extern float axis_steps_per_unit[NUM_AXIS];
extern unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software extern unsigned long max_acceleration_units_per_sq_second[NUM_AXIS]; // Use M201 to override by software

6
Marlin/stepper.cpp
View File

@ -400,7 +400,7 @@ ISR(TIMER1_COMPA_vect) {
current_block = NULL; current_block = NULL;
plan_discard_current_block(); plan_discard_current_block();
#ifdef SD_FINISHED_RELEASECOMMAND #ifdef SD_FINISHED_RELEASECOMMAND
if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enquecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND)); if ((cleaning_buffer_counter == 1) && (SD_FINISHED_STEPPERRELEASE)) enqueuecommands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
#endif #endif
cleaning_buffer_counter--; cleaning_buffer_counter--;
OCR1A = 200; OCR1A = 200;
@ -718,7 +718,7 @@ ISR(TIMER1_COMPA_vect) {
// Calculate new timer value // Calculate new timer value
unsigned short timer; unsigned short timer;
unsigned short step_rate; unsigned short step_rate;
if (step_events_completed <= (unsigned long int)current_block->accelerate_until) { if (step_events_completed <= (unsigned long)current_block->accelerate_until) {
MultiU24X24toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate); MultiU24X24toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
acc_step_rate += current_block->initial_rate; acc_step_rate += current_block->initial_rate;
@ -742,7 +742,7 @@ ISR(TIMER1_COMPA_vect) {
#endif #endif
} }
else if (step_events_completed > (unsigned long int)current_block->decelerate_after) { else if (step_events_completed > (unsigned long)current_block->decelerate_after) {
MultiU24X24toH16(step_rate, deceleration_time, current_block->acceleration_rate); MultiU24X24toH16(step_rate, deceleration_time, current_block->acceleration_rate);
if (step_rate > acc_step_rate) { // Check step_rate stays positive if (step_rate > acc_step_rate) { // Check step_rate stays positive

48
Marlin/temperature.cpp
View File

@ -77,14 +77,14 @@ unsigned char soft_pwm_bed;
#define HAS_BED_THERMAL_PROTECTION (defined(THERMAL_RUNAWAY_PROTECTION_BED_PERIOD) && THERMAL_RUNAWAY_PROTECTION_BED_PERIOD > 0 && TEMP_SENSOR_BED != 0) #define HAS_BED_THERMAL_PROTECTION (defined(THERMAL_RUNAWAY_PROTECTION_BED_PERIOD) && THERMAL_RUNAWAY_PROTECTION_BED_PERIOD > 0 && TEMP_SENSOR_BED != 0)
#if HAS_HEATER_THERMAL_PROTECTION || HAS_BED_THERMAL_PROTECTION #if HAS_HEATER_THERMAL_PROTECTION || HAS_BED_THERMAL_PROTECTION
enum TRState { TRReset, TRInactive, TRFirstHeating, TRStable, TRRunaway }; enum TRState { TRReset, TRInactive, TRFirstHeating, TRStable, TRRunaway };
void thermal_runaway_protection(TRState *state, unsigned long *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc); void thermal_runaway_protection(TRState *state, millis_t *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc);
#if HAS_HEATER_THERMAL_PROTECTION #if HAS_HEATER_THERMAL_PROTECTION
static TRState thermal_runaway_state_machine[4] = { TRReset, TRReset, TRReset, TRReset }; static TRState thermal_runaway_state_machine[4] = { TRReset, TRReset, TRReset, TRReset };
static unsigned long thermal_runaway_timer[4]; // = {0,0,0,0}; static millis_t thermal_runaway_timer[4]; // = {0,0,0,0};
#endif #endif
#if HAS_BED_THERMAL_PROTECTION #if HAS_BED_THERMAL_PROTECTION
static TRState thermal_runaway_bed_state_machine = TRReset; static TRState thermal_runaway_bed_state_machine = TRReset;
static unsigned long thermal_runaway_bed_timer; static millis_t thermal_runaway_bed_timer;
#endif #endif
#endif #endif
@ -118,7 +118,7 @@ static volatile bool temp_meas_ready = false;
static float temp_iState_min_bed; static float temp_iState_min_bed;
static float temp_iState_max_bed; static float temp_iState_max_bed;
#else //PIDTEMPBED #else //PIDTEMPBED
static unsigned long previous_millis_bed_heater; static millis_t previous_bed_check_ms;
#endif //PIDTEMPBED #endif //PIDTEMPBED
static unsigned char soft_pwm[EXTRUDERS]; static unsigned char soft_pwm[EXTRUDERS];
@ -126,7 +126,7 @@ static volatile bool temp_meas_ready = false;
static unsigned char soft_pwm_fan; static unsigned char soft_pwm_fan;
#endif #endif
#if HAS_AUTO_FAN #if HAS_AUTO_FAN
static unsigned long extruder_autofan_last_check; static millis_t previous_auto_fan_check_ms;
#endif #endif
#ifdef PIDTEMP #ifdef PIDTEMP
@ -171,7 +171,7 @@ static void updateTemperaturesFromRawValues();
#ifdef WATCH_TEMP_PERIOD #ifdef WATCH_TEMP_PERIOD
int watch_start_temp[EXTRUDERS] = { 0 }; int watch_start_temp[EXTRUDERS] = { 0 };
unsigned long watchmillis[EXTRUDERS] = { 0 }; millis_t watchmillis[EXTRUDERS] = { 0 };
#endif //WATCH_TEMP_PERIOD #endif //WATCH_TEMP_PERIOD
#ifndef SOFT_PWM_SCALE #ifndef SOFT_PWM_SCALE
@ -196,7 +196,7 @@ void PID_autotune(float temp, int extruder, int ncycles)
int cycles = 0; int cycles = 0;
bool heating = true; bool heating = true;
unsigned long temp_millis = millis(), t1 = temp_millis, t2 = temp_millis; millis_t temp_ms = millis(), t1 = temp_ms, t2 = temp_ms;
long t_high = 0, t_low = 0; long t_high = 0, t_low = 0;
long bias, d; long bias, d;
@ -205,7 +205,7 @@ void PID_autotune(float temp, int extruder, int ncycles)
float max = 0, min = 10000; float max = 0, min = 10000;
#if HAS_AUTO_FAN #if HAS_AUTO_FAN
unsigned long extruder_autofan_last_check = temp_millis; millis_t previous_auto_fan_check_ms = temp_ms;
#endif #endif
if (extruder >= EXTRUDERS if (extruder >= EXTRUDERS
@ -229,7 +229,7 @@ void PID_autotune(float temp, int extruder, int ncycles)
// PID Tuning loop // PID Tuning loop
for (;;) { for (;;) {
unsigned long ms = millis(); millis_t ms = millis();
if (temp_meas_ready) { // temp sample ready if (temp_meas_ready) { // temp sample ready
updateTemperaturesFromRawValues(); updateTemperaturesFromRawValues();
@ -240,9 +240,9 @@ void PID_autotune(float temp, int extruder, int ncycles)
min = min(min, input); min = min(min, input);
#if HAS_AUTO_FAN #if HAS_AUTO_FAN
if (ms > extruder_autofan_last_check + 2500) { if (ms > previous_auto_fan_check_ms + 2500) {
checkExtruderAutoFans(); checkExtruderAutoFans();
extruder_autofan_last_check = ms; previous_auto_fan_check_ms = ms;
} }
#endif #endif
@ -317,7 +317,7 @@ void PID_autotune(float temp, int extruder, int ncycles)
return; return;
} }
// Every 2 seconds... // Every 2 seconds...
if (ms > temp_millis + 2000) { if (ms > temp_ms + 2000) {
int p; int p;
if (extruder < 0) { if (extruder < 0) {
p = soft_pwm_bed; p = soft_pwm_bed;
@ -332,7 +332,7 @@ void PID_autotune(float temp, int extruder, int ncycles)
SERIAL_PROTOCOLPGM(MSG_AT); SERIAL_PROTOCOLPGM(MSG_AT);
SERIAL_PROTOCOLLN(p); SERIAL_PROTOCOLLN(p);
temp_millis = ms; temp_ms = ms;
} // every 2 seconds } // every 2 seconds
// Over 2 minutes? // Over 2 minutes?
if (((ms - t1) + (ms - t2)) > (10L*60L*1000L*2L)) { if (((ms - t1) + (ms - t2)) > (10L*60L*1000L*2L)) {
@ -592,7 +592,7 @@ void manage_heater() {
#endif //HEATER_0_USES_MAX6675 #endif //HEATER_0_USES_MAX6675
#if defined(WATCH_TEMP_PERIOD) || !defined(PIDTEMPBED) || HAS_AUTO_FAN #if defined(WATCH_TEMP_PERIOD) || !defined(PIDTEMPBED) || HAS_AUTO_FAN
unsigned long ms = millis(); millis_t ms = millis();
#endif #endif
// Loop through all extruders // Loop through all extruders
@ -631,15 +631,15 @@ void manage_heater() {
} // Extruders Loop } // Extruders Loop
#if HAS_AUTO_FAN #if HAS_AUTO_FAN
if (ms > extruder_autofan_last_check + 2500) { // only need to check fan state very infrequently if (ms > previous_auto_fan_check_ms + 2500) { // only need to check fan state very infrequently
checkExtruderAutoFans(); checkExtruderAutoFans();
extruder_autofan_last_check = ms; previous_auto_fan_check_ms = ms;
} }
#endif #endif
#ifndef PIDTEMPBED #ifndef PIDTEMPBED
if (ms < previous_millis_bed_heater + BED_CHECK_INTERVAL) return; if (ms < previous_bed_check_ms + BED_CHECK_INTERVAL) return;
previous_millis_bed_heater = ms; previous_bed_check_ms = ms;
#endif //PIDTEMPBED #endif //PIDTEMPBED
#if TEMP_SENSOR_BED != 0 #if TEMP_SENSOR_BED != 0
@ -992,7 +992,7 @@ void tp_init()
void setWatch() { void setWatch() {
#ifdef WATCH_TEMP_PERIOD #ifdef WATCH_TEMP_PERIOD
unsigned long ms = millis(); millis_t ms = millis();
for (int e = 0; e < EXTRUDERS; e++) { for (int e = 0; e < EXTRUDERS; e++) {
if (degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE * 2)) { if (degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE * 2)) {
watch_start_temp[e] = degHotend(e); watch_start_temp[e] = degHotend(e);
@ -1004,7 +1004,7 @@ void setWatch() {
#if HAS_HEATER_THERMAL_PROTECTION || HAS_BED_THERMAL_PROTECTION #if HAS_HEATER_THERMAL_PROTECTION || HAS_BED_THERMAL_PROTECTION
void thermal_runaway_protection(TRState *state, unsigned long *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) { void thermal_runaway_protection(TRState *state, millis_t *timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) {
static float tr_target_temperature[EXTRUDERS+1] = { 0.0 }; static float tr_target_temperature[EXTRUDERS+1] = { 0.0 };
@ -1109,16 +1109,16 @@ void disable_heater() {
#ifdef HEATER_0_USES_MAX6675 #ifdef HEATER_0_USES_MAX6675
#define MAX6675_HEAT_INTERVAL 250u #define MAX6675_HEAT_INTERVAL 250u
unsigned long max6675_previous_millis = MAX6675_HEAT_INTERVAL; millis_t previous_max6675_ms = MAX6675_HEAT_INTERVAL;
int max6675_temp = 2000; int max6675_temp = 2000;
static int read_max6675() { static int read_max6675() {
unsigned long ms = millis(); millis_t ms = millis();
if (ms < max6675_previous_millis + MAX6675_HEAT_INTERVAL) if (ms < previous_max6675_ms + MAX6675_HEAT_INTERVAL)
return max6675_temp; return max6675_temp;
max6675_previous_millis = ms; previous_max6675_ms = ms;
max6675_temp = 0; max6675_temp = 0;
#ifdef PRR #ifdef PRR

69
Marlin/ultralcd.cpp
View File

@ -22,7 +22,7 @@ int absPreheatHPBTemp;
int absPreheatFanSpeed; int absPreheatFanSpeed;
#ifdef FILAMENT_LCD_DISPLAY #ifdef FILAMENT_LCD_DISPLAY
unsigned long message_millis = 0; millis_t previous_lcd_status_ms = 0;
#endif #endif
/* !Configuration settings */ /* !Configuration settings */
@ -77,8 +77,6 @@ static void lcd_status_screen();
static void lcd_level_bed(); static void lcd_level_bed();
#endif #endif
static void lcd_quick_feedback();//Cause an LCD refresh, and give the user visual or audible feedback that something has happened
/* Different types of actions that can be used in menu items. */ /* Different types of actions that can be used in menu items. */
static void menu_action_back(menuFunc_t data); static void menu_action_back(menuFunc_t data);
static void menu_action_submenu(menuFunc_t data); static void menu_action_submenu(menuFunc_t data);
@ -220,7 +218,7 @@ static void lcd_status_screen();
volatile uint8_t slow_buttons; // Bits of the pressed buttons. volatile uint8_t slow_buttons; // Bits of the pressed buttons.
#endif #endif
uint8_t currentMenuViewOffset; /* scroll offset in the current menu */ uint8_t currentMenuViewOffset; /* scroll offset in the current menu */
uint32_t blocking_enc; millis_t next_button_update_ms;
uint8_t lastEncoderBits; uint8_t lastEncoderBits;
uint32_t encoderPosition; uint32_t encoderPosition;
#if (SDCARDDETECT > 0) #if (SDCARDDETECT > 0)
@ -230,7 +228,7 @@ static void lcd_status_screen();
#endif // ULTIPANEL #endif // ULTIPANEL
menuFunc_t currentMenu = lcd_status_screen; /* function pointer to the currently active menu */ menuFunc_t currentMenu = lcd_status_screen; /* function pointer to the currently active menu */
uint32_t lcd_next_update_millis; millis_t next_lcd_update_ms;
uint8_t lcd_status_update_delay; uint8_t lcd_status_update_delay;
bool ignore_click = false; bool ignore_click = false;
bool wait_for_unclick; bool wait_for_unclick;
@ -267,7 +265,7 @@ static void lcd_status_screen() {
encoderRateMultiplierEnabled = false; encoderRateMultiplierEnabled = false;
#ifdef LCD_PROGRESS_BAR #ifdef LCD_PROGRESS_BAR
unsigned long ms = millis(); millis_t ms = millis();
#ifndef PROGRESS_MSG_ONCE #ifndef PROGRESS_MSG_ONCE
if (ms > progressBarTick + PROGRESS_BAR_MSG_TIME + PROGRESS_BAR_BAR_TIME) { if (ms > progressBarTick + PROGRESS_BAR_MSG_TIME + PROGRESS_BAR_BAR_TIME) {
progressBarTick = ms; progressBarTick = ms;
@ -324,7 +322,7 @@ static void lcd_status_screen() {
#endif #endif
); );
#ifdef FILAMENT_LCD_DISPLAY #ifdef FILAMENT_LCD_DISPLAY
message_millis = millis(); // get status message to show up for a while previous_lcd_status_ms = millis(); // get status message to show up for a while
#endif #endif
} }
@ -433,7 +431,7 @@ void lcd_set_home_offsets() {
plan_set_position(0.0, 0.0, 0.0, current_position[E_AXIS]); plan_set_position(0.0, 0.0, 0.0, current_position[E_AXIS]);
// Audio feedback // Audio feedback
enquecommands_P(PSTR("M300 S659 P200\nM300 S698 P200")); enqueuecommands_P(PSTR("M300 S659 P200\nM300 S698 P200"));
lcd_return_to_status(); lcd_return_to_status();
} }
@ -1114,15 +1112,15 @@ menu_edit_type(unsigned long, long5, ftostr5, 0.01)
lcd_move_y(); lcd_move_y();
} }
static void reprapworld_keypad_move_home() { static void reprapworld_keypad_move_home() {
enquecommands_P((PSTR("G28"))); // move all axis home enqueuecommands_P((PSTR("G28"))); // move all axis home
} }
#endif //REPRAPWORLD_KEYPAD #endif //REPRAPWORLD_KEYPAD
/** End of menus **/ /** End of menus **/
static void lcd_quick_feedback() { void lcd_quick_feedback() {
lcdDrawUpdate = 2; lcdDrawUpdate = 2;
blocking_enc = millis() + 500; next_button_update_ms = millis() + 500;
#ifdef LCD_USE_I2C_BUZZER #ifdef LCD_USE_I2C_BUZZER
#ifndef LCD_FEEDBACK_FREQUENCY_HZ #ifndef LCD_FEEDBACK_FREQUENCY_HZ
@ -1140,15 +1138,15 @@ static void lcd_quick_feedback() {
#ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2 #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
#endif #endif
const unsigned int delay = 1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2; const uint16_t delay = 1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2;
int i = LCD_FEEDBACK_FREQUENCY_DURATION_MS * LCD_FEEDBACK_FREQUENCY_HZ / 1000; uint16_t i = LCD_FEEDBACK_FREQUENCY_DURATION_MS * LCD_FEEDBACK_FREQUENCY_HZ / 1000;
while (i--) { while (i--) {
WRITE(BEEPER,HIGH); WRITE(BEEPER,HIGH);
delayMicroseconds(delay); delayMicroseconds(delay);
WRITE(BEEPER,LOW); WRITE(BEEPER,LOW);
delayMicroseconds(delay); delayMicroseconds(delay);
} }
const int j = max(10000 - LCD_FEEDBACK_FREQUENCY_DURATION_MS * 1000, 0); const uint16_t j = max(10000 - LCD_FEEDBACK_FREQUENCY_DURATION_MS * 1000, 0);
if (j) delayMicroseconds(j); if (j) delayMicroseconds(j);
#endif #endif
} }
@ -1156,15 +1154,15 @@ static void lcd_quick_feedback() {
/** Menu action functions **/ /** Menu action functions **/
static void menu_action_back(menuFunc_t data) { lcd_goto_menu(data); } static void menu_action_back(menuFunc_t data) { lcd_goto_menu(data); }
static void menu_action_submenu(menuFunc_t data) { lcd_goto_menu(data); } static void menu_action_submenu(menuFunc_t data) { lcd_goto_menu(data); }
static void menu_action_gcode(const char* pgcode) { enquecommands_P(pgcode); } static void menu_action_gcode(const char* pgcode) { enqueuecommands_P(pgcode); }
static void menu_action_function(menuFunc_t data) { (*data)(); } static void menu_action_function(menuFunc_t data) { (*data)(); }
static void menu_action_sdfile(const char* filename, char* longFilename) { static void menu_action_sdfile(const char* filename, char* longFilename) {
char cmd[30]; char cmd[30];
char* c; char* c;
sprintf_P(cmd, PSTR("M23 %s"), filename); sprintf_P(cmd, PSTR("M23 %s"), filename);
for(c = &cmd[4]; *c; c++) *c = tolower(*c); for(c = &cmd[4]; *c; c++) *c = tolower(*c);
enquecommand(cmd); enqueuecommand(cmd);
enquecommands_P(PSTR("M24")); enqueuecommands_P(PSTR("M24"));
lcd_return_to_status(); lcd_return_to_status();
} }
static void menu_action_sddirectory(const char* filename, char* longFilename) { static void menu_action_sddirectory(const char* filename, char* longFilename) {
@ -1252,7 +1250,7 @@ int lcd_strlen_P(const char *s) {
void lcd_update() { void lcd_update() {
#ifdef ULTIPANEL #ifdef ULTIPANEL
static unsigned long timeoutToStatus = 0; static millis_t return_to_status_ms = 0;
#endif #endif
#ifdef LCD_HAS_SLOW_BUTTONS #ifdef LCD_HAS_SLOW_BUTTONS
@ -1282,8 +1280,8 @@ void lcd_update() {
} }
#endif//CARDINSERTED #endif//CARDINSERTED
uint32_t ms = millis(); millis_t ms = millis();
if (ms > lcd_next_update_millis) { if (ms > next_lcd_update_ms) {
#ifdef ULTIPANEL #ifdef ULTIPANEL
@ -1335,7 +1333,7 @@ void lcd_update() {
encoderPosition += (encoderDiff * encoderMultiplier) / ENCODER_PULSES_PER_STEP; encoderPosition += (encoderDiff * encoderMultiplier) / ENCODER_PULSES_PER_STEP;
encoderDiff = 0; encoderDiff = 0;
} }
timeoutToStatus = ms + LCD_TIMEOUT_TO_STATUS; return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
lcdDrawUpdate = 1; lcdDrawUpdate = 1;
} }
#endif //ULTIPANEL #endif //ULTIPANEL
@ -1371,20 +1369,24 @@ void lcd_update() {
#endif #endif
#ifdef ULTIPANEL #ifdef ULTIPANEL
// Return to Status Screen after a timeout
if (currentMenu != lcd_status_screen && if (currentMenu != lcd_status_screen &&
#if defined(MANUAL_BED_LEVELING) #ifdef MANUAL_BED_LEVELING
currentMenu != _lcd_level_bed && currentMenu != _lcd_level_bed &&
currentMenu != _lcd_level_bed_homing && currentMenu != _lcd_level_bed_homing &&
#endif // MANUAL_BED_LEVELING #endif
millis() > timeoutToStatus) { millis() > return_to_status_ms
) {
lcd_return_to_status(); lcd_return_to_status();
lcdDrawUpdate = 2; lcdDrawUpdate = 2;
} }
#endif //ULTIPANEL
#endif // ULTIPANEL
if (lcdDrawUpdate == 2) lcd_implementation_clear(); if (lcdDrawUpdate == 2) lcd_implementation_clear();
if (lcdDrawUpdate) lcdDrawUpdate--; if (lcdDrawUpdate) lcdDrawUpdate--;
lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL; next_lcd_update_ms = millis() + LCD_UPDATE_INTERVAL;
} }
} }
@ -1403,7 +1405,7 @@ void lcd_finishstatus(bool persist=false) {
lcdDrawUpdate = 2; lcdDrawUpdate = 2;
#ifdef FILAMENT_LCD_DISPLAY #ifdef FILAMENT_LCD_DISPLAY
message_millis = millis(); //get status message to show up for a while previous_lcd_status_ms = millis(); //get status message to show up for a while
#endif #endif
} }
@ -1473,7 +1475,7 @@ void lcd_buttons_update() {
if (READ(BTN_EN1) == 0) newbutton |= EN_A; if (READ(BTN_EN1) == 0) newbutton |= EN_A;
if (READ(BTN_EN2) == 0) newbutton |= EN_B; if (READ(BTN_EN2) == 0) newbutton |= EN_B;
#if BTN_ENC > 0 #if BTN_ENC > 0
if (millis() > blocking_enc && READ(BTN_ENC) == 0) newbutton |= EN_C; if (millis() > next_button_update_ms && READ(BTN_ENC) == 0) newbutton |= EN_C;
#endif #endif
buttons = newbutton; buttons = newbutton;
#ifdef LCD_HAS_SLOW_BUTTONS #ifdef LCD_HAS_SLOW_BUTTONS
@ -1797,7 +1799,7 @@ char *ftostr52(const float &x) {
if (max_software_endstops && current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; if (max_software_endstops && current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
encoderPosition = 0; encoderPosition = 0;
line_to_current(); line_to_current();
lcdDrawUpdate = 1; lcdDrawUpdate = 2;
} }
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Z"), ftostr43(current_position[Z_AXIS])); if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Z"), ftostr43(current_position[Z_AXIS]));
static bool debounce_click = false; static bool debounce_click = false;
@ -1815,7 +1817,7 @@ char *ftostr52(const float &x) {
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
line_to_current(); line_to_current();
mbl.active = 1; mbl.active = 1;
enquecommands_P(PSTR("G28")); enqueuecommands_P(PSTR("G28"));
lcd_return_to_status(); lcd_return_to_status();
} else { } else {
current_position[Z_AXIS] = MESH_HOME_SEARCH_Z; current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
@ -1828,7 +1830,7 @@ char *ftostr52(const float &x) {
current_position[X_AXIS] = mbl.get_x(ix); current_position[X_AXIS] = mbl.get_x(ix);
current_position[Y_AXIS] = mbl.get_y(iy); current_position[Y_AXIS] = mbl.get_y(iy);
line_to_current(); line_to_current();
lcdDrawUpdate = 1; lcdDrawUpdate = 2;
} }
} }
} else { } else {
@ -1837,6 +1839,7 @@ char *ftostr52(const float &x) {
} }
static void _lcd_level_bed_homing() { static void _lcd_level_bed_homing() {
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("XYZ"), "Homing");
if (axis_known_position[X_AXIS] && if (axis_known_position[X_AXIS] &&
axis_known_position[Y_AXIS] && axis_known_position[Y_AXIS] &&
axis_known_position[Z_AXIS]) { axis_known_position[Z_AXIS]) {
@ -1848,6 +1851,7 @@ char *ftostr52(const float &x) {
_lcd_level_bed_position = 0; _lcd_level_bed_position = 0;
lcd_goto_menu(_lcd_level_bed); lcd_goto_menu(_lcd_level_bed);
} }
lcdDrawUpdate = 2;
} }
static void lcd_level_bed() { static void lcd_level_bed() {
@ -1855,7 +1859,8 @@ char *ftostr52(const float &x) {
axis_known_position[Y_AXIS] = false; axis_known_position[Y_AXIS] = false;
axis_known_position[Z_AXIS] = false; axis_known_position[Z_AXIS] = false;
mbl.reset(); mbl.reset();
enquecommands_P(PSTR("G28")); enqueuecommands_P(PSTR("G28"));
lcdDrawUpdate = 2;
lcd_goto_menu(_lcd_level_bed_homing); lcd_goto_menu(_lcd_level_bed_homing);
} }

3
Marlin/ultralcd.h
View File

@ -49,10 +49,11 @@
extern bool cancel_heatup; extern bool cancel_heatup;
#ifdef FILAMENT_LCD_DISPLAY #ifdef FILAMENT_LCD_DISPLAY
extern unsigned long message_millis; extern millis_t previous_lcd_status_ms;
#endif #endif
void lcd_buzz(long duration,uint16_t freq); void lcd_buzz(long duration,uint16_t freq);
void lcd_quick_feedback(); // Audible feedback for a button click - could also be visual
bool lcd_clicked(); bool lcd_clicked();
void lcd_ignore_click(bool b=true); void lcd_ignore_click(bool b=true);

29
Marlin/ultralcd_implementation_hitachi_HD44780.h
View File

@ -610,7 +610,7 @@ static void lcd_implementation_status_screen() {
// Show Filament Diameter and Volumetric Multiplier % // Show Filament Diameter and Volumetric Multiplier %
// After allowing lcd_status_message to show for 5 seconds // After allowing lcd_status_message to show for 5 seconds
if (millis() >= message_millis + 5000) { if (millis() >= previous_lcd_status_ms + 5000) {
lcd_printPGM(PSTR("Dia ")); lcd_printPGM(PSTR("Dia "));
lcd.print(ftostr12ns(filament_width_meas)); lcd.print(ftostr12ns(filament_width_meas));
lcd_printPGM(PSTR(" V")); lcd_printPGM(PSTR(" V"));
@ -724,8 +724,8 @@ static void lcd_implementation_drawmenu_sddirectory(bool sel, uint8_t row, const
#define lcd_implementation_drawmenu_function(sel, row, pstr, data) lcd_implementation_drawmenu_generic(sel, row, pstr, '>', ' ') #define lcd_implementation_drawmenu_function(sel, row, pstr, data) lcd_implementation_drawmenu_generic(sel, row, pstr, '>', ' ')
#ifdef LCD_HAS_STATUS_INDICATORS #ifdef LCD_HAS_STATUS_INDICATORS
static void lcd_implementation_update_indicators()
{ static void lcd_implementation_update_indicators() {
#if defined(LCD_I2C_PANELOLU2) || defined(LCD_I2C_VIKI) #if defined(LCD_I2C_PANELOLU2) || defined(LCD_I2C_VIKI)
//set the LEDS - referred to as backlights by the LiquidTWI2 library //set the LEDS - referred to as backlights by the LiquidTWI2 library
static uint8_t ledsprev = 0; static uint8_t ledsprev = 0;
@ -741,29 +741,28 @@ static void lcd_implementation_update_indicators()
ledsprev = leds; ledsprev = leds;
} }
#endif #endif
} }
#endif
#endif // LCD_HAS_STATUS_INDICATORS
#ifdef LCD_HAS_SLOW_BUTTONS #ifdef LCD_HAS_SLOW_BUTTONS
extern uint32_t blocking_enc;
static uint8_t lcd_implementation_read_slow_buttons() extern millis_t next_button_update_ms;
{
static uint8_t lcd_implementation_read_slow_buttons() {
#ifdef LCD_I2C_TYPE_MCP23017 #ifdef LCD_I2C_TYPE_MCP23017
uint8_t slow_buttons; uint8_t slow_buttons;
// Reading these buttons this is likely to be too slow to call inside interrupt context // Reading these buttons this is likely to be too slow to call inside interrupt context
// so they are called during normal lcd_update // so they are called during normal lcd_update
slow_buttons = lcd.readButtons() << B_I2C_BTN_OFFSET; slow_buttons = lcd.readButtons() << B_I2C_BTN_OFFSET;
#if defined(LCD_I2C_VIKI) #ifdef LCD_I2C_VIKI
if(slow_buttons & (B_MI|B_RI)) { //LCD clicked if ((slow_buttons & (B_MI|B_RI)) && millis() < next_button_update_ms) // LCD clicked
if(blocking_enc > millis()) {
slow_buttons &= ~(B_MI|B_RI); // Disable LCD clicked buttons if screen is updated slow_buttons &= ~(B_MI|B_RI); // Disable LCD clicked buttons if screen is updated
}
}
#endif #endif
return slow_buttons; return slow_buttons;
#endif #endif
} }
#endif
#endif // LCD_HAS_SLOW_BUTTONS
#endif //__ULTRALCD_IMPLEMENTATION_HITACHI_HD44780_H #endif //__ULTRALCD_IMPLEMENTATION_HITACHI_HD44780_H

Write Preview
Loading…
Cancel
Save