forksand
/
marlin-lulzbot-laser
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'origin/Marlin_v1' into Marlin_v1

Browse Source
master
Erik van der Zalm 13 years ago
parent 65934eee9c 9980ceb4a3
commit ac82411c73
16 changed files with 1434 additions and 1147 deletions
Show Stats Download Patch File Download Diff File

268
Marlin/Configuration.h
Unescape View File

@ -1,10 +1,13 @@
#ifndef __CONFIGURATION_H #ifndef __CONFIGURATION_H
#define __CONFIGURATION_H #define __CONFIGURATION_H
//#define DEBUG_STEPS
#define MM_PER_ARC_SEGMENT 1
#define N_ARC_CORRECTION 25 // This determines the communication speed of the printer
//#define BAUDRATE 250000
#define BAUDRATE 115200
//#define BAUDRATE 230400
// Frequency limit // Frequency limit
// See nophead's blog for more info // See nophead's blog for more info
@ -26,7 +29,9 @@
// Teensylu = 8 // Teensylu = 8
#define MOTHERBOARD 7 #define MOTHERBOARD 7
//===========================================================================
//=============================Thermal Settings ============================
//===========================================================================
//// Thermistor settings: //// Thermistor settings:
// 1 is 100k thermistor // 1 is 100k thermistor
@ -49,49 +54,103 @@
//#define BED_USES_THERMISTOR //#define BED_USES_THERMISTOR
//#define BED_USES_AD595 //#define BED_USES_AD595
#define HEATER_CHECK_INTERVAL 50 #define HEATER_CHECK_INTERVAL 50 //ms
#define BED_CHECK_INTERVAL 5000 #define BED_CHECK_INTERVAL 5000 //ms
//// Experimental watchdog and minimal temp
// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
// If the temperature has not increased at the end of that period, the target temperature is set to zero. It can be reset with another M104/M109
/// CURRENTLY NOT IMPLEMENTED AND UNUSEABLE
//#define WATCHPERIOD 5000 //5 seconds
//// Endstop Settings // Actual temperature must be close to target for this long before M109 returns success
#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors //#define TEMP_RESIDENCY_TIME 20 // (seconds)
// The pullups are needed if you directly connect a mechanical endswitch between the signal and ground pins. //#define TEMP_HYSTERESIS 5 // (C°) range of +/- temperatures considered "close" to the target one
const bool ENDSTOPS_INVERTING = true; // set to true to invert the logic of the endstops.
// For optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
// This determines the communication speed of the printer //// The minimal temperature defines the temperature below which the heater will not be enabled
#define BAUDRATE 250000 #define HEATER_0_MINTEMP 5
//#define BAUDRATE 115200 //#define HEATER_1_MINTEMP 5
//#define BAUDRATE 230400 //#define BED_MINTEMP 5
// Comment out (using // at the start of the line) to disable SD support:
// #define ULTRA_LCD //any lcd // When temperature exceeds max temp, your heater will be switched off.
// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure!
// You should use MINTEMP for thermistor short/failure protection.
#define HEATER_0_MAXTEMP 275
//#define_HEATER_1_MAXTEMP 275
//#define BED_MAXTEMP 150
#define ULTIPANEL
#ifdef ULTIPANEL
//#define NEWPANEL //enable this if you have a click-encoder panel // PID settings:
#define SDSUPPORT // Uncomment the following line to enable PID support.
#define ULTRA_LCD
#define LCD_WIDTH 20 #define PIDTEMP
#define LCD_HEIGHT 4 #ifdef PIDTEMP
#else //no panel but just lcd //#define PID_DEBUG // Sends debug data to the serial port.
#ifdef ULTRA_LCD //#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
#define LCD_WIDTH 16
#define LCD_HEIGHT 2 #define PID_MAX 255 // limits current to nozzle; 255=full current
#define PID_INTEGRAL_DRIVE_MAX 255 //limit for the integral term
#define K1 0.95 //smoothing factor withing the PID
#define PID_dT 0.1 //sampling period of the PID
//To develop some PID settings for your machine, you can initiall follow
// the Ziegler-Nichols method.
// set Ki and Kd to zero.
// heat with a defined Kp and see if the temperature stabilizes
// ideally you do this graphically with repg.
// the PID_CRITIAL_GAIN should be the Kp at which temperature oscillatins are not dampned out/decreas in amplitutde
// PID_SWING_AT_CRITIAL is the time for a full period of the oscillations at the critical Gain
// usually further manual tunine is necessary.
#define PID_CRITIAL_GAIN 3000
#define PID_SWING_AT_CRITIAL 45 //seconds
#define PID_PI //no differentail term
//#define PID_PID //normal PID
#ifdef PID_PID
//PID according to Ziegler-Nichols method
#define DEFAULT_Kp (0.6*PID_CRITIAL_GAIN)
#define DEFAULT_Ki (2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
#define DEFAULT_Kd (PID_SWING_AT_CRITIAL/8./PID_dT)
#endif #endif
#endif
#ifdef PID_PI
//PI according to Ziegler-Nichols method
#define DEFAULT_Kp (PID_CRITIAL_GAIN/2.2)
#define DEFAULT_Ki (1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
#define DEFAULT_Kd (0)
#endif
// this adds an experimental additional term to the heatingpower, proportional to the extrusion speed.
// if Kc is choosen well, the additional required power due to increased melting should be compensated.
#define PID_ADD_EXTRUSION_RATE
#ifdef PID_ADD_EXTRUSION_RATE
#define DEFAULT_Kc (3) //heatingpower=Kc*(e_speed)
#endif
#endif // PIDTEMP
//#define SDSUPPORT // Enable SD Card Support in Hardware Console
const int dropsegments=5; //everything with this number of steps will be ignored as move
//// ADVANCED SETTINGS - to tweak parameters
#include "thermistortables.h"
//===========================================================================
//=============================Mechanical Settings===========================
//===========================================================================
// Endstop Settings
#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors
// The pullups are needed if you directly connect a mechanical endswitch between the signal and ground pins.
const bool ENDSTOPS_INVERTING = true; // set to true to invert the logic of the endstops.
// For optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
// For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1 // For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1
#define X_ENABLE_ON 0 #define X_ENABLE_ON 0
@ -156,88 +215,33 @@ const int dropsegments=5; //everything with this number of steps will be ignore
#define DEFAULT_ZJERK 0.4 // (mm/sec) #define DEFAULT_ZJERK 0.4 // (mm/sec)
// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
//this enables the watchdog interrupt.
#define USE_WATCHDOG
//you cannot reboot on a mega2560 due to a bug in he bootloader. Hence, you have to reset manually, and this is done hereby:
#define RESET_MANUAL
#define WATCHDOG_TIMEOUT 4
//// Experimental watchdog and minimal temp
// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
// If the temperature has not increased at the end of that period, the target temperature is set to zero. It can be reset with another M104/M109
/// CURRENTLY NOT IMPLEMENTED AND UNUSEABLE
//#define WATCHPERIOD 5000 //5 seconds
// Actual temperature must be close to target for this long before M109 returns success
//#define TEMP_RESIDENCY_TIME 20 // (seconds)
//#define TEMP_HYSTERESIS 5 // (C°) range of +/- temperatures considered "close" to the target one
//// The minimal temperature defines the temperature below which the heater will not be enabled
//#define HEATER_0_MINTEMP 5
//#define HEATER_1_MINTEMP 5
//#define BED_MINTEMP 5
//===========================================================================
//=============================Additional Features===========================
//===========================================================================
// When temperature exceeds max temp, your heater will be switched off. // EEPROM
// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure! // the microcontroller can store settings in the EEPROM, e.g. max velocity...
// You should use MINTEMP for thermistor short/failure protection. // M500 - stores paramters in EEPROM
//#define HEATER_0_MAXTEMP 275 // M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).
//#define_HEATER_1_MAXTEMP 275 // M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to.
//#define BED_MAXTEMP 150 //define this to enable eeprom support
#define EEPROM_SETTINGS
//to disable EEPROM Serial responses and decrease program space by ~1700 byte: comment this out:
// please keep turned on if you can.
#define EEPROM_CHITCHAT
/// PID settings:
// Uncomment the following line to enable PID support.
#define PIDTEMP // The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
#ifdef PIDTEMP // this enables the watchdog interrupt.
//#define PID_DEBUG // Sends debug data to the serial port. #define USE_WATCHDOG
//#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in % // you cannot reboot on a mega2560 due to a bug in he bootloader. Hence, you have to reset manually, and this is done hereby:
#define RESET_MANUAL
#define PID_MAX 255 // limits current to nozzle; 255=full current #define WATCHDOG_TIMEOUT 4 //seconds
#define PID_INTEGRAL_DRIVE_MAX 255 //limit for the integral term
#define K1 0.95 //smoothing factor withing the PID
#define PID_dT 0.1 //sampling period of the PID
//To develop some PID settings for your machine, you can initiall follow
// the Ziegler-Nichols method.
// set Ki and Kd to zero.
// heat with a defined Kp and see if the temperature stabilizes
// ideally you do this graphically with repg.
// the PID_CRITIAL_GAIN should be the Kp at which temperature oscillatins are not dampned out/decreas in amplitutde
// PID_SWING_AT_CRITIAL is the time for a full period of the oscillations at the critical Gain
// usually further manual tunine is necessary.
#define PID_CRITIAL_GAIN 3000
#define PID_SWING_AT_CRITIAL 45 //seconds
#define PID_PI //no differentail term
//#define PID_PID //normal PID
#ifdef PID_PID
//PID according to Ziegler-Nichols method
#define DEFAULT_Kp (0.6*PID_CRITIAL_GAIN)
#define DEFAULT_Ki (2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
#define DEFAULT_Kd (PID_SWING_AT_CRITIAL/8./PID_dT)
#endif
#ifdef PID_PI
//PI according to Ziegler-Nichols method
#define DEFAULT_Kp (PID_CRITIAL_GAIN/2.2)
#define DEFAULT_Ki (1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT)
#define DEFAULT_Kd (0)
#endif
// this adds an experimental additional term to the heatingpower, proportional to the extrusion speed.
// if Kc is choosen well, the additional required power due to increased melting should be compensated.
#define PID_ADD_EXTRUSION_RATE
#ifdef PID_ADD_EXTRUSION_RATE
#define DEFAULT_Kc (5) //heatingpower=Kc*(e_speed)
#endif
#endif // PIDTEMP
// extruder advance constant (s2/mm3) // extruder advance constant (s2/mm3)
// //
@ -258,6 +262,52 @@ const int dropsegments=5; //everything with this number of steps will be ignore
#endif // ADVANCE #endif // ADVANCE
//LCD and SD support
//#define ULTRA_LCD //general lcd support, also 16x2
//#define SDSUPPORT // Enable SD Card Support in Hardware Console
#define ULTIPANEL
#ifdef ULTIPANEL
#define NEWPANEL //enable this if you have a click-encoder panel
#define SDSUPPORT
#define ULTRA_LCD
#define LCD_WIDTH 20
#define LCD_HEIGHT 4
#else //no panel but just lcd
#ifdef ULTRA_LCD
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#endif
#endif
// A debugging feature to compare calculated vs performed steps, to see if steps are lost by the software.
//#define DEBUG_STEPS
// Arc interpretation settings:
#define MM_PER_ARC_SEGMENT 1
#define N_ARC_CORRECTION 25
//automatic temperature: just for testing, this is very dangerous, keep disabled!
// not working yet.
//Erik: the settings currently depend dramatically on skeinforge39 or 41.
//#define AUTOTEMP
#define AUTOTEMP_MIN 190
#define AUTOTEMP_MAX 260
#define AUTOTEMP_FACTOR 1000. //current target temperature= min+largest buffered espeeds)*FACTOR
const int dropsegments=0; //everything with less than this number of steps will be ignored as move and joined with the next movement
//===========================================================================
//=============================Buffers ============================
//===========================================================================
// The number of linear motions that can be in the plan at any give time. // The number of linear motions that can be in the plan at any give time.
// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ringbuffering. // THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ringbuffering.
#if defined SDSUPPORT #if defined SDSUPPORT
@ -266,8 +316,12 @@ const int dropsegments=5; //everything with this number of steps will be ignore
#define BLOCK_BUFFER_SIZE 8 // maximize block buffer #define BLOCK_BUFFER_SIZE 8 // maximize block buffer
#endif #endif
//The ASCII buffer for recieving from the serial: //The ASCII buffer for recieving from the serial:
#define MAX_CMD_SIZE 96 #define MAX_CMD_SIZE 96
#define BUFSIZE 4 #define BUFSIZE 4
#include "thermistortables.h"
#endif //__CONFIGURATION_H #endif //__CONFIGURATION_H

