Initial modifications to Marlin 1.1.4. At this point, it should support

single toolheads on gladiola and oliveoil, but not multiple extruders.

Marlin/Configuration_LulzBot.h

@@ -0,0 +1,548 @@
+#ifndef CONFIGURATION_LULZBOT
+#define CONFIGURATION_LULZBOT
+
+// Change printer model and toolhead here
+
+#define LULZBOT_Oliveoil_TAZ_6
+#define TOOLHEAD_Angelfish_Aero
+
+/* We define the LULZBOT_ values based on which print head or printer variants we are compiling for,
+ * these constants are then placed where appropriate in the following files:
+ *
+ *    - Configuration.h
+ *    - Configuration_adv.h
+ *    - pins.h
+ *    - Default_Version.h
+ *
+ * Using our own set of constants make it easier to keep track of changes from upstream.
+ * All values are prefixed with LULZBOT_ so that it is easy to see what was changed and where.
+ * If a setting is commented out, we define a LULZBOT_{SETTING}_DISABLED here, just so
+ * we have a record of things that got disabled.
+ */
+
+#if ( \
+    !defined(LULZBOT_Gladiola_Mini) && \
+    !defined(LULZBOT_Huerfano_Mini) && \
+    !defined(LULZBOT_Oliveoil_TAZ_6) && \
+    !defined(LULZBOT_Huerfano_TAZ_7) \
+) || ( \
+    !defined(TOOLHEAD_Gladiola_SingleExtruder) && \
+    !defined(TOOLHEAD_Oliveoil_SingleExtruder) && \
+    !defined(TOOLHEAD_Kanyu_Flexystruder) && \
+    !defined(TOOLHEAD_Opah_Moarstruder) && \
+    !defined(TOOLHEAD_Javelin_DualExtruder) && \
+    !defined(TOOLHEAD_Longfin_FlexyDually) && \
+    !defined(TOOLHEAD_Yellowfin_DualExtruder) && \
+    !defined(TOOLHEAD_Angelfish_Aero) \
+)
+#error Must specify model and toolhead to build:
+#error
+#error   make clean
+#error   make MODEL=<model> TOOLHEAD=<toolhead>
+#error
+#error   Model Choices:
+#error      Gladiola_Mini    // Lulzbot Mini  (Gladiola)
+#error      Huerfano_Mini    // Lulzbot Mini  (Huerfano)
+#error      Oliveoil_TAZ_6   // Lulzbot TAZ 6 (Olive Oil)
+#error      Huerfano_TAZ_7   // Lulzbot TAZ 7 (Huerfano)
+#error
+#error   Toolhead Choices:
+#error      Gladiola_SingleExtruder  // Standard Single Extruder (Gladiola)
+#error      Oliveoil_SingleExtruder  // Standard Single Extruder (TAZ Olive)
+#error      Kanyu_Flexystruder       // Flexystruder (Kanyu)
+#error      Opah_Moarstruder         // Moarstruder (Opah)
+#error      Javelin_DualExtruder     // Dual Extruder v2 (Javelin)
+#error      Longfin_FlexyDually      // FlexyDually (Longfin)
+#error      Yellowfin_DualExtruder   // Dual Extruder v3 (Yellowfin)
+#error      Angelfish_Aero           // Titan AERO (Angelfish)
+#endif
+
+#define LULZBOT_FW_VERSION ".1"
+
+// Select options based on printer model
+
+#if defined(LULZBOT_Gladiola_Mini)
+#define LULZBOT_CUSTOM_MACHINE_NAME "Mini"
+    #define LULZBOT_MINI_BED
+#endif
+
+#if defined(LULZBOT_Huerfano_Mini)
+    #define LULZBOT_CUSTOM_MACHINE_NAME "Mini Too"
+    #define LULZBOT_MINI_Z_BELT
+    #define LULZBOT_MINI_BED
+#endif
+
+#if defined(LULZBOT_Oliveoil_TAZ_6)
+    #define LULZBOT_CUSTOM_MACHINE_NAME "TAZ 6"
+    #define LULZBOT_TAZ_BED
+#endif
+
+#if defined(LULZBOT_Huerfano_TAZ_7)
+    #define LULZBOT_CUSTOM_MACHINE_NAME "TAZ 7"
+    #define LULZBOT_TAZ_Z_BELT
+    #define LULZBOT_TAZ_BED
+#endif
+
+// Shared values
+#define LULZBOT_STRING_CONFIG_H_AUTHOR        "(Aleph Objects Inc., LulzBot Default)"
+#define LULZBOT_BUFSIZE                       10
+
+// Temperature settings
+
+#define LULZBOT_TEMP_SENSOR_0                 5
+#define LULZBOT_TEMP_SENSOR_BED               7
+#define LULZBOT_TEMP_RESIDENCY_TIME           1
+#define LULZBOT_TEMP_HYSTERESIS               10
+#define LULZBOT_TEMP_WINDOW                   10
+
+#define LULZBOT_TEMP_BED_RESIDENCY_TIME       1
+#define LULZBOT_TEMP_BED_HYSTERESIS           5
+#define LULZBOT_TEMP_BED_WINDOW               5
+
+#define LULZBOT_HEATER_MAXTEMP                305
+#define LULZBOT_EXTRUDE_MINTEMP               120
+
+#define LULZBOT_PIDTEMPBED
+
+#define LULZBOT_MAX_BED_POWER                 206
+
+#define LULZBOT_THERMAL_PROTECTION_PERIOD     15     // Seconds
+#define LULZBOT_THERMAL_PROTECTION_HYSTERESIS 30     // Degrees Celsius
+
+#define LULZBOT_THERMAL_PROTECTION_BED_PERIOD     15     // Seconds
+#define LULZBOT_THERMAL_PROTECTION_BED_HYSTERESIS 10     // Degrees Celsius
+
+// Motherboard specifics and custom pins for probing.
+
+#if defined(LULZBOT_Gladiola_Mini) || defined(LULZBOT_Huerfano_Mini)
+    #define LULZBOT_MOTHERBOARD                   BOARD_MINIRAMBO
+    #define LULZBOT_CONTROLLER_FAN_PIN            FAN_1_PIN  // Digital pin 6
+    #define LULZBOT_Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN
+
+#elif defined(LULZBOT_Oliveoil_TAZ_6) || defined(LULZBOT_Huerfano_TAZ_7)
+    #define LULZBOT_MOTHERBOARD                   BOARD_RAMBO
+    #define LULZBOT_CONTROLLER_FAN_PIN            FAN_2_PIN  // Digital pin 2
+    #define LULZBOT_Z_MIN_PROBE_ENDSTOP
+    #define LULZBOT_Z_MIN_PROBE_PIN               SERVO0_PIN // Digital pin 22
+#endif
+
+#define LULZBOT_USE_XMIN_PLUG
+#define LULZBOT_USE_YMIN_PLUG
+#define LULZBOT_USE_ZMIN_PLUG
+#define LULZBOT_USE_XMAX_PLUG
+#define LULZBOT_USE_YMAX_PLUG
+#define LULZBOT_USE_ZMAX_PLUG
+
+#if defined(LULZBOT_Gladiola_Mini) || defined(LULZBOT_Huerfano_Mini)
+    #define LULZBOT_X_MIN_ENDSTOP_INVERTING       true
+    #define LULZBOT_Y_MIN_ENDSTOP_INVERTING       true
+    #define LULZBOT_Z_MIN_ENDSTOP_INVERTING       true
+    #define LULZBOT_Z_MIN_PROBE_ENDSTOP_INVERTING true
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING       true
+    #define LULZBOT_Y_MAX_ENDSTOP_INVERTING       true
+    #define LULZBOT_Z_MAX_ENDSTOP_INVERTING       true
+
+#elif defined(LULZBOT_Oliveoil_TAZ_6) || defined(LULZBOT_Huerfano_TAZ_7)
+    #define LULZBOT_X_MIN_ENDSTOP_INVERTING       false
+    #define LULZBOT_Y_MIN_ENDSTOP_INVERTING       false
+    #define LULZBOT_Z_MIN_ENDSTOP_INVERTING       true
+    #define LULZBOT_Z_MIN_PROBE_ENDSTOP_INVERTING true
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING       false
+    #define LULZBOT_Y_MAX_ENDSTOP_INVERTING       false
+    #define LULZBOT_Z_MAX_ENDSTOP_INVERTING       false
+#endif
+
+#define LULZBOT_INVERT_X_DIR                  false
+#define LULZBOT_INVERT_Y_DIR                  true
+#define LULZBOT_INVERT_Z_DIR                  false
+#define LULZBOT_INVERT_E0_DIR                 true
+#define LULZBOT_INVERT_E1_DIR                 true
+
+#if defined(LULZBOT_Gladiola_Mini) || defined(LULZBOT_Huerfano_Mini)
+    #define LULZBOT_HOMING_Z_WITH_PROBE           false
+    #define LULZBOT_INVERT_X_HOME_DIR             -1
+    #define LULZBOT_INVERT_Y_HOME_DIR              1
+    #define LULZBOT_INVERT_Z_HOME_DIR              1
+    #define LULZBOT_QUICKHOME
+
+#elif defined(LULZBOT_Oliveoil_TAZ_6) || defined(LULZBOT_Huerfano_TAZ_7)
+    #define LULZBOT_HOMING_Z_WITH_PROBE           true
+    #define LULZBOT_INVERT_X_HOME_DIR             -1
+    #define LULZBOT_INVERT_Y_HOME_DIR              1
+    #define LULZBOT_INVERT_Z_HOME_DIR             -1
+    #define LULZBOT_QUICKHOME
+#endif
+
+#if defined(LULZBOT_MINI_BED)
+    #define LULZBOT_LEFT_PROBE_BED_POSITION        0
+    #define LULZBOT_RIGHT_PROBE_BED_POSITION     164
+    #define LULZBOT_FRONT_PROBE_BED_POSITION      -6
+    #define LULZBOT_BACK_PROBE_BED_POSITION      162
+
+    #define LULZBOT_HOMING_FEEDRATE_XY            (30*60)
+    #define LULZBOT_HOMING_FEEDRATE_Z             (12*60)
+
+#elif defined(LULZBOT_TAZ_BED)
+    #define LULZBOT_LEFT_PROBE_BED_POSITION       -9
+    #define LULZBOT_RIGHT_PROBE_BED_POSITION     288
+    #define LULZBOT_BACK_PROBE_BED_POSITION      289
+    #define LULZBOT_FRONT_PROBE_BED_POSITION      -9
+
+    #define LULZBOT_HOMING_FEEDRATE_XY            (50*60)
+    #define LULZBOT_HOMING_FEEDRATE_Z             (8*60)
+
+    #define LULZBOT_Z_SAFE_HOMING
+    #define LULZBOT_Z_SAFE_HOMING_X_POINT         (-19)
+    #define LULZBOT_Z_SAFE_HOMING_Y_POINT         (258)
+    #define LULZBOT_Z_HOMING_HEIGHT               5
+    #define LULZBOT_RAISE_AFTER_HOME // Not in upstream Marlin.
+#endif
+
+#elif defined(LULZBOT_MINI_BED)
+    #define LULZBOT_WIPE_X1                       115
+    #define LULZBOT_WIPE_X2                       45
+    #define LULZBOT_WIPE_Y1                       173
+    #define LULZBOT_WIPE_Y2                       173
+
+#else defined(LULZBOT_TAZ_BED)
+    #define LULZBOT_WIPE_X1                      -16
+    #define LULZBOT_WIPE_X2                      -16
+    #define LULZBOT_WIPE_Y1                       95
+    #define LULZBOT_WIPE_Y2                       25
+#endif
+
+#define LULZBOT_NOZZLE_CLEAN_FEATURE
+
+#define LULZBOT_AUTO_BED_LEVELING_3POINT
+#define LULZBOT_ABL_PROBE_PT_1_X LULZBOT_LEFT_PROBE_BED_POSITION
+#define LULZBOT_ABL_PROBE_PT_1_Y LULZBOT_FRONT_PROBE_BED_POSITION
+#define LULZBOT_ABL_PROBE_PT_2_X LULZBOT_RIGHT_PROBE_BED_POSITION
+#define LULZBOT_ABL_PROBE_PT_2_Y LULZBOT_FRONT_PROBE_BED_POSITION
+#define LULZBOT_ABL_PROBE_PT_3_X LULZBOT_RIGHT_PROBE_BED_POSITION
+#define LULZBOT_ABL_PROBE_PT_3_Y LULZBOT_BACK_PROBE_BED_POSITION
+
+/* Define probe parameters related to bed leveling,
+ * e.g. the washers on the bed. These are confusingly
+ * named Z_MIN_PROBE in Marlin. The Z-Home switch
+ * is called Z_MIN_ENDSTOP
+ */
+#define LULZBOT_FIX_MOUNTED_PROBE
+#define LULZBOT_PROBE_DOUBLE_TOUCH
+#define LULZBOT_X_PROBE_OFFSET_FROM_EXTRUDER  0
+#define LULZBOT_Y_PROBE_OFFSET_FROM_EXTRUDER  0
+#define LULZBOT_Z_PROBE_OFFSET_FROM_EXTRUDER  -1.5
+#define LULZBOT_Z_PROBE_OFFSET_RANGE_MIN      -2
+#define LULZBOT_Z_PROBE_OFFSET_RANGE_MAX      5
+#define LULZBOT_XY_PROBE_SPEED                6000
+#define LULZBOT_Z_PROBE_SPEED_SLOW           (1*60)
+#define LULZBOT_Z_PROBE_SPEED_FAST           (8*60)
+#define LULZBOT_Z_CLEARANCE_DEPLOY_PROBE      5
+#define LULZBOT_Z_CLEARANCE_BETWEEN_PROBES    5
+
+/* Enable the probe pins only only when homing/probing.
+ *   Z_MIN_PIN corresponds to the Z-Home push button.
+ *   LULZBOT_Z_MIN_PROBE_PIN are the bed washers.
+ */
+#define LULZBOT_ENABLE_PROBE_PINS(enable) { \
+    if(enable) { \
+      /* Set both as inputs with pull-up resistor */ \
+      SET_INPUT(LULZBOT_Z_MIN_PROBE_PIN); \
+      WRITE(LULZBOT_Z_MIN_PROBE_PIN, HIGH); \
+      SET_INPUT(Z_MIN_PIN); \
+      WRITE(Z_MIN_PIN, HIGH); \
+    } else { \
+      /* Ground both pins to prevent EMI */ \
+      SET_OUTPUT(LULZBOT_Z_MIN_PROBE_PIN); \
+      WRITE(LULZBOT_Z_MIN_PROBE_PIN, LOW); \
+      SET_OUTPUT(Z_MIN_PIN); \
+      WRITE(Z_MIN_PIN, LOW); \
+    } \
+}
+
+#define LULZBOT_FAN_KICKSTART_TIME          100
+#define LULZBOT_FAN_MIN_PWM                  70
+
+#define LULZBOT_REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
+#define LULZBOT_SDSUPPORT
+#define LULZBOT_XYZ_HOLLOW_FRAME_DISABLE
+#define LULZBOT_MENU_HOLLOW_FRAME_DISABLE
+#define LULZBOT_USE_SMALL_INFOFONT
+#define LULZBOT_BABYSTEPPING
+#define LULZBOT_BABYSTEP_ZPROBE_OFFSET
+#define LULZBOT_SHOW_CUSTOM_BOOTSCREEN
+#define LULZBOT_HOST_KEEPALIVE_FEATURE_DISABLED
+#define LULZBOT_MENU_BED_LEVELING_GCODE       "G28 XY\nM109 S175\nG28 Z\nM109 R145\nG12\nG29\nM104 S0"
+
+#if defined(TOOLHEAD_Gladiola_SingleExtruder)
+    #define LULZBOT_TOOLHEAD_VER               VERSION_STRING
+    #define LULZBOT_UUID                       "351487b6-ca9a-4c1a-8765-d668b1da6585"
+    #define LULZBOT_PWM_MOTOR_CURRENT          {1300, 1630, 1250} // Values in milliamps
+    #define LULZBOT_EXTRUDERS                  1
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING    false
+    #define LULZBOT_X_MAX_POS                  175
+    #define LULZBOT_X_MIN_POS                    0
+    #define LULZBOT_Y_MAX_POS                  191
+    #define LULZBOT_Y_MIN_POS                  -10
+    #define LULZBOT_AO_Hexagon
+#endif /* TOOLHEAD_Gladiola_SingleExtruder */
+
+#if defined(TOOLHEAD_Oliveoil_SingleExtruder) || defined(TOOLHEAD_Angelfish_Aero)
+    #define LULZBOT_TOOLHEAD_VER               VERSION_STRING
+    #define LULZBOT_UUID                       "845f003c-aebd-4e53-a6b9-7d0984fde609"
+    #define LULZBOT_EXTRUDERS                  1
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING    false
+    #define LULZBOT_X_MAX_POS                  300
+    #define LULZBOT_X_MIN_POS                  -20
+    #define LULZBOT_Y_MAX_POS                  303
+    #define LULZBOT_Y_MIN_POS                  -20
+    #define LULZBOT_AO_Hexagon
+#endif /* TOOLHEAD_Oliveoil_SingleExtruder || TOOLHEAD_Angelfish_Aero */
+
+#if defined(TOOLHEAD_Oliveoil_SingleExtruder)
+    #define LULZBOT_TOOLHEAD_NAME              "Single Extruder"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #define LULZBOT_BUILD_VARIANT              " LulzBot"
+    #define LULZBOT_DIGIPOT_MOTOR_CURRENT      {175,175,200,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
+#endif /* TOOLHEAD_Oliveoil_SingleExtruder */
+
+#if defined(TOOLHEAD_Angelfish_Aero)
+    #define LULZBOT_TOOLHEAD_NAME              "Titan AERO"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #define LULZBOT_BUILD_VARIANT              " LulzBot AERO"
+    #define LULZBOT_DIGIPOT_MOTOR_CURRENT      {175,175,200,160,160} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
+#endif /* TOOLHEAD_Angelfish_Aero */
+
+#if defined(TOOLHEAD_Kanyu_Flexystruder)
+    #define LULZBOT_TOOLHEAD_VER               VERSION_STRING" Flexystruder"
+    #define LULZBOT_TOOLHEAD_NAME              "Flexystruder"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #define LULZBOT_BUILD_VARIANT              " LulzBot Flexy"
+    #define LULZBOT_DIGIPOT_MOTOR_CURRENT      {175,175,200,67,135}
+    #define LULZBOT_EXTRUDERS                  1
+    #define LULZBOT_UUID                       "564bab1c-704c-4225-b329-ac1a093d2638"
+    #undef  LULZBOT_X_MAX_ENDSTOP_INVERTING
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING    true
+    #define LULZBOT_X_MAX_POS                  288
+    #define LULZBOT_X_MIN_POS                  -27
+    #define LULZBOT_Y_MAX_POS                  302
+    #define LULZBOT_Y_MIN_POS                  -20
+    #define LULZBOT_AO_Hexagon
+#endif /* TOOLHEAD_Kanyu_Flexystruder */
+
+#if defined(TOOLHEAD_Opah_Moarstruder)
+    #define LULZBOT_TOOLHEAD_VER               VERSION_STRING
+    #define LULZBOT_TOOLHEAD_NAME              "MOARstruder"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #define LULZBOT_BUILD_VARIANT              " LulzBot MOAR"
+    #undef  LULZBOT_DEFAULT_ACCELERATION
+    #define LULZBOT_DEFAULT_ACCELERATION       250
+    #define LULZBOT_DIGIPOT_MOTOR_CURRENT      {175,175,200,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
+    #define LULZBOT_EXTRUDERS                  1
+    #define LULZBOT_UUID                       "d651819d-4a79-4b73-bc5b-ae1fe1aab36b"
+    #undef  LULZBOT_X_MAX_ENDSTOP_INVERTING
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING    true
+    #define LULZBOT_X_MAX_POS                  290
+    #define LULZBOT_X_MIN_POS                  -20
+    #define LULZBOT_Y_MAX_POS                  303
+    #define LULZBOT_Y_MIN_POS                  -20
+    #define LULZBOT_Moarstruder
+#endif /* TOOLHEAD_Opah_Moarstruder */
+
+#if defined(TOOLHEAD_Javelin_DualExtruder) || defined(TOOLHEAD_Longfin_FlexyDually) || defined(TOOLHEAD_Yellowfin_DualExtruder)
+    #define LULZBOT_TOOLHEAD_VER               VERSION_STRING" Dual"
+    #define LULZBOT_BUILD_VARIANT              " LulzBot Dual"
+    #define LULZBOT_SWAP_FAN_PINS_6_AND_8
+    #define LULZBOT_DIGIPOT_MOTOR_CURRENT      {175,175,200,160,160} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
+    #define LULZBOT_EXTRUDERS                  2
+    #define LULZBOT_UUID                       "c5077702-4ecd-4532-beaf-6acf94acc404"
+    #undef  LULZBOT_X_MAX_ENDSTOP_INVERTING
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING    true
+    #define LULZBOT_X_MAX_POS                     288
+    #define LULZBOT_X_MIN_POS                     -22
+    #define LULZBOT_Y_MAX_POS                     303
+    #define LULZBOT_Y_MIN_POS                     -20
+    #define LULZBOT_TEMP_SENSOR_1                   5
+    #define LULZBOT_AO_Hexagon
+#endif /* TOOLHEAD_Javelin_DualExtruder || TOOLHEAD_Longfin_FlexyDually || TOOLHEAD_Yellowfin_DualExtruder */
+
+#if defined(TOOLHEAD_Javelin_DualExtruder)
+    #define LULZBOT_TOOLHEAD_NAME              "Dual Extruder 2"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #undef  LULZBOT_WIPE_Y2
+    #define LULZBOT_WIPE_Y2                    73
+#endif /* TOOLHEAD_Javelin_DualExtruder */
+
+#if defined(TOOLHEAD_Longfin_FlexyDually)
+    #define LULZBOT_TOOLHEAD_NAME              "FlexyDually v2"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #undef  LULZBOT_WIPE_Y2
+    #define LULZBOT_WIPE_Y2                    73
+#endif /* TOOLHEAD_Longfin_FlexyDually */
+
+
+#if defined(TOOLHEAD_Yellowfin_DualExtruder)
+    #define LULZBOT_TOOLHEAD_NAME              "Dual Extruder 3"
+//          16 chars max                        ^^^^^^^^^^^^^^^
+    #define LULZBOT_AFTER_Z_PROBE_CMD               "G92 Z15.5" // Correction for raised homing button
+    #undef  LULZBOT_WIPE_X1
+    #undef  LULZBOT_WIPE_X2
+    #define LULZBOT_WIPE_X1                       -22
+    #define LULZBOT_WIPE_X2                       -22
+    #define LULZBOT_X_MAX_ENDSTOP_INVERTING     false   // Yellowfin toolhead has a normally closed endstop
+    #undef  LULZBOT_Z_HOMING_HEIGHT
+    #define LULZBOT_Z_HOMING_HEIGHT                10
+    #undef  LULZBOT_Z_SAFE_HOMING_X_POINT
+    #undef  LULZBOT_Z_SAFE_HOMING_Y_POINT
+    #define LULZBOT_Z_SAFE_HOMING_X_POINT        (-22)    // X point for Z homing when homing all axis (G28)
+    #define LULZBOT_Z_SAFE_HOMING_Y_POINT        (260)    // Y point for Z homing when homing all axis (G28)
+    #undef  LULZBOT_X_MAX_POS
+    #define LULZBOT_X_MAX_POS                      290
+    #define LULZBOT_AO_Hexagon
+#endif /* TOOLHEAD_Yellowfin_DualExtruder */
+
+/* HOTEND Variants */
+
+#if defined(LULZBOT_Moarstruder)
+    // LulzBot MOARstruder (40v)
+    #define LULZBOT_DEFAULT_Kp 55.64
+    #define LULZBOT_DEFAULT_Ki 6.79
+    #define LULZBOT_DEFAULT_Kd 113.94
+#endif /* LULZBOT_Moarstruder */
+
+#if defined(LULZBOT_AO_Hexagon)
+    // LulzBot AO-Hexagon (24v)
+    #define LULZBOT_DEFAULT_Kp 28.79
+    #define LULZBOT_DEFAULT_Ki 1.91
+    #define LULZBOT_DEFAULT_Kd 108.51
+#endif /* LULZBOT_AO_Hexagon */
+
+// Heated bed parameters
+
+//24V 360W silicone heater from NPH on 3mm borosilicate (TAZ 2.2+)
+#if defined(LULZBOT_TAZ_BED)
+  #define LULZBOT_DEFAULT_bedKp                 162
+  #define LULZBOT_DEFAULT_bedKi                 17
+  #define LULZBOT_DEFAULT_bedKd                 378
+
+#elif defined(LULZBOT_MINI_BED)
+  #define LULZBOT_DEFAULT_bedKp                 294
+  #define LULZBOT_DEFAULT_bedKi                 65
+  #define LULZBOT_DEFAULT_bedKd                 382
+#endif
+
+// Acceleration, feedrate and E-Steps
+
+#ifdef defined(LULZBOT_Huerfano_TAZ_7)
+    // Z-belt driven TAZ 7
+    #define LULZBOT_DEFAULT_MAX_FEEDRATE          {800, 800, 600, 40}   // (mm/sec)
+    #define LULZBOT_DEFAULT_MAX_ACCELERATION      {9000,9000,10,10000}
+    #define LULZBOT_XY_STEPS                      100.5
+    #define LULZBOT_Z_STEPS                       1790.08264463
+    #define LULZBOT_E_STEPS                       760
+    #define LULZBOT_DEFAULT_ACCELERATION          500
+    #define LULZBOT_DEFAULT_TRAVEL_ACCELERATION   3000
+    #define LULZBOT_DEFAULT_XJERK                 8.0
+    #define LULZBOT_DEFAULT_YJERK                 8.0
+    #define LULZBOT_DEFAULT_ZJERK                 0.4
+    #define LULZBOT_DEFAULT_EJERK                10.0
+
+    #define LULZBOT_Z_MAX_POS                     290
+    #define LULZBOT_Z_MIN_POS                       0
+
+#elif defined(LULZBOT_Gladiola_Mini)
+    #define LULZBOT_DEFAULT_MAX_FEEDRATE          {800, 800, 8, 40}      // (mm/sec)
+    #define LULZBOT_DEFAULT_MAX_ACCELERATION      {9000,9000,100,10000}
+    #define LULZBOT_XY_STEPS                      100.5
+    #define LULZBOT_Z_STEPS                       1600
+    #define LULZBOT_E_STEPS                       833
+    #define LULZBOT_DEFAULT_ACCELERATION          2000
+    #define LULZBOT_DEFAULT_TRAVEL_ACCELERATION   3000
+    #define LULZBOT_DEFAULT_XJERK                 12.0
+    #define LULZBOT_DEFAULT_YJERK                 12.0
+    #define LULZBOT_DEFAULT_ZJERK                  0.4
+    #define LULZBOT_DEFAULT_EJERK                 10.0
+
+    #define LULZBOT_Z_MAX_POS                      159
+    #define LULZBOT_Z_MIN_POS                       -2
+
+#elif defined(LULZBOT_Oliveoil_TAZ_6)
+    #define LULZBOT_DEFAULT_MAX_FEEDRATE          {800, 800, 3, 40}      // (mm/sec)
+    #define LULZBOT_DEFAULT_MAX_ACCELERATION      {9000,9000,100,10000}
+    #define LULZBOT_XY_STEPS                      100.5
+    #define LULZBOT_Z_STEPS                       1600
+    #define LULZBOT_E_STEPS                       830
+    #define LULZBOT_DEFAULT_ACCELERATION          500
+    #define LULZBOT_DEFAULT_TRAVEL_ACCELERATION   3000
+    #define LULZBOT_DEFAULT_XJERK                 8.0
+    #define LULZBOT_DEFAULT_YJERK                 8.0
+    #define LULZBOT_DEFAULT_ZJERK                 0.4
+    #define LULZBOT_DEFAULT_EJERK                10.0
+
+    #define LULZBOT_Z_MAX_POS                     270
+    #define LULZBOT_Z_MIN_POS                       0
+#endif
+
+// default steps per unit for LulzBot TAZ
+
+#if LULZBOT_EXTRUDERS == 1
+    #define LULZBOT_DEFAULT_AXIS_STEPS_PER_UNIT   {LULZBOT_XY_STEPS,LULZBOT_XY_STEPS,LULZBOT_Z_STEPS,LULZBOT_E_STEPS}
+#elif LULZBOT_EXTRUDERS == 2
+    #define LULZBOT_DEFAULT_AXIS_STEPS_PER_UNIT   {LULZBOT_XY_STEPS,LULZBOT_XY_STEPS,LULZBOT_Z_STEPS,LULZBOT_E_STEPS,LULZBOT_E_STEPS}
+#elif LULZBOT_EXTRUDERS == 3
+    #define LULZBOT_DEFAULT_AXIS_STEPS_PER_UNIT   {LULZBOT_XY_STEPS,LULZBOT_XY_STEPS,LULZBOT_Z_STEPS,LULZBOT_E_STEPS,LULZBOT_E_STEPS,LULZBOT_E_STEPS}
+#elif LULZBOT_EXTRUDERS == 4
+    #define LULZBOT_DEFAULT_AXIS_STEPS_PER_UNIT   {LULZBOT_XY_STEPS,LULZBOT_XY_STEPS,LULZBOT_Z_STEPS,LULZBOT_E_STEPS,LULZBOT_E_STEPS,830,LULZBOT_E_STEPS}
+#endif
+
+// Nozzle wiping points
+
+#define LULZBOT_NOZZLE_CLEAN_START_POINT      {LULZBOT_WIPE_X1, LULZBOT_WIPE_Y1, 1}
+#define LULZBOT_NOZZLE_CLEAN_END_POINT        {LULZBOT_WIPE_X2, LULZBOT_WIPE_Y2, 1}
+
+// Gralco's customized Z Offset overlay (also requires dogm_bitmaps_Lulzbot.h)
+
+#define LULZBOT_ZOFFSET_OVERLAY(zprobe_zoffset) \
+    static float old_zprobe_zoffset = 0; \
+    static bool up_arrow; \
+    if(zprobe_zoffset != old_zprobe_zoffset) { \
+        up_arrow = zprobe_zoffset > old_zprobe_zoffset; \
+    } \
+    old_zprobe_zoffset = zprobe_zoffset; \
+    uint8_t noz_pos = -6*zprobe_zoffset; \
+    u8g.drawBitmapP(66,noz_pos,2,12,nozzle_bmp); \
+    u8g.drawBitmapP(60,24,3,1,offset_bedline_bmp); \
+    u8g.drawBitmapP(0,47,3,16,ccw_bmp); \
+    u8g.drawStr(27,60,"Z"); \
+    u8g.drawBitmapP(34,49,2,10,down_arrow_bmp); \
+    u8g.drawBitmapP(85,47,3,16,cw_bmp); \
+    u8g.drawStr(107,60,"Z"); \
+    u8g.drawBitmapP(113,51,2,10,up_arrow_bmp); \
+    if (up_arrow) { \
+        u8g.setColorIndex(0); \
+        u8g.drawBox(113,46,16,13); \
+        u8g.setColorIndex(1); \
+        u8g.drawBitmapP(113,48,2,13,longup_arrow_bmp); \
+    } else { \
+        u8g.setColorIndex(0); \
+        u8g.drawBox(34,49,16,13); \
+        u8g.setColorIndex(1); \
+        u8g.drawBitmapP(34,49,2,13,longdown_arrow_bmp); \
+    }
+
+// Customized splash screen
+#define LULZBOT_CUSTOM_BOOTSCREEN() \
+    u8g.firstPage(); \
+    do { \
+        u8g.drawBitmapP(0,0,CEILING(CUSTOM_BOOTSCREEN_BMPWIDTH, 8),CUSTOM_BOOTSCREEN_BMPHEIGHT,custom_start_bmp); \
+        u8g.setFont(u8g_font_6x13); \
+        u8g.drawStr(61,17,LULZBOT_CUSTOM_MACHINE_NAME); \
+        u8g.setFont(u8g_font_04b_03); \
+        u8g.drawStr(62,28,LULZBOT_TOOLHEAD_NAME); \
+        u8g.setFont(u8g_font_5x8); \
+        u8g.drawStr(63,41,"LulzBot.com"); \
+        u8g.setFont(u8g_font_5x8); \
+        u8g.drawStr(62,62,"v"); \
+        u8g.drawStr(67,62,SHORT_BUILD_VERSION LULZBOT_FW_VERSION); \
+    } while( u8g.nextPage() );
+
+#endif /* CONFIGURATION_LULZBOT */

