Add files via upload

Firmware/Marlin/BlinkM.cpp

@@ -0,0 +1,29 @@
+/*
+  BlinkM.cpp - Library for controlling a BlinkM over i2c
+  Created by Tim Koster, August 21 2013.
+*/
+#include "Marlin.h"
+#ifdef BLINKM
+
+#if (ARDUINO >= 100)
+  # include "Arduino.h"
+#else
+  # include "WProgram.h"
+#endif
+
+#include "BlinkM.h"
+
+void SendColors(byte red, byte grn, byte blu)
+{
+  Wire.begin(); 
+  Wire.beginTransmission(0x09);
+  Wire.write('o');                    //to disable ongoing script, only needs to be used once
+  Wire.write('n');
+  Wire.write(red);
+  Wire.write(grn);
+  Wire.write(blu);
+  Wire.endTransmission();
+}
+
+#endif //BLINKM
+

Firmware/Marlin/BlinkM.h

@@ -0,0 +1,14 @@
+/*
+  BlinkM.h
+  Library header file for BlinkM library
+ */
+#if (ARDUINO >= 100)
+  # include "Arduino.h"
+#else
+  # include "WProgram.h"
+#endif
+
+#include "Wire.h"
+
+void SendColors(byte red, byte grn, byte blu);
+

Firmware/Marlin/ConfigurationStore.cpp