80
Marlin/EEPROMwrite.h
Unescape View File

@ -25,6 +25,9 @@ template <class T> int EEPROM_readAnything(int &ee, T& value)
} }
//====================================================================================== //======================================================================================
#define EEPROM_OFFSET 100 #define EEPROM_OFFSET 100
@ -35,8 +38,9 @@ template <class T> int EEPROM_readAnything(int &ee, T& value)
// ALSO: always make sure the variables in the Store and retrieve sections are in the same order. // ALSO: always make sure the variables in the Store and retrieve sections are in the same order.
#define EEPROM_VERSION "V04" #define EEPROM_VERSION "V04"
void StoreSettings() inline void StoreSettings()
{ {
#ifdef EEPROM_SETTINGS
char ver[4]= "000"; char ver[4]= "000";
int i=EEPROM_OFFSET; int i=EEPROM_OFFSET;
EEPROM_writeAnything(i,ver); // invalidate data first EEPROM_writeAnything(i,ver); // invalidate data first
@ -62,11 +66,14 @@ void StoreSettings()
char ver2[4]=EEPROM_VERSION; char ver2[4]=EEPROM_VERSION;
i=EEPROM_OFFSET; i=EEPROM_OFFSET;
EEPROM_writeAnything(i,ver2); // validate data EEPROM_writeAnything(i,ver2); // validate data
SERIAL_ECHOLN("Settings Stored"); SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Settings Stored");
#endif //EEPROM_SETTINGS
} }
void RetrieveSettings(bool def=false) inline void RetrieveSettings(bool def=false)
{ // if def=true, the default values will be used { // if def=true, the default values will be used
#ifdef EEPROM_SETTINGS
int i=EEPROM_OFFSET; int i=EEPROM_OFFSET;
char stored_ver[4]; char stored_ver[4];
char ver[4]=EEPROM_VERSION; char ver[4]=EEPROM_VERSION;
@ -91,7 +98,8 @@ void RetrieveSettings(bool def=false)
EEPROM_readAnything(i,Ki); EEPROM_readAnything(i,Ki);
EEPROM_readAnything(i,Kd); EEPROM_readAnything(i,Kd);
SERIAL_ECHOLN("Stored settings retreived:"); SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Stored settings retreived:");
} }
else else
{ {
@ -111,22 +119,62 @@ void RetrieveSettings(bool def=false)
mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE; mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
max_xy_jerk=DEFAULT_XYJERK; max_xy_jerk=DEFAULT_XYJERK;
max_z_jerk=DEFAULT_ZJERK; max_z_jerk=DEFAULT_ZJERK;
SERIAL_ECHO_START;
SERIAL_ECHOLN("Using Default settings:"); SERIAL_ECHOLN("Using Default settings:");
} }
SERIAL_ECHOLN("Steps per unit:"); #ifdef EEPROM_CHITCHAT
SERIAL_ECHOLN(" M92 X" <<_FLOAT(axis_steps_per_unit[0],3) << " Y" << _FLOAT(axis_steps_per_unit[1],3) << " Z" << _FLOAT(axis_steps_per_unit[2],3) << " E" << _FLOAT(axis_steps_per_unit[3],3)); SERIAL_ECHO_START;
SERIAL_ECHOLN("Maximum feedrates (mm/s):"); SERIAL_ECHOLNPGM("Steps per unit:");
SERIAL_ECHOLN(" M203 X" <<_FLOAT(max_feedrate[0]/60,2)<<" Y" << _FLOAT(max_feedrate[1]/60,2) << " Z" << _FLOAT(max_feedrate[2]/60,2) << " E" << _FLOAT(max_feedrate[3]/60,2)); SERIAL_ECHO_START;
SERIAL_ECHOLN("Maximum Acceleration (mm/s2):"); SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[0]);
SERIAL_ECHOLN(" M201 X" <<_FLOAT(max_acceleration_units_per_sq_second[0],0) << " Y" << _FLOAT(max_acceleration_units_per_sq_second[1],0) << " Z" << _FLOAT(max_acceleration_units_per_sq_second[2],0) << " E" << _FLOAT(max_acceleration_units_per_sq_second[3],0)); SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[1]);
SERIAL_ECHOLN("Acceleration: S=acceleration, T=retract acceleration"); SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[2]);
SERIAL_ECHOLN(" M204 S" <<_FLOAT(acceleration,2) << " T" << _FLOAT(retract_acceleration,2)); SERIAL_ECHOPAIR(" E",axis_steps_per_unit[3]);
SERIAL_ECHOLN("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum xY jerk (mm/s), Z=maximum Z jerk (mm/s)"); SERIAL_ECHOLN("");
SERIAL_ECHOLN(" M205 S" <<_FLOAT(minimumfeedrate/60,2) << " T" << _FLOAT(mintravelfeedrate/60,2) << " B" << _FLOAT(minsegmenttime,2) << " X" << _FLOAT(max_xy_jerk/60,2) << " Z" << _FLOAT(max_z_jerk/60,2));
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Maximum feedrates (mm/s):");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M203 X",max_feedrate[0]/60);
SERIAL_ECHOPAIR(" Y",max_feedrate[1]/60 );
SERIAL_ECHOPAIR(" Z", max_feedrate[2]/60 );
SERIAL_ECHOPAIR(" E", max_feedrate[3]/60);
SERIAL_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Maximum Acceleration (mm/s2):");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M201 X" ,max_acceleration_units_per_sq_second[0] );
SERIAL_ECHOPAIR(" Y" , max_acceleration_units_per_sq_second[1] );
SERIAL_ECHOPAIR(" Z" ,max_acceleration_units_per_sq_second[2] );
SERIAL_ECHOPAIR(" E" ,max_acceleration_units_per_sq_second[3]);
SERIAL_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Acceleration: S=acceleration, T=retract acceleration");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M204 S",acceleration );
SERIAL_ECHOPAIR(" T" ,retract_acceleration);
SERIAL_ECHOLN("");
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Advanced variables: S=Min feedrate (mm/s), T=Min travel feedrate (mm/s), B=minimum segment time (ms), X=maximum xY jerk (mm/s), Z=maximum Z jerk (mm/s)");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M205 S",minimumfeedrate/60 );
SERIAL_ECHOPAIR(" T" ,mintravelfeedrate/60 );
SERIAL_ECHOPAIR(" B" ,minsegmenttime );
SERIAL_ECHOPAIR(" X" ,max_xy_jerk/60 );
SERIAL_ECHOPAIR(" Z" ,max_z_jerk/60);
SERIAL_ECHOLN("");
#ifdef PIDTEMP #ifdef PIDTEMP
SERIAL_ECHOLN("PID settings:"); SERIAL_ECHO_START;
SERIAL_ECHOLN(" M301 P" << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3)); SERIAL_ECHOLNPGM("PID settings:");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M301 P",Kp );
SERIAL_ECHOPAIR(" I" ,Ki );
SERIAL_ECHOPAIR(" D" ,Kd);
SERIAL_ECHOLN("");
#endif
#endif #endif
#endif //EEPROM_SETTINGS
} }
#endif #endif

51
Marlin/Marlin.h
Unescape View File

@ -5,12 +5,52 @@
// Licence: GPL // Licence: GPL
#include <WProgram.h> #include <WProgram.h>
#include "fastio.h" #include "fastio.h"
#include <avr/pgmspace.h>
#include "Configuration.h"
//#define SERIAL_ECHO(x) Serial << "echo: " << x;
//#define SERIAL_ECHOLN(x) Serial << "echo: "<<x<<endl;
//#define SERIAL_ERROR(x) Serial << "Error: " << x;
//#define SERIAL_ERRORLN(x) Serial << "Error: " << x<<endl;
//#define SERIAL_PROTOCOL(x) Serial << x;
//#define SERIAL_PROTOCOLLN(x) Serial << x<<endl;
#define SERIAL_PROTOCOL(x) Serial.print(x);
#define SERIAL_PROTOCOLPGM(x) serialprintPGM(PSTR(x));
#define SERIAL_PROTOCOLLN(x) {Serial.print(x);Serial.write('\n');}
#define SERIAL_PROTOCOLLNPGM(x) {serialprintPGM(PSTR(x));Serial.write('\n');}
const char errormagic[] PROGMEM ="Error:";
const char echomagic[] PROGMEM ="echo:";
#define SERIAL_ERROR_START serialprintPGM(errormagic);
#define SERIAL_ERROR(x) SERIAL_PROTOCOL(x)
#define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x)
#define SERIAL_ERRORLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
#define SERIAL_ECHO_START serialprintPGM(echomagic);
#define SERIAL_ECHO(x) SERIAL_PROTOCOL(x)
#define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x)
#define SERIAL_ECHOLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
#define SERIAL_ECHOPAIR(name,value) {SERIAL_ECHOPGM(name);SERIAL_ECHO(value);}
//things to write to serial from Programmemory. saves 400 to 2k of RAM.
#define SerialprintPGM(x) serialprintPGM(PSTR(x))
inline void serialprintPGM(const char *str)
{
char ch=pgm_read_byte(str);
while(ch)
{
Serial.write(ch);
ch=pgm_read_byte(++str);
}
}
#include "streaming.h"
#define SERIAL_ECHO(x) Serial << "echo: " << x;
#define SERIAL_ECHOLN(x) Serial << "echo: "<<x<<endl;
#define SERIAL_ERROR(x) Serial << "echo: ERROR: " << x;
#define SERIAL_ERRORLN(x) Serial << "echo: ERROR: " << x<<endl;
void get_command(); void get_command();
void process_commands(); void process_commands();
@ -69,5 +109,6 @@ void enquecommand(const char *cmd); //put an ascii command at the end of the cur
extern float homing_feedrate[]; extern float homing_feedrate[];
extern bool axis_relative_modes[]; extern bool axis_relative_modes[];
extern float current_position[NUM_AXIS] ;
#endif #endif