Marlin/Configuration_adv.h

@@ -34,6 +34,8 @@
 #define CONFIGURATION_ADV_H
 #define CONFIGURATION_ADV_H_VERSION 010100
 
+#include "Configuration_LulzBot.h"
+
 // @section temperature
 
 //===========================================================================
@@ -62,8 +64,8 @@
  * If you get false positives for "Thermal Runaway" increase THERMAL_PROTECTION_HYSTERESIS and/or THERMAL_PROTECTION_PERIOD
  */
 #if ENABLED(THERMAL_PROTECTION_HOTENDS)
-  #define THERMAL_PROTECTION_PERIOD 40        // Seconds
-  #define THERMAL_PROTECTION_HYSTERESIS 4     // Degrees Celsius
+  #define THERMAL_PROTECTION_PERIOD     LULZBOT_THERMAL_PROTECTION_PERIOD        // Seconds
+  #define THERMAL_PROTECTION_HYSTERESIS LULZBOT_THERMAL_PROTECTION_HYSTERESIS    // Degrees Celsius
 
   /**
    * Whenever an M104 or M109 increases the target temperature the firmware will wait for the
@@ -82,8 +84,8 @@
  * Thermal Protection parameters for the bed are just as above for hotends.
  */
 #if ENABLED(THERMAL_PROTECTION_BED)
