q3k
/
Marlin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

hackerspace-green
Erik van der Zalm 2011-11-13 20:46:44 +01:00
parent 65934eee9c 9980ceb4a3
commit ac82411c73
16 changed files with 1443 additions and 1156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

286
Marlin/Configuration.h
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
// 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
//// Endstop Settings // 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
// PID settings:
// Uncomment the following line to enable PID support.
#define PIDTEMP
#ifdef PIDTEMP
//#define PID_DEBUG // Sends debug data to the serial port.
//#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
#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
#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
//===========================================================================
//=============================Mechanical Settings===========================
//===========================================================================
// Endstop Settings
#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors #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. // 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. 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 optos H21LOB set to true, for Mendel-Parts newer optos TCST2103 set to false
// This determines the communication speed of the printer
#define BAUDRATE 250000
//#define BAUDRATE 115200
//#define BAUDRATE 230400
// Comment out (using // at the start of the line) to disable SD support:
// #define ULTRA_LCD //any lcd
#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
//#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"
// 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)
//===========================================================================
//=============================Additional Features===========================
//===========================================================================
// EEPROM
// the microcontroller can store settings in the EEPROM, e.g. max velocity...
// M500 - stores paramters in EEPROM
// 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.
//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
// The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature // The watchdog waits for the watchperiod in milliseconds whenever an M104 or M109 increases the target temperature
//this enables the watchdog interrupt. // this enables the watchdog interrupt.
#define USE_WATCHDOG #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: // 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 RESET_MANUAL
#define WATCHDOG_TIMEOUT 4 //seconds
#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
// 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
/// PID settings:
// Uncomment the following line to enable PID support.
#define PIDTEMP
#ifdef PIDTEMP
//#define PID_DEBUG // Sends debug data to the serial port.
//#define PID_OPENLOOP 1 // Puts PID in open loop. M104 sets the output power in %
#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
#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

