2016-03-25 06:19:46 +00:00
/**
2016-03-24 18:01:20 +00:00
* Marlin 3 D 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/>.
*
*/
2012-06-02 18:44:17 +00:00
# ifndef MARLIN_H
# define MARLIN_H
2011-11-04 17:02:56 +00:00
2011-11-30 08:07:56 +00:00
# include <math.h>
2011-12-22 13:55:45 +00:00
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <inttypes.h>
2012-02-09 18:38:53 +00:00
# include <util/delay.h>
2011-12-22 11:38:50 +00:00
# include <avr/pgmspace.h>
2011-12-22 13:55:45 +00:00
# include <avr/eeprom.h>
2012-11-06 11:06:41 +00:00
# include <avr/interrupt.h>
2011-12-22 13:55:45 +00:00
2016-07-26 06:04:19 +00:00
# include "MarlinConfig.h"
2016-07-19 13:31:09 +00:00
# include "enum.h"
2016-07-30 01:56:26 +00:00
# include "types.h"
# include "fastio.h"
2016-07-26 03:53:36 +00:00
# include "utility.h"
2017-04-02 06:04:54 +00:00
# include "serial.h"
2011-12-22 13:55:45 +00:00
2016-04-27 01:13:27 +00:00
# if ENABLED(PRINTCOUNTER)
# include "printcounter.h"
# else
# include "stopwatch.h"
# endif
2016-04-06 03:34:03 +00:00
2016-03-19 05:22:40 +00:00
void idle (
2016-04-28 16:57:21 +00:00
# if ENABLED(FILAMENT_CHANGE_FEATURE)
bool no_stepper_sleep = false // pass true to keep steppers from disabling on timeout
2016-03-19 05:22:40 +00:00
# endif
) ;
2015-05-27 03:08:21 +00:00
2015-10-03 06:08:58 +00:00
void manage_inactivity ( bool ignore_stepper_queue = false ) ;
2011-08-12 20:28:35 +00:00
2016-07-20 17:30:10 +00:00
# if ENABLED(DUAL_X_CARRIAGE) || ENABLED(DUAL_NOZZLE_DUPLICATION_MODE)
2016-05-18 22:51:17 +00:00
extern bool extruder_duplication_enabled ;
# endif
2016-07-11 17:19:07 +00:00
# if HAS_X2_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_X() do{ X_ENABLE_WRITE( X_ENABLE_ON); X2_ENABLE_WRITE( X_ENABLE_ON); }while(0)
# define disable_X() do{ X_ENABLE_WRITE(!X_ENABLE_ON); X2_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0)
2015-04-03 22:31:35 +00:00
# elif HAS_X_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_X() X_ENABLE_WRITE( X_ENABLE_ON)
# define disable_X() do{ X_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0)
2011-08-12 20:28:35 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_X() NOOP
# define disable_X() NOOP
2011-08-12 20:28:35 +00:00
# endif
2011-11-06 18:23:08 +00:00
2016-07-11 17:19:07 +00:00
# if HAS_Y2_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_Y() do{ Y_ENABLE_WRITE( Y_ENABLE_ON); Y2_ENABLE_WRITE(Y_ENABLE_ON); }while(0)
# define disable_Y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); Y2_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0)
2016-07-11 17:19:07 +00:00
# elif HAS_Y_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_Y() Y_ENABLE_WRITE( Y_ENABLE_ON)
# define disable_Y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0)
2011-08-12 20:28:35 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_Y() NOOP
# define disable_Y() NOOP
2011-08-12 20:28:35 +00:00
# endif
2011-11-06 18:23:08 +00:00
2016-07-11 17:19:07 +00:00
# if HAS_Z2_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_Z() do{ Z_ENABLE_WRITE( Z_ENABLE_ON); Z2_ENABLE_WRITE(Z_ENABLE_ON); }while(0)
# define disable_Z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); Z2_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0)
2016-07-11 17:19:07 +00:00
# elif HAS_Z_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_Z() Z_ENABLE_WRITE( Z_ENABLE_ON)
# define disable_Z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0)
2011-08-12 20:28:35 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_Z() NOOP
# define disable_Z() NOOP
2011-08-12 20:28:35 +00:00
# endif
2011-11-04 17:02:56 +00:00
2016-06-28 22:06:56 +00:00
# if ENABLED(MIXING_EXTRUDER)
/**
* Mixing steppers synchronize their enable ( and direction ) together
*/
# if MIXING_STEPPERS > 3
2017-04-11 16:10:26 +00:00
# define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); E3_ENABLE_WRITE( E_ENABLE_ON); }
# define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); E3_ENABLE_WRITE(!E_ENABLE_ON); }
2016-06-28 22:06:56 +00:00
# elif MIXING_STEPPERS > 2
2017-04-11 16:10:26 +00:00
# define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); }
# define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); }
2016-06-28 22:06:56 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); }
# define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); }
2016-06-28 22:06:56 +00:00
# endif
2017-04-11 16:10:26 +00:00
# define enable_E1() NOOP
# define disable_E1() NOOP
# define enable_E2() NOOP
# define disable_E2() NOOP
# define enable_E3() NOOP
# define disable_E3() NOOP
# define enable_E4() NOOP
# define disable_E4() NOOP
2016-06-28 22:06:56 +00:00
# else // !MIXING_EXTRUDER
# if HAS_E0_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_E0() E0_ENABLE_WRITE( E_ENABLE_ON)
# define disable_E0() E0_ENABLE_WRITE(!E_ENABLE_ON)
2016-06-28 22:06:56 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E0() NOOP
# define disable_E0() NOOP
2016-06-28 22:06:56 +00:00
# endif
# if E_STEPPERS > 1 && HAS_E1_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_E1() E1_ENABLE_WRITE( E_ENABLE_ON)
# define disable_E1() E1_ENABLE_WRITE(!E_ENABLE_ON)
2016-06-28 22:06:56 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E1() NOOP
# define disable_E1() NOOP
2016-06-28 22:06:56 +00:00
# endif
# if E_STEPPERS > 2 && HAS_E2_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_E2() E2_ENABLE_WRITE( E_ENABLE_ON)
# define disable_E2() E2_ENABLE_WRITE(!E_ENABLE_ON)
2016-06-28 22:06:56 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E2() NOOP
# define disable_E2() NOOP
2016-06-28 22:06:56 +00:00
# endif
# if E_STEPPERS > 3 && HAS_E3_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_E3() E3_ENABLE_WRITE( E_ENABLE_ON)
# define disable_E3() E3_ENABLE_WRITE(!E_ENABLE_ON)
2016-06-28 22:06:56 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E3() NOOP
# define disable_E3() NOOP
2016-06-28 22:06:56 +00:00
# endif
2017-04-06 21:46:30 +00:00
# if E_STEPPERS > 4 && HAS_E4_ENABLE
2017-04-11 16:10:26 +00:00
# define enable_E4() E4_ENABLE_WRITE( E_ENABLE_ON)
# define disable_E4() E4_ENABLE_WRITE(!E_ENABLE_ON)
2017-04-06 21:46:30 +00:00
# else
2017-04-11 16:10:26 +00:00
# define enable_E4() NOOP
# define disable_E4() NOOP
2017-04-06 21:46:30 +00:00
# endif
2016-06-28 22:06:56 +00:00
# endif // !MIXING_EXTRUDER
2011-12-06 04:33:33 +00:00
2016-09-29 20:06:01 +00:00
# if ENABLED(G38_PROBE_TARGET)
2016-09-26 06:30:34 +00:00
extern bool G38_move , // flag to tell the interrupt handler that a G38 command is being run
G38_endstop_hit ; // flag from the interrupt handler to indicate if the endstop went active
2016-09-19 19:17:10 +00:00
# endif
2015-04-04 03:45:24 +00:00
/**
* The axis order in all axis related arrays is X , Y , Z , E
*/
2016-04-27 14:15:20 +00:00
# define _AXIS(AXIS) AXIS ##_AXIS
2015-05-10 19:37:39 +00:00
2015-04-04 02:25:22 +00:00
void enable_all_steppers ( ) ;
2017-03-18 02:12:19 +00:00
void disable_e_steppers ( ) ;
2015-04-04 02:25:22 +00:00
void disable_all_steppers ( ) ;
2011-08-12 20:28:35 +00:00
void FlushSerialRequestResend ( ) ;
2015-05-12 09:08:20 +00:00
void ok_to_send ( ) ;
2011-08-12 20:28:35 +00:00
2015-10-03 06:08:58 +00:00
void kill ( const char * ) ;
2012-03-25 12:36:51 +00:00
2016-07-06 19:00:28 +00:00
void quickstop_stepper ( ) ;
2016-06-03 00:11:54 +00:00
2015-07-31 05:24:43 +00:00
# if ENABLED(FILAMENT_RUNOUT_SENSOR)
2016-04-18 06:16:49 +00:00
void handle_filament_runout ( ) ;
2015-03-07 20:43:15 +00:00
# endif
2015-04-27 03:08:45 +00:00
extern uint8_t marlin_debug_flags ;
2016-03-30 02:50:01 +00:00
# define DEBUGGING(F) (marlin_debug_flags & (DEBUG_## F))
2015-04-27 03:08:45 +00:00
2015-04-08 07:56:19 +00:00
extern bool Running ;
inline bool IsRunning ( ) { return Running ; }
inline bool IsStopped ( ) { return ! Running ; }
2011-08-12 20:28:35 +00:00
2017-04-02 02:32:36 +00:00
bool enqueue_and_echo_command ( const char * cmd , bool say_ok = false ) ; // Add a single command to the end of the buffer. Return false on failure.
void enqueue_and_echo_commands_P ( const char * const cmd ) ; // Set one or more commands to be prioritized over the next Serial/SD command.
2016-06-01 00:41:32 +00:00
void clear_command_queue ( ) ;
2015-02-07 22:24:20 +00:00
2015-04-13 01:07:08 +00:00
extern millis_t previous_cmd_ms ;
inline void refresh_cmd_timeout ( ) { previous_cmd_ms = millis ( ) ; }
2014-02-03 10:30:12 +00:00
2015-07-31 05:24:43 +00:00
# if ENABLED(FAST_PWM_FAN)
2015-03-20 09:50:28 +00:00
void setPwmFrequency ( uint8_t pin , int val ) ;
2015-04-04 03:45:24 +00:00
# endif
2011-08-12 20:28:35 +00:00
2016-07-16 01:49:34 +00:00
/**
* Feedrate scaling and conversion
*/
extern int feedrate_percentage ;
# define MMM_TO_MMS(MM_M) ((MM_M) / 60.0)
# define MMS_TO_MMM(MM_S) ((MM_S)*60.0)
2016-08-07 07:20:25 +00:00
# define MMS_SCALED(MM_S) ((MM_S)*feedrate_percentage*0.01)
2016-07-16 01:49:34 +00:00
2011-11-04 17:02:56 +00:00
extern bool axis_relative_modes [ ] ;
2014-12-29 01:43:14 +00:00
extern bool volumetric_enabled ;
2016-08-19 03:13:47 +00:00
extern int flow_percentage [ EXTRUDERS ] ; // Extrusion factor for each extruder
2014-12-29 01:43:14 +00:00
extern float filament_size [ EXTRUDERS ] ; // cross-sectional area of filament (in millimeters), typically around 1.75 or 2.85, 0 disables the volumetric calculations for the extruder.
2014-01-31 16:43:11 +00:00
extern float volumetric_multiplier [ EXTRUDERS ] ; // reciprocal of cross-sectional area of filament (in square millimeters), stored this way to reduce computational burden in planner
2016-08-21 03:38:32 +00:00
extern bool axis_known_position [ XYZ ] ; // axis[n].is_known
extern bool axis_homed [ XYZ ] ; // axis[n].is_homed
2016-07-07 02:59:19 +00:00
extern volatile bool wait_for_heatup ;
2015-04-04 03:45:24 +00:00
2017-04-09 16:12:08 +00:00
# if HAS_RESUME_CONTINUE
2016-09-12 01:51:53 +00:00
extern volatile bool wait_for_user ;
# endif
2016-07-24 23:34:01 +00:00
extern float current_position [ NUM_AXIS ] ;
2017-03-05 00:01:33 +00:00
// Workspace offsets
2017-04-15 02:41:21 +00:00
# if HAS_WORKSPACE_OFFSET
# if HAS_HOME_OFFSET
extern float home_offset [ XYZ ] ;
# endif
# if HAS_POSITION_SHIFT
extern float position_shift [ XYZ ] ;
# endif
# endif
# if HAS_HOME_OFFSET && HAS_POSITION_SHIFT
extern float workspace_offset [ XYZ ] ;
# define WORKSPACE_OFFSET(AXIS) workspace_offset[AXIS]
# elif HAS_HOME_OFFSET
# define WORKSPACE_OFFSET(AXIS) home_offset[AXIS]
# elif HAS_POSITION_SHIFT
# define WORKSPACE_OFFSET(AXIS) position_shift[AXIS]
# else
# define WORKSPACE_OFFSET(AXIS) 0
# endif
# define LOGICAL_POSITION(POS, AXIS) ((POS) + WORKSPACE_OFFSET(AXIS))
# define RAW_POSITION(POS, AXIS) ((POS) - WORKSPACE_OFFSET(AXIS))
# if HAS_POSITION_SHIFT || DISABLED(DELTA)
# define LOGICAL_X_POSITION(POS) LOGICAL_POSITION(POS, X_AXIS)
# define LOGICAL_Y_POSITION(POS) LOGICAL_POSITION(POS, Y_AXIS)
# define RAW_X_POSITION(POS) RAW_POSITION(POS, X_AXIS)
# define RAW_Y_POSITION(POS) RAW_POSITION(POS, Y_AXIS)
2017-03-05 00:01:33 +00:00
# else
2017-04-15 02:41:21 +00:00
# define LOGICAL_X_POSITION(POS) (POS)
# define LOGICAL_Y_POSITION(POS) (POS)
# define RAW_X_POSITION(POS) (POS)
# define RAW_Y_POSITION(POS) (POS)
2017-03-05 00:01:33 +00:00
# endif
# define LOGICAL_Z_POSITION(POS) LOGICAL_POSITION(POS, Z_AXIS)
# define RAW_Z_POSITION(POS) RAW_POSITION(POS, Z_AXIS)
2017-04-15 02:41:21 +00:00
# define RAW_CURRENT_POSITION(A) RAW_##A##_POSITION(current_position[A##_AXIS])
2016-08-21 01:07:42 +00:00
2017-04-15 02:41:21 +00:00
// Hotend Offsets
2016-10-28 23:39:23 +00:00
# if HOTENDS > 1
extern float hotend_offset [ XYZ ] [ HOTENDS ] ;
# endif
2016-08-21 01:07:42 +00:00
// Software Endstops
2017-04-15 02:41:21 +00:00
extern float soft_endstop_min [ XYZ ] , soft_endstop_max [ XYZ ] ;
2017-03-05 00:01:33 +00:00
2017-03-16 22:20:24 +00:00
# if HAS_SOFTWARE_ENDSTOPS
2016-08-21 01:07:42 +00:00
extern bool soft_endstops_enabled ;
void clamp_to_software_endstops ( float target [ XYZ ] ) ;
# else
# define soft_endstops_enabled false
# define clamp_to_software_endstops(x) NOOP
# endif
2016-07-24 23:34:01 +00:00
2017-04-15 02:41:21 +00:00
# if HAS_WORKSPACE_OFFSET || ENABLED(DUAL_X_CARRIAGE)
2017-03-05 00:01:33 +00:00
void update_software_endstops ( const AxisEnum axis ) ;
# endif
2016-07-24 23:34:01 +00:00
2016-04-28 01:06:32 +00:00
// GCode support for external objects
2016-05-18 01:22:41 +00:00
bool code_seen ( char ) ;
2016-05-31 15:26:08 +00:00
int code_value_int ( ) ;
2017-05-03 22:10:44 +00:00
int16_t code_value_temp_abs ( ) ;
int16_t code_value_temp_diff ( ) ;
# if ENABLED(INCH_MODE_SUPPORT)
float code_value_linear_units ( ) ;
float code_value_axis_units ( const AxisEnum axis ) ;
float code_value_per_axis_unit ( const AxisEnum axis ) ;
# else
# define code_value_linear_units() code_value_float()
# define code_value_axis_units(A) code_value_float()
# define code_value_per_axis_unit(A) code_value_float()
# endif
2016-04-28 01:06:32 +00:00
2016-09-12 08:48:29 +00:00
# if IS_KINEMATIC
2016-08-21 03:38:32 +00:00
extern float delta [ ABC ] ;
2016-09-15 07:31:36 +00:00
void inverse_kinematics ( const float logical [ XYZ ] ) ;
2016-09-12 08:48:29 +00:00
# endif
# if ENABLED(DELTA)
2016-09-15 05:27:31 +00:00
extern float endstop_adj [ ABC ] ,
2016-09-12 08:48:29 +00:00
delta_radius ,
delta_diagonal_rod ,
2017-04-18 12:43:25 +00:00
delta_calibration_radius ,
2016-09-12 08:48:29 +00:00
delta_segments_per_second ,
2017-04-18 12:43:25 +00:00
delta_tower_angle_trim [ 2 ] ,
2016-12-13 08:43:36 +00:00
delta_clip_start_height ;
2015-09-03 05:38:47 +00:00
void recalc_delta_settings ( float radius , float diagonal_rod ) ;
2016-09-12 01:11:30 +00:00
# elif IS_SCARA
2016-09-12 08:48:29 +00:00
void forward_kinematics_SCARA ( const float & a , const float & b ) ;
2014-06-23 15:09:57 +00:00
# endif
2015-04-04 03:45:24 +00:00
2016-09-26 04:17:39 +00:00
# if ENABLED(AUTO_BED_LEVELING_BILINEAR)
2016-12-10 06:17:49 +00:00
extern int bilinear_grid_spacing [ 2 ] , bilinear_start [ 2 ] ;
2017-04-21 06:34:03 +00:00
extern float bilinear_grid_factor [ 2 ] ,
z_values [ GRID_MAX_POINTS_X ] [ GRID_MAX_POINTS_Y ] ;
float bilinear_z_offset ( const float logical [ XYZ ] ) ;
2016-12-10 06:17:49 +00:00
void set_bed_leveling_enabled ( bool enable = true ) ;
# endif
2017-04-06 23:46:47 +00:00
# if ENABLED(AUTO_BED_LEVELING_UBL)
2017-04-08 08:16:13 +00:00
typedef struct { double A , B , D ; } linear_fit ;
linear_fit * lsf_linear_fit ( double x [ ] , double y [ ] , double z [ ] , const int ) ;
2017-04-06 23:46:47 +00:00
# endif
2017-05-01 21:13:09 +00:00
# if HAS_LEVELING
2016-12-10 06:17:49 +00:00
void reset_bed_level ( ) ;
2016-09-12 01:56:16 +00:00
# endif
2017-02-21 12:49:31 +00:00
# if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
void set_z_fade_height ( const float zfh ) ;
# endif
2015-07-31 05:24:43 +00:00
# if ENABLED(Z_DUAL_ENDSTOPS)
2015-07-15 02:49:43 +00:00
extern float z_endstop_adj ;
# endif
2015-04-04 03:45:24 +00:00
2016-06-15 01:05:20 +00:00
# if HAS_BED_PROBE
2015-03-26 04:14:00 +00:00
extern float zprobe_zoffset ;
2017-04-11 10:05:23 +00:00
void refresh_zprobe_zoffset ( const bool no_babystep = false ) ;
2017-04-06 23:46:47 +00:00
# define DEPLOY_PROBE() set_probe_deployed(true)
# define STOW_PROBE() set_probe_deployed(false)
2015-03-26 04:14:00 +00:00
# endif
2015-04-04 03:45:24 +00:00
2016-04-07 00:31:18 +00:00
# if ENABLED(HOST_KEEPALIVE_FEATURE)
2017-03-29 00:45:54 +00:00
extern MarlinBusyState busy_state ;
# define KEEPALIVE_STATE(n) do{ busy_state = n; }while(0)
# else
# define KEEPALIVE_STATE(n) NOOP
2016-04-07 00:31:18 +00:00
# endif
2016-03-06 02:27:45 +00:00
# if FAN_COUNT > 0
2017-05-03 22:12:14 +00:00
extern int16_t fanSpeeds [ FAN_COUNT ] ;
2017-05-07 11:06:06 +00:00
# if ENABLED(PROBING_FANS_OFF)
extern bool fans_paused ;
extern int16_t paused_fanSpeeds [ FAN_COUNT ] ;
# endif
2016-03-06 02:27:45 +00:00
# endif
2015-04-04 03:45:24 +00:00
2015-07-31 05:24:43 +00:00
# if ENABLED(BARICUDA)
2016-04-18 06:12:15 +00:00
extern int baricuda_valve_pressure ;
extern int baricuda_e_to_p_pressure ;
2013-05-14 21:56:32 +00:00
# endif
2012-12-03 11:13:20 +00:00
2016-03-30 03:28:23 +00:00
# if ENABLED(FILAMENT_WIDTH_SENSOR)
2016-09-06 04:57:12 +00:00
extern bool filament_sensor ; // Flag that filament sensor readings should control extrusion
extern float filament_width_nominal , // Theoretical filament diameter i.e., 3.00 or 1.75
filament_width_meas ; // Measured filament diameter
extern int8_t measurement_delay [ ] ; // Ring buffer to delay measurement
extern int filwidth_delay_index [ 2 ] ; // Ring buffer indexes. Used by planner, temperature, and main code
extern int meas_delay_cm ; // Delay distance
2014-08-07 00:30:57 +00:00
# endif
2016-04-28 16:57:21 +00:00
# if ENABLED(FILAMENT_CHANGE_FEATURE)
extern FilamentChangeMenuResponse filament_change_menu_response ;
# endif
2016-08-01 00:49:34 +00:00
# if ENABLED(PID_EXTRUSION_SCALING)
2015-08-31 02:04:30 +00:00
extern int lpq_len ;
# endif
2015-07-31 05:24:43 +00:00
# if ENABLED(FWRETRACT)
2015-03-20 09:50:28 +00:00
extern bool autoretract_enabled ;
2015-07-15 02:49:43 +00:00
extern bool retracted [ EXTRUDERS ] ; // extruder[n].retracted
2016-06-22 10:27:31 +00:00
extern float retract_length , retract_length_swap , retract_feedrate_mm_s , retract_zlift ;
2016-07-16 01:49:34 +00:00
extern float retract_recover_length , retract_recover_length_swap , retract_recover_feedrate_mm_s ;
2012-12-03 11:13:20 +00:00
# endif
2011-11-04 17:02:56 +00:00
2016-04-06 03:34:03 +00:00
// Print job timer
2016-04-27 01:13:27 +00:00
# if ENABLED(PRINTCOUNTER)
extern PrintCounter print_job_timer ;
# else
extern Stopwatch print_job_timer ;
# endif
2012-11-06 11:06:41 +00:00
2011-12-06 04:33:33 +00:00
// Handling multiple extruders pins
extern uint8_t active_extruder ;
2016-04-03 23:18:49 +00:00
# if HAS_TEMP_HOTEND || HAS_TEMP_BED
2015-11-09 23:02:11 +00:00
void print_heaterstates ( ) ;
# endif
2016-06-28 22:06:56 +00:00
# if ENABLED(MIXING_EXTRUDER)
extern float mixing_factor [ MIXING_STEPPERS ] ;
# endif
2016-05-18 01:22:41 +00:00
void calculate_volumetric_multipliers ( ) ;
2015-01-02 16:11:18 +00:00
2016-07-19 00:56:14 +00:00
/**
* Blocking movement and shorthand functions
*/
2016-08-10 07:03:04 +00:00
void do_blocking_move_to ( const float & x , const float & y , const float & z , const float & fr_mm_s = 0.0 ) ;
void do_blocking_move_to_x ( const float & x , const float & fr_mm_s = 0.0 ) ;
void do_blocking_move_to_z ( const float & z , const float & fr_mm_s = 0.0 ) ;
void do_blocking_move_to_xy ( const float & x , const float & y , const float & fr_mm_s = 0.0 ) ;
2016-07-19 00:56:14 +00:00
2017-03-31 05:15:32 +00:00
# if ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) || HAS_PROBING_PROCEDURE || HOTENDS > 1 || ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE)
bool axis_unhomed_error ( const bool x , const bool y , const bool z ) ;
# endif
2017-05-12 03:33:47 +00:00
/**
* position_is_reachable family of functions
*/
# if IS_KINEMATIC // (DELTA or SCARA)
# if ENABLED(DELTA)
# define DELTA_PRINTABLE_RADIUS_SQUARED ((float)DELTA_PRINTABLE_RADIUS * (float)DELTA_PRINTABLE_RADIUS )
# endif
# if IS_SCARA
extern const float L1 , L2 ;
# endif
inline bool position_is_reachable_raw_xy ( float raw_x , float raw_y ) {
# if ENABLED(DELTA)
return ( HYPOT2 ( raw_x , raw_y ) < = DELTA_PRINTABLE_RADIUS_SQUARED ) ;
# elif IS_SCARA
# if MIDDLE_DEAD_ZONE_R > 0
const float R2 = HYPOT2 ( raw_x - SCARA_OFFSET_X , raw_y - SCARA_OFFSET_Y ) ;
return R2 > = sq ( float ( MIDDLE_DEAD_ZONE_R ) ) & & R2 < = sq ( L1 + L2 ) ;
# else
return HYPOT2 ( raw_x - SCARA_OFFSET_X , raw_y - SCARA_OFFSET_Y ) < = sq ( L1 + L2 ) ;
# endif
# else // CARTESIAN
# error
# endif
}
inline bool position_is_reachable_by_probe_raw_xy ( float raw_x , float raw_y ) {
// both the nozzle and the probe must be able to reach the point
return ( position_is_reachable_raw_xy ( raw_x , raw_y ) & &
position_is_reachable_raw_xy (
raw_x - X_PROBE_OFFSET_FROM_EXTRUDER ,
raw_y - Y_PROBE_OFFSET_FROM_EXTRUDER ) ) ;
}
# else // CARTESIAN
inline bool position_is_reachable_raw_xy ( float raw_x , float raw_y ) {
// note to reviewer: this +/-0.0001 logic is copied from original postion_is_reachable
return WITHIN ( raw_x , X_MIN_POS - 0.0001 , X_MAX_POS + 0.0001 )
& & WITHIN ( raw_y , Y_MIN_POS - 0.0001 , Y_MAX_POS + 0.0001 ) ;
}
inline bool position_is_reachable_by_probe_raw_xy ( float raw_x , float raw_y ) {
// note to reviewer: this logic is copied from UBL_G29.cpp and does not contain the +/-0.0001 above
return WITHIN ( raw_x , MIN_PROBE_X , MAX_PROBE_X )
& & WITHIN ( raw_y , MIN_PROBE_Y , MAX_PROBE_Y ) ;
}
# endif // CARTESIAN
inline bool position_is_reachable_by_probe_xy ( float target_x , float target_y ) {
return position_is_reachable_by_probe_raw_xy (
RAW_X_POSITION ( target_x ) ,
RAW_Y_POSITION ( target_y ) ) ;
}
inline bool position_is_reachable_xy ( float target_x , float target_y ) {
return position_is_reachable_raw_xy ( RAW_X_POSITION ( target_x ) , RAW_Y_POSITION ( target_y ) ) ;
}
# endif //MARLIN_H