-  #define THERMAL_PROTECTION_BED_PERIOD 20    // Seconds
-  #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius
+  #define THERMAL_PROTECTION_BED_PERIOD     LULZBOT_THERMAL_PROTECTION_BED_PERIOD    // Seconds
+  #define THERMAL_PROTECTION_BED_HYSTERESIS LULZBOT_THERMAL_PROTECTION_BED_HYSTERESIS // Degrees Celsius
 
   /**
    * Whenever an M140 or M190 increases the target temperature the firmware will wait for the
@@ -118,7 +120,7 @@
  * Also, if the temperature is set to a value below mintemp, it will not be changed by autotemp.
  * On an Ultimaker, some initial testing worked with M109 S215 B260 F1 in the start.gcode
  */
-#define AUTOTEMP
+//#define AUTOTEMP LULZBOT_AUTOTEMP_DISABLED
 #if ENABLED(AUTOTEMP)
   #define AUTOTEMP_OLDWEIGHT 0.98
 #endif
@@ -181,9 +183,9 @@
  * The fan will turn on automatically whenever any stepper is enabled
  * and turn off after a set period after all steppers are turned off.
  */
-//#define USE_CONTROLLER_FAN
+#define USE_CONTROLLER_FAN LULZBOT_USE_CONTROLLER_FAN
 #if ENABLED(USE_CONTROLLER_FAN)