251
Marlin/Marlin.pde
Unescape View File

@ -32,7 +32,6 @@
#include "pins.h" #include "pins.h"
#include "Marlin.h" #include "Marlin.h"
#include "ultralcd.h" #include "ultralcd.h"
#include "streaming.h"
#include "planner.h" #include "planner.h"
#include "stepper.h" #include "stepper.h"
#include "temperature.h" #include "temperature.h"
@ -40,7 +39,8 @@
#include "cardreader.h" #include "cardreader.h"
char version_string[] = "1.0.0 Alpha 1"; #define VERSION_STRING "1.0.0 Alpha 1"
@ -99,8 +99,9 @@ char version_string[] = "1.0.0 Alpha 1";
// 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 - advanced settings: minimum travel speed S=while printing T=travel only, B=minimum segment time X= maximum xy jerk, Z=maximum Z jerk
// M220 - set speed factor override percentage S:factor in percent // M220 - set speed factor override percentage S:factor in percent
// M301 - Set PID parameters P I and D // M301 - Set PID parameters P I and D
// M400 - Finish all moves
// M500 - stores paramters in EEPROM // M500 - stores paramters in EEPROM
// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). D // M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily).
// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. // M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to.
//Stepper Movement Variables //Stepper Movement Variables
@ -122,13 +123,14 @@ bool axis_relative_modes[] = AXIS_RELATIVE_MODES;
volatile int feedmultiply=100; //100->1 200->2 volatile int feedmultiply=100; //100->1 200->2
int saved_feedmultiply; int saved_feedmultiply;
volatile bool feedmultiplychanged=false; volatile bool feedmultiplychanged=false;
float current_position[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
//=========================================================================== //===========================================================================
//=============================private variables============================= //=============================private variables=============================
//=========================================================================== //===========================================================================
const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'}; const char axis_codes[NUM_AXIS] = {'X', 'Y', 'Z', 'E'};
static float destination[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0}; static float destination[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
static float current_position[NUM_AXIS] = { 0.0, 0.0, 0.0, 0.0};
static float offset[3] = {0.0, 0.0, 0.0}; static float offset[3] = {0.0, 0.0, 0.0};
static bool home_all_axis = true; static bool home_all_axis = true;
static float feedrate = 1500.0, next_feedrate, saved_feedrate; static float feedrate = 1500.0, next_feedrate, saved_feedrate;
@ -173,6 +175,23 @@ static unsigned long stoptime=0;
//=========================================================================== //===========================================================================
extern "C"{
extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;
int freeMemory() {
int free_memory;
if((int)__brkval == 0)
free_memory = ((int)&free_memory) - ((int)&__bss_end);
else
free_memory = ((int)&free_memory) - ((int)__brkval);
return free_memory;
}
}
//adds an command to the main command buffer //adds an command to the main command buffer
//thats really done in a non-safe way. //thats really done in a non-safe way.
@ -183,7 +202,10 @@ void enquecommand(const char *cmd)
{ {
//this is dangerous if a mixing of serial and this happsens //this is dangerous if a mixing of serial and this happsens
strcpy(&(cmdbuffer[bufindw][0]),cmd); strcpy(&(cmdbuffer[bufindw][0]),cmd);
SERIAL_ECHOLN("enqueing \""<<cmdbuffer[bufindw]<<"\""); SERIAL_ECHO_START;
SERIAL_ECHOPGM("enqueing \"");
SERIAL_ECHO(cmdbuffer[bufindw]);
SERIAL_ECHOLNPGM("\"");
bufindw= (bufindw + 1)%BUFSIZE; bufindw= (bufindw + 1)%BUFSIZE;
buflen += 1; buflen += 1;
} }
@ -192,8 +214,12 @@ void enquecommand(const char *cmd)
void setup() void setup()
{ {
Serial.begin(BAUDRATE); Serial.begin(BAUDRATE);
SERIAL_ECHOLN("Marlin "<<version_string); SERIAL_ECHO_START;
Serial.println("start"); SERIAL_ECHOLNPGM(VERSION_STRING);
SERIAL_PROTOCOLLNPGM("start");
SERIAL_ECHO_START;
SERIAL_ECHOPGM("Free Memory:");
SERIAL_ECHOLN(freeMemory());
for(int8_t i = 0; i < BUFSIZE; i++) for(int8_t i = 0; i < BUFSIZE; i++)
{ {
fromsd[i] = false; fromsd[i] = false;
@ -228,12 +254,12 @@ void loop()
if(strstr(cmdbuffer[bufindr],"M29") == NULL) if(strstr(cmdbuffer[bufindr],"M29") == NULL)
{ {
card.write_command(cmdbuffer[bufindr]); card.write_command(cmdbuffer[bufindr]);
Serial.println("ok"); SERIAL_PROTOCOLLNPGM("ok");
} }
else else
{ {
card.closefile(); card.closefile();
Serial.println("Done saving file."); SERIAL_PROTOCOLLNPGM("Done saving file.");
} }
} }
else else
@ -249,6 +275,7 @@ void loop()
//check heater every n milliseconds //check heater every n milliseconds
manage_heater(); manage_heater();
manage_inactivity(1); manage_inactivity(1);
checkHitEndstops();
LCD_STATUS; LCD_STATUS;
} }
@ -268,8 +295,9 @@ inline void get_command()
strchr_pointer = strchr(cmdbuffer[bufindw], 'N'); strchr_pointer = strchr(cmdbuffer[bufindw], 'N');
gcode_N = (strtol(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL, 10)); gcode_N = (strtol(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL, 10));
if(gcode_N != gcode_LastN+1 && (strstr(cmdbuffer[bufindw], "M110") == NULL) ) { if(gcode_N != gcode_LastN+1 && (strstr(cmdbuffer[bufindw], "M110") == NULL) ) {
Serial.print("Serial Error: Line Number is not Last Line Number+1, Last Line:"); SERIAL_ERROR_START;
Serial.println(gcode_LastN); SERIAL_ERRORPGM("Line Number is not Last Line Number+1, Last Line:");
SERIAL_ERRORLN(gcode_LastN);
//Serial.println(gcode_N); //Serial.println(gcode_N);
FlushSerialRequestResend(); FlushSerialRequestResend();
serial_count = 0; serial_count = 0;
@ -284,8 +312,9 @@ inline void get_command()
strchr_pointer = strchr(cmdbuffer[bufindw], '*'); strchr_pointer = strchr(cmdbuffer[bufindw], '*');
if( (int)(strtod(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL)) != checksum) { if( (int)(strtod(&cmdbuffer[bufindw][strchr_pointer - cmdbuffer[bufindw] + 1], NULL)) != checksum) {
Serial.print("Error: checksum mismatch, Last Line:"); SERIAL_ERROR_START;
Serial.println(gcode_LastN); SERIAL_ERRORPGM("checksum mismatch, Last Line:");
SERIAL_ERRORLN(gcode_LastN);
FlushSerialRequestResend(); FlushSerialRequestResend();
serial_count = 0; serial_count = 0;
return; return;
@ -294,8 +323,9 @@ inline void get_command()
} }
else else
{ {
Serial.print("Error: No Checksum with line number, Last Line:"); SERIAL_ERROR_START;
Serial.println(gcode_LastN); SERIAL_ERRORPGM("No Checksum with line number, Last Line:");
SERIAL_ERRORLN(gcode_LastN);
FlushSerialRequestResend(); FlushSerialRequestResend();
serial_count = 0; serial_count = 0;
return; return;
@ -308,8 +338,9 @@ inline void get_command()
{ {
if((strstr(cmdbuffer[bufindw], "*") != NULL)) if((strstr(cmdbuffer[bufindw], "*") != NULL))
{ {
Serial.print("Error: No Line Number with checksum, Last Line:"); SERIAL_ERROR_START;
Serial.println(gcode_LastN); SERIAL_ERRORPGM("No Line Number with checksum, Last Line:");
SERIAL_ERRORLN(gcode_LastN);
serial_count = 0; serial_count = 0;
return; return;
} }
@ -325,7 +356,7 @@ inline void get_command()
if(card.saving) if(card.saving)
break; break;
#endif //SDSUPPORT #endif //SDSUPPORT
Serial.println("ok"); SERIAL_PROTOCOLLNPGM("ok");
break; break;
default: default:
break; break;
@ -350,22 +381,23 @@ inline void get_command()
return; return;
} }
while( !card.eof() && buflen < BUFSIZE) { while( !card.eof() && buflen < BUFSIZE) {
int16_t n=card.get();
serial_char = card.get(); serial_char = (char)n;
if(serial_char == '\n' || serial_char == '\r' || serial_char == ':' || serial_count >= (MAX_CMD_SIZE - 1)) if(serial_char == '\n' || serial_char == '\r' || serial_char == ':' || serial_count >= (MAX_CMD_SIZE - 1)||n==-1)
{ {
if(card.eof()){ if(card.eof()){
card.sdprinting = false; card.sdprinting = false;
Serial.println("echo: Done printing file"); SERIAL_PROTOCOLLNPGM("Done printing file");
stoptime=millis(); stoptime=millis();
char time[30]; char time[30];
unsigned long t=(stoptime-starttime)/1000; unsigned long t=(stoptime-starttime)/1000;
int sec,min; int sec,min;
min=t/60; min=t/60;
sec=t%60; sec=t%60;
sprintf(time,"echo: %i min, %i sec",min,sec); sprintf(time,"%i min, %i sec",min,sec);
Serial.println(time); SERIAL_ECHO_START;
SERIAL_ECHOLN(time);
LCD_MESSAGE(time); LCD_MESSAGE(time);
card.checkautostart(true); card.checkautostart(true);
} }
@ -386,6 +418,7 @@ inline void get_command()
if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char; if(!comment_mode) cmdbuffer[bufindw][serial_count++] = serial_char;
} }
} }
#endif //SDSUPPORT #endif //SDSUPPORT
} }
@ -417,20 +450,25 @@ inline bool code_seen(char code)
destination[LETTER##_AXIS] = 1.5 * LETTER##_MAX_LENGTH * LETTER##_HOME_DIR; \ destination[LETTER##_AXIS] = 1.5 * LETTER##_MAX_LENGTH * LETTER##_HOME_DIR; \
feedrate = homing_feedrate[LETTER##_AXIS]; \ feedrate = homing_feedrate[LETTER##_AXIS]; \
prepare_move(); \ prepare_move(); \
st_synchronize();\
\ \
current_position[LETTER##_AXIS] = 0;\ current_position[LETTER##_AXIS] = 0;\
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\ plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\
destination[LETTER##_AXIS] = -5 * LETTER##_HOME_DIR;\ destination[LETTER##_AXIS] = -5 * LETTER##_HOME_DIR;\
prepare_move(); \ prepare_move(); \
st_synchronize();\
\ \
destination[LETTER##_AXIS] = 10 * LETTER##_HOME_DIR;\ destination[LETTER##_AXIS] = 10 * LETTER##_HOME_DIR;\
feedrate = homing_feedrate[LETTER##_AXIS]/2 ; \ feedrate = homing_feedrate[LETTER##_AXIS]/2 ; \
prepare_move(); \ prepare_move(); \
st_synchronize();\
\ \
current_position[LETTER##_AXIS] = (LETTER##_HOME_DIR == -1) ? 0 : LETTER##_MAX_LENGTH;\ current_position[LETTER##_AXIS] = (LETTER##_HOME_DIR == -1) ? 0 : LETTER##_MAX_LENGTH;\
plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\ plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);\
destination[LETTER##_AXIS] = current_position[LETTER##_AXIS];\ destination[LETTER##_AXIS] = current_position[LETTER##_AXIS];\
feedrate = 0.0;\ feedrate = 0.0;\
st_synchronize();\
endstops_hit_on_purpose();\
} }
inline void process_commands() inline void process_commands()
@ -461,6 +499,7 @@ inline void process_commands()
previous_millis_cmd = millis(); previous_millis_cmd = millis();
return; return;
case 4: // G4 dwell case 4: // G4 dwell
LCD_MESSAGEPGM("DWELL...");
codenum = 0; codenum = 0;
if(code_seen('P')) codenum = code_value(); // milliseconds to wait if(code_seen('P')) codenum = code_value(); // milliseconds to wait
if(code_seen('S')) codenum = code_value() * 1000; // seconds to wait if(code_seen('S')) codenum = code_value() * 1000; // seconds to wait
@ -495,6 +534,7 @@ inline void process_commands()
feedrate = saved_feedrate; feedrate = saved_feedrate;
feedmultiply = saved_feedmultiply; feedmultiply = saved_feedmultiply;
previous_millis_cmd = millis(); previous_millis_cmd = millis();
endstops_hit_on_purpose();
break; break;
case 90: // G90 case 90: // G90
relative_mode = false; relative_mode = false;
@ -521,13 +561,14 @@ inline void process_commands()
#ifdef SDSUPPORT #ifdef SDSUPPORT
case 20: // M20 - list SD card case 20: // M20 - list SD card
Serial.println("Begin file list"); SERIAL_PROTOCOLLNPGM("Begin file list");
card.ls(); card.ls();
Serial.println("End file list"); SERIAL_PROTOCOLLNPGM("End file list");
break; break;
case 21: // M21 - init SD card case 21: // M21 - init SD card
card.initsd(); card.initsd();
break; break;
case 22: //M22 - release SD card case 22: //M22 - release SD card
card.release(); card.release();
@ -579,8 +620,9 @@ inline void process_commands()
int sec,min; int sec,min;
min=t/60; min=t/60;
sec=t%60; sec=t%60;
sprintf(time,"echo: time needed %i min, %i sec",min,sec); sprintf(time,"%i min, %i sec",min,sec);
Serial.println(time); SERIAL_ECHO_START;
SERIAL_ECHOLN(time);
LCD_MESSAGE(time); LCD_MESSAGE(time);
} }
break; break;
@ -617,37 +659,30 @@ inline void process_commands()
if (code_seen('S')) setTargetBed(code_value()); if (code_seen('S')) setTargetBed(code_value());
break; break;
case 105: // M105 case 105: // M105
//SERIAL_ECHOLN(freeMemory());
#if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595) #if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
tt = degHotend0(); SERIAL_PROTOCOLPGM("ok T:");
#endif SERIAL_PROTOCOL( degHotend0());
#if TEMP_1_PIN > -1
bt = degBed();
#endif
#if (TEMP_0_PIN > -1) || defined (HEATER_USES_AD595)
Serial.print("ok T:");
Serial.print(tt);
#if TEMP_1_PIN > -1 #if TEMP_1_PIN > -1
#ifdef PIDTEMP SERIAL_PROTOCOLPGM(" B:");
Serial.print(" B:"); SERIAL_PROTOCOL(degBed());
#if TEMP_1_PIN > -1
Serial.println(bt);
#else
Serial.println(HeaterPower);
#endif
#else //not PIDTEMP
Serial.println();
#endif //PIDTEMP
#else
Serial.println();
#endif //TEMP_1_PIN #endif //TEMP_1_PIN
#else #else
SERIAL_ERRORLN("No thermistors - no temp"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("No thermistors - no temp");
#endif
#ifdef PIDTEMP
SERIAL_PROTOCOLPGM(" @:");
SERIAL_PROTOCOL( HeaterPower);
#endif #endif
SERIAL_PROTOCOLLN("");
return; return;
break; break;
case 109: case 109:
{// M109 - Wait for extruder heater to reach target. {// M109 - Wait for extruder heater to reach target.
LCD_MESSAGE("Heating..."); LCD_MESSAGEPGM("Heating...");
if (code_seen('S')) setTargetHotend0(code_value()); if (code_seen('S')) setTargetHotend0(code_value());
setWatch(); setWatch();
@ -668,8 +703,8 @@ inline void process_commands()
#endif //TEMP_RESIDENCY_TIME #endif //TEMP_RESIDENCY_TIME
if( (millis() - codenum) > 1000 ) if( (millis() - codenum) > 1000 )
{ //Print Temp Reading every 1 second while heating up/cooling down { //Print Temp Reading every 1 second while heating up/cooling down
Serial.print("T:"); SERIAL_PROTOCOLPGM("T:");
Serial.println( degHotend0() ); SERIAL_PROTOCOLLN( degHotend0() );
codenum = millis(); codenum = millis();
} }
manage_heater(); manage_heater();
@ -685,12 +720,13 @@ inline void process_commands()
} }
#endif //TEMP_RESIDENCY_TIME #endif //TEMP_RESIDENCY_TIME
} }
LCD_MESSAGE("Heating done."); LCD_MESSAGEPGM("Heating done.");
starttime=millis(); starttime=millis();
} }
break; break;
case 190: // M190 - Wait bed for heater to reach target. case 190: // M190 - Wait bed for heater to reach target.
#if TEMP_1_PIN > -1 #if TEMP_1_PIN > -1
LCD_MESSAGEPGM("Bed Heating.");
if (code_seen('S')) setTargetBed(code_value()); if (code_seen('S')) setTargetBed(code_value());
codenum = millis(); codenum = millis();
while(isHeatingBed()) while(isHeatingBed())
@ -698,16 +734,17 @@ inline void process_commands()
if( (millis()-codenum) > 1000 ) //Print Temp Reading every 1 second while heating up. if( (millis()-codenum) > 1000 ) //Print Temp Reading every 1 second while heating up.
{ {
float tt=degHotend0(); float tt=degHotend0();
Serial.print("T:"); SERIAL_PROTOCOLPGM("T:");
Serial.println( tt ); SERIAL_PROTOCOLLN(tt );
Serial.print("ok T:"); SERIAL_PROTOCOLPGM("ok T:");
Serial.print( tt ); SERIAL_PROTOCOL(tt );
Serial.print(" B:"); SERIAL_PROTOCOLPGM(" B:");
Serial.println( degBed() ); SERIAL_PROTOCOLLN(degBed() );
codenum = millis(); codenum = millis();
} }
manage_heater(); manage_heater();
} }
LCD_MESSAGEPGM("Bed done.");
#endif #endif
break; break;
@ -752,6 +789,7 @@ inline void process_commands()
else else
{ {
st_synchronize(); st_synchronize();
LCD_MESSAGEPGM("Free move.");
disable_x(); disable_x();
disable_y(); disable_y();
disable_z(); disable_z();
@ -770,53 +808,53 @@ inline void process_commands()
} }
break; break;
case 115: // M115 case 115: // M115
Serial.println("FIRMWARE_NAME:Marlin; Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1"); SerialprintPGM("FIRMWARE_NAME:Marlin; Sprinter/grbl mashup for gen6 FIRMWARE_URL:http://www.mendel-parts.com PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:1");
break; break;
case 114: // M114 case 114: // M114
Serial.print("X:"); SERIAL_PROTOCOLPGM("X:");
Serial.print(current_position[X_AXIS]); SERIAL_PROTOCOL(current_position[X_AXIS]);
Serial.print("Y:"); SERIAL_PROTOCOLPGM("Y:");
Serial.print(current_position[Y_AXIS]); SERIAL_PROTOCOL(current_position[Y_AXIS]);
Serial.print("Z:"); SERIAL_PROTOCOLPGM("Z:");
Serial.print(current_position[Z_AXIS]); SERIAL_PROTOCOL(current_position[Z_AXIS]);
Serial.print("E:"); SERIAL_PROTOCOLPGM("E:");
Serial.print(current_position[E_AXIS]); SERIAL_PROTOCOL(current_position[E_AXIS]);
#ifdef DEBUG_STEPS #ifdef DEBUG_STEPS
Serial.print(" Count X:"); SERIAL_PROTOCOLPGM(" Count X:");
Serial.print(float(count_position[X_AXIS])/axis_steps_per_unit[X_AXIS]); SERIAL_PROTOCOL(float(count_position[X_AXIS])/axis_steps_per_unit[X_AXIS]);
Serial.print("Y:"); SERIAL_PROTOCOLPGM("Y:");
Serial.print(float(count_position[Y_AXIS])/axis_steps_per_unit[Y_AXIS]); SERIAL_PROTOCOL(float(count_position[Y_AXIS])/axis_steps_per_unit[Y_AXIS]);
Serial.print("Z:"); SERIAL_PROTOCOLPGM("Z:");
Serial.println(float(count_position[Z_AXIS])/axis_steps_per_unit[Z_AXIS]); SERIAL_PROTOCOL(float(count_position[Z_AXIS])/axis_steps_per_unit[Z_AXIS]);
#endif #endif
Serial.println(""); SERIAL_PROTOCOLLN("");
break; break;
case 119: // M119 case 119: // M119
#if (X_MIN_PIN > -1) #if (X_MIN_PIN > -1)
Serial.print("x_min:"); SERIAL_PROTOCOLPGM("x_min:");
Serial.print((READ(X_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(X_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
#if (X_MAX_PIN > -1) #if (X_MAX_PIN > -1)
Serial.print("x_max:"); SERIAL_PROTOCOLPGM("x_max:");
Serial.print((READ(X_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(X_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
#if (Y_MIN_PIN > -1) #if (Y_MIN_PIN > -1)
Serial.print("y_min:"); SERIAL_PROTOCOLPGM("y_min:");
Serial.print((READ(Y_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(Y_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
#if (Y_MAX_PIN > -1) #if (Y_MAX_PIN > -1)
Serial.print("y_max:"); SERIAL_PROTOCOLPGM("y_max:");
Serial.print((READ(Y_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(Y_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
#if (Z_MIN_PIN > -1) #if (Z_MIN_PIN > -1)
Serial.print("z_min:"); SERIAL_PROTOCOLPGM("z_min:");
Serial.print((READ(Z_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(Z_MIN_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
#if (Z_MAX_PIN > -1) #if (Z_MAX_PIN > -1)
Serial.print("z_max:"); SERIAL_PROTOCOLPGM("z_max:");
Serial.print((READ(Z_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "); SERIAL_PROTOCOL(((READ(Z_MAX_PIN)^ENDSTOPS_INVERTING)?"H ":"L "));
#endif #endif
Serial.println(""); SERIAL_PROTOCOLLN("");
break; break;
//TODO: update for all axis, use for loop //TODO: update for all axis, use for loop
case 201: // M201 case 201: // M201
@ -867,8 +905,28 @@ inline void process_commands()
if(code_seen('P')) Kp = code_value(); if(code_seen('P')) Kp = code_value();
if(code_seen('I')) Ki = code_value()*PID_dT; if(code_seen('I')) Ki = code_value()*PID_dT;
if(code_seen('D')) Kd = code_value()/PID_dT; if(code_seen('D')) Kd = code_value()/PID_dT;
#ifdef PID_ADD_EXTRUSION_RATE
if(code_seen('C')) Kc = code_value();
#endif
SERIAL_PROTOCOL("ok p:");
SERIAL_PROTOCOL(Kp);
SERIAL_PROTOCOL(" i:");
SERIAL_PROTOCOL(Ki/PID_dT);
SERIAL_PROTOCOL(" d:");
SERIAL_PROTOCOL(Kd*PID_dT);
#ifdef PID_ADD_EXTRUSION_RATE
SERIAL_PROTOCOL(" c:");
SERIAL_PROTOCOL(Kc*PID_dT);
#endif
SERIAL_PROTOCOLLN("");
break; break;
#endif //PIDTEMP #endif //PIDTEMP
case 400: // finish all moves
{
st_synchronize();
}
break;
case 500: // Store settings in EEPROM case 500: // Store settings in EEPROM
{ {
StoreSettings(); StoreSettings();
@ -889,9 +947,10 @@ inline void process_commands()
} }
else else
{ {
Serial.print("echo: Unknown command:\""); SERIAL_ECHO_START;
Serial.print(cmdbuffer[bufindr]); SERIAL_ECHOPGM("Unknown command:\"");
Serial.println("\""); SERIAL_ECHO(cmdbuffer[bufindr]);
SERIAL_ECHOLNPGM("\"");
} }
ClearToSend(); ClearToSend();
@ -901,8 +960,8 @@ void FlushSerialRequestResend()
{ {
//char cmdbuffer[bufindr][100]="Resend:"; //char cmdbuffer[bufindr][100]="Resend:";
Serial.flush(); Serial.flush();
Serial.print("Resend:"); SERIAL_PROTOCOLPGM("Resend:");
Serial.println(gcode_LastN + 1); SERIAL_PROTOCOLLN(gcode_LastN + 1);
ClearToSend(); ClearToSend();
} }
@ -913,7 +972,7 @@ void ClearToSend()
if(fromsd[bufindr]) if(fromsd[bufindr])
return; return;
#endif //SDSUPPORT #endif //SDSUPPORT
Serial.println("ok"); SERIAL_PROTOCOLLNPGM("ok");
} }
inline void get_coordinates() inline void get_coordinates()
@ -987,7 +1046,9 @@ void kill()
disable_e(); disable_e();
if(PS_ON_PIN > -1) pinMode(PS_ON_PIN,INPUT); if(PS_ON_PIN > -1) pinMode(PS_ON_PIN,INPUT);
SERIAL_ERRORLN("Printer halted. kill() called !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Printer halted. kill() called !!");
LCD_MESSAGEPGM("KILLED. ");
while(1); // Wait for reset while(1); // Wait for reset
} }

33
Marlin/cardreader.h
Unescape View File

@ -30,8 +30,8 @@ public:
inline void ls() {root.ls();}; inline void ls() {root.ls();};
inline bool eof() { sdpos = file.curPosition();return sdpos>=filesize ;}; inline bool eof() { return sdpos>=filesize ;};
inline char get() { int16_t n = file.read(); return (n!=-1)?(char)n:'\n';}; inline int16_t get() { sdpos = file.curPosition();return (int16_t)file.read();};
inline void setIndex(long index) {sdpos = index;file.seekSet(index);}; inline void setIndex(long index) {sdpos = index;file.seekSet(index);};
public: public:
@ -52,6 +52,35 @@ private:
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.
}; };
#else
class CardReader
{
public:
inline CardReader(){};
inline static void initsd(){};
inline static void write_command(char *buf){};
inline static void checkautostart(bool x) {};
inline static void closefile() {};
inline static void release(){};
inline static void startFileprint(){};
inline static void startFilewrite(char *name){};
inline static void pauseSDPrint(){};
inline static void getStatus(){};
inline static void selectFile(char* name){};
inline static void getfilename(const uint8_t nr){};
inline static uint8_t getnrfilenames(){return 0;};
inline static void ls() {};
inline static bool eof() {return true;};
inline static char get() {return 0;};
inline static void setIndex(){};
};
#endif //SDSUPPORT #endif //SDSUPPORT

47
Marlin/cardreader.pde
Unescape View File

@ -29,20 +29,24 @@ void CardReader::initsd()
if (!card.init(SPI_FULL_SPEED,SDSS)) if (!card.init(SPI_FULL_SPEED,SDSS))
{ {
//if (!card.init(SPI_HALF_SPEED,SDSS)) //if (!card.init(SPI_HALF_SPEED,SDSS))
SERIAL_ECHOLN("SD init fail"); SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("SD init fail");
} }
else if (!volume.init(&card)) else if (!volume.init(&card))
{ {
SERIAL_ERRORLN("volume.init failed"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("volume.init failed");
} }
else if (!root.openRoot(&volume)) else if (!root.openRoot(&volume))
{ {
SERIAL_ERRORLN("openRoot failed"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("openRoot failed");
} }
else else
{ {
cardOK = true; cardOK = true;
SERIAL_ECHOLN("SD card ok"); SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("SD card ok");
} }
#endif //SDSS #endif //SDSS
} }
@ -76,17 +80,17 @@ void CardReader::selectFile(char* name)
file.close(); file.close();
if (file.open(&root, name, O_READ)) { if (file.open(&root, name, O_READ)) {
Serial.print("File opened:");
Serial.print(name);
Serial.print(" Size:");
filesize = file.fileSize(); filesize = file.fileSize();
Serial.println(filesize); SERIAL_PROTOCOLPGM("File opened:");
SERIAL_PROTOCOL(name);
SERIAL_PROTOCOLPGM(" Size:");
SERIAL_PROTOCOLLN(filesize);
sdpos = 0; sdpos = 0;
Serial.println("File selected"); SERIAL_PROTOCOLLNPGM("File selected");
} }
else{ else{
Serial.println("file.open failed"); SERIAL_PROTOCOLLNPGM("file.open failed");
} }
} }
} }
@ -101,14 +105,14 @@ void CardReader::startFilewrite(char *name)
if (!file.open(&root, name, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) if (!file.open(&root, name, O_CREAT | O_APPEND | O_WRITE | O_TRUNC))
{ {
Serial.print("open failed, File: "); SERIAL_PROTOCOLPGM("open failed, File: ");
Serial.print(name); SERIAL_PROTOCOL(name);
Serial.print("."); SERIAL_PROTOCOLLNPGM(".");
} }
else{ else{
saving = true; saving = true;
Serial.print("Writing to file: "); SERIAL_PROTOCOLPGM("Writing to file: ");
Serial.println(name); SERIAL_PROTOCOLLN(name);
} }
} }
} }
@ -116,13 +120,13 @@ void CardReader::startFilewrite(char *name)
void CardReader::getStatus() void CardReader::getStatus()
{ {
if(cardOK){ if(cardOK){
Serial.print("SD printing byte "); SERIAL_PROTOCOLPGM("SD printing byte ");
Serial.print(sdpos); SERIAL_PROTOCOL(sdpos);
Serial.print("/"); SERIAL_PROTOCOLPGM("/");
Serial.println(filesize); SERIAL_PROTOCOLLN(filesize);
} }
else{ else{
Serial.println("Not SD printing"); SERIAL_PROTOCOLLNPGM("Not SD printing");
} }
} }
void CardReader::write_command(char *buf) void CardReader::write_command(char *buf)
@ -143,7 +147,8 @@ void CardReader::write_command(char *buf)
file.write(begin); file.write(begin);
if (file.writeError) if (file.writeError)
{ {
SERIAL_ERRORLN("error writing to file"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("error writing to file");
} }
} }

36
Marlin/planner.cpp
Unescape View File

@ -86,6 +86,10 @@ long position[4]; //rescaled from extern when axis_steps_per_unit are changed
static float previous_speed[4]; // Speed of previous path line segment static float previous_speed[4]; // Speed of previous path line segment
static float previous_nominal_speed; // Nominal speed of previous path line segment static float previous_nominal_speed; // Nominal speed of previous path line segment
#ifdef AUTOTEMP
float high_e_speed=0;
#endif
//=========================================================================== //===========================================================================
//=============================private variables ============================ //=============================private variables ============================
@ -372,6 +376,34 @@ block_t *plan_get_current_block() {
return(block); return(block);
} }
#ifdef AUTOTEMP
void getHighESpeed()
{
if(degTargetHotend0()+2<AUTOTEMP_MIN) //probably temperature set to zero.
return; //do nothing
float high=0;
char block_index = block_buffer_tail;
while(block_index != block_buffer_head) {
float se=block_buffer[block_index].speed_e;
if(se>high)
{
high=se;
}
block_index = (block_index+1) & (BLOCK_BUFFER_SIZE - 1);
}
high_e_speed=high*axis_steps_per_unit[E_AXIS]/(1000000.0); //so it is independent of the esteps/mm. before
float g=AUTOTEMP_MIN+high_e_speed*AUTOTEMP_FACTOR;
float t=constrain(AUTOTEMP_MIN,g,AUTOTEMP_MAX);
setTargetHotend0(t);
SERIAL_ECHO_START;
SERIAL_ECHOPAIR("highe",high_e_speed);
SERIAL_ECHOPAIR(" t",t);
SERIAL_ECHOLN("");
}
#endif
void check_axes_activity() { void check_axes_activity() {
unsigned char x_active = 0; unsigned char x_active = 0;
unsigned char y_active = 0; unsigned char y_active = 0;
@ -686,7 +718,9 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa
memcpy(position, target, sizeof(target)); // position[] = target[] memcpy(position, target, sizeof(target)); // position[] = target[]
planner_recalculate(); planner_recalculate();
#ifdef AUTOTEMP
getHighESpeed();
#endif
st_wake_up(); st_wake_up();
} }

4
Marlin/planner.h
Unescape View File

@ -92,5 +92,7 @@ extern float max_xy_jerk; //speed than can be stopped at once, if i understand c
extern float max_z_jerk; extern float max_z_jerk;
extern float mintravelfeedrate; extern float mintravelfeedrate;
extern unsigned long axis_steps_per_sqr_second[NUM_AXIS]; extern unsigned long axis_steps_per_sqr_second[NUM_AXIS];
#ifdef AUTOTEMP
extern float high_e_speed;
#endif
#endif #endif

56
Marlin/stepper.cpp
Unescape View File

@ -33,12 +33,14 @@
#include "speed_lookuptable.h" #include "speed_lookuptable.h"
//=========================================================================== //===========================================================================
//=============================public variables ============================ //=============================public variables ============================
//=========================================================================== //===========================================================================
block_t *current_block; // A pointer to the block currently being traced block_t *current_block; // A pointer to the block currently being traced
//=========================================================================== //===========================================================================
//=============================private variables ============================ //=============================private variables ============================
//=========================================================================== //===========================================================================
@ -62,7 +64,9 @@ static long acceleration_time, deceleration_time;
static unsigned short acc_step_rate; // needed for deccelaration start point static unsigned short acc_step_rate; // needed for deccelaration start point
static char step_loops; static char step_loops;
volatile long endstops_trigsteps[3]={0,0,0};
volatile long endstops_stepsTotal,endstops_stepsDone;
static volatile bool endstops_hit=false;
// if DEBUG_STEPS is enabled, M114 can be used to compare two methods of determining the X,Y,Z position of the printer. // if DEBUG_STEPS is enabled, M114 can be used to compare two methods of determining the X,Y,Z position of the printer.
// for debugging purposes only, should be disabled by default // for debugging purposes only, should be disabled by default
@ -152,9 +156,49 @@ asm volatile ( \
#define DISABLE_STEPPER_DRIVER_INTERRUPT() TIMSK1 &= ~(1<<OCIE1A) #define DISABLE_STEPPER_DRIVER_INTERRUPT() TIMSK1 &= ~(1<<OCIE1A)
void endstops_triggered(const unsigned long &stepstaken)
{
//this will only work if there is no bufferig
//however, if you perform a move at which the endstops should be triggered, and wait for it to complete, i.e. by blocking command, it should work
//yes, it uses floats, but: if endstops are triggered, thats hopefully not critical anymore anyways.
//endstops_triggerpos;
if(endstops_hit) //hitting a second time while the first hit is not reported
return;
if(current_block == NULL)
return;
endstops_stepsTotal=current_block->step_event_count;
endstops_stepsDone=stepstaken;
endstops_trigsteps[0]=current_block->steps_x;
endstops_trigsteps[1]=current_block->steps_y;
endstops_trigsteps[2]=current_block->steps_z;
endstops_hit=true;
}
void checkHitEndstops()
{
if( !endstops_hit)
return;
float endstops_triggerpos[3]={0,0,0};
float ratiodone=endstops_stepsDone/float(endstops_stepsTotal); //ratio of current_block thas was performed
endstops_triggerpos[0]=current_position[0]-(endstops_trigsteps[0]*ratiodone)/float(axis_steps_per_unit[0]);
endstops_triggerpos[1]=current_position[1]-(endstops_trigsteps[1]*ratiodone)/float(axis_steps_per_unit[1]);
endstops_triggerpos[2]=current_position[2]-(endstops_trigsteps[2]*ratiodone)/float(axis_steps_per_unit[2]);
SERIAL_ECHO_START;
SERIAL_ECHOPGM("endstops hit: ");
SERIAL_ECHOPAIR(" X:",endstops_triggerpos[0]);
SERIAL_ECHOPAIR(" Y:",endstops_triggerpos[1]);
SERIAL_ECHOPAIR(" Z:",endstops_triggerpos[2]);
SERIAL_ECHOLN("");
endstops_hit=false;
}
void endstops_hit_on_purpose()
{
endstops_hit=false;
}
// __________________________ // __________________________
// /| |\ _________________ ^ // /| |\ _________________ ^
@ -232,7 +276,9 @@ inline void trapezoid_generator_reset() {
ISR(TIMER1_COMPA_vect) ISR(TIMER1_COMPA_vect)
{ {
if(busy){ if(busy){
/* SERIAL_ERRORLN(*(unsigned short *)OCR1A<< " ISR overtaking itself.");*/ SERIAL_ERROR_START
SERIAL_ERROR(*(unsigned short *)OCR1A);
SERIAL_ERRORLNPGM(" ISR overtaking itself.");
return; return;
} // The busy-flag is used to avoid reentering this interrupt } // The busy-flag is used to avoid reentering this interrupt
@ -294,6 +340,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if X_MIN_PIN > -1 #if X_MIN_PIN > -1
if(READ(X_MIN_PIN) != ENDSTOPS_INVERTING) { if(READ(X_MIN_PIN) != ENDSTOPS_INVERTING) {
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif
@ -305,6 +352,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if X_MAX_PIN > -1 #if X_MAX_PIN > -1
if((READ(X_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_x >0)){ if((READ(X_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_x >0)){
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif
@ -317,6 +365,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if Y_MIN_PIN > -1 #if Y_MIN_PIN > -1
if(READ(Y_MIN_PIN) != ENDSTOPS_INVERTING) { if(READ(Y_MIN_PIN) != ENDSTOPS_INVERTING) {
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif
@ -328,6 +377,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if Y_MAX_PIN > -1 #if Y_MAX_PIN > -1
if((READ(Y_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_y >0)){ if((READ(Y_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_y >0)){
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif
@ -340,6 +390,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if Z_MIN_PIN > -1 #if Z_MIN_PIN > -1
if(READ(Z_MIN_PIN) != ENDSTOPS_INVERTING) { if(READ(Z_MIN_PIN) != ENDSTOPS_INVERTING) {
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif
@ -351,6 +402,7 @@ ISR(TIMER1_COMPA_vect)
#endif #endif
#if Z_MAX_PIN > -1 #if Z_MAX_PIN > -1
if((READ(Z_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_z >0)){ if((READ(Z_MAX_PIN) != ENDSTOPS_INVERTING) && (current_block->steps_z >0)){
endstops_triggered(step_events_completed);
step_events_completed = current_block->step_event_count; step_events_completed = current_block->step_event_count;
} }
#endif #endif

7
Marlin/stepper.h
Unescape View File

@ -40,5 +40,12 @@ void st_wake_up();
extern volatile int count_direction[NUM_AXIS]; extern volatile int count_direction[NUM_AXIS];
#endif #endif
void checkHitEndstops(); //call from somwhere to create an serial error message with the locations the endstops where hit, in case they were triggered
void endstops_hit_on_purpose(); //avoid creation of the message, i.e. after homeing and before a routine call of checkHitEndstops();
extern block_t *current_block; // A pointer to the block currently being traced extern block_t *current_block; // A pointer to the block currently being traced
#endif #endif

84
Marlin/streaming.h
Unescape View File

@ -1,84 +0,0 @@
/*
Streaming.h - Arduino library for supporting the << streaming operator
Copyright (c) 2010 Mikal Hart. All rights reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef ARDUINO_STREAMING
#define ARDUINO_STREAMING
//#include <WProgram.h>
#define STREAMING_LIBRARY_VERSION 4
// Generic template
template<class T>
inline Print &operator <<(Print &stream, T arg)
{ stream.print(arg); return stream; }
struct _BASED
{
long val;
int base;
_BASED(long v, int b): val(v), base(b)
{}
};
#define _HEX(a) _BASED(a, HEX)
#define _DEC(a) _BASED(a, DEC)
#define _OCT(a) _BASED(a, OCT)
#define _BIN(a) _BASED(a, BIN)
#define _BYTE(a) _BASED(a, BYTE)
// Specialization for class _BASED
// Thanks to Arduino forum user Ben Combee who suggested this
// clever technique to allow for expressions like
// Serial << _HEX(a);
inline Print &operator <<(Print &obj, const _BASED &arg)
{ obj.print(arg.val, arg.base); return obj; }
#if ARDUINO >= 18
// Specialization for class _FLOAT
// Thanks to Michael Margolis for suggesting a way
// to accommodate Arduino 0018's floating point precision
// feature like this:
// Serial << _FLOAT(gps_latitude, 6); // 6 digits of precision
struct _FLOAT
{
float val;
int digits;
_FLOAT(double v, int d): val(v), digits(d)
{}
};
inline Print &operator <<(Print &obj, const _FLOAT &arg)
{ obj.print(arg.val, arg.digits); return obj; }
#endif
// Specialization for enum _EndLineCode
// Thanks to Arduino forum user Paul V. who suggested this
// clever technique to allow for expressions like
// Serial << "Hello!" << endl;
enum _EndLineCode { endl };
inline Print &operator <<(Print &obj, _EndLineCode arg)
{ obj.println(); return obj; }
#endif

28
Marlin/temperature.cpp
Unescape View File

@ -35,7 +35,6 @@
#include "pins.h" #include "pins.h"
#include "Marlin.h" #include "Marlin.h"
#include "ultralcd.h" #include "ultralcd.h"
#include "streaming.h"
#include "temperature.h" #include "temperature.h"
#include "watchdog.h" #include "watchdog.h"
@ -160,11 +159,13 @@ void manage_heater()
// pTerm+=Kc*current_block->speed_e; //additional heating if extrusion speed is high // pTerm+=Kc*current_block->speed_e; //additional heating if extrusion speed is high
// #endif // #endif
pid_output = constrain(pTerm + iTerm - dTerm, 0, PID_MAX); pid_output = constrain(pTerm + iTerm - dTerm, 0, PID_MAX);
} }
#endif //PID_OPENLOOP #endif //PID_OPENLOOP
#ifdef PID_DEBUG #ifdef PID_DEBUG
SERIAL_ECHOLN(" PIDDEBUG Input "<<pid_input<<" Output "<<pid_output" pTerm "<<pTerm<<" iTerm "<<iTerm<<" dTerm "<<dTerm); //SERIAL_ECHOLN(" PIDDEBUG Input "<<pid_input<<" Output "<<pid_output" pTerm "<<pTerm<<" iTerm "<<iTerm<<" dTerm "<<dTerm);
#endif //PID_DEBUG #endif //PID_DEBUG
HeaterPower=pid_output;
analogWrite(HEATER_0_PIN, pid_output); analogWrite(HEATER_0_PIN, pid_output);
#endif //PIDTEMP #endif //PIDTEMP
@ -253,7 +254,7 @@ int temp2analogBed(int celsius) {
return (1023 * OVERSAMPLENR) - raw; return (1023 * OVERSAMPLENR) - raw;
#elif defined BED_USES_AD595 #elif defined BED_USES_AD595
return celsius * (1024.0 / (5.0 * 100.0) ) * OVERSAMPLENR; return lround(celsius * (1024.0 * OVERSAMPLENR/ (5.0 * 100.0) ) );
#endif #endif
} }
@ -464,7 +465,8 @@ ISR(TIMER0_COMPB_vect)
temp_count++; temp_count++;
break; break;
default: default:
SERIAL_ERRORLN("Temp measurement error!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temp measurement error!");
break; break;
} }
@ -498,7 +500,8 @@ ISR(TIMER0_COMPB_vect)
if(current_raw[TEMPSENSOR_HOTEND_0] >= maxttemp_0) { if(current_raw[TEMPSENSOR_HOTEND_0] >= maxttemp_0) {
target_raw[TEMPSENSOR_HOTEND_0] = 0; target_raw[TEMPSENSOR_HOTEND_0] = 0;
analogWrite(HEATER_0_PIN, 0); analogWrite(HEATER_0_PIN, 0);
SERIAL_ERRORLN("Temperature extruder 0 switched off. MAXTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature extruder 0 switched off. MAXTEMP triggered !!");
kill(); kill();
} }
#endif #endif
@ -509,7 +512,8 @@ ISR(TIMER0_COMPB_vect)
target_raw[TEMPSENSOR_HOTEND_1] = 0; target_raw[TEMPSENSOR_HOTEND_1] = 0;
if(current_raw[2] >= maxttemp_1) { if(current_raw[2] >= maxttemp_1) {
analogWrite(HEATER_2_PIN, 0); analogWrite(HEATER_2_PIN, 0);
SERIAL_ERRORLN("Temperature extruder 1 switched off. MAXTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature extruder 1 switched off. MAXTEMP triggered !!");
kill() kill()
} }
#endif #endif
@ -520,7 +524,8 @@ ISR(TIMER0_COMPB_vect)
if(current_raw[TEMPSENSOR_HOTEND_0] <= minttemp_0) { if(current_raw[TEMPSENSOR_HOTEND_0] <= minttemp_0) {
target_raw[TEMPSENSOR_HOTEND_0] = 0; target_raw[TEMPSENSOR_HOTEND_0] = 0;
analogWrite(HEATER_0_PIN, 0); analogWrite(HEATER_0_PIN, 0);
SERIAL_ERRORLN("Temperature extruder 0 switched off. MINTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature extruder 0 switched off. MINTEMP triggered !!");
kill(); kill();
} }
#endif #endif
@ -531,7 +536,8 @@ ISR(TIMER0_COMPB_vect)
if(current_raw[TEMPSENSOR_HOTEND_1] <= minttemp_1) { if(current_raw[TEMPSENSOR_HOTEND_1] <= minttemp_1) {
target_raw[TEMPSENSOR_HOTEND_1] = 0; target_raw[TEMPSENSOR_HOTEND_1] = 0;
analogWrite(HEATER_2_PIN, 0); analogWrite(HEATER_2_PIN, 0);
SERIAL_ERRORLN("Temperature extruder 1 switched off. MINTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature extruder 1 switched off. MINTEMP triggered !!");
kill(); kill();
} }
#endif #endif
@ -542,7 +548,8 @@ ISR(TIMER0_COMPB_vect)
if(current_raw[1] <= bed_minttemp) { if(current_raw[1] <= bed_minttemp) {
target_raw[1] = 0; target_raw[1] = 0;
WRITE(HEATER_1_PIN, 0); WRITE(HEATER_1_PIN, 0);
SERIAL_ERRORLN("Temperatur heated bed switched off. MINTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperatur heated bed switched off. MINTEMP triggered !!");
kill(); kill();
} }
#endif #endif
@ -553,7 +560,8 @@ ISR(TIMER0_COMPB_vect)
if(current_raw[1] >= bed_maxttemp) { if(current_raw[1] >= bed_maxttemp) {
target_raw[1] = 0; target_raw[1] = 0;
WRITE(HEATER_1_PIN, 0); WRITE(HEATER_1_PIN, 0);
SERIAL_ERRORLN("Temperature heated bed switched off. MAXTEMP triggered !!"); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Temperature heated bed switched off. MAXTEMP triggered !!");
kill(); kill();
} }
#endif #endif

1
Marlin/ultralcd.h
Unescape View File

@ -83,6 +83,7 @@
#define LCD_MESSAGE(x) lcd_status(x); #define LCD_MESSAGE(x) lcd_status(x);
#define LCD_MESSAGEPGM(x) lcd_statuspgm(PSTR(x));
#define LCD_STATUS lcd_status() #define LCD_STATUS lcd_status()
#else //no lcd #else //no lcd
#define LCD_STATUS #define LCD_STATUS

142
Marlin/ultralcd.pde
Unescape View File

@ -42,6 +42,19 @@ static long previous_millis_buttons=0;
static MainMenu menu; static MainMenu menu;
#include <avr/pgmspace.h>
void lcdProgMemprint(const char *str)
{
char ch=pgm_read_byte(str);
while(ch)
{
lcd.print(ch);
ch=pgm_read_byte(++str);
}
}
#define lcdprintPGM(x) lcdProgMemprint(PSTR(x))
//=========================================================================== //===========================================================================
//=============================functions ============================ //=============================functions ============================
@ -54,6 +67,20 @@ void lcd_status(const char* message)
strncpy(messagetext,message,LCD_WIDTH); strncpy(messagetext,message,LCD_WIDTH);
} }
void lcd_statuspgm(const char* message)
{
char ch=pgm_read_byte(message);
char *target=messagetext;
uint8_t cnt=0;
while(ch &&cnt<LCD_WIDTH)
{
*target=ch;
target++;
cnt++;
ch=pgm_read_byte(++message);
}
}
inline void clear() inline void clear()
{ {
lcd.clear(); lcd.clear();
@ -92,7 +119,7 @@ void lcd_init()
lcd.createChar(2,Thermometer); lcd.createChar(2,Thermometer);
lcd.createChar(3,uplevel); lcd.createChar(3,uplevel);
lcd.createChar(4,refresh); lcd.createChar(4,refresh);
LCD_MESSAGE(fillto(LCD_WIDTH,"UltiMarlin ready.")); LCD_MESSAGEPGM("UltiMarlin ready.");
} }
@ -264,9 +291,9 @@ void MainMenu::showStatus()
feedmultiplychanged=false; feedmultiplychanged=false;
encoderpos=feedmultiply; encoderpos=feedmultiply;
clear(); clear();
lcd.setCursor(0,0);lcd.print("\002123/567\001 "); lcd.setCursor(0,0);lcdprintPGM("\002123/567\001 ");
#if defined BED_USES_THERMISTOR || defined BED_USES_AD595 #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
lcd.setCursor(10,0);lcd.print("B123/567\001 "); lcd.setCursor(10,0);lcdprintPGM("B123/567\001 ");
#endif #endif
} }
@ -311,7 +338,7 @@ void MainMenu::showStatus()
if(starttime!=oldtime) if(starttime!=oldtime)
{ {
lcd.print(itostr2(time/60));lcd.print("h ");lcd.print(itostr2(time%60));lcd.print("m"); lcd.print(itostr2(time/60));lcdprintPGM("h ");lcd.print(itostr2(time%60));lcdprintPGM("m");
oldtime=time; oldtime=time;
} }
} }
@ -320,7 +347,7 @@ void MainMenu::showStatus()
if((currentz!=oldzpos)||force_lcd_update) if((currentz!=oldzpos)||force_lcd_update)
{ {
lcd.setCursor(10,1); lcd.setCursor(10,1);
lcd.print("Z:");lcd.print(itostr31(currentz)); lcdprintPGM("Z:");lcd.print(itostr31(currentz));
oldzpos=currentz; oldzpos=currentz;
} }
static int oldfeedmultiply=0; static int oldfeedmultiply=0;
@ -339,7 +366,7 @@ void MainMenu::showStatus()
{ {
oldfeedmultiply=curfeedmultiply; oldfeedmultiply=curfeedmultiply;
lcd.setCursor(0,2); lcd.setCursor(0,2);
lcd.print(itostr3(curfeedmultiply));lcd.print("% "); lcd.print(itostr3(curfeedmultiply));lcdprintPGM("% ");
} }
if(messagetext[0]!='\0') if(messagetext[0]!='\0')
{ {
@ -353,9 +380,9 @@ void MainMenu::showStatus()
if(force_lcd_update) //initial display of content if(force_lcd_update) //initial display of content
{ {
encoderpos=feedmultiply; encoderpos=feedmultiply;
lcd.setCursor(0,0);lcd.print("\002123/567\001 "); lcd.setCursor(0,0);lcdprintPGM("\002123/567\001 ");
#if defined BED_USES_THERMISTOR || defined BED_USES_AD595 #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
lcd.setCursor(10,0);lcd.print("B123/567\001 "); lcd.setCursor(10,0);lcdprintPGM("B123/567\001 ");
#endif #endif
} }
@ -405,7 +432,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Prepare"); lcd.setCursor(0,line);lcdprintPGM(" Prepare");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -418,7 +445,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Auto Home"); lcd.setCursor(0,line);lcdprintPGM(" Auto Home");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -431,7 +458,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Set Origin"); lcd.setCursor(0,line);lcdprintPGM(" Set Origin");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
@ -445,7 +472,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Preheat"); lcd.setCursor(0,line);lcdprintPGM(" Preheat");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -458,7 +485,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Extrude"); lcd.setCursor(0,line);lcdprintPGM(" Extrude");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -472,7 +499,7 @@ void MainMenu::showPrepare()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Disable Steppers"); lcd.setCursor(0,line);lcdprintPGM(" Disable Steppers");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -541,7 +568,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Control"); lcd.setCursor(0,line);lcdprintPGM(" Control");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -554,7 +581,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" \002Nozzle:"); lcd.setCursor(0,line);lcdprintPGM(" \002Nozzle:");
lcd.setCursor(13,line);lcd.print(ftostr3(intround(degHotend0()))); lcd.setCursor(13,line);lcd.print(ftostr3(intround(degHotend0())));
} }
@ -588,7 +615,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Fan speed:"); lcd.setCursor(0,line);lcdprintPGM(" Fan speed:");
lcd.setCursor(13,line);lcd.print(ftostr3(fanpwm)); lcd.setCursor(13,line);lcd.print(ftostr3(fanpwm));
} }
@ -625,8 +652,8 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Acc:"); lcd.setCursor(0,line);lcdprintPGM(" Acc:");
lcd.setCursor(13,line);lcd.print(itostr3(acceleration/100));lcd.print("00"); lcd.setCursor(13,line);lcd.print(itostr3(acceleration/100));lcdprintPGM("00");
} }
if((activeline==line) ) if((activeline==line) )
@ -650,7 +677,7 @@ void MainMenu::showControl()
{ {
if(encoderpos<5) encoderpos=5; if(encoderpos<5) encoderpos=5;
if(encoderpos>990) encoderpos=990; if(encoderpos>990) encoderpos=990;
lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00"); lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
} }
} }
}break; }break;
@ -658,7 +685,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Vxy-jerk: "); lcd.setCursor(0,line);lcdprintPGM(" Vxy-jerk: ");
lcd.setCursor(13,line);lcd.print(itostr3(max_xy_jerk/60)); lcd.setCursor(13,line);lcd.print(itostr3(max_xy_jerk/60));
} }
@ -692,7 +719,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" PID-P: "); lcd.setCursor(0,line);lcdprintPGM(" PID-P: ");
lcd.setCursor(13,line);lcd.print(itostr4(Kp)); lcd.setCursor(13,line);lcd.print(itostr4(Kp));
} }
@ -726,7 +753,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" PID-I: "); lcd.setCursor(0,line);lcdprintPGM(" PID-I: ");
lcd.setCursor(13,line);lcd.print(ftostr51(Ki)); lcd.setCursor(13,line);lcd.print(ftostr51(Ki));
} }
@ -760,7 +787,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" PID-D: "); lcd.setCursor(0,line);lcdprintPGM(" PID-D: ");
lcd.setCursor(13,line);lcd.print(itostr4(Kd)); lcd.setCursor(13,line);lcd.print(itostr4(Kd));
} }
@ -797,7 +824,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" PID-C: "); lcd.setCursor(0,line);lcdprintPGM(" PID-C: ");
lcd.setCursor(13,line);lcd.print(itostr3(Kc)); lcd.setCursor(13,line);lcd.print(itostr3(Kc));
} }
@ -834,11 +861,11 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Vmax "); lcd.setCursor(0,line);lcdprintPGM(" Vmax ");
if(i==ItemC_vmaxx)lcd.print("x:"); if(i==ItemC_vmaxx)lcdprintPGM("x:");
if(i==ItemC_vmaxy)lcd.print("y:"); if(i==ItemC_vmaxy)lcdprintPGM("y:");
if(i==ItemC_vmaxz)lcd.print("z:"); if(i==ItemC_vmaxz)lcdprintPGM("z:");
if(i==ItemC_vmaxe)lcd.print("e:"); if(i==ItemC_vmaxe)lcdprintPGM("e:");
lcd.setCursor(13,line);lcd.print(itostr3(max_feedrate[i-ItemC_vmaxx]/60)); lcd.setCursor(13,line);lcd.print(itostr3(max_feedrate[i-ItemC_vmaxx]/60));
} }
@ -873,7 +900,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Vmin:"); lcd.setCursor(0,line);lcdprintPGM(" Vmin:");
lcd.setCursor(13,line);lcd.print(itostr3(minimumfeedrate/60)); lcd.setCursor(13,line);lcd.print(itostr3(minimumfeedrate/60));
} }
@ -907,7 +934,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" VTrav min:"); lcd.setCursor(0,line);lcdprintPGM(" VTrav min:");
lcd.setCursor(13,line);lcd.print(itostr3(mintravelfeedrate/60)); lcd.setCursor(13,line);lcd.print(itostr3(mintravelfeedrate/60));
} }
@ -945,12 +972,12 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Amax "); lcd.setCursor(0,line);lcdprintPGM(" Amax ");
if(i==ItemC_amaxx)lcd.print("x:"); if(i==ItemC_amaxx)lcdprintPGM("x:");
if(i==ItemC_amaxy)lcd.print("y:"); if(i==ItemC_amaxy)lcdprintPGM("y:");
if(i==ItemC_amaxz)lcd.print("z:"); if(i==ItemC_amaxz)lcdprintPGM("z:");
if(i==ItemC_amaxe)lcd.print("e:"); if(i==ItemC_amaxe)lcdprintPGM("e:");
lcd.setCursor(13,line);lcd.print(itostr3(max_acceleration_units_per_sq_second[i-ItemC_amaxx]/100));lcd.print("00"); lcd.setCursor(13,line);lcd.print(itostr3(max_acceleration_units_per_sq_second[i-ItemC_amaxx]/100));lcdprintPGM("00");
} }
if((activeline==line) ) if((activeline==line) )
@ -974,7 +1001,7 @@ void MainMenu::showControl()
{ {
if(encoderpos<1) encoderpos=1; if(encoderpos<1) encoderpos=1;
if(encoderpos>990) encoderpos=990; if(encoderpos>990) encoderpos=990;
lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00"); lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
} }
} }
}break; }break;
@ -982,8 +1009,8 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" A-retract:"); lcd.setCursor(0,line);lcdprintPGM(" A-retract:");
lcd.setCursor(13,line);lcd.print(ftostr3(retract_acceleration/100));lcd.print("00"); lcd.setCursor(13,line);lcd.print(ftostr3(retract_acceleration/100));lcdprintPGM("00");
} }
if((activeline==line) ) if((activeline==line) )
@ -1008,7 +1035,7 @@ void MainMenu::showControl()
{ {
if(encoderpos<10) encoderpos=10; if(encoderpos<10) encoderpos=10;
if(encoderpos>990) encoderpos=990; if(encoderpos>990) encoderpos=990;
lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcd.print("00"); lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
} }
} }
}break; }break;
@ -1016,7 +1043,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Esteps/mm:"); lcd.setCursor(0,line);lcdprintPGM(" Esteps/mm:");
lcd.setCursor(13,line);lcd.print(itostr4(axis_steps_per_unit[3])); lcd.setCursor(13,line);lcd.print(itostr4(axis_steps_per_unit[3]));
} }
@ -1053,7 +1080,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Store EPROM"); lcd.setCursor(0,line);lcdprintPGM(" Store EPROM");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -1067,7 +1094,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Load EPROM"); lcd.setCursor(0,line);lcdprintPGM(" Load EPROM");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -1081,7 +1108,7 @@ void MainMenu::showControl()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" Restore Failsafe"); lcd.setCursor(0,line);lcdprintPGM(" Restore Failsafe");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -1165,7 +1192,7 @@ void MainMenu::showSD()
{ {
if(force_lcd_update) if(force_lcd_update)
{ {
lcd.setCursor(0,line);lcd.print(" File"); lcd.setCursor(0,line);lcdprintPGM(" File");
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -1185,11 +1212,11 @@ void MainMenu::showSD()
if(true) if(true)
#endif #endif
{ {
lcd.print(" \004Refresh"); lcdprintPGM(" \004Refresh");
} }
else else
{ {
lcd.print(" \004Insert Card"); lcdprintPGM(" \004Insert Card");
} }
} }
@ -1210,7 +1237,7 @@ void MainMenu::showSD()
{ {
card.getfilename(i-2); card.getfilename(i-2);
//Serial.print("Filenr:");Serial.println(i-2); //Serial.print("Filenr:");Serial.println(i-2);
lcd.setCursor(0,line);lcd.print(" ");lcd.print(card.filename); lcd.setCursor(0,line);lcdprintPGM(" ");lcd.print(card.filename);
} }
if((activeline==line) && CLICKED) if((activeline==line) && CLICKED)
{ {
@ -1292,7 +1319,7 @@ void MainMenu::showMainMenu()
{ {
case ItemM_watch: case ItemM_watch:
{ {
if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Watch \x7E");} if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Watch \x7E");}
if((activeline==line)&&CLICKED) if((activeline==line)&&CLICKED)
{ {
BLOCK; BLOCK;
@ -1302,7 +1329,7 @@ void MainMenu::showMainMenu()
} break; } break;
case ItemM_prepare: case ItemM_prepare:
{ {
if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Prepare \x7E");} if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Prepare \x7E");}
if((activeline==line)&&CLICKED) if((activeline==line)&&CLICKED)
{ {
BLOCK; BLOCK;
@ -1313,7 +1340,7 @@ void MainMenu::showMainMenu()
case ItemM_control: case ItemM_control:
{ {
if(force_lcd_update) {lcd.setCursor(0,line);lcd.print(" Control \x7E");} if(force_lcd_update) {lcd.setCursor(0,line);lcdprintPGM(" Control \x7E");}
if((activeline==line)&&CLICKED) if((activeline==line)&&CLICKED)
{ {
BLOCK; BLOCK;
@ -1334,13 +1361,13 @@ void MainMenu::showMainMenu()
#endif #endif
{ {
if(card.sdprinting) if(card.sdprinting)
lcd.print(" Stop Print \x7E"); lcdprintPGM(" Stop Print \x7E");
else else
lcd.print(" Card Menu \x7E"); lcdprintPGM(" Card Menu \x7E");
} }
else else
{ {
lcd.print(" No Card"); lcdprintPGM(" No Card");
} }
} }
#ifdef CARDINSERTED #ifdef CARDINSERTED
@ -1356,7 +1383,8 @@ void MainMenu::showMainMenu()
}break; }break;
#endif #endif
default: default:
SERIAL_ERRORLN("Something is wrong in the MenuStructure."); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Something is wrong in the MenuStructure.");
break; break;
} }
} }

7
Marlin/watchdog.pde
Unescape View File

@ -41,10 +41,11 @@ ISR(WDT_vect)
{ {
#ifdef RESET_MANUAL #ifdef RESET_MANUAL
LCD_MESSAGE("Please Reset!"); LCD_MESSAGEPGM("Please Reset!");
SERIAL_ERRORLN("Something is wrong, please turn off the printer."); SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Something is wrong, please turn off the printer.");
#else #else
LCD_MESSAGE("Timeout, resetting!"); LCD_MESSAGEPGM("Timeout, resetting!");
#endif #endif
//disable watchdog, it will survife reboot. //disable watchdog, it will survife reboot.
WDTCSR |= (1<<WDCE) | (1<<WDE); WDTCSR |= (1<<WDCE) | (1<<WDE);

Write Preview
Loading…
Cancel
Save