168
Marlin/EEPROMwrite.h
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,71 +66,115 @@ 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
int i=EEPROM_OFFSET; #ifdef EEPROM_SETTINGS
char stored_ver[4]; int i=EEPROM_OFFSET;
char ver[4]=EEPROM_VERSION; char stored_ver[4];
EEPROM_readAnything(i,stored_ver); //read stored version char ver[4]=EEPROM_VERSION;
// SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]"); EEPROM_readAnything(i,stored_ver); //read stored version
if ((!def)&&(strncmp(ver,stored_ver,3)==0)) // SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
{ // version number match if ((!def)&&(strncmp(ver,stored_ver,3)==0))
EEPROM_readAnything(i,axis_steps_per_unit); { // version number match
EEPROM_readAnything(i,max_feedrate); EEPROM_readAnything(i,axis_steps_per_unit);
EEPROM_readAnything(i,max_acceleration_units_per_sq_second); EEPROM_readAnything(i,max_feedrate);
EEPROM_readAnything(i,acceleration); EEPROM_readAnything(i,max_acceleration_units_per_sq_second);
EEPROM_readAnything(i,retract_acceleration); EEPROM_readAnything(i,acceleration);
EEPROM_readAnything(i,minimumfeedrate); EEPROM_readAnything(i,retract_acceleration);
EEPROM_readAnything(i,mintravelfeedrate); EEPROM_readAnything(i,minimumfeedrate);
EEPROM_readAnything(i,minsegmenttime); EEPROM_readAnything(i,mintravelfeedrate);
EEPROM_readAnything(i,max_xy_jerk); EEPROM_readAnything(i,minsegmenttime);
EEPROM_readAnything(i,max_z_jerk); EEPROM_readAnything(i,max_xy_jerk);
#ifndef PIDTEMP EEPROM_readAnything(i,max_z_jerk);
float Kp,Ki,Kd; #ifndef PIDTEMP
#endif float Kp,Ki,Kd;
EEPROM_readAnything(i,Kp); #endif
EEPROM_readAnything(i,Ki); EEPROM_readAnything(i,Kp);
EEPROM_readAnything(i,Kd); EEPROM_readAnything(i,Ki);
EEPROM_readAnything(i,Kd);
SERIAL_ECHOLN("Stored settings retreived:"); SERIAL_ECHO_START;
} SERIAL_ECHOLNPGM("Stored settings retreived:");
else
{
float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
float tmp2[]=DEFAULT_MAX_FEEDRATE;
long tmp3[]=DEFAULT_MAX_ACCELERATION;
for (short i=0;i<4;i++)
{
axis_steps_per_unit[i]=tmp1[i];
max_feedrate[i]=tmp2[i];
max_acceleration_units_per_sq_second[i]=tmp3[i];
} }
acceleration=DEFAULT_ACCELERATION; else
retract_acceleration=DEFAULT_RETRACT_ACCELERATION; {
minimumfeedrate=DEFAULT_MINIMUMFEEDRATE; float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
minsegmenttime=DEFAULT_MINSEGMENTTIME; float tmp2[]=DEFAULT_MAX_FEEDRATE;
mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE; long tmp3[]=DEFAULT_MAX_ACCELERATION;
max_xy_jerk=DEFAULT_XYJERK; for (short i=0;i<4;i++)
max_z_jerk=DEFAULT_ZJERK; {
SERIAL_ECHOLN("Using Default settings:"); axis_steps_per_unit[i]=tmp1[i];
} max_feedrate[i]=tmp2[i];
SERIAL_ECHOLN("Steps per unit:"); max_acceleration_units_per_sq_second[i]=tmp3[i];
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_ECHOLN("Maximum feedrates (mm/s):"); acceleration=DEFAULT_ACCELERATION;
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)); retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
SERIAL_ECHOLN("Maximum Acceleration (mm/s2):"); minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
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)); minsegmenttime=DEFAULT_MINSEGMENTTIME;
SERIAL_ECHOLN("Acceleration: S=acceleration, T=retract acceleration"); mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
SERIAL_ECHOLN(" M204 S" <<_FLOAT(acceleration,2) << " T" << _FLOAT(retract_acceleration,2)); max_xy_jerk=DEFAULT_XYJERK;
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)"); max_z_jerk=DEFAULT_ZJERK;
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;
#ifdef PIDTEMP SERIAL_ECHOLN("Using Default settings:");
SERIAL_ECHOLN("PID settings:"); }
SERIAL_ECHOLN(" M301 P" << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3)); #ifdef EEPROM_CHITCHAT
SERIAL_ECHO_START;
SERIAL_ECHOLNPGM("Steps per unit:");
SERIAL_ECHO_START;
SERIAL_ECHOPAIR(" M92 X",axis_steps_per_unit[0]);
SERIAL_ECHOPAIR(" Y",axis_steps_per_unit[1]);
SERIAL_ECHOPAIR(" Z",axis_steps_per_unit[2]);
SERIAL_ECHOPAIR(" E",axis_steps_per_unit[3]);
SERIAL_ECHOLN("");
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
SERIAL_ECHO_START;
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
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

255
Marlin/Marlin.pde
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 #endif //TEMP_1_PIN
Serial.println(bt); #else
#else SERIAL_ERROR_START;
Serial.println(HeaterPower); SERIAL_ERRORLNPGM("No thermistors - no temp");
#endif
#else //not PIDTEMP
Serial.println();
#endif //PIDTEMP
#else
Serial.println();
#endif //TEMP_1_PIN
#else
SERIAL_ERRORLN("No thermistors - no temp");
#endif #endif
#ifdef PIDTEMP
SERIAL_PROTOCOLPGM(" @:");
SERIAL_PROTOCOL( HeaterPower);
#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
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
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");
} }
} }

1386
Marlin/pins.h
View File

File diff suppressed because it is too large Load Diff

38
Marlin/planner.cpp
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();
} }
@ -702,4 +736,4 @@ void plan_set_position(const float &x, const float &y, const float &z, const flo
previous_speed[2] = 0.0; previous_speed[2] = 0.0;
previous_speed[3] = 0.0; previous_speed[3] = 0.0;
} }

6
Marlin/planner.h
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
#endif extern float high_e_speed;
#endif
#endif

58
Marlin/stepper.cpp
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
@ -614,4 +666,4 @@ void st_synchronize()
manage_inactivity(1); manage_inactivity(1);
LCD_STATUS; LCD_STATUS;
} }
} }

7
Marlin/stepper.h
View File

@ -39,6 +39,13 @@ void st_wake_up();
extern volatile long count_position[NUM_AXIS]; extern volatile long count_position[NUM_AXIS];
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
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

30
Marlin/temperature.cpp
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
@ -561,4 +569,4 @@ ISR(TIMER0_COMPB_vect)
} }
} }

1
Marlin/ultralcd.h
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
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
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);