-  //#define CONTROLLER_FAN_PIN FAN1_PIN  // Set a custom pin for the controller fan
+  #define CONTROLLER_FAN_PIN LULZBOT_CONTROLLER_FAN_PIN  // Set a custom pin for the controller fan
   #define CONTROLLERFAN_SECS 60          // Duration in seconds for the fan to run after all motors are disabled
   #define CONTROLLERFAN_SPEED 255        // 255 == full speed
 #endif
@@ -191,12 +193,12 @@
 // When first starting the main fan, run it at full speed for the
 // given number of milliseconds.  This gets the fan spinning reliably
 // before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu)
-//#define FAN_KICKSTART_TIME 100
+#define FAN_KICKSTART_TIME LULZBOT_FAN_KICKSTART_TIME
 
 // This defines the minimal speed for the main fan, run in PWM mode
 // to enable uncomment and set minimal PWM speed for reliable running (1-255)
 // if fan speed is [1 - (FAN_MIN_PWM-1)] it is set to FAN_MIN_PWM
-//#define FAN_MIN_PWM 50
+#define FAN_MIN_PWM LULZBOT_FAN_MIN_PWM
 
 // @section extruder
 
@@ -339,7 +341,7 @@
 #define Y_HOME_BUMP_MM 5
 #define Z_HOME_BUMP_MM 2
 #define HOMING_BUMP_DIVISOR {2, 2, 4}  // Re-Bump Speed Divisor (Divides the Homing Feedrate)