@@ -0,0 +1,299 @@
+#include "Marlin.h"
+#include "planner.h"
+#include "temperature.h"
+#include "ultralcd.h"
+#include "ConfigurationStore.h"
+
+void _EEPROM_writeData(int &pos, uint8_t* value, uint8_t size)
+{
+    do
+    {
+        eeprom_write_byte((unsigned char*)pos, *value);
+        pos++;
+        value++;
+    }while(--size);
+}
+#define EEPROM_WRITE_VAR(pos, value) _EEPROM_writeData(pos, (uint8_t*)&value, sizeof(value))
+void _EEPROM_readData(int &pos, uint8_t* value, uint8_t size)
+{
+    do
+    {
+        *value = eeprom_read_byte((unsigned char*)pos);
+        pos++;
+        value++;
+    }while(--size);
+}
+#define EEPROM_READ_VAR(pos, value) _EEPROM_readData(pos, (uint8_t*)&value, sizeof(value))
+//======================================================================================
+
+
+
+
+#define EEPROM_OFFSET 100
+
+
+// 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.
+#define EEPROM_VERSION "V10"
+
+#ifdef EEPROM_SETTINGS
+void Config_StoreSettings() 
+{
+  char ver[4]= "000";
+  int i=EEPROM_OFFSET;
+  EEPROM_WRITE_VAR(i,ver); // invalidate data first 
+  EEPROM_WRITE_VAR(i,axis_steps_per_unit);  
+  EEPROM_WRITE_VAR(i,max_feedrate);  
+  EEPROM_WRITE_VAR(i,max_acceleration_units_per_sq_second);
+  EEPROM_WRITE_VAR(i,acceleration);
+  EEPROM_WRITE_VAR(i,retract_acceleration);
+  EEPROM_WRITE_VAR(i,minimumfeedrate);
+  EEPROM_WRITE_VAR(i,mintravelfeedrate);
+  EEPROM_WRITE_VAR(i,minsegmenttime);
+  EEPROM_WRITE_VAR(i,max_xy_jerk);
+  EEPROM_WRITE_VAR(i,max_z_jerk);
+  EEPROM_WRITE_VAR(i,max_e_jerk);
+  EEPROM_WRITE_VAR(i,add_homeing);
+  #ifdef DELTA
+  EEPROM_WRITE_VAR(i,endstop_adj);
+  #endif
+  #ifndef ULTIPANEL
+  int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
+  int absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
+  #endif
+  EEPROM_WRITE_VAR(i,plaPreheatHotendTemp);
+  EEPROM_WRITE_VAR(i,plaPreheatHPBTemp);
+  EEPROM_WRITE_VAR(i,plaPreheatFanSpeed);
+  EEPROM_WRITE_VAR(i,absPreheatHotendTemp);
+  EEPROM_WRITE_VAR(i,absPreheatHPBTemp);
+  EEPROM_WRITE_VAR(i,absPreheatFanSpeed);
+  EEPROM_WRITE_VAR(i,zprobe_zoffset);
+  #ifdef PIDTEMP
+    EEPROM_WRITE_VAR(i,Kp);
+    EEPROM_WRITE_VAR(i,Ki);
+    EEPROM_WRITE_VAR(i,Kd);
+  #else
+		float dummy = 3000.0f;
+    EEPROM_WRITE_VAR(i,dummy);
+		dummy = 0.0f;
+    EEPROM_WRITE_VAR(i,dummy);
+    EEPROM_WRITE_VAR(i,dummy);
+  #endif
+  #ifndef DOGLCD
+    int lcd_contrast = 32;
+  #endif
+  EEPROM_WRITE_VAR(i,lcd_contrast);
+  char ver2[4]=EEPROM_VERSION;
+  i=EEPROM_OFFSET;
+  EEPROM_WRITE_VAR(i,ver2); // validate data
+  SERIAL_ECHO_START;
+  SERIAL_ECHOLNPGM("Settings Stored");
+}
+#endif //EEPROM_SETTINGS
+
+
+#ifndef DISABLE_M503
+void Config_PrintSettings()
+{  // Always have this function, even with EEPROM_SETTINGS disabled, the current values will be shown
+    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]);
+    SERIAL_ECHOPAIR(" Y",max_feedrate[1] ); 
+    SERIAL_ECHOPAIR(" Z", max_feedrate[2] ); 
+    SERIAL_ECHOPAIR(" E", max_feedrate[3]);
+    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),  E=maximum E jerk (mm/s)");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPAIR("  M205 S",minimumfeedrate ); 
+    SERIAL_ECHOPAIR(" T" ,mintravelfeedrate ); 
+    SERIAL_ECHOPAIR(" B" ,minsegmenttime ); 
+    SERIAL_ECHOPAIR(" X" ,max_xy_jerk ); 
+    SERIAL_ECHOPAIR(" Z" ,max_z_jerk);
+    SERIAL_ECHOPAIR(" E" ,max_e_jerk);
+    SERIAL_ECHOLN(""); 
+
+    SERIAL_ECHO_START;
+    SERIAL_ECHOLNPGM("Home offset (mm):");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPAIR("  M206 X",add_homeing[0] );
+    SERIAL_ECHOPAIR(" Y" ,add_homeing[1] );
+    SERIAL_ECHOPAIR(" Z" ,add_homeing[2] );
+    SERIAL_ECHOLN("");
+#ifdef DELTA
+    SERIAL_ECHO_START;
+    SERIAL_ECHOLNPGM("Endstop adjustement (mm):");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPAIR("  M666 X",endstop_adj[0] );
+    SERIAL_ECHOPAIR(" Y" ,endstop_adj[1] );
+    SERIAL_ECHOPAIR(" Z" ,endstop_adj[2] );
+    SERIAL_ECHOLN("");
+#endif
+#ifdef PIDTEMP
+    SERIAL_ECHO_START;
+    SERIAL_ECHOLNPGM("PID settings:");
+    SERIAL_ECHO_START;
+    SERIAL_ECHOPAIR("   M301 P",Kp); 
+    SERIAL_ECHOPAIR(" I" ,unscalePID_i(Ki)); 
+    SERIAL_ECHOPAIR(" D" ,unscalePID_d(Kd));
+    SERIAL_ECHOLN(""); 
+#endif
+} 
+#endif
+
+
+#ifdef EEPROM_SETTINGS
+void Config_RetrieveSettings()
+{
+    int i=EEPROM_OFFSET;
+    char stored_ver[4];
+    char ver[4]=EEPROM_VERSION;
+    EEPROM_READ_VAR(i,stored_ver); //read stored version
+    //  SERIAL_ECHOLN("Version: [" << ver << "] Stored version: [" << stored_ver << "]");
+    if (strncmp(ver,stored_ver,3) == 0)
+    {
+        // version number match
+        EEPROM_READ_VAR(i,axis_steps_per_unit);  
+        EEPROM_READ_VAR(i,max_feedrate);  
+        EEPROM_READ_VAR(i,max_acceleration_units_per_sq_second);
+
+        // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
+		reset_acceleration_rates();
+
+        EEPROM_READ_VAR(i,acceleration);
+        EEPROM_READ_VAR(i,retract_acceleration);
+        EEPROM_READ_VAR(i,minimumfeedrate);
+        EEPROM_READ_VAR(i,mintravelfeedrate);
+        EEPROM_READ_VAR(i,minsegmenttime);
+        EEPROM_READ_VAR(i,max_xy_jerk);
+        EEPROM_READ_VAR(i,max_z_jerk);
+        EEPROM_READ_VAR(i,max_e_jerk);
+        EEPROM_READ_VAR(i,add_homeing);
+        #ifdef DELTA
+        EEPROM_READ_VAR(i,endstop_adj);
+        #endif
+        #ifndef ULTIPANEL
+        int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed;
+        int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed;
+        #endif
+        EEPROM_READ_VAR(i,plaPreheatHotendTemp);
+        EEPROM_READ_VAR(i,plaPreheatHPBTemp);
+        EEPROM_READ_VAR(i,plaPreheatFanSpeed);
+        EEPROM_READ_VAR(i,absPreheatHotendTemp);
+        EEPROM_READ_VAR(i,absPreheatHPBTemp);
+        EEPROM_READ_VAR(i,absPreheatFanSpeed);
+        EEPROM_READ_VAR(i,zprobe_zoffset);
+        #ifndef PIDTEMP
+        float Kp,Ki,Kd;
+        #endif
+        // do not need to scale PID values as the values in EEPROM are already scaled		
+        EEPROM_READ_VAR(i,Kp);
+        EEPROM_READ_VAR(i,Ki);
+        EEPROM_READ_VAR(i,Kd);
+        #ifndef DOGLCD
+        int lcd_contrast;
+        #endif
+        EEPROM_READ_VAR(i,lcd_contrast);
+
+		// Call updatePID (similar to when we have processed M301)
+		updatePID();
+        SERIAL_ECHO_START;
+        SERIAL_ECHOLNPGM("Stored settings retrieved");
+    }
+    else
+    {
+        Config_ResetDefault();
+    }
+    #ifdef EEPROM_CHITCHAT
+      Config_PrintSettings();
+    #endif
+}
+#endif
+
+void Config_ResetDefault()
+{
+    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];
+    }
+
+    // steps per sq second need to be updated to agree with the units per sq second
+    reset_acceleration_rates();
+
+    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;
+    max_e_jerk=DEFAULT_EJERK;
+    add_homeing[0] = add_homeing[1] = add_homeing[2] = 0;
+#ifdef DELTA
+    endstop_adj[0] = endstop_adj[1] = endstop_adj[2] = 0;
+#endif
+#ifdef ULTIPANEL
+    plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP;
+    plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP;
+    plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED;
+    absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP;
+    absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP;
+    absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED;
+#endif
+#ifdef ENABLE_AUTO_BED_LEVELING
+    zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER;
+#endif
+#ifdef DOGLCD
+    lcd_contrast = DEFAULT_LCD_CONTRAST;
+#endif
+#ifdef PIDTEMP
+    Kp = DEFAULT_Kp;
+    Ki = scalePID_i(DEFAULT_Ki);
+    Kd = scalePID_d(DEFAULT_Kd);
+
+    // call updatePID (similar to when we have processed M301)
+    updatePID();
+
+#ifdef PID_ADD_EXTRUSION_RATE
+    Kc = DEFAULT_Kc;
+#endif//PID_ADD_EXTRUSION_RATE
+#endif//PIDTEMP
+
+SERIAL_ECHO_START;
+SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
+
+}

Firmware/Marlin/ConfigurationStore.h

@@ -0,0 +1,22 @@
+#ifndef CONFIG_STORE_H
+#define CONFIG_STORE_H
+
+#include "Configuration.h"
+
+void Config_ResetDefault();
+
+#ifndef DISABLE_M503
+void Config_PrintSettings();
+#else
+FORCE_INLINE void Config_PrintSettings() {}
+#endif
+
+#ifdef EEPROM_SETTINGS
+void Config_StoreSettings();
+void Config_RetrieveSettings();
+#else
+FORCE_INLINE void Config_StoreSettings() {}
+FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); }
+#endif
+
+#endif//CONFIG_STORE_H