Hi

Marlin/Configuration.h

@@ -1,39 +1,64 @@
+
 #ifndef CONFIGURATION_H
 #define CONFIGURATION_H
 
 // BASIC SETTINGS: select your board type, thermistor type, axis scaling, and endstop configuration
 
 //// The following define selects which electronics board you have. Please choose the one that matches your setup
 // Gen6 = 5, 
-#define MOTHERBOARD 5 
+#define MOTHERBOARD 7
 
 //// Thermistor settings:
 // 1 is 100k thermistor
 // 2 is 200k thermistor
 // 3 is mendel-parts thermistor
-#define THERMISTORHEATER 3
+#define THERMISTORHEATER 2
+// Select one of these only to define how the nozzle temp is read.
+//#define HEATER_USES_THERMISTOR
+#define HEATER_USES_AD595
+//#define HEATER_USES_MAX6675
+
+// Select one of these only to define how the bed temp is read.
+//#define BED_USES_THERMISTOR
+//#define BED_USES_AD595
 
+#define HEATER_CHECK_INTERVAL 50
+#define BED_CHECK_INTERVAL 5000
+#define BNUMTEMPS NUMTEMPS
+#define bedtemptable temptable
 
-//// Calibration variables
-// X, Y, Z, E steps per unit - Metric Mendel / Orca with V9 extruder:
-float axis_steps_per_unit[] = {40, 40, 3333.92, 67}; 
-// For E steps per unit = 67 for v9 with direct drive (needs finetuning) for other extruders this needs to be changed 
-// Metric Prusa Mendel with Makergear geared stepper extruder:
-//float axis_steps_per_unit[] = {80,80,3200/1.25,1380}; 
 
 //// 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 = false; // 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
 
 // This determines the communication speed of the printer
-#define BAUDRATE 250000
+#define BAUDRATE 115200
 
 // Comment out (using // at the start of the line) to disable SD support:
-//#define SDSUPPORT
+
+// #define ULTRA_LCD  //any lcd 
+#define LCD_WIDTH 16
+#define LCD_HEIGHT 2
+
+//#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
+#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"
@@ -47,14 +72,14 @@ const bool ENDSTOPS_INVERTING = false; // set to true to invert the logic of the
 // Disables axis when it's not being used.
 #define DISABLE_X false
 #define DISABLE_Y false
-#define DISABLE_Z true
+#define DISABLE_Z false
 #define DISABLE_E false
 
 // Inverting axis direction
 #define INVERT_X_DIR true    // for Mendel set to false, for Orca set to true
 #define INVERT_Y_DIR false   // for Mendel set to true, for Orca set to false
 #define INVERT_Z_DIR true    // for Mendel set to false, for Orca set to true
-#define INVERT_E_DIR true   // for direct drive extruder v9 set to true, for geared extruder set to false
+#define INVERT_E_DIR false   // for direct drive extruder v9 set to true, for geared extruder set to false
 
 //// ENDSTOP SETTINGS:
 // Sets direction of endstops when homing; 1=MAX, -1=MIN
@@ -64,26 +89,47 @@ const bool ENDSTOPS_INVERTING = false; // set to true to invert the logic of the
 
 #define min_software_endstops false //If true, axis won't move to coordinates less than zero.
 #define max_software_endstops true  //If true, axis won't move to coordinates greater than the defined lengths below.
-#define X_MAX_LENGTH 200
-#define Y_MAX_LENGTH 200
-#define Z_MAX_LENGTH 100
+#define X_MAX_LENGTH 210
+#define Y_MAX_LENGTH 210
+#define Z_MAX_LENGTH 210
 
 //// MOVEMENT SETTINGS
 #define NUM_AXIS 4 // The axis order in all axis related arrays is X, Y, Z, E
-float max_feedrate[] = {60000, 60000, 100, 500000}; // set the max speeds
-float homing_feedrate[] = {2400, 2400, 80, 0};  // set the homing speeds
+//note: on bernhards ultimaker 200 200 12 are working well.
+float homing_feedrate[] = {70*60, 70*60, 12*60, 0};  // set the homing speeds
+//the followint checks if an extrusion is existent in the move. if _not_, the speed of the move is set to the maximum speed. 
+//!!!!!!Use only if you know that your printer works at the maximum declared speeds.
+// works around the skeinforge cool-bug. There all moves are slowed to have a minimum layer time. However slow travel moves= ooze
+#define TRAVELING_AT_MAXSPEED  
 bool axis_relative_modes[] = {false, false, false, false};
 
-//// Acceleration settings
-// X, Y, Z, E maximum start speed for accelerated moves. E default values are good for skeinforge 40+, for older versions raise them a lot.
-float acceleration = 2000;         // Normal acceleration mm/s^2
-float retract_acceleration = 7000; // Normal acceleration mm/s^2
-float max_jerk = 20*60;
-long max_acceleration_units_per_sq_second[] = {7000,7000,100,10000}; // X, Y, Z and E max acceleration in mm/s^2 for printing moves or retracts
-// Not used long max_travel_acceleration_units_per_sq_second[] = {500,500,50,500}; // X, Y, Z max acceleration in mm/s^2 for travel moves
 