-//#define QUICK_HOME  //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially.
+#define QUICK_HOME LULZBOT_QUICKHOME  //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially.
 
 // When G28 is called, this option will make Y home before X
 //#define HOME_Y_BEFORE_X
@@ -419,8 +421,8 @@
  *    M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
  *    M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
  */
-//#define PWM_MOTOR_CURRENT { 1300, 1300, 1250 }          // Values in milliamps
-//#define DIGIPOT_MOTOR_CURRENT { 135,135,135,135,135 }   // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
+#define PWM_MOTOR_CURRENT     LULZBOT_PMW_MOTOR_CURRENT          // Values in milliamps
+#define DIGIPOT_MOTOR_CURRENT LULZBOT_DIGIPOT_MOTOR_CURRENT   // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
 //#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 }    // Default drive percent - X, Y, Z, E axis
 
 // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
@@ -548,10 +550,10 @@
  */
 #if ENABLED(DOGLCD)
   // Enable to save many cycles by drawing a hollow frame on the Info Screen
-  #define XYZ_HOLLOW_FRAME
+  //#define XYZ_HOLLOW_FRAME LULZBOT_XYZ_HOLLOW_FRAME_DISABLE
 
   // Enable to save many cycles by drawing a hollow frame on Menu Screens
-  #define MENU_HOLLOW_FRAME
+  //#define MENU_HOLLOW_FRAME LULZBOT_MENU_HOLLOW_FRAME_DISABLE
 
   // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
   // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
