muele-marlin/Marlin/src/Marlin.cpp

1026 lines
27 KiB
C++
Raw Normal View History

/**
2016-03-24 18:01:20 +00:00
* Marlin 3D Printer Firmware
2017-03-18 15:15:54 +00:00
* Copyright (C) 2016, 2017 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/>.
2016-03-24 18:01:20 +00:00
*
*/
/**
* About Marlin
*
* This firmware is a mashup between Sprinter and grbl.
* - https://github.com/kliment/Sprinter
* - https://github.com/simen/grbl
2015-04-14 00:17:36 +00:00
*/
2016-11-19 03:54:38 +00:00
#include "Marlin.h"
2017-09-06 11:28:33 +00:00
#include "lcd/ultralcd.h"
#include "module/motion.h"
2017-09-06 11:28:33 +00:00
#include "module/planner.h"
#include "module/stepper.h"
#include "module/endstops.h"
2017-09-08 20:35:25 +00:00
#include "module/probe.h"
2017-09-06 11:28:33 +00:00
#include "module/temperature.h"
#include "sd/cardreader.h"
#include "module/configuration_store.h"
2017-09-09 05:18:43 +00:00
#include "module/printcounter.h" // PrintCounter or Stopwatch
#ifdef ARDUINO
2017-09-06 11:28:33 +00:00
#include <pins_arduino.h>
#endif
2017-09-06 11:28:33 +00:00
#include <math.h>
#include "libs/nozzle.h"
#include "gcode/gcode.h"
2017-09-06 11:28:33 +00:00
#include "gcode/parser.h"
#include "gcode/queue.h"
2016-11-19 03:54:38 +00:00
2017-09-14 20:33:07 +00:00
#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
#include "libs/buzzer.h"
#endif
#if (ENABLED(SWITCHING_EXTRUDER) && !DONT_SWITCH) || ENABLED(SWITCHING_NOZZLE)
#include "module/tool_change.h"
#endif
2017-09-17 23:45:21 +00:00
#if ENABLED(DIGIPOT_I2C)
#include "feature/digipot/digipot.h"
#endif
2016-11-19 03:54:38 +00:00
#if ENABLED(BEZIER_CURVE_SUPPORT)
2017-09-06 11:28:33 +00:00
#include "module/planner_bezier.h"
2016-11-19 03:54:38 +00:00
#endif
#if ENABLED(MAX7219_DEBUG)
2017-09-08 19:47:47 +00:00
#include "feature/Max7219_Debug_LEDs.h"
#endif
2017-09-08 19:47:47 +00:00
#if HAS_COLOR_LEDS
#include "feature/leds/leds.h"
#endif
2016-11-19 03:54:38 +00:00
#if HAS_SERVOS
2017-09-06 11:28:33 +00:00
#include "HAL/servo.h"
2016-11-19 03:54:38 +00:00
#endif
#if HAS_DIGIPOTSS
#include <SPI.h>
#endif
#if ENABLED(DAC_STEPPER_CURRENT)
2017-09-06 11:28:33 +00:00
#include "feature/dac/stepper_dac.h"
2016-11-19 03:54:38 +00:00
#endif
#if ENABLED(EXPERIMENTAL_I2CBUS)
2017-09-06 11:28:33 +00:00
#include "feature/twibus.h"
2017-09-17 07:49:13 +00:00
TWIBus i2c;
2016-11-19 03:54:38 +00:00
#endif
#if ENABLED(I2C_POSITION_ENCODERS)
2017-09-06 11:28:33 +00:00
#include "feature/I2CPositionEncoder.h"
#endif
2016-11-19 03:54:38 +00:00
#if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
2017-09-06 11:28:33 +00:00
#include "HAL/HAL_endstop_interrupts.h"
2016-11-19 03:54:38 +00:00
#endif
2017-09-17 23:34:04 +00:00
#if ENABLED(HAVE_TMC2130)
#include "feature/tmc2130.h"
#endif
#if ENABLED(SDSUPPORT)
CardReader card;
#endif
2016-09-29 20:06:01 +00:00
#if ENABLED(G38_PROBE_TARGET)
2016-09-26 06:30:34 +00:00
bool G38_move = false,
G38_endstop_hit = false;
#endif
2017-09-08 20:35:25 +00:00
#if ENABLED(DELTA)
#include "module/delta.h"
#elif IS_SCARA
#include "module/scara.h"
#endif
#if HAS_LEVELING
#include "feature/bedlevel/bedlevel.h"
2017-03-18 15:15:54 +00:00
#endif
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ENABLED(PAUSE_PARK_NO_STEPPER_TIMEOUT)
#include "feature/pause.h"
#endif
2017-09-09 05:18:43 +00:00
2017-09-16 10:09:34 +00:00
#if ENABLED(TEMP_STAT_LEDS)
#include "feature/leds/tempstat.h"
#endif
2015-04-08 07:56:19 +00:00
bool Running = true;
2016-10-05 02:32:37 +00:00
/**
* axis_homed
* Flags that each linear axis was homed.
* XYZ on cartesian, ABC on delta, ABZ on SCARA.
*
* axis_known_position
* Flags that the position is known in each linear axis. Set when homed.
* Cleared whenever a stepper powers off, potentially losing its position.
*/
bool axis_homed[XYZ] = { false }, axis_known_position[XYZ] = { false };
2015-04-08 07:56:19 +00:00
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
TempUnit input_temp_units = TEMPUNIT_C;
#endif
// Initialized by settings.load()
float filament_size[EXTRUDERS], volumetric_multiplier[EXTRUDERS];
2016-03-06 02:27:45 +00:00
#if FAN_COUNT > 0
int16_t fanSpeeds[FAN_COUNT] = { 0 };
#if ENABLED(PROBING_FANS_OFF)
bool fans_paused = false;
int16_t paused_fanSpeeds[FAN_COUNT] = { 0 };
#endif
2016-03-06 02:27:45 +00:00
#endif
2016-10-07 03:06:33 +00:00
// For M109 and M190, this flag may be cleared (by M108) to exit the wait loop
2016-07-07 02:59:19 +00:00
volatile bool wait_for_heatup = true;
2015-04-08 07:56:19 +00:00
2016-10-07 03:06:33 +00:00
// For M0/M1, this flag may be cleared (by M108) to exit the wait-for-user loop
#if HAS_RESUME_CONTINUE
2016-09-15 07:53:46 +00:00
volatile bool wait_for_user = false;
2016-09-12 01:51:53 +00:00
#endif
2015-04-03 22:45:41 +00:00
// Inactivity shutdown
2017-09-17 04:57:09 +00:00
millis_t max_inactive_time = 0,
stepper_inactive_time = (DEFAULT_STEPPER_DEACTIVE_TIME) * 1000UL;
2016-04-18 06:13:07 +00:00
#if ENABLED(Z_DUAL_ENDSTOPS)
float z_endstop_adj;
2015-04-03 22:45:41 +00:00
#endif
2017-09-08 20:35:25 +00:00
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
static bool filament_ran_out = false;
#endif
2017-09-08 20:35:25 +00:00
#if ENABLED(ADVANCED_PAUSE_FEATURE)
AdvancedPauseMenuResponse advanced_pause_menu_response;
#endif
2017-09-08 20:35:25 +00:00
#if ENABLED(MIXING_EXTRUDER)
float mixing_factor[MIXING_STEPPERS]; // Reciprocal of mix proportion. 0.0 = off, otherwise >= 1.0.
#if MIXING_VIRTUAL_TOOLS > 1
float mixing_virtual_tool_mix[MIXING_VIRTUAL_TOOLS][MIXING_STEPPERS];
#endif
2017-09-08 20:35:25 +00:00
#endif
2017-09-08 20:35:25 +00:00
#ifdef CHDK
millis_t chdkHigh = 0;
bool chdkActive = false;
#endif
2016-10-02 06:48:17 +00:00
2017-09-08 20:35:25 +00:00
#if ENABLED(PID_EXTRUSION_SCALING)
int lpq_len = 20;
#endif
2016-08-19 06:11:41 +00:00
2017-09-08 20:35:25 +00:00
#if ENABLED(I2C_POSITION_ENCODERS)
I2CPositionEncodersMgr I2CPEM;
uint8_t blockBufferIndexRef = 0;
millis_t lastUpdateMillis;
#endif
2017-04-15 03:44:08 +00:00
2016-09-15 18:22:23 +00:00
/**
2017-09-08 20:35:25 +00:00
* ***************************************************************************
* ******************************** FUNCTIONS ********************************
* ***************************************************************************
2016-09-15 18:22:23 +00:00
*/
2017-09-08 20:35:25 +00:00
void setup_killpin() {
#if HAS_KILL
SET_INPUT_PULLUP(KILL_PIN);
2016-09-15 20:43:06 +00:00
#endif
2017-09-08 20:35:25 +00:00
}
2017-09-08 20:35:25 +00:00
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
2017-09-08 20:35:25 +00:00
void setup_filrunoutpin() {
#if ENABLED(ENDSTOPPULLUP_FIL_RUNOUT)
SET_INPUT_PULLUP(FIL_RUNOUT_PIN);
#else
SET_INPUT(FIL_RUNOUT_PIN);
#endif
2017-09-08 20:35:25 +00:00
}
2016-03-31 00:19:54 +00:00
2017-09-08 20:35:25 +00:00
#endif
2017-09-08 20:35:25 +00:00
void setup_powerhold() {
#if HAS_SUICIDE
OUT_WRITE(SUICIDE_PIN, HIGH);
#endif
2017-09-08 20:35:25 +00:00
#if HAS_POWER_SWITCH
#if ENABLED(PS_DEFAULT_OFF)
OUT_WRITE(PS_ON_PIN, PS_ON_ASLEEP);
#else
OUT_WRITE(PS_ON_PIN, PS_ON_AWAKE);
2017-04-15 03:44:08 +00:00
#endif
#endif
2017-09-08 20:35:25 +00:00
}
2017-04-15 03:44:08 +00:00
2017-09-08 20:35:25 +00:00
void suicide() {
#if HAS_SUICIDE
OUT_WRITE(SUICIDE_PIN, LOW);
2016-10-02 06:48:17 +00:00
#endif
2017-09-08 20:35:25 +00:00
}
2017-09-08 20:35:25 +00:00
#if HAS_SERVOS
HAL_SERVO_LIB servo[NUM_SERVOS];
2017-09-08 20:35:25 +00:00
void servo_init() {
#if NUM_SERVOS >= 1 && HAS_SERVO_0
servo[0].attach(SERVO0_PIN);
servo[0].detach(); // Just set up the pin. We don't have a position yet. Don't move to a random position.
#endif
#if NUM_SERVOS >= 2 && HAS_SERVO_1
servo[1].attach(SERVO1_PIN);
servo[1].detach();
#endif
#if NUM_SERVOS >= 3 && HAS_SERVO_2
servo[2].attach(SERVO2_PIN);
servo[2].detach();
#endif
#if NUM_SERVOS >= 4 && HAS_SERVO_3
servo[3].attach(SERVO3_PIN);
servo[3].detach();
2016-10-02 06:48:17 +00:00
#endif
2017-09-08 20:35:25 +00:00
#if HAS_Z_SERVO_ENDSTOP
servo_probe_init();
2016-10-02 06:48:17 +00:00
#endif
}
2015-07-09 23:57:44 +00:00
2017-09-08 20:35:25 +00:00
#endif // HAS_SERVOS
2015-07-09 23:57:44 +00:00
2017-09-08 20:35:25 +00:00
/**
* Stepper Reset (RigidBoard, et.al.)
*/
#if HAS_STEPPER_RESET
void disableStepperDrivers() {
OUT_WRITE(STEPPER_RESET_PIN, LOW); // drive it down to hold in reset motor driver chips
}
void enableStepperDrivers() { SET_INPUT(STEPPER_RESET_PIN); } // set to input, which allows it to be pulled high by pullups
#endif
2016-08-28 00:53:02 +00:00
2017-09-08 20:35:25 +00:00
#if ENABLED(EXPERIMENTAL_I2CBUS) && I2C_SLAVE_ADDRESS > 0
2015-04-29 02:10:07 +00:00
2017-09-08 20:35:25 +00:00
void i2c_on_receive(int bytes) { // just echo all bytes received to serial
i2c.receive(bytes);
}
2017-04-15 03:44:08 +00:00
2017-09-08 20:35:25 +00:00
void i2c_on_request() { // just send dummy data for now
i2c.reply("Hello World!\n");
}
2015-07-09 23:57:44 +00:00
2017-09-08 20:35:25 +00:00
#endif
#if ENABLED(MIXING_EXTRUDER)
void normalize_mix() {
float mix_total = 0.0;
for (uint8_t i = 0; i < MIXING_STEPPERS; i++) mix_total += RECIPROCAL(mixing_factor[i]);
// Scale all values if they don't add up to ~1.0
if (!NEAR(mix_total, 1.0)) {
SERIAL_PROTOCOLLNPGM("Warning: Mix factors must add up to 1.0. Scaling.");
for (uint8_t i = 0; i < MIXING_STEPPERS; i++) mixing_factor[i] *= mix_total;
}
}
#if ENABLED(DIRECT_MIXING_IN_G1)
// Get mixing parameters from the GCode
// The total "must" be 1.0 (but it will be normalized)
// If no mix factors are given, the old mix is preserved
void gcode_get_mix() {
const char* mixing_codes = "ABCDHI";
byte mix_bits = 0;
for (uint8_t i = 0; i < MIXING_STEPPERS; i++) {
2017-06-27 04:31:45 +00:00
if (parser.seenval(mixing_codes[i])) {
SBI(mix_bits, i);
2017-05-20 08:03:08 +00:00
float v = parser.value_float();
NOLESS(v, 0.0);
mixing_factor[i] = RECIPROCAL(v);
}
}
// If any mixing factors were included, clear the rest
// If none were included, preserve the last mix
if (mix_bits) {
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
if (!TEST(mix_bits, i)) mixing_factor[i] = 0.0;
normalize_mix();
}
}
#endif
#endif
/**************************************************
***************** GCode Handlers *****************
**************************************************/
2017-09-06 11:28:33 +00:00
/**
* Sensitive pin test for M42, M226
*/
2017-09-16 08:42:05 +00:00
bool pin_is_protected(const int8_t pin) {
2017-09-06 11:28:33 +00:00
static const int8_t sensitive_pins[] PROGMEM = SENSITIVE_PINS;
for (uint8_t i = 0; i < COUNT(sensitive_pins); i++)
if (pin == (int8_t)pgm_read_byte(&sensitive_pins[i])) return true;
return false;
}
2017-09-06 11:28:33 +00:00
void quickstop_stepper() {
stepper.quick_stop();
stepper.synchronize();
set_current_from_steppers_for_axis(ALL_AXES);
SYNC_PLAN_POSITION_KINEMATIC();
}
2017-09-06 11:28:33 +00:00
#include "gcode/feature/caselight/M355.h"
2017-09-06 11:28:33 +00:00
#if ENABLED(MIXING_EXTRUDER)
#include "gcode/feature/mixing/M163.h"
#if MIXING_VIRTUAL_TOOLS > 1
#include "gcode/feature/mixing/M164.h"
#endif
#if ENABLED(DIRECT_MIXING_IN_G1)
#include "gcode/feature/mixing/M165.h"
#endif
#endif
2017-09-06 11:28:33 +00:00
#include "gcode/control/M999.h"
2017-09-06 11:28:33 +00:00
#include "gcode/control/T.h"
2017-05-04 21:38:29 +00:00
#if ENABLED(USE_CONTROLLER_FAN)
void controllerFan() {
2017-03-29 00:45:54 +00:00
static millis_t lastMotorOn = 0, // Last time a motor was turned on
nextMotorCheck = 0; // Last time the state was checked
const millis_t ms = millis();
2016-04-10 22:55:12 +00:00
if (ELAPSED(ms, nextMotorCheck)) {
nextMotorCheck = ms + 2500UL; // Not a time critical function, so only check every 2.5s
2017-04-20 19:04:26 +00:00
if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON || thermalManager.soft_pwm_amount_bed > 0
|| E0_ENABLE_READ == E_ENABLE_ON // If any of the drivers are enabled...
#if E_STEPPERS > 1
|| E1_ENABLE_READ == E_ENABLE_ON
#if HAS_X2_ENABLE
|| X2_ENABLE_READ == X_ENABLE_ON
#endif
#if E_STEPPERS > 2
|| E2_ENABLE_READ == E_ENABLE_ON
#if E_STEPPERS > 3
|| E3_ENABLE_READ == E_ENABLE_ON
#if E_STEPPERS > 4
|| E4_ENABLE_READ == E_ENABLE_ON
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#endif // E_STEPPERS > 1
) {
lastMotorOn = ms; //... set time to NOW so the fan will turn on
}
// Fan off if no steppers have been enabled for CONTROLLERFAN_SECS seconds
2016-04-10 22:55:12 +00:00
uint8_t speed = (!lastMotorOn || ELAPSED(ms, lastMotorOn + (CONTROLLERFAN_SECS) * 1000UL)) ? 0 : CONTROLLERFAN_SPEED;
// allows digital or PWM fan output to be used (see M42 handling)
WRITE(CONTROLLER_FAN_PIN, speed);
analogWrite(CONTROLLER_FAN_PIN, speed);
}
}
#endif // USE_CONTROLLER_FAN
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
void handle_filament_runout() {
if (!filament_ran_out) {
filament_ran_out = true;
enqueue_and_echo_commands_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
stepper.synchronize();
}
}
#endif // FILAMENT_RUNOUT_SENSOR
2017-07-18 08:18:05 +00:00
float calculate_volumetric_multiplier(const float diameter) {
2017-09-16 16:41:12 +00:00
if (!parser.volumetric_enabled || diameter == 0) return 1.0;
2017-03-24 05:53:28 +00:00
return 1.0 / (M_PI * sq(diameter * 0.5));
}
void calculate_volumetric_multipliers() {
for (uint8_t i = 0; i < COUNT(filament_size); i++)
volumetric_multiplier[i] = calculate_volumetric_multiplier(filament_size[i]);
}
void enable_all_steppers() {
enable_X();
enable_Y();
enable_Z();
enable_E0();
enable_E1();
enable_E2();
enable_E3();
enable_E4();
}
2017-03-18 02:12:19 +00:00
void disable_e_steppers() {
disable_E0();
disable_E1();
disable_E2();
disable_E3();
disable_E4();
2015-04-03 22:31:35 +00:00
}
2017-03-18 02:12:19 +00:00
void disable_all_steppers() {
disable_X();
disable_Y();
disable_Z();
2017-03-18 02:12:19 +00:00
disable_e_steppers();
}
2015-04-03 22:31:35 +00:00
/**
* Manage several activities:
* - Check for Filament Runout
* - Keep the command buffer full
* - Check for maximum inactive time between commands
* - Check for maximum inactive time between stepper commands
* - Check if pin CHDK needs to go LOW
* - Check for KILL button held down
* - Check for HOME button held down
* - Check if cooling fan needs to be switched on
* - Check if an idle but hot extruder needs filament extruded (EXTRUDER_RUNOUT_PREVENT)
2015-04-03 22:31:35 +00:00
*/
void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
2015-08-05 11:40:36 +00:00
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
if ((IS_SD_PRINTING || print_job_timer.isRunning()) && (READ(FIL_RUNOUT_PIN) == FIL_RUNOUT_INVERTING))
2016-04-18 06:16:49 +00:00
handle_filament_runout();
2015-04-03 22:31:35 +00:00
#endif
if (commands_in_queue < BUFSIZE) get_available_commands();
2015-04-03 22:31:35 +00:00
2017-03-29 00:45:54 +00:00
const millis_t ms = millis();
2015-04-03 22:31:35 +00:00
2017-09-16 01:44:40 +00:00
if (max_inactive_time && ELAPSED(ms, gcode.previous_cmd_ms + max_inactive_time)) {
2017-06-09 15:51:23 +00:00
SERIAL_ERROR_START();
2017-05-20 08:03:08 +00:00
SERIAL_ECHOLNPAIR(MSG_KILL_INACTIVE_TIME, parser.command_ptr);
kill(PSTR(MSG_KILLED));
}
2017-02-10 06:13:58 +00:00
// Prevent steppers timing-out in the middle of M600
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ENABLED(PAUSE_PARK_NO_STEPPER_TIMEOUT)
#define MOVE_AWAY_TEST !move_away_flag
2017-02-10 06:13:58 +00:00
#else
#define MOVE_AWAY_TEST true
#endif
2017-09-16 01:44:40 +00:00
if (MOVE_AWAY_TEST && stepper_inactive_time && ELAPSED(ms, gcode.previous_cmd_ms + stepper_inactive_time)
2016-04-28 01:06:32 +00:00
&& !ignore_stepper_queue && !planner.blocks_queued()) {
#if ENABLED(DISABLE_INACTIVE_X)
disable_X();
#endif
#if ENABLED(DISABLE_INACTIVE_Y)
disable_Y();
#endif
#if ENABLED(DISABLE_INACTIVE_Z)
disable_Z();
#endif
#if ENABLED(DISABLE_INACTIVE_E)
2017-03-18 02:12:19 +00:00
disable_e_steppers();
#endif
2017-07-01 23:33:54 +00:00
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(ULTRA_LCD) // Only needed with an LCD
2017-09-08 20:35:25 +00:00
ubl.lcd_map_control = defer_return_to_status = false;
#endif
}
#ifdef CHDK // Check if pin should be set to LOW after M240 set it to HIGH
if (chdkActive && ELAPSED(ms, chdkHigh + CHDK_DELAY)) {
chdkActive = false;
WRITE(CHDK, LOW);
}
#endif
2015-04-03 22:31:35 +00:00
#if HAS_KILL
2015-08-05 11:40:36 +00:00
// Check if the kill button was pressed and wait just in case it was an accidental
// key kill key press
// -------------------------------------------------------------------------------
2015-04-03 22:45:41 +00:00
static int killCount = 0; // make the inactivity button a bit less responsive
const int KILL_DELAY = 750;
2015-04-03 22:31:35 +00:00
if (!READ(KILL_PIN))
killCount++;
else if (killCount > 0)
killCount--;
2015-04-03 22:31:35 +00:00
// Exceeded threshold and we can confirm that it was not accidental
// KILL the machine
// ----------------------------------------------------------------
if (killCount >= KILL_DELAY) {
2017-06-09 15:51:23 +00:00
SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_KILL_BUTTON);
kill(PSTR(MSG_KILLED));
}
#endif
2015-04-03 22:31:35 +00:00
#if HAS_HOME
// Check to see if we have to home, use poor man's debouncer
// ---------------------------------------------------------
2015-04-03 22:45:41 +00:00
static int homeDebounceCount = 0; // poor man's debouncing count
const int HOME_DEBOUNCE_DELAY = 2500;
if (!IS_SD_PRINTING && !READ(HOME_PIN)) {
2015-04-03 22:31:35 +00:00
if (!homeDebounceCount) {
2016-02-21 01:35:35 +00:00
enqueue_and_echo_commands_P(PSTR("G28"));
LCD_MESSAGEPGM(MSG_AUTO_HOME);
2015-04-03 22:31:35 +00:00
}
if (homeDebounceCount < HOME_DEBOUNCE_DELAY)
homeDebounceCount++;
else
homeDebounceCount = 0;
}
2015-04-03 22:31:35 +00:00
#endif
2015-08-05 11:40:36 +00:00
2017-05-04 21:38:29 +00:00
#if ENABLED(USE_CONTROLLER_FAN)
controllerFan(); // Check if fan should be turned on to cool stepper drivers down
#endif
2015-04-03 22:31:35 +00:00
#if ENABLED(EXTRUDER_RUNOUT_PREVENT)
2017-09-16 01:44:40 +00:00
if (ELAPSED(ms, gcode.previous_cmd_ms + (EXTRUDER_RUNOUT_SECONDS) * 1000UL)
&& thermalManager.degHotend(active_extruder) > EXTRUDER_RUNOUT_MINTEMP) {
#if ENABLED(SWITCHING_EXTRUDER)
const bool oldstatus = E0_ENABLE_READ;
enable_E0();
#else // !SWITCHING_EXTRUDER
bool oldstatus;
switch (active_extruder) {
default: oldstatus = E0_ENABLE_READ; enable_E0(); break;
#if E_STEPPERS > 1
case 1: oldstatus = E1_ENABLE_READ; enable_E1(); break;
#if E_STEPPERS > 2
case 2: oldstatus = E2_ENABLE_READ; enable_E2(); break;
#if E_STEPPERS > 3
case 3: oldstatus = E3_ENABLE_READ; enable_E3(); break;
#if E_STEPPERS > 4
case 4: oldstatus = E4_ENABLE_READ; enable_E4(); break;
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#endif // E_STEPPERS > 1
}
#endif // !SWITCHING_EXTRUDER
gcode.refresh_cmd_timeout()
const float olde = current_position[E_AXIS];
current_position[E_AXIS] += EXTRUDER_RUNOUT_EXTRUDE;
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED), active_extruder);
current_position[E_AXIS] = olde;
planner.set_e_position_mm(olde);
stepper.synchronize();
#if ENABLED(SWITCHING_EXTRUDER)
E0_ENABLE_WRITE(oldstatus);
#else
switch (active_extruder) {
case 0: E0_ENABLE_WRITE(oldstatus); break;
#if E_STEPPERS > 1
case 1: E1_ENABLE_WRITE(oldstatus); break;
#if E_STEPPERS > 2
case 2: E2_ENABLE_WRITE(oldstatus); break;
#if E_STEPPERS > 3
case 3: E3_ENABLE_WRITE(oldstatus); break;
#if E_STEPPERS > 4
case 4: E4_ENABLE_WRITE(oldstatus); break;
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#endif // E_STEPPERS > 1
}
#endif // !SWITCHING_EXTRUDER
}
#endif // EXTRUDER_RUNOUT_PREVENT
2015-04-03 22:31:35 +00:00
#if ENABLED(DUAL_X_CARRIAGE)
// handle delayed move timeout
2016-04-10 22:55:12 +00:00
if (delayed_move_time && ELAPSED(ms, delayed_move_time + 1000UL) && IsRunning()) {
// travel moves have been received so enact them
delayed_move_time = 0xFFFFFFFFUL; // force moves to be done
set_destination_to_current();
prepare_move_to_destination();
}
#endif
2015-04-03 22:31:35 +00:00
#if ENABLED(TEMP_STAT_LEDS)
2015-04-03 22:31:35 +00:00
handle_status_leds();
#endif
2015-04-03 22:31:35 +00:00
2017-04-15 03:44:08 +00:00
#if ENABLED(HAVE_TMC2130)
2017-09-06 11:28:33 +00:00
tmc2130_checkOverTemp();
#endif
2016-04-28 01:06:32 +00:00
planner.check_axes_activity();
}
/**
* Standard idle routine keeps the machine alive
*/
void idle(
#if ENABLED(ADVANCED_PAUSE_FEATURE)
bool no_stepper_sleep/*=false*/
#endif
) {
#if ENABLED(MAX7219_DEBUG)
Max7219_idle_tasks();
#endif // MAX7219_DEBUG
lcd_update();
2017-09-09 04:49:49 +00:00
#if ENABLED(HOST_KEEPALIVE_FEATURE)
gcode.host_keepalive();
#endif
#if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED)
thermalManager.auto_report_temperatures();
#endif
manage_inactivity(
#if ENABLED(ADVANCED_PAUSE_FEATURE)
no_stepper_sleep
#endif
);
thermalManager.manage_heater();
#if ENABLED(PRINTCOUNTER)
print_job_timer.tick();
#endif
2016-10-05 02:31:50 +00:00
#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
buzzer.tick();
#endif
#if ENABLED(I2C_POSITION_ENCODERS)
if (planner.blocks_queued() &&
( (blockBufferIndexRef != planner.block_buffer_head) ||
((lastUpdateMillis + I2CPE_MIN_UPD_TIME_MS) < millis())) ) {
blockBufferIndexRef = planner.block_buffer_head;
I2CPEM.update();
lastUpdateMillis = millis();
}
#endif
}
/**
* Kill all activity and lock the machine.
* After this the machine will need to be reset.
*/
void kill(const char* lcd_msg) {
2017-06-09 15:51:23 +00:00
SERIAL_ERROR_START();
2016-07-10 02:50:45 +00:00
SERIAL_ERRORLNPGM(MSG_ERR_KILLED);
thermalManager.disable_all_heaters();
disable_all_steppers();
2017-03-29 00:45:54 +00:00
#if ENABLED(ULTRA_LCD)
2016-07-10 02:50:45 +00:00
kill_screen(lcd_msg);
2015-10-04 15:33:55 +00:00
#else
UNUSED(lcd_msg);
#endif
_delay_ms(600); // Wait a short time (allows messages to get out before shutting down.
cli(); // Stop interrupts
2017-03-29 00:45:54 +00:00
_delay_ms(250); //Wait to ensure all interrupts routines stopped
thermalManager.disable_all_heaters(); //turn off heaters again
2017-07-28 04:42:01 +00:00
#ifdef ACTION_ON_KILL
SERIAL_ECHOLNPGM("//action:" ACTION_ON_KILL);
#endif
2017-07-07 02:24:30 +00:00
2015-03-30 23:50:05 +00:00
#if HAS_POWER_SWITCH
2016-12-03 04:40:18 +00:00
SET_INPUT(PS_ON_PIN);
2015-03-30 23:50:05 +00:00
#endif
suicide();
while (1) {
#if ENABLED(USE_WATCHDOG)
watchdog_reset();
#endif
} // Wait for reset
}
/**
* Turn off heaters and stop the print in progress
* After a stop the machine may be resumed with M999
*/
2016-04-18 07:05:22 +00:00
void stop() {
thermalManager.disable_all_heaters(); // 'unpause' taken care of in here
#if ENABLED(PROBING_FANS_OFF)
if (fans_paused) fans_pause(false); // put things back the way they were
#endif
if (IsRunning()) {
Stopped_gcode_LastN = gcode_LastN; // Save last g_code for restart
2017-06-09 15:51:23 +00:00
SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
LCD_MESSAGEPGM(MSG_STOPPED);
safe_delay(350); // allow enough time for messages to get out before stopping
Running = false;
}
}
2016-09-12 01:21:54 +00:00
/**
* Marlin entry-point: Set up before the program loop
* - Set up the kill pin, filament runout, power hold
* - Start the serial port
* - Print startup messages and diagnostics
* - Get EEPROM or default settings
* - Initialize managers for:
* temperature
* planner
* watchdog
* stepper
* photo pin
* servos
* LCD controller
* Digipot I2C
* Z probe sled
* status LEDs
*/
void setup() {
#if ENABLED(MAX7219_DEBUG)
Max7219_init();
#endif
2016-09-22 22:10:20 +00:00
#ifdef DISABLE_JTAG
2016-09-12 01:21:54 +00:00
// Disable JTAG on AT90USB chips to free up pins for IO
MCUCR = 0x80;
MCUCR = 0x80;
#endif
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
setup_filrunoutpin();
#endif
setup_killpin();
setup_powerhold();
#if HAS_STEPPER_RESET
disableStepperDrivers();
#endif
MYSERIAL.begin(BAUDRATE);
while(!MYSERIAL);
2016-09-12 01:21:54 +00:00
SERIAL_PROTOCOLLNPGM("start");
2017-06-09 15:51:23 +00:00
SERIAL_ECHO_START();
2016-09-12 01:21:54 +00:00
// Check startup - does nothing if bootloader sets MCUSR to 0
byte mcu = HAL_get_reset_source();
2017-06-16 19:20:58 +00:00
if (mcu & 1) SERIAL_ECHOLNPGM(MSG_POWERUP);
if (mcu & 2) SERIAL_ECHOLNPGM(MSG_EXTERNAL_RESET);
if (mcu & 4) SERIAL_ECHOLNPGM(MSG_BROWNOUT_RESET);
if (mcu & 8) SERIAL_ECHOLNPGM(MSG_WATCHDOG_RESET);
2016-09-12 01:21:54 +00:00
if (mcu & 32) SERIAL_ECHOLNPGM(MSG_SOFTWARE_RESET);
HAL_clear_reset_source();
#if ENABLED(USE_WATCHDOG) //reinit watchdog after HAL_get_reset_source call
watchdog_init();
#endif
2016-09-12 01:21:54 +00:00
SERIAL_ECHOPGM(MSG_MARLIN);
2016-09-12 22:49:35 +00:00
SERIAL_CHAR(' ');
SERIAL_ECHOLNPGM(SHORT_BUILD_VERSION);
2017-06-09 15:51:23 +00:00
SERIAL_EOL();
2016-09-12 01:21:54 +00:00
2016-09-12 22:49:35 +00:00
#if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR)
2017-06-09 15:51:23 +00:00
SERIAL_ECHO_START();
2016-09-12 22:49:35 +00:00
SERIAL_ECHOPGM(MSG_CONFIGURATION_VER);
SERIAL_ECHOPGM(STRING_DISTRIBUTION_DATE);
SERIAL_ECHOLNPGM(MSG_AUTHOR STRING_CONFIG_H_AUTHOR);
SERIAL_ECHO_START();
2016-09-12 22:49:35 +00:00
SERIAL_ECHOLNPGM("Compiled: " __DATE__);
#endif
2016-09-12 01:21:54 +00:00
2017-06-09 15:51:23 +00:00
SERIAL_ECHO_START();
2016-09-12 22:49:35 +00:00
SERIAL_ECHOPAIR(MSG_FREE_MEMORY, freeMemory());
SERIAL_ECHOLNPAIR(MSG_PLANNER_BUFFER_BYTES, (int)sizeof(block_t)*BLOCK_BUFFER_SIZE);
2016-09-12 01:21:54 +00:00
queue_setup();
2016-09-12 01:21:54 +00:00
// Load data from EEPROM if available (or use defaults)
// This also updates variables in the planner, elsewhere
2017-04-10 02:47:49 +00:00
(void)settings.load();
2016-09-12 01:21:54 +00:00
#if HAS_M206_COMMAND
2017-03-05 00:01:33 +00:00
// Initialize current position based on home_offset
2017-03-05 01:19:06 +00:00
COPY(current_position, home_offset);
2017-03-05 00:01:33 +00:00
#else
ZERO(current_position);
#endif
2016-09-12 01:21:54 +00:00
// Vital to init stepper/planner equivalent for current_position
SYNC_PLAN_POSITION_KINEMATIC();
thermalManager.init(); // Initialize temperature loop
stepper.init(); // Initialize stepper, this enables interrupts!
2017-09-08 20:35:25 +00:00
#if HAS_SERVOS
servo_init();
#endif
2016-09-12 01:21:54 +00:00
2016-11-01 11:24:21 +00:00
#if HAS_PHOTOGRAPH
OUT_WRITE(PHOTOGRAPH_PIN, LOW);
#endif
#if HAS_CASE_LIGHT
case_light_on = CASE_LIGHT_DEFAULT_ON;
case_light_brightness = CASE_LIGHT_DEFAULT_BRIGHTNESS;
2016-11-28 05:51:51 +00:00
update_case_light();
#endif
2017-04-07 18:52:45 +00:00
#if ENABLED(SPINDLE_LASER_ENABLE)
OUT_WRITE(SPINDLE_LASER_ENABLE_PIN, !SPINDLE_LASER_ENABLE_INVERT); // init spindle to off
#if SPINDLE_DIR_CHANGE
OUT_WRITE(SPINDLE_DIR_PIN, SPINDLE_INVERT_DIR ? 255 : 0); // init rotation to clockwise (M3)
#endif
2017-09-06 11:28:33 +00:00
#if ENABLED(SPINDLE_LASER_PWM) && defined(SPINDLE_LASER_PWM_PIN) && SPINDLE_LASER_PWM_PIN >= 0
2017-04-07 18:52:45 +00:00
SET_OUTPUT(SPINDLE_LASER_PWM_PIN);
analogWrite(SPINDLE_LASER_PWM_PIN, SPINDLE_LASER_PWM_INVERT ? 255 : 0); // set to lowest speed
#endif
#endif
2016-09-12 01:21:54 +00:00
#if HAS_BED_PROBE
endstops.enable_z_probe(false);
#endif
2017-05-04 21:38:29 +00:00
#if ENABLED(USE_CONTROLLER_FAN)
SET_OUTPUT(CONTROLLER_FAN_PIN); //Set pin used for driver cooling fan
2016-09-12 01:21:54 +00:00
#endif
#if HAS_STEPPER_RESET
enableStepperDrivers();
#endif
#if ENABLED(DIGIPOT_I2C)
digipot_i2c_init();
#endif
#if ENABLED(DAC_STEPPER_CURRENT)
dac_init();
#endif
2017-04-14 21:36:02 +00:00
#if (ENABLED(Z_PROBE_SLED) || ENABLED(SOLENOID_PROBE)) && HAS_SOLENOID_1
OUT_WRITE(SOL1_PIN, LOW); // turn it off
#endif
2016-09-12 01:21:54 +00:00
2017-07-02 07:26:49 +00:00
#if HAS_HOME
SET_INPUT_PULLUP(HOME_PIN);
#endif
2016-09-12 01:21:54 +00:00
2016-09-24 20:33:29 +00:00
#if PIN_EXISTS(STAT_LED_RED)
OUT_WRITE(STAT_LED_RED_PIN, LOW); // turn it off
2016-09-12 01:21:54 +00:00
#endif
2016-09-24 20:33:29 +00:00
#if PIN_EXISTS(STAT_LED_BLUE)
OUT_WRITE(STAT_LED_BLUE_PIN, LOW); // turn it off
2016-09-12 01:21:54 +00:00
#endif
#if ENABLED(NEOPIXEL_RGBW_LED)
SET_OUTPUT(NEOPIXEL_PIN);
setup_neopixel();
#endif
2017-04-14 21:54:53 +00:00
#if ENABLED(RGB_LED) || ENABLED(RGBW_LED)
2017-03-18 15:17:00 +00:00
SET_OUTPUT(RGB_LED_R_PIN);
SET_OUTPUT(RGB_LED_G_PIN);
SET_OUTPUT(RGB_LED_B_PIN);
2017-04-14 21:54:53 +00:00
#if ENABLED(RGBW_LED)
SET_OUTPUT(RGB_LED_W_PIN);
#endif
2016-11-30 01:51:13 +00:00
#endif
#if ENABLED(MK2_MULTIPLEXER)
SET_OUTPUT(E_MUX0_PIN);
SET_OUTPUT(E_MUX1_PIN);
SET_OUTPUT(E_MUX2_PIN);
#endif
#if HAS_FANMUX
fanmux_init();
#endif
2016-09-12 01:21:54 +00:00
lcd_init();
2017-07-02 05:35:41 +00:00
#ifndef CUSTOM_BOOTSCREEN_TIMEOUT
#define CUSTOM_BOOTSCREEN_TIMEOUT 2500
#endif
2016-09-12 01:21:54 +00:00
#if ENABLED(SHOW_BOOTSCREEN)
2017-07-02 05:35:41 +00:00
#if ENABLED(DOGLCD) // On DOGM the first bootscreen is already drawn
#if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
safe_delay(CUSTOM_BOOTSCREEN_TIMEOUT); // Custom boot screen pause
lcd_bootscreen(); // Show Marlin boot screen
#endif
safe_delay(BOOTSCREEN_TIMEOUT); // Pause
2016-09-12 01:21:54 +00:00
#elif ENABLED(ULTRA_LCD)
2017-07-02 05:35:41 +00:00
lcd_bootscreen();
#if DISABLED(SDSUPPORT)
lcd_init();
#endif
2016-09-12 01:21:54 +00:00
#endif
#endif
#if ENABLED(MIXING_EXTRUDER) && MIXING_VIRTUAL_TOOLS > 1
// Initialize mixing to 100% color 1
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
mixing_factor[i] = (i == 0) ? 1.0 : 0.0;
2016-09-12 01:21:54 +00:00
for (uint8_t t = 0; t < MIXING_VIRTUAL_TOOLS; t++)
for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
mixing_virtual_tool_mix[t][i] = mixing_factor[i];
#endif
#if ENABLED(BLTOUCH)
2017-09-08 20:35:25 +00:00
bltouch_init();
#endif
#if ENABLED(I2C_POSITION_ENCODERS)
I2CPEM.init();
#endif
2016-09-12 01:21:54 +00:00
#if ENABLED(EXPERIMENTAL_I2CBUS) && I2C_SLAVE_ADDRESS > 0
i2c.onReceive(i2c_on_receive);
i2c.onRequest(i2c_on_request);
#endif
#if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
setup_endstop_interrupts();
#endif
2017-06-05 22:41:38 +00:00
#if ENABLED(SWITCHING_EXTRUDER) && !DONT_SWITCH
move_extruder_servo(0); // Initialize extruder servo
#endif
#if ENABLED(SWITCHING_NOZZLE)
move_nozzle_servo(0); // Initialize nozzle servo
#endif
#if ENABLED(PARKING_EXTRUDER)
#if ENABLED(PARKING_EXTRUDER_SOLENOIDS_INVERT)
pe_activate_magnet(0);
pe_activate_magnet(1);
#else
pe_deactivate_magnet(0);
pe_deactivate_magnet(1);
#endif
#endif
2016-09-12 01:21:54 +00:00
}
/**
* The main Marlin program loop
*
* - Save or log commands to SD
* - Process available commands (if not saving)
* - Call heater manager
* - Call inactivity manager
* - Call endstop manager
* - Call LCD update
*/
void loop() {
if (commands_in_queue < BUFSIZE) get_available_commands();
#if ENABLED(SDSUPPORT)
card.checkautostart(false);
#endif
advance_command_queue();
2016-09-12 01:21:54 +00:00
endstops.report_state();
idle();
}