+// default settings 
+
+#define DEFAULT_AXIS_STEPS_PER_UNIT   {79.87220447,79.87220447,200*8/3,14}                    // default steps per unit for ultimaker 
+#define DEFAULT_MAX_FEEDRATE          {160*60, 160*60, 10*60, 500000}        
+#define DEFAULT_MAX_ACCELERATION      {9000,9000,150,10000}    // X, Y, Z, E maximum start speed for accelerated moves. E default values are good for skeinforge 40+, for older versions raise them a lot.
+
+#define DEFAULT_ACCELERATION          4600    // X, Y, Z and E max acceleration in mm/s^2 for printing moves 
+#define DEFAULT_RETRACT_ACCELERATION  7000   // X, Y, Z and E max acceleration in mm/s^2 for r retracts
+
+#define DEFAULT_MINIMUMFEEDRATE       0*60      // minimum feedrate
+#define DEFAULT_MINTRAVELFEEDRATE     140*60
+
+// minimum time in microseconds that a movement needs to take if the buffer is emptied.   Increase this number if you see blobs while printing high speed & high detail.  It will slowdown on the detailed stuff.
+#define DEFAULT_MINSEGMENTTIME        20000
+#define DEFAULT_XYJERK                30.0*60    
+#define DEFAULT_ZJERK                 10.0*60
 
 // 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
+
+
 // 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
 //#define WATCHPERIOD 5000 //5 seconds
 
@@ -97,21 +143,43 @@ long max_acceleration_units_per_sq_second[] = {7000,7000,100,10000}; // X, Y, Z
 #define MAXTEMP 275
 
 
+
+
+
 /// PID settings:
 // Uncomment the following line to enable PID support.
-//#define PIDTEMP
+#define SMOOTHING
+#define SMOOTHFACTOR 5.0
+float current_raw_average=0;
+
+
+#define GRACETEMP 0  //temperature which already counts as reached for M109
+#define PIDTEMP
+
 #ifdef PIDTEMP
-//#define PID_DEBUG 1 // 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 156 // limits current to nozzle
-#define PID_INTEGRAL_DRIVE_MAX 156.0
-#define PID_dT 0.16
-double Kp = 20.0;
-double Ki = 1.5*PID_dT;
-double Kd = 80/PID_dT;
+  //#define PID_DEBUG 1 // 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
+  #define PID_INTEGRAL_DRIVE_MAX 255
+  #define PID_dT 0.05
+ //machine with red silicon: 1950:45 second ; with fan fully blowin 3000:47
+
+  #define PID_CRITIAL_GAIN 3000
+  #define PID_SWING_AT_CRITIAL 45 //seconds
+  #define PIDIADD 5
+/*
+  //PID according to Ziegler-Nichols method
+  float Kp = 0.6*PID_CRITIAL_GAIN; 
+  float Ki =PIDIADD+2*Kp/PID_SWING_AT_CRITIAL*PID_dT;  
+  float Kd = Kp*PID_SWING_AT_CRITIAL/8./PID_dT;  
+*/
+  //PI according to Ziegler-Nichols method
+  float Kp = PID_CRITIAL_GAIN/2.2; 
+  float Ki =1.2*Kp/PID_SWING_AT_CRITIAL*PID_dT;  
+  float Kd = 0;
+  float Kc = 9; //heatingpower=Kc*(e_speed)
 #endif // PIDTEMP
 
-
 // extruder advance constant (s2/mm3)
 //
 // advance (steps) = STEPS_PER_CUBIC_MM_E * EXTUDER_ADVANCE_K * cubic mm per second ^ 2
@@ -122,9 +190,9 @@ double Kd = 80/PID_dT;
 //#define ADVANCE
 
 #ifdef ADVANCE
-#define EXTRUDER_ADVANCE_K 0.02
+#define EXTRUDER_ADVANCE_K .3
 
-#define D_FILAMENT 1.7
+#define D_FILAMENT 2.8
 #define STEPS_MM_E 65
 #define EXTRUTION_AREA (0.25 * D_FILAMENT * D_FILAMENT * 3.14159)
 #define STEPS_PER_CUBIC_MM_E (axis_steps_per_unit[E_AXIS]/ EXTRUTION_AREA)

Marlin/EEPROM.h