@@ -559,7 +561,7 @@
 
   // A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM.
   // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
-  //#define USE_SMALL_INFOFONT
+  #define USE_SMALL_INFOFONT LULZBOT_USE_SMALL_INFOFONT
 
   // Enable this option and reduce the value to optimize screen updates.
   // The normal delay is 10µs. Use the lowest value that still gives a reliable display.
@@ -588,12 +590,12 @@
  *
  * Warning: Does not respect endstops!
  */
-//#define BABYSTEPPING
+#define BABYSTEPPING LULZBOT_BABYSTEPPING
 #if ENABLED(BABYSTEPPING)
-  #define BABYSTEP_XY              // Also enable X/Y Babystepping. Not supported on DELTA!
+  //#define BABYSTEP_XY LULZBOT_BABYSTEP_XY_DISABLED             // Also enable X/Y Babystepping. Not supported on DELTA!
   #define BABYSTEP_INVERT_Z false  // Change if Z babysteps should go the other way
   #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
-  //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
+  #define BABYSTEP_ZPROBE_OFFSET LULZBOT_BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
   //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
   #define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
                                         // Note: Extra time may be added to mitigate controller latency.
@@ -729,7 +731,7 @@
 
 // The ASCII buffer for serial input
 #define MAX_CMD_SIZE 96
-#define BUFSIZE 4
+#define BUFSIZE LULZBOT_BUFSIZE
 
 // Transfer Buffer Size
 // To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0.

Marlin/Makefile

@@ -56,12 +56,12 @@
 #
 
 # This defines the board to compile for (see boards.h for your board's ID)
-HARDWARE_MOTHERBOARD ?= 11
+HARDWARE_MOTHERBOARD ?= 301
 
 # Arduino source install directory, and version number
 # On most linuxes this will be /usr/share/arduino
-ARDUINO_INSTALL_DIR  ?= ${HOME}/Arduino
-ARDUINO_VERSION      ?= 106
+ARDUINO_INSTALL_DIR  ?= ${HOME}/devel/arduino-1.8.3
+ARDUINO_VERSION      ?= 183
 
 # You can optionally set a path to the avr-gcc tools. Requires a trailing slash. (ex: /usr/local/avr-gcc/bin)
 AVR_TOOLS_PATH ?=
@@ -82,6 +82,9 @@ LIQUID_TWI2        ?= 0
 # this defines if Wire is needed
 WIRE               ?= 0
 
+# this defines if U8GLIB is needed
+U8GLIB             ?= 1
+
 ############################################################################
 # Below here nothing should be changed...
 
@@ -270,6 +273,10 @@ ifeq ($(WIRE), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire/utility
 endif
+ifeq ($(U8GLIB), 1)
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/utility
+endif
 
 ifeq ($(HARDWARE_VARIANT), arduino)
 HARDWARE_SUB_VARIANT ?= mega
@@ -296,7 +303,7 @@ CXXSRC = WMath.cpp WString.cpp Print.cpp Marlin_main.cpp \
 	temperature.cpp cardreader.cpp configuration_store.cpp \
 	watchdog.cpp SPI.cpp servo.cpp Tone.cpp ultralcd.cpp digipot_mcp4451.cpp \
 	dac_mcp4728.cpp vector_3.cpp qr_solve.cpp endstops.cpp stopwatch.cpp utility.cpp \
-	printcounter.cpp nozzle.cpp serial.cpp
+	printcounter.cpp nozzle.cpp serial.cpp gcode.cpp
 ifeq ($(LIQUID_TWI2), 0)
 CXXSRC += LiquidCrystal.cpp
 else
@@ -309,6 +316,10 @@ SRC += twi.c
 CXXSRC += Wire.cpp
 endif
 
+ifeq ($(U8GLIB), 1)
+SRC += u8g_ll_api.c u8g_bitmap.c u8g_clip.c u8g_com_null.c u8g_delay.c u8g_page.c u8g_pb.c u8g_pb16h1.c u8g_rect.c u8g_state.c u8g_font.c u8g_font_data.c
+endif
+
 #Check for Arduino 1.0.0 or higher and use the correct source files for that version
 ifeq ($(shell [ $(ARDUINO_VERSION) -ge 100 ] && echo true), true)
 CXXSRC += main.cpp

Marlin/Marlin_main.cpp

@@ -3745,6 +3745,7 @@ inline void gcode_G4() {
  *
  */
 inline void gcode_G28(const bool always_home_all) {
+  LULZBOT_ENABLE_PROBE_PINS(true);
 
   #if ENABLED(DEBUG_LEVELING_FEATURE)
     if (DEBUGGING(LEVELING)) {
@@ -3926,6 +3927,22 @@ inline void gcode_G28(const bool always_home_all) {
     tool_change(old_tool_index, 0, true);
   #endif
 
+  #ifdef LULZBOT_RAISE_AFTER_HOME
+      if (home_all || homeZ) {
+        // Raise Z after homing Z if z is not already high enough (never lower z)
+        destination[Z_AXIS] = LOGICAL_Z_POSITION(Z_HOMING_HEIGHT);
+        if (destination[Z_AXIS] > current_position[Z_AXIS]) {
+
+          #if ENABLED(DEBUG_LEVELING_FEATURE)
+            if (DEBUGGING(LEVELING))
+              SERIAL_ECHOLNPAIR("Raise Z (after homing) to ", destination[Z_AXIS]);
+          #endif
+
+          do_blocking_move_to_z(destination[Z_AXIS]);
+        }
+      }
+  #endif
+
   lcd_refresh();
 
   report_current_position();
@@ -3933,6 +3950,8 @@ inline void gcode_G28(const bool always_home_all) {
   #if ENABLED(DEBUG_LEVELING_FEATURE)
     if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("<<< gcode_G28");
   #endif
+
+  LULZBOT_ENABLE_PROBE_PINS(false);
 } // G28
 
 void home_all_axes() { gcode_G28(true); }
@@ -5280,7 +5299,7 @@ void home_all_axes() { gcode_G28(true); }
       #if DISABLED(PROBE_MANUALLY)
         home_offset[Z_AXIS] -= probe_pt(dx, dy, stow_after_each, 1, false); // 1st probe to set height
       #endif
-      
+
       do {
 
         float z_at_pt[13] = { 0.0 };
@@ -5380,7 +5399,7 @@ void home_all_axes() { gcode_G28(true); }
           #if ENABLED(PROBE_MANUALLY)
             test_precision = 0.00; // forced end
           #endif
-          
+
           switch (probe_points) {
             case 1:
               test_precision = 0.00; // forced end
@@ -10486,7 +10505,9 @@ void process_next_command() {
       #if HAS_LEVELING
         case 29: // G29 Detailed Z probe, probes the bed at 3 or more points,
                  // or provides access to the UBL System if enabled.
+          LULZBOT_ENABLE_PROBE_PINS(true);
           gcode_G29();
+          LULZBOT_ENABLE_PROBE_PINS(false);
           break;
       #endif // HAS_LEVELING
 
@@ -10795,7 +10816,9 @@ void process_next_command() {
         gcode_M118();
         break;
       case 119: // M119: Report endstop states
+        LULZBOT_ENABLE_PROBE_PINS(true);
         gcode_M119();
+        LULZBOT_ENABLE_PROBE_PINS(false);
         break;
       case 120: // M120: Enable endstops
         gcode_M120();
@@ -12861,7 +12884,7 @@ void kill(const char* lcd_msg) {
   #if defined(ACTION_ON_KILL)
     SERIAL_ECHOLNPGM("//action:" ACTION_ON_KILL);
   #endif
-  
+
   #if HAS_POWER_SWITCH
     SET_INPUT(PS_ON_PIN);
   #endif

Marlin/_Bootscreen.h

@@ -0,0 +1,103 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Custom Bitmap for splashscreen
+ *
+ * You may use one of the following tools to generate the C++ bitmap array from
+ * a black and white image:
+ *
+ *  - http://www.marlinfw.org/tools/u8glib/converter.html
+ *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
+ */
+#include <avr/pgmspace.h>
+
+#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  60
+#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
+
+const unsigned char custom_start_bmp[574] PROGMEM = {
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x23, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x4c, 0x80, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x5e, 0x80, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x92, 0x40, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xa1, 0x40, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x1, 0x21, 0x20, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x2, 0x7f, 0x90, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x2, 0x0, 0x10, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x4, 0x0, 0x8, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x8, 0x0, 0x4, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x8, 0x0, 0x6, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x10, 0x0, 0x2, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x30, 0x1e, 0x1, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x20, 0x7f, 0x81, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x41, 0xff, 0xe0, 0x80, 0x0, 0x0,
+0x0, 0x0, 0x43, 0xfc, 0xf0, 0x80, 0x0, 0x0,
+0x0, 0x0, 0x87, 0x3b, 0x78, 0x40, 0x0, 0x0,
+0x0, 0x1, 0x8e, 0xdb, 0xfc, 0x60, 0x0, 0x0,
+0x0, 0x1, 0xf, 0xeb, 0xcc, 0x20, 0x0, 0x0,
+0x0, 0x2, 0x1f, 0xed, 0xb6, 0x10, 0x0, 0x0,
+0x0, 0x2, 0x1f, 0xde, 0xb6, 0x10, 0x0, 0x0,
+0x0, 0x4, 0x39, 0xcd, 0x7f, 0x8, 0x0, 0x0,
+0x0, 0x4, 0x36, 0xe0, 0xff, 0x8, 0x0, 0x0,
+0x0, 0x8, 0x7e, 0xc0, 0xbb, 0x84, 0x0, 0x0,
+0x0, 0x18, 0x7f, 0x0, 0x5d, 0x86, 0x0, 0x0,
+0x0, 0x10, 0x7f, 0xc0, 0xed, 0x82, 0x0, 0x0,
+0x0, 0x20, 0x3c, 0xc0, 0x73, 0x1, 0x0, 0x0,
+0x0, 0x20, 0x3b, 0x33, 0x7f, 0x1, 0x0, 0x0,
+0x0, 0x70, 0x1b, 0xe7, 0x7e, 0x3, 0x80, 0x0,
+0x0, 0xc8, 0x1d, 0xee, 0xde, 0x4, 0xc0, 0x0,
+0x0, 0x88, 0xf, 0xde, 0xdc, 0x4, 0x40, 0x0,
+0x1, 0x24, 0xf, 0xdf, 0x3c, 0x9, 0x20, 0x0,
+0x1, 0x26, 0x7, 0xdb, 0xf8, 0x19, 0x20, 0x0,
+0x2, 0x72, 0x3, 0xe7, 0xf0, 0x13, 0x90, 0x0,
+0x2, 0x51, 0x1, 0xff, 0xe0, 0x22, 0x90, 0x0,
+0x4, 0x89, 0x0, 0x7f, 0x80, 0x24, 0x48, 0x0,
+0x9, 0x4, 0x80, 0x1e, 0x0, 0x48, 0x24, 0x0,
+0xb, 0xfe, 0x40, 0x0, 0x0, 0xdf, 0xf4, 0x0,
+0x10, 0x0, 0x40, 0x0, 0x0, 0x80, 0x2, 0x0,
+0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x10, 0x22, 0x10, 0x3c, 0x3c, 0xe, 0x1f, 0x0,
+0x10, 0x22, 0x10, 0x4, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x8, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x8, 0x3c, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x10, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x20, 0x22, 0x11, 0x4, 0x0,
+0x1e, 0x1c, 0x1e, 0x3c, 0x3c, 0xe, 0x4, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
+};

Marlin/dogm_bitmaps.h

@@ -34,6 +34,8 @@
 
 //#define START_BMPHIGH
 
+#include "dogm_bitmaps_LulzBot.h"
+
 #if ENABLED(SHOW_BOOTSCREEN)
   #if ENABLED(START_BMPHIGH)
     #define START_BMPWIDTH      112

Marlin/dogm_bitmaps_LulzBot.h

@@ -0,0 +1,256 @@
+#define LULZBOT_BMPWIDTH 	60	//Width in pixels
+#define LULZBOT_BMPHEIGHT 	64	//Height in pixels
+#define LULZBOT_BMPBYTEWIDTH 	8	//Width in bytes
+const unsigned char lulzbot_bmp[574] PROGMEM = { //AVR-GCC, WinAVR
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x23, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x4c, 0x80, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x5e, 0x80, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x92, 0x40, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0xa1, 0x40, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x1, 0x21, 0x20, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x2, 0x7f, 0x90, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x2, 0x0, 0x10, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x4, 0x0, 0x8, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x8, 0x0, 0x4, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x8, 0x0, 0x6, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x10, 0x0, 0x2, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x30, 0x1e, 0x1, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x20, 0x7f, 0x81, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x41, 0xff, 0xe0, 0x80, 0x0, 0x0,
+0x0, 0x0, 0x43, 0xfc, 0xf0, 0x80, 0x0, 0x0,
+0x0, 0x0, 0x87, 0x3b, 0x78, 0x40, 0x0, 0x0,
+0x0, 0x1, 0x8e, 0xdb, 0xfc, 0x60, 0x0, 0x0,
+0x0, 0x1, 0xf, 0xeb, 0xcc, 0x20, 0x0, 0x0,
+0x0, 0x2, 0x1f, 0xed, 0xb6, 0x10, 0x0, 0x0,
+0x0, 0x2, 0x1f, 0xde, 0xb6, 0x10, 0x0, 0x0,
+0x0, 0x4, 0x39, 0xcd, 0x7f, 0x8, 0x0, 0x0,
+0x0, 0x4, 0x36, 0xe0, 0xff, 0x8, 0x0, 0x0,
+0x0, 0x8, 0x7e, 0xc0, 0xbb, 0x84, 0x0, 0x0,
+0x0, 0x18, 0x7f, 0x0, 0x5d, 0x86, 0x0, 0x0,
+0x0, 0x10, 0x7f, 0xc0, 0xed, 0x82, 0x0, 0x0,
+0x0, 0x20, 0x3c, 0xc0, 0x73, 0x1, 0x0, 0x0,
+0x0, 0x20, 0x3b, 0x33, 0x7f, 0x1, 0x0, 0x0,
+0x0, 0x70, 0x1b, 0xe7, 0x7e, 0x3, 0x80, 0x0,
+0x0, 0xc8, 0x1d, 0xee, 0xde, 0x4, 0xc0, 0x0,
+0x0, 0x88, 0xf, 0xde, 0xdc, 0x4, 0x40, 0x0,
+0x1, 0x24, 0xf, 0xdf, 0x3c, 0x9, 0x20, 0x0,
+0x1, 0x26, 0x7, 0xdb, 0xf8, 0x19, 0x20, 0x0,
+0x2, 0x72, 0x3, 0xe7, 0xf0, 0x13, 0x90, 0x0,
+0x2, 0x51, 0x1, 0xff, 0xe0, 0x22, 0x90, 0x0,
+0x4, 0x89, 0x0, 0x7f, 0x80, 0x24, 0x48, 0x0,
+0x9, 0x4, 0x80, 0x1e, 0x0, 0x48, 0x24, 0x0,
+0xb, 0xfe, 0x40, 0x0, 0x0, 0xdf, 0xf4, 0x0,
+0x10, 0x0, 0x40, 0x0, 0x0, 0x80, 0x2, 0x0,
+0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x10, 0x22, 0x10, 0x3c, 0x3c, 0xe, 0x1f, 0x0,
+0x10, 0x22, 0x10, 0x4, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x8, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x8, 0x3c, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x10, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x20, 0x22, 0x11, 0x4, 0x0,
+0x1e, 0x1c, 0x1e, 0x3c, 0x3c, 0xe, 0x4, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
+};
+
+const unsigned char cw_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+	0x07,0xf8,0x00,
+	0x0c,0x0c,0x00,
+	0x10,0x02,0x00,
+	0x20,0x01,0x00,
+	0x60,0x01,0x80,
+	0x40,0x00,0x80,
+	0x40,0x03,0xe0,
+	0x40,0x01,0xc0,
+	0x40,0x00,0x80,
+	0x40,0x00,0x00,
+	0x40,0x00,0x00,
+	0x60,0x00,0x00,
+	0x20,0x00,0x00,
+	0x10,0x00,0x00,
+	0x0c,0x0c,0x00,
+	0x07,0xf8,0x00
+};
+
+const unsigned char ccw_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+/*
+000000000001111111100000
+000000000011000000110000
+000000000100000000001000
+000000001000000000000100
+000000011000000000000110
+000000010000000000000010
+000001111100000000000010
+000000111000000000000010
+000000010000000000000010
+000000000000000000000010
+000000000000000000000010
+000000000000000000000110
+000000000000000000000100
+000000000000000000001000
+000000000011000000110000
+000000000001111111100000
+*/
+	0x00,0x1f,0xe0,
+	0x00,0x30,0x30,
+	0x00,0x40,0x08,
+	0x00,0x80,0x04,
+	0x01,0x80,0x06,
+	0x01,0x00,0x02,
+	0x07,0xc0,0x02,
+	0x03,0x80,0x02,
+	0x01,0x00,0x02,
+	0x00,0x00,0x02,
+	0x00,0x00,0x02,
+	0x00,0x00,0x06,
+	0x00,0x00,0x04,
+	0x00,0x00,0x08,
+	0x00,0x30,0x30,
+	0x00,0x1f,0xe0
+};
+
+const unsigned char up_arrow_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+   /*0000 0110 0000
+     0000 1111 0000
+     0001 1111 1000
+     0011 1111 1100
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000*/
+
+	0x06,0x00,
+	0x0F,0x00,
+	0x1F,0x80,
+	0x3F,0xC0,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00
+};
+
+const unsigned char longup_arrow_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+   /*0000 0110 0000
+     0000 1111 0000
+     0001 1111 1000
+     0011 1111 1100
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000*/
+
+	0x06,0x00,
+	0x0F,0x00,
+	0x1F,0x80,
+	0x3F,0xC0,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00,
+	0x06,0x00
+};
+
+const unsigned char down_arrow_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+   /*0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0011 1111 1100
+     0001 1111 1000
+     0000 1111 0000
+     0000 0110 0000*/
+
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x3F,0xC0,
+     0x1F,0x80,
+     0x0F,0x00,
+     0x06,0x00
+};
+
+const unsigned char longdown_arrow_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+   /*0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0000 0110 0000
+     0011 1111 1100
+     0001 1111 1000
+     0000 1111 0000
+     0000 0110 0000*/
+
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x06,0x00,
+     0x3F,0xC0,
+     0x1F,0x80,
+     0x0F,0x00,
+     0x06,0x00
+};
+
+const unsigned char offset_bedline_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+   //1111 1111 1111 1111 1111 1111
+
+     0xFF,0xFF,0xFF
+};
+
+const unsigned char nozzle_bmp[] PROGMEM = { //AVR-GCC, WinAVR
+	0x7F,0x80,
+	0xFF,0xC0,
+	0xFF,0xC0,
+	0xFF,0xC0,
+	0x7F,0x80,
+	0x7F,0x80,
+	0xFF,0xC0,
+	0xFF,0xC0,
+	0xFF,0xC0,
+	0x3F,0x00,
+	0x1E,0x00,
+	0x0C,0x00
+};

Marlin/pins_RAMBO.h

@@ -126,8 +126,13 @@
 #define HEATER_2_PIN        6
 #define HEATER_BED_PIN      3
 
-#define FAN_PIN             8
-#define FAN1_PIN            6
+#ifdef LULZBOT_SWAP_FAN_PINS
+  #define FAN_PIN           6
+  #define FAN1_PIN          8
+#else
+  #define FAN_PIN           8
+  #define FAN1_PIN          6
+#endif
 #define FAN2_PIN            2
 
 //

Marlin/ultralcd.cpp

@@ -31,6 +31,8 @@
 #include "configuration_store.h"
 #include "utility.h"
 
+#include "Configuration_LulzBot.h"
+
 #if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
   #include "buzzer.h"
 #endif
@@ -1011,6 +1013,7 @@ void kill_screen(const char* lcd_msg) {
         }
         if (lcdDrawUpdate)
           lcd_implementation_drawedit(PSTR(MSG_ZPROBE_ZOFFSET), ftostr43sign(zprobe_zoffset));
+          LULZBOT_ZOFFSET_OVERLAY(zprobe_zoffset);
       }
 
     #else // !BABYSTEP_ZPROBE_OFFSET
@@ -2385,7 +2388,7 @@ void kill_screen(const char* lcd_msg) {
       #endif
       MENU_ITEM(submenu, MSG_BED_LEVELING, lcd_bed_leveling);
     #elif PLANNER_LEVELING
-      MENU_ITEM(gcode, MSG_BED_LEVELING, PSTR("G28\nG29"));
+      MENU_ITEM(gcode, MSG_BED_LEVELING, PSTR(LULZBOT_MENU_BED_LEVELING_GCODE));
     #endif
 
     #if HAS_M206_COMMAND

Marlin/ultralcd_impl_DOGM.h

@@ -264,13 +264,17 @@ void lcd_printPGM_utf(const char *str, uint8_t n=LCD_WIDTH) {
   #if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
 
     void lcd_custom_bootscreen() {
-      u8g.firstPage();
-      do {
-        u8g.drawBitmapP(
-          (128 - (CUSTOM_BOOTSCREEN_BMPWIDTH))  /2,
-          ( 64 - (CUSTOM_BOOTSCREEN_BMPHEIGHT)) /2,
-          CEILING(CUSTOM_BOOTSCREEN_BMPWIDTH, 8), CUSTOM_BOOTSCREEN_BMPHEIGHT, custom_start_bmp);
-      } while (u8g.nextPage());
+      #ifdef LULZBOT_CUSTOM_BOOTSCREEN
+        LULZBOT_CUSTOM_BOOTSCREEN();
+      #else
+        u8g.firstPage();
+        do {
+          u8g.drawBitmapP(
+            (128 - (CUSTOM_BOOTSCREEN_BMPWIDTH))  /2,
+            ( 64 - (CUSTOM_BOOTSCREEN_BMPHEIGHT)) /2,
+            CEILING(CUSTOM_BOOTSCREEN_BMPWIDTH, 8), CUSTOM_BOOTSCREEN_BMPHEIGHT, custom_start_bmp);
+        } while (u8g.nextPage());
+      #endif
     }
 
   #endif // SHOW_CUSTOM_BOOTSCREEN