@@ -0,0 +1,120 @@
+
+//======================================================================================
+template <class T> int EEPROM_writeAnything(int &ee, const T& value)
+{
+    const byte* p = (const byte*)(const void*)&value;
+    int i;
+    for (i = 0; i < sizeof(value); i++)
+	  EEPROM.write(ee++, *p++);
+    return i;
+}
+//======================================================================================
+template <class T> int EEPROM_readAnything(int &ee, T& value)
+{
+    byte* p = (byte*)(void*)&value;
+    int i;
+    for (i = 0; i < sizeof(value); i++)
+	  *p++ = EEPROM.read(ee++);
+    return i;
+}
+//======================================================================================
+
+#define EEPROM_OFFSET 100
+
+#define EEPROM_VERSION "V04"  // IMPORTANT:  Whenever there are changes made to the variables stored in EEPROM
+                              // in the functions below, also increment the version number. This makes sure that
+                              // the default values are used whenever there is a change to the data, to prevent
+                              // wrong data being written to the variables.
+                              // ALSO:  always make sure the variables in the Store and retrieve sections are in the same order.
+void StoreSettings() {
+  char ver[4]= "000";
+  int i=EEPROM_OFFSET;
+  EEPROM_writeAnything(i,ver); // invalidate data first 
+  EEPROM_writeAnything(i,axis_steps_per_unit);  
+  EEPROM_writeAnything(i,max_feedrate);  
+  EEPROM_writeAnything(i,max_acceleration_units_per_sq_second);
+  EEPROM_writeAnything(i,acceleration);
+  EEPROM_writeAnything(i,retract_acceleration);
+  EEPROM_writeAnything(i,minimumfeedrate);
+  EEPROM_writeAnything(i,mintravelfeedrate);
+  EEPROM_writeAnything(i,minsegmenttime);
+  EEPROM_writeAnything(i,max_xy_jerk);
+  EEPROM_writeAnything(i,max_z_jerk);
+  #ifdef PIDTEMP
+  EEPROM_writeAnything(i,Kp);
+  EEPROM_writeAnything(i,Ki);
+  EEPROM_writeAnything(i,Kd);
+#else
+  EEPROM_writeAnything(i,3000);
+  EEPROM_writeAnything(i,0);
+  EEPROM_writeAnything(i,0);
+#endif
+  char ver2[4]=EEPROM_VERSION;
+  i=EEPROM_OFFSET;
+  EEPROM_writeAnything(i,ver2); // validate data
+   ECHOLN("Settings Stored");
+
+}
+
+void RetrieveSettings(bool def=false){  // if def=true, the default values will be used
+  int i=EEPROM_OFFSET;
+  char stored_ver[4];
+  char ver[4]=EEPROM_VERSION;
+  EEPROM_readAnything(i,stored_ver); //read stored version
+//  ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
+  if ((!def)&&(strncmp(ver,stored_ver,3)==0)) {   // version number match
+      EEPROM_readAnything(i,axis_steps_per_unit);  
+      EEPROM_readAnything(i,max_feedrate);  
+      EEPROM_readAnything(i,max_acceleration_units_per_sq_second);
+      EEPROM_readAnything(i,acceleration);
+      EEPROM_readAnything(i,retract_acceleration);
+      EEPROM_readAnything(i,minimumfeedrate);
+      EEPROM_readAnything(i,mintravelfeedrate);
+      EEPROM_readAnything(i,minsegmenttime);
+      EEPROM_readAnything(i,max_xy_jerk);
+      EEPROM_readAnything(i,max_z_jerk);
+#ifndef PIDTEMP
+      float Kp,Ki,Kd;
+#endif
+      EEPROM_readAnything(i,Kp);
+      EEPROM_readAnything(i,Ki);
+      EEPROM_readAnything(i,Kd);
+
+      ECHOLN("Stored settings retreived:");
+  }
+  else {
+    float tmp1[]=DEFAULT_AXIS_STEPS_PER_UNIT;
+    float tmp2[]=DEFAULT_MAX_FEEDRATE;
+    long tmp3[]=DEFAULT_MAX_ACCELERATION;
+    for (int 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;
+    retract_acceleration=DEFAULT_RETRACT_ACCELERATION;
+    minimumfeedrate=DEFAULT_MINIMUMFEEDRATE;
+    minsegmenttime=DEFAULT_MINSEGMENTTIME;       
+    mintravelfeedrate=DEFAULT_MINTRAVELFEEDRATE;
+    max_xy_jerk=DEFAULT_XYJERK;
+    max_z_jerk=DEFAULT_ZJERK;
+    ECHOLN("Using Default settings:");
+  }
+  ECHOLN("Steps per unit:");
+  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));
+  ECHOLN("Maximum feedrates (mm/s):");
+  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));
+  ECHOLN("Maximum Acceleration (mm/s2):");
+  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));
+  ECHOLN("Acceleration: S=acceleration, T=retract acceleration");
+  ECHOLN("   M204 S"  <<_FLOAT(acceleration,2) << " T" << _FLOAT(retract_acceleration,2));
+  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)");
+  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));
+#ifdef PIDTEMP
+  ECHOLN("PID settings:");
+  ECHOLN("   M301 P"  << _FLOAT(Kp,3) << " I" << _FLOAT(Ki,3) << " D" << _FLOAT(Kd,3));  
+#endif
+
+}  
+
+