Macros
#define	AVR_ATmega2560_FAMILY_PLUS_70

#define	HAS_CLASSIC_JERK (ENABLED(CLASSIC_JERK) \|\| IS_KINEMATIC)

#define	HAS_CLASSIC_E_JERK (HAS_CLASSIC_JERK && DISABLED(LIN_ADVANCE))

#define	X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS))

#define	Y_MAX_LENGTH (Y_MAX_POS - (Y_MIN_POS))

#define	Z_MAX_LENGTH (Z_MAX_POS - (Z_MIN_POS))

#define	X_BED_SIZE X_MAX_LENGTH

#define	Y_BED_SIZE Y_MAX_LENGTH

#define	_X_HALF_BED ((X_BED_SIZE) / 2)

#define	_Y_HALF_BED ((Y_BED_SIZE) / 2)

#define	X_CENTER _X_HALF_BED

#define	Y_CENTER _Y_HALF_BED

#define	X_MIN_BED (X_CENTER - _X_HALF_BED)

#define	X_MAX_BED (X_MIN_BED + X_BED_SIZE)

#define	Y_MIN_BED (Y_CENTER - _Y_HALF_BED)

#define	Y_MAX_BED (Y_MIN_BED + Y_BED_SIZE)

#define	CORE_IS_XY EITHER(COREXY, COREYX)

#define	CORE_IS_XZ EITHER(COREXZ, COREZX)

#define	CORE_IS_YZ EITHER(COREYZ, COREZY)

#define	IS_CORE (CORE_IS_XY \|\| CORE_IS_XZ \|\| CORE_IS_YZ)

#define	X_HOME_POS (X_HOME_DIR < 0 ? X_MIN_POS : X_MAX_POS)

#define	Y_HOME_POS (Y_HOME_DIR < 0 ? Y_MIN_POS : Y_MAX_POS)

#define	Z_HOME_POS (Z_HOME_DIR < 0 ? Z_MIN_POS : Z_MAX_POS)

#define	MESH_INSET 0

#define	DEFAULT_KEEPALIVE_INTERVAL 2

#define	HAS_LCD_CONTRAST defined(_LCD_CONTRAST_INIT)

#define	DISABLE_INACTIVE_X DISABLE_X

#define	DISABLE_INACTIVE_Y DISABLE_Y

#define	DISABLE_INACTIVE_Z DISABLE_Z

#define	DISABLE_INACTIVE_E DISABLE_E

#define	PSU_NAME "Generic"

#define	HAS_POWER_SWITCH (ENABLED(PSU_CONTROL) && PIN_EXISTS(PS_ON))

#define	ANY_TEMP_SENSOR_IS(n) (TEMP_SENSOR_0 == (n) \|\| TEMP_SENSOR_1 == (n) \|\| TEMP_SENSOR_2 == (n) \|\| TEMP_SENSOR_3 == (n) \|\| TEMP_SENSOR_4 == (n) \|\| TEMP_SENSOR_5 == (n) \|\| TEMP_SENSOR_BED == (n) \|\| TEMP_SENSOR_CHAMBER == (n))

#define	HAS_USER_THERMISTORS ANY_TEMP_SENSOR_IS(1000)

#define	HOTEND_USES_THERMISTOR ANY(HEATER_0_USES_THERMISTOR, HEATER_1_USES_THERMISTOR, HEATER_2_USES_THERMISTOR, HEATER_3_USES_THERMISTOR, HEATER_4_USES_THERMISTOR)

#define	ARRAY_BY_EXTRUDERS(V...) ARRAY_N(EXTRUDERS, V)

#define	ARRAY_BY_EXTRUDERS1(v1) ARRAY_BY_EXTRUDERS(v1, v1, v1, v1, v1, v1)

#define	ARRAY_BY_HOTENDS(V...) ARRAY_N(HOTENDS, V)

#define	ARRAY_BY_HOTENDS1(v1) ARRAY_BY_HOTENDS(v1, v1, v1, v1, v1, v1)

#define	TRINAMICS (HAS_TRINAMIC \|\| HAS_DRIVER(TMC2130_STANDALONE) \|\| HAS_DRIVER(TMC2208_STANDALONE) \|\| HAS_DRIVER(TMC2209_STANDALONE) \|\| HAS_DRIVER(TMC26X_STANDALONE) \|\| HAS_DRIVER(TMC2660_STANDALONE) \|\| HAS_DRIVER(TMC5130_STANDALONE) \|\| HAS_DRIVER(TMC5160_STANDALONE) \|\| HAS_DRIVER(TMC2160_STANDALONE))

#define	MINIMUM_STEPPER_POST_DIR_DELAY 0

#define	MINIMUM_STEPPER_PRE_DIR_DELAY MINIMUM_STEPPER_POST_DIR_DELAY

#define	MINIMUM_STEPPER_PULSE 2

#define	MAXIMUM_STEPPER_RATE 250000

#define	IS_X2_ENDSTOP(A, M) (ENABLED(X_DUAL_ENDSTOPS) && X2_USE_ENDSTOP == _##A##M##_)

#define	IS_Y2_ENDSTOP(A, M) (ENABLED(Y_DUAL_ENDSTOPS) && Y2_USE_ENDSTOP == _##A##M##_)

#define	IS_Z2_OR_PROBE(A, M)

#define	IS_Z3_OR_PROBE(A, M)

#define	HAS_X_ENABLE (PIN_EXISTS(X_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X)))

#define	HAS_X_DIR (PIN_EXISTS(X_DIR))

#define	HAS_X_STEP (PIN_EXISTS(X_STEP))

#define	HAS_X_MICROSTEPS (PIN_EXISTS(X_MS1))

#define	HAS_X2_ENABLE (PIN_EXISTS(X2_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X2)))

#define	HAS_X2_DIR (PIN_EXISTS(X2_DIR))

#define	HAS_X2_STEP (PIN_EXISTS(X2_STEP))

#define	HAS_X2_MICROSTEPS (PIN_EXISTS(X2_MS1))

#define	HAS_Y_ENABLE (PIN_EXISTS(Y_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Y)))

#define	HAS_Y_DIR (PIN_EXISTS(Y_DIR))

#define	HAS_Y_STEP (PIN_EXISTS(Y_STEP))

#define	HAS_Y_MICROSTEPS (PIN_EXISTS(Y_MS1))

#define	HAS_Y2_ENABLE (PIN_EXISTS(Y2_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Y2)))

#define	HAS_Y2_DIR (PIN_EXISTS(Y2_DIR))

#define	HAS_Y2_STEP (PIN_EXISTS(Y2_STEP))

#define	HAS_Y2_MICROSTEPS (PIN_EXISTS(Y2_MS1))

#define	HAS_Z_ENABLE (PIN_EXISTS(Z_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z)))

#define	HAS_Z_DIR (PIN_EXISTS(Z_DIR))

#define	HAS_Z_STEP (PIN_EXISTS(Z_STEP))

#define	HAS_Z_MICROSTEPS (PIN_EXISTS(Z_MS1))

#define	HAS_Z2_ENABLE (PIN_EXISTS(Z2_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z2)))

#define	HAS_Z2_DIR (PIN_EXISTS(Z2_DIR))

#define	HAS_Z2_STEP (PIN_EXISTS(Z2_STEP))

#define	HAS_Z2_MICROSTEPS (PIN_EXISTS(Z2_MS1))

#define	HAS_Z3_ENABLE (PIN_EXISTS(Z3_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z3)))

#define	HAS_Z3_DIR (PIN_EXISTS(Z3_DIR))

#define	HAS_Z3_STEP (PIN_EXISTS(Z3_STEP))

#define	HAS_Z3_MICROSTEPS (PIN_EXISTS(Z3_MS1))

#define	HAS_E0_ENABLE (PIN_EXISTS(E0_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E0)))

#define	HAS_E0_DIR (PIN_EXISTS(E0_DIR))

#define	HAS_E0_STEP (PIN_EXISTS(E0_STEP))

#define	HAS_E0_MICROSTEPS (PIN_EXISTS(E0_MS1))

#define	HAS_SOLENOID_0 (PIN_EXISTS(SOL0))

#define	HAS_E1_ENABLE (PIN_EXISTS(E1_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E1)))

#define	HAS_E1_DIR (PIN_EXISTS(E1_DIR))

#define	HAS_E1_STEP (PIN_EXISTS(E1_STEP))

#define	HAS_E1_MICROSTEPS (PIN_EXISTS(E1_MS1))

#define	HAS_SOLENOID_1 (PIN_EXISTS(SOL1))

#define	HAS_E2_ENABLE (PIN_EXISTS(E2_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E2)))

#define	HAS_E2_DIR (PIN_EXISTS(E2_DIR))

#define	HAS_E2_STEP (PIN_EXISTS(E2_STEP))

#define	HAS_E2_MICROSTEPS (PIN_EXISTS(E2_MS1))

#define	HAS_SOLENOID_2 (PIN_EXISTS(SOL2))

#define	HAS_E3_ENABLE (PIN_EXISTS(E3_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E3)))

#define	HAS_E3_DIR (PIN_EXISTS(E3_DIR))

#define	HAS_E3_STEP (PIN_EXISTS(E3_STEP))

#define	HAS_E3_MICROSTEPS (PIN_EXISTS(E3_MS1))

#define	HAS_SOLENOID_3 (PIN_EXISTS(SOL3))

#define	HAS_E4_ENABLE (PIN_EXISTS(E4_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E4)))

#define	HAS_E4_DIR (PIN_EXISTS(E4_DIR))

#define	HAS_E4_STEP (PIN_EXISTS(E4_STEP))

#define	HAS_E4_MICROSTEPS (PIN_EXISTS(E4_MS1))

#define	HAS_SOLENOID_4 (PIN_EXISTS(SOL4))

#define	HAS_E5_ENABLE (PIN_EXISTS(E5_ENABLE) \|\| (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E5)))

#define	HAS_E5_DIR (PIN_EXISTS(E5_DIR))

#define	HAS_E5_STEP (PIN_EXISTS(E5_STEP))

#define	HAS_E5_MICROSTEPS (PIN_EXISTS(E5_MS1))

#define	HAS_SOLENOID_5 (PIN_EXISTS(SOL5))

#define	HAS_E_STEPPER_ENABLE

#define	_HAS_STOP(A, M) (PIN_EXISTS(A##_##M) && !IS_X2_ENDSTOP(A,M) && !IS_Y2_ENDSTOP(A,M) && !IS_Z2_OR_PROBE(A,M))

#define	HAS_X_MIN _HAS_STOP(X,MIN)

#define	HAS_X_MAX _HAS_STOP(X,MAX)

#define	HAS_Y_MIN _HAS_STOP(Y,MIN)

#define	HAS_Y_MAX _HAS_STOP(Y,MAX)

#define	HAS_Z_MIN _HAS_STOP(Z,MIN)

#define	HAS_Z_MAX _HAS_STOP(Z,MAX)

#define	HAS_X2_MIN (PIN_EXISTS(X2_MIN))

#define	HAS_X2_MAX (PIN_EXISTS(X2_MAX))

#define	HAS_Y2_MIN (PIN_EXISTS(Y2_MIN))

#define	HAS_Y2_MAX (PIN_EXISTS(Y2_MAX))

#define	HAS_Z2_MIN (PIN_EXISTS(Z2_MIN))

#define	HAS_Z2_MAX (PIN_EXISTS(Z2_MAX))

#define	HAS_Z3_MIN (PIN_EXISTS(Z3_MIN))

#define	HAS_Z3_MAX (PIN_EXISTS(Z3_MAX))

#define	HAS_Z_MIN_PROBE_PIN (HAS_CUSTOM_PROBE_PIN && PIN_EXISTS(Z_MIN_PROBE))

#define	HAS_CALIBRATION_PIN (PIN_EXISTS(CALIBRATION))

#define	HAS_ADC_TEST(P) (PIN_EXISTS(TEMP_##P) && TEMP_SENSOR_##P != 0 && DISABLED(HEATER_##P##_USES_MAX6675))

#define	HAS_TEMP_ADC_0 HAS_ADC_TEST(0)

#define	HAS_TEMP_ADC_1 HAS_ADC_TEST(1)

#define	HAS_TEMP_ADC_2 HAS_ADC_TEST(2)

#define	HAS_TEMP_ADC_3 HAS_ADC_TEST(3)

#define	HAS_TEMP_ADC_4 HAS_ADC_TEST(4)

#define	HAS_TEMP_ADC_5 HAS_ADC_TEST(5)

#define	HAS_TEMP_ADC_BED HAS_ADC_TEST(BED)

#define	HAS_TEMP_ADC_CHAMBER HAS_ADC_TEST(CHAMBER)

#define	HAS_TEMP_HOTEND (HAS_TEMP_ADC_0 \|\| ENABLED(HEATER_0_USES_MAX6675))

#define	HAS_TEMP_BED HAS_TEMP_ADC_BED

#define	HAS_TEMP_CHAMBER HAS_TEMP_ADC_CHAMBER

#define	HAS_HEATED_CHAMBER (HAS_TEMP_CHAMBER && PIN_EXISTS(HEATER_CHAMBER))

#define	HAS_HEATER_0 (PIN_EXISTS(HEATER_0))

#define	HAS_HEATER_1 (PIN_EXISTS(HEATER_1))

#define	HAS_HEATER_2 (PIN_EXISTS(HEATER_2))

#define	HAS_HEATER_3 (PIN_EXISTS(HEATER_3))

#define	HAS_HEATER_4 (PIN_EXISTS(HEATER_4))

#define	HAS_HEATER_5 (PIN_EXISTS(HEATER_5))

#define	HAS_HEATER_BED (PIN_EXISTS(HEATER_BED))

#define	HAS_HEATED_BED (HAS_TEMP_BED && HAS_HEATER_BED)

#define	BED_OR_CHAMBER (HAS_HEATED_BED \|\| HAS_TEMP_CHAMBER)

#define	HAS_TEMP_SENSOR (HAS_TEMP_HOTEND \|\| BED_OR_CHAMBER)

#define	HAS_PID_HEATING EITHER(PIDTEMP, PIDTEMPBED)

#define	HAS_PID_FOR_BOTH BOTH(PIDTEMP, PIDTEMPBED)

#define	HAS_THERMALLY_PROTECTED_BED (HAS_HEATED_BED && ENABLED(THERMAL_PROTECTION_BED))

#define	WATCH_HOTENDS (ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0)

#define	WATCH_BED (HAS_THERMALLY_PROTECTED_BED && WATCH_BED_TEMP_PERIOD > 0)

#define	WATCH_CHAMBER (HAS_HEATED_CHAMBER && ENABLED(THERMAL_PROTECTION_CHAMBER) && WATCH_CHAMBER_TEMP_PERIOD > 0)

#define	HAS_AUTO_FAN_0 (HOTENDS > 0 && PIN_EXISTS(E0_AUTO_FAN))

#define	HAS_AUTO_FAN_1 (HOTENDS > 1 && PIN_EXISTS(E1_AUTO_FAN))

#define	HAS_AUTO_FAN_2 (HOTENDS > 2 && PIN_EXISTS(E2_AUTO_FAN))

#define	HAS_AUTO_FAN_3 (HOTENDS > 3 && PIN_EXISTS(E3_AUTO_FAN))

#define	HAS_AUTO_FAN_4 (HOTENDS > 4 && PIN_EXISTS(E4_AUTO_FAN))

#define	HAS_AUTO_FAN_5 (HOTENDS > 5 && PIN_EXISTS(E5_AUTO_FAN))

#define	HAS_AUTO_CHAMBER_FAN (HAS_TEMP_CHAMBER && PIN_EXISTS(CHAMBER_AUTO_FAN))

#define	HAS_AUTO_FAN (HAS_AUTO_FAN_0 \|\| HAS_AUTO_FAN_1 \|\| HAS_AUTO_FAN_2 \|\| HAS_AUTO_FAN_3 \|\| HAS_AUTO_FAN_4 \|\| HAS_AUTO_FAN_5 \|\| HAS_AUTO_CHAMBER_FAN)

#define	_FANOVERLAP(A, B) (A##_AUTO_FAN_PIN == E##B##_AUTO_FAN_PIN)

#define	HAS_FAN0 (PIN_EXISTS(FAN))

#define	HAS_FAN1 (PIN_EXISTS(FAN1) && CONTROLLER_FAN_PIN != FAN1_PIN && E0_AUTO_FAN_PIN != FAN1_PIN && E1_AUTO_FAN_PIN != FAN1_PIN && E2_AUTO_FAN_PIN != FAN1_PIN && E3_AUTO_FAN_PIN != FAN1_PIN && E4_AUTO_FAN_PIN != FAN1_PIN && E5_AUTO_FAN_PIN != FAN1_PIN)

#define	HAS_FAN2 (PIN_EXISTS(FAN2) && CONTROLLER_FAN_PIN != FAN2_PIN && E0_AUTO_FAN_PIN != FAN2_PIN && E1_AUTO_FAN_PIN != FAN2_PIN && E2_AUTO_FAN_PIN != FAN2_PIN && E3_AUTO_FAN_PIN != FAN2_PIN && E4_AUTO_FAN_PIN != FAN2_PIN && E5_AUTO_FAN_PIN != FAN2_PIN)

#define	HAS_CONTROLLER_FAN (PIN_EXISTS(CONTROLLER_FAN))

#define	HAS_SERVO_0 (PIN_EXISTS(SERVO0) && NUM_SERVOS > 0)

#define	HAS_SERVO_1 (PIN_EXISTS(SERVO1) && NUM_SERVOS > 1)

#define	HAS_SERVO_2 (PIN_EXISTS(SERVO2) && NUM_SERVOS > 2)

#define	HAS_SERVO_3 (PIN_EXISTS(SERVO3) && NUM_SERVOS > 3)

#define	HAS_SERVOS (NUM_SERVOS > 0)

#define	HAS_SERVO_ANGLES (EITHER(SWITCHING_EXTRUDER, SWITCHING_NOZZLE) \|\| (HAS_Z_SERVO_PROBE && defined(Z_PROBE_SERVO_NR)))

#define	HAS_FILAMENT_WIDTH_SENSOR (PIN_EXISTS(FILWIDTH))

#define	HAS_HOME (PIN_EXISTS(HOME))

#define	HAS_KILL (PIN_EXISTS(KILL))

#define	HAS_SUICIDE (PIN_EXISTS(SUICIDE))

#define	HAS_PHOTOGRAPH (PIN_EXISTS(PHOTOGRAPH))

#define	HAS_BUZZER (PIN_EXISTS(BEEPER) \|\| EITHER(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))

#define	USE_BEEPER (HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))

#define	HAS_CASE_LIGHT (PIN_EXISTS(CASE_LIGHT) && ENABLED(CASE_LIGHT_ENABLE))

#define	HAS_STEPPER_RESET (PIN_EXISTS(STEPPER_RESET))

#define	HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS))

#define	HAS_MOTOR_CURRENT_PWM ANY_PIN(MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y, MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_Z, MOTOR_CURRENT_PWM_E)

#define	HAS_MICROSTEPS (HAS_X_MICROSTEPS \|\| HAS_X2_MICROSTEPS \|\| HAS_Y_MICROSTEPS \|\| HAS_Y2_MICROSTEPS \|\| HAS_Z_MICROSTEPS \|\| HAS_Z2_MICROSTEPS \|\| HAS_Z3_MICROSTEPS \|\| HAS_E0_MICROSTEPS \|\| HAS_E1_MICROSTEPS \|\| HAS_E2_MICROSTEPS \|\| HAS_E3_MICROSTEPS \|\| HAS_E4_MICROSTEPS \|\| HAS_E5_MICROSTEPS)

#define	HAS_AUTO_REPORTING EITHER(AUTO_REPORT_TEMPERATURES, AUTO_REPORT_SD_STATUS)

#define	EXTRUDE_MINTEMP 170

#define	WRITE_HEATER_0P(v) WRITE(HEATER_0_PIN, (v) ^ HEATER_0_INVERTING)

#define	WRITE_HEATER_0(v) WRITE_HEATER_0P(v)

#define	MIN_POWER 0

#define	FAN_INVERTING false

#define	FAN_COUNT 0

#define	HAS_FANMUX PIN_EXISTS(FANMUX0)

#define	FAN_MIN_PWM 0

#define	FAN_MAX_PWM 255

#define	UBL_SEGMENTED BOTH(AUTO_BED_LEVELING_UBL, DELTA)

#define	ABL_PLANAR EITHER(AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT)

#define	ABL_GRID EITHER(AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_BILINEAR)

#define	HAS_ABL_NOT_UBL (ABL_PLANAR \|\| ABL_GRID)

#define	HAS_ABL_OR_UBL (HAS_ABL_NOT_UBL \|\| ENABLED(AUTO_BED_LEVELING_UBL))

#define	HAS_LEVELING (HAS_ABL_OR_UBL \|\| ENABLED(MESH_BED_LEVELING))

#define	HAS_AUTOLEVEL (HAS_ABL_OR_UBL && DISABLED(PROBE_MANUALLY))

#define	HAS_MESH ANY(AUTO_BED_LEVELING_BILINEAR, AUTO_BED_LEVELING_UBL, MESH_BED_LEVELING)

#define	PLANNER_LEVELING (HAS_LEVELING && DISABLED(AUTO_BED_LEVELING_UBL))

#define	HAS_PROBING_PROCEDURE (HAS_ABL_OR_UBL \|\| ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))

#define	HAS_POSITION_MODIFIERS (ENABLED(FWRETRACT) \|\| HAS_LEVELING \|\| ENABLED(SKEW_CORRECTION))

#define	QUIET_PROBING (HAS_BED_PROBE && (EITHER(PROBING_HEATERS_OFF, PROBING_FANS_OFF) \|\| DELAY_BEFORE_PROBING > 0))

#define	HEATER_IDLE_HANDLER EITHER(ADVANCED_PAUSE_FEATURE, PROBING_HEATERS_OFF)

#define	MIN_PROBE_EDGE 0

#define	MIN_PROBE_EDGE_LEFT MIN_PROBE_EDGE

#define	MIN_PROBE_EDGE_RIGHT MIN_PROBE_EDGE

#define	MIN_PROBE_EDGE_FRONT MIN_PROBE_EDGE

#define	MIN_PROBE_EDGE_BACK MIN_PROBE_EDGE

#define	NOZZLE_TO_PROBE_OFFSET { 0, 0, 0 }

#define	Z_HOMING_HEIGHT 0

#define	HAS_POSITION_SHIFT DISABLED(NO_WORKSPACE_OFFSETS)

#define	HAS_HOME_OFFSET (DISABLED(NO_WORKSPACE_OFFSETS) && IS_CARTESIAN)

#define	HAS_SCARA_OFFSET (DISABLED(NO_WORKSPACE_OFFSETS) && IS_SCARA)

#define	HAS_WORKSPACE_OFFSET (HAS_POSITION_SHIFT && HAS_HOME_OFFSET)

#define	HAS_M206_COMMAND (HAS_HOME_OFFSET && !IS_SCARA)

#define	LCD_TIMEOUT_TO_STATUS 15000

#define	USE_GCODE_SUBCODES ANY(G38_PROBE_TARGET, CNC_COORDINATE_SYSTEMS, POWER_LOSS_RECOVERY)

#define	MAX_VFAT_ENTRIES (2)

#define	EARLY_WATCHDOG (ENABLED(USE_WATCHDOG) && defined(ARDUINO_ARCH_SAM))

#define	Z_STEPPER_COUNT 1

#define	Z_STEPPER_ALIGN_AMP 1.0

Macro Definition Documentation

◆ AVR_ATmega2560_FAMILY_PLUS_70

#define AVR_ATmega2560_FAMILY_PLUS_70

Value:

( \
     MB(BQ_ZUM_MEGA_3D)                 \
  || MB(MIGHTYBOARD_REVE)               \
  || MB(MINIRAMBO)                      \
  || MB(SCOOVO_X9H)                     \
)

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/. Conditionals_post.h Defines that depend on configuration but are not editable.

◆ HAS_CLASSIC_JERK

#define HAS_CLASSIC_JERK (ENABLED(CLASSIC_JERK) || IS_KINEMATIC)

◆ HAS_CLASSIC_E_JERK

#define HAS_CLASSIC_E_JERK (HAS_CLASSIC_JERK && DISABLED(LIN_ADVANCE))

◆ X_MAX_LENGTH

#define X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS))

Axis lengths and center

◆ Y_MAX_LENGTH

#define Y_MAX_LENGTH (Y_MAX_POS - (Y_MIN_POS))

◆ Z_MAX_LENGTH

#define Z_MAX_LENGTH (Z_MAX_POS - (Z_MIN_POS))

◆ X_BED_SIZE

#define X_BED_SIZE X_MAX_LENGTH

◆ Y_BED_SIZE

#define Y_BED_SIZE Y_MAX_LENGTH

◆ _X_HALF_BED

#define _X_HALF_BED ((X_BED_SIZE) / 2)

◆ _Y_HALF_BED

#define _Y_HALF_BED ((Y_BED_SIZE) / 2)

◆ X_CENTER

#define X_CENTER _X_HALF_BED

◆ Y_CENTER

#define Y_CENTER _Y_HALF_BED

◆ X_MIN_BED

#define X_MIN_BED (X_CENTER - _X_HALF_BED)

◆ X_MAX_BED

#define X_MAX_BED (X_MIN_BED + X_BED_SIZE)

◆ Y_MIN_BED

#define Y_MIN_BED (Y_CENTER - _Y_HALF_BED)

◆ Y_MAX_BED

#define Y_MAX_BED (Y_MIN_BED + Y_BED_SIZE)

◆ CORE_IS_XY

#define CORE_IS_XY EITHER(COREXY, COREYX)

Dual X Carriage CoreXY, CoreXZ, and CoreYZ - and their reverse

◆ CORE_IS_XZ

#define CORE_IS_XZ EITHER(COREXZ, COREZX)

◆ CORE_IS_YZ

#define CORE_IS_YZ EITHER(COREYZ, COREZY)

◆ IS_CORE

#define IS_CORE (CORE_IS_XY || CORE_IS_XZ || CORE_IS_YZ)

◆ X_HOME_POS

#define X_HOME_POS (X_HOME_DIR < 0 ? X_MIN_POS : X_MAX_POS)

No adjustable bed on non-cartesians SCARA cannot use SLOWDOWN and requires QUICKHOME Set the home position based on settings or manual overrides

◆ Y_HOME_POS

#define Y_HOME_POS (Y_HOME_DIR < 0 ? Y_MIN_POS : Y_MAX_POS)

◆ Z_HOME_POS

#define Z_HOME_POS (Z_HOME_DIR < 0 ? Z_MIN_POS : Z_MAX_POS)

◆ MESH_INSET

#define MESH_INSET 0

If DELTA_HEIGHT isn't defined use the old setting Z Sled Probe requires Z_SAFE_HOMING DELTA should ignore Z_SAFE_HOMING and SLOWDOWN

◆ DEFAULT_KEEPALIVE_INTERVAL

#define DEFAULT_KEEPALIVE_INTERVAL 2

Safe Homing Options Host keep alive

◆ HAS_LCD_CONTRAST

#define HAS_LCD_CONTRAST defined(_LCD_CONTRAST_INIT)

Provide a MAX_AUTORETRACT for older configs LCD Contrast for Graphical Displays

◆ DISABLE_INACTIVE_X

#define DISABLE_INACTIVE_X DISABLE_X

Override here because this is set in Configuration_adv.h Set defaults for missing (newer) options

◆ DISABLE_INACTIVE_Y

#define DISABLE_INACTIVE_Y DISABLE_Y

◆ DISABLE_INACTIVE_Z

#define DISABLE_INACTIVE_Z DISABLE_Z

◆ DISABLE_INACTIVE_E

#define DISABLE_INACTIVE_E DISABLE_E

◆ PSU_NAME

#define PSU_NAME "Generic"

Power Supply Control

◆ HAS_POWER_SWITCH

#define HAS_POWER_SWITCH (ENABLED(PSU_CONTROL) && PIN_EXISTS(PS_ON))

◆ ANY_TEMP_SENSOR_IS

#define ANY_TEMP_SENSOR_IS ( n ) (TEMP_SENSOR_0 == (n) || TEMP_SENSOR_1 == (n) || TEMP_SENSOR_2 == (n) || TEMP_SENSOR_3 == (n) || TEMP_SENSOR_4 == (n) || TEMP_SENSOR_5 == (n) || TEMP_SENSOR_BED == (n) || TEMP_SENSOR_CHAMBER == (n))

Temp Sensor defines

◆ HAS_USER_THERMISTORS

#define HAS_USER_THERMISTORS ANY_TEMP_SENSOR_IS(1000)

◆ HOTEND_USES_THERMISTOR

#define HOTEND_USES_THERMISTOR ANY(HEATER_0_USES_THERMISTOR, HEATER_1_USES_THERMISTOR, HEATER_2_USES_THERMISTOR, HEATER_3_USES_THERMISTOR, HEATER_4_USES_THERMISTOR)

◆ ARRAY_BY_EXTRUDERS

#define ARRAY_BY_EXTRUDERS ( V... ) ARRAY_N(EXTRUDERS, V)

Default hotend offsets, if not defined ARRAY_BY_EXTRUDERS based on EXTRUDERS

◆ ARRAY_BY_EXTRUDERS1

#define ARRAY_BY_EXTRUDERS1 ( v1 ) ARRAY_BY_EXTRUDERS(v1, v1, v1, v1, v1, v1)

◆ ARRAY_BY_HOTENDS

#define ARRAY_BY_HOTENDS ( V... ) ARRAY_N(HOTENDS, V)

ARRAY_BY_HOTENDS based on HOTENDS

◆ ARRAY_BY_HOTENDS1

#define ARRAY_BY_HOTENDS1 ( v1 ) ARRAY_BY_HOTENDS(v1, v1, v1, v1, v1, v1)

◆ TRINAMICS

#define TRINAMICS (HAS_TRINAMIC || HAS_DRIVER(TMC2130_STANDALONE) || HAS_DRIVER(TMC2208_STANDALONE) || HAS_DRIVER(TMC2209_STANDALONE) || HAS_DRIVER(TMC26X_STANDALONE) || HAS_DRIVER(TMC2660_STANDALONE) || HAS_DRIVER(TMC5130_STANDALONE) || HAS_DRIVER(TMC5160_STANDALONE) || HAS_DRIVER(TMC2160_STANDALONE))

Driver Timings NOTE: Driver timing order is longest-to-shortest duration. Preserve this ordering when adding new drivers.

◆ MINIMUM_STEPPER_POST_DIR_DELAY

#define MINIMUM_STEPPER_POST_DIR_DELAY 0

◆ MINIMUM_STEPPER_PRE_DIR_DELAY

#define MINIMUM_STEPPER_PRE_DIR_DELAY MINIMUM_STEPPER_POST_DIR_DELAY

◆ MINIMUM_STEPPER_PULSE

#define MINIMUM_STEPPER_PULSE 2

◆ MAXIMUM_STEPPER_RATE

#define MAXIMUM_STEPPER_RATE 250000

◆ IS_X2_ENDSTOP

#define IS_X2_ENDSTOP	(	A,
		M
	)	(ENABLED(X_DUAL_ENDSTOPS) && X2_USE_ENDSTOP == _##A##M##_)

X_DUAL_ENDSTOPS endstop reassignment

◆ IS_Y2_ENDSTOP

#define IS_Y2_ENDSTOP	(	A,
		M
	)	(ENABLED(Y_DUAL_ENDSTOPS) && Y2_USE_ENDSTOP == _##A##M##_)

Y_DUAL_ENDSTOPS endstop reassignment

◆ IS_Z2_OR_PROBE

#define IS_Z2_OR_PROBE	(	A,
		M
	)

Value:

( \
     (Z_MULTI_ENDSTOPS && Z2_USE_ENDSTOP == _##A##M##_) \
  || (HAS_CUSTOM_PROBE_PIN && Z_MIN_PROBE_PIN == A##_##M##_PIN ) )

Z_DUAL_ENDSTOPS endstop reassignment

◆ IS_Z3_OR_PROBE

#define IS_Z3_OR_PROBE	(	A,
		M
	)

Value:

( \
     (ENABLED(Z_TRIPLE_ENDSTOPS) && Z3_USE_ENDSTOP == _##A##M##_) \
  || (HAS_CUSTOM_PROBE_PIN && Z_MIN_PROBE_PIN == A##_##M##_PIN ) )

◆ HAS_X_ENABLE

#define HAS_X_ENABLE (PIN_EXISTS(X_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X)))

Set ENDSTOPPULLUPS for active endstop switches Set ENDSTOPPULLDOWNS for active endstop switches Shorthand for pin tests, used wherever needed

◆ HAS_X_DIR

#define HAS_X_DIR (PIN_EXISTS(X_DIR))

◆ HAS_X_STEP

#define HAS_X_STEP (PIN_EXISTS(X_STEP))

◆ HAS_X_MICROSTEPS

#define HAS_X_MICROSTEPS (PIN_EXISTS(X_MS1))

◆ HAS_X2_ENABLE

#define HAS_X2_ENABLE (PIN_EXISTS(X2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X2)))

◆ HAS_X2_DIR

#define HAS_X2_DIR (PIN_EXISTS(X2_DIR))

◆ HAS_X2_STEP

#define HAS_X2_STEP (PIN_EXISTS(X2_STEP))

◆ HAS_X2_MICROSTEPS

#define HAS_X2_MICROSTEPS (PIN_EXISTS(X2_MS1))

◆ HAS_Y_ENABLE

#define HAS_Y_ENABLE (PIN_EXISTS(Y_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Y)))

◆ HAS_Y_DIR

#define HAS_Y_DIR (PIN_EXISTS(Y_DIR))

◆ HAS_Y_STEP

#define HAS_Y_STEP (PIN_EXISTS(Y_STEP))

◆ HAS_Y_MICROSTEPS

#define HAS_Y_MICROSTEPS (PIN_EXISTS(Y_MS1))

◆ HAS_Y2_ENABLE

#define HAS_Y2_ENABLE (PIN_EXISTS(Y2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Y2)))

◆ HAS_Y2_DIR

#define HAS_Y2_DIR (PIN_EXISTS(Y2_DIR))

◆ HAS_Y2_STEP

#define HAS_Y2_STEP (PIN_EXISTS(Y2_STEP))

◆ HAS_Y2_MICROSTEPS

#define HAS_Y2_MICROSTEPS (PIN_EXISTS(Y2_MS1))

◆ HAS_Z_ENABLE

#define HAS_Z_ENABLE (PIN_EXISTS(Z_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z)))

◆ HAS_Z_DIR

#define HAS_Z_DIR (PIN_EXISTS(Z_DIR))

◆ HAS_Z_STEP

#define HAS_Z_STEP (PIN_EXISTS(Z_STEP))

◆ HAS_Z_MICROSTEPS

#define HAS_Z_MICROSTEPS (PIN_EXISTS(Z_MS1))

◆ HAS_Z2_ENABLE

#define HAS_Z2_ENABLE (PIN_EXISTS(Z2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z2)))

◆ HAS_Z2_DIR

#define HAS_Z2_DIR (PIN_EXISTS(Z2_DIR))

◆ HAS_Z2_STEP

#define HAS_Z2_STEP (PIN_EXISTS(Z2_STEP))

◆ HAS_Z2_MICROSTEPS

#define HAS_Z2_MICROSTEPS (PIN_EXISTS(Z2_MS1))

◆ HAS_Z3_ENABLE

#define HAS_Z3_ENABLE (PIN_EXISTS(Z3_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(Z3)))

◆ HAS_Z3_DIR

#define HAS_Z3_DIR (PIN_EXISTS(Z3_DIR))

◆ HAS_Z3_STEP

#define HAS_Z3_STEP (PIN_EXISTS(Z3_STEP))

◆ HAS_Z3_MICROSTEPS

#define HAS_Z3_MICROSTEPS (PIN_EXISTS(Z3_MS1))

◆ HAS_E0_ENABLE

#define HAS_E0_ENABLE (PIN_EXISTS(E0_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E0)))

◆ HAS_E0_DIR

#define HAS_E0_DIR (PIN_EXISTS(E0_DIR))

◆ HAS_E0_STEP

#define HAS_E0_STEP (PIN_EXISTS(E0_STEP))

◆ HAS_E0_MICROSTEPS

#define HAS_E0_MICROSTEPS (PIN_EXISTS(E0_MS1))

◆ HAS_SOLENOID_0

#define HAS_SOLENOID_0 (PIN_EXISTS(SOL0))

◆ HAS_E1_ENABLE

#define HAS_E1_ENABLE (PIN_EXISTS(E1_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E1)))

◆ HAS_E1_DIR

#define HAS_E1_DIR (PIN_EXISTS(E1_DIR))

◆ HAS_E1_STEP

#define HAS_E1_STEP (PIN_EXISTS(E1_STEP))

◆ HAS_E1_MICROSTEPS

#define HAS_E1_MICROSTEPS (PIN_EXISTS(E1_MS1))

◆ HAS_SOLENOID_1

#define HAS_SOLENOID_1 (PIN_EXISTS(SOL1))

◆ HAS_E2_ENABLE

#define HAS_E2_ENABLE (PIN_EXISTS(E2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E2)))

◆ HAS_E2_DIR

#define HAS_E2_DIR (PIN_EXISTS(E2_DIR))

◆ HAS_E2_STEP

#define HAS_E2_STEP (PIN_EXISTS(E2_STEP))

◆ HAS_E2_MICROSTEPS

#define HAS_E2_MICROSTEPS (PIN_EXISTS(E2_MS1))

◆ HAS_SOLENOID_2

#define HAS_SOLENOID_2 (PIN_EXISTS(SOL2))

◆ HAS_E3_ENABLE

#define HAS_E3_ENABLE (PIN_EXISTS(E3_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E3)))

◆ HAS_E3_DIR

#define HAS_E3_DIR (PIN_EXISTS(E3_DIR))

◆ HAS_E3_STEP

#define HAS_E3_STEP (PIN_EXISTS(E3_STEP))

◆ HAS_E3_MICROSTEPS

#define HAS_E3_MICROSTEPS (PIN_EXISTS(E3_MS1))

◆ HAS_SOLENOID_3

#define HAS_SOLENOID_3 (PIN_EXISTS(SOL3))

◆ HAS_E4_ENABLE

#define HAS_E4_ENABLE (PIN_EXISTS(E4_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E4)))

◆ HAS_E4_DIR

#define HAS_E4_DIR (PIN_EXISTS(E4_DIR))

◆ HAS_E4_STEP

#define HAS_E4_STEP (PIN_EXISTS(E4_STEP))

◆ HAS_E4_MICROSTEPS

#define HAS_E4_MICROSTEPS (PIN_EXISTS(E4_MS1))

◆ HAS_SOLENOID_4

#define HAS_SOLENOID_4 (PIN_EXISTS(SOL4))

◆ HAS_E5_ENABLE

#define HAS_E5_ENABLE (PIN_EXISTS(E5_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(E5)))

◆ HAS_E5_DIR

#define HAS_E5_DIR (PIN_EXISTS(E5_DIR))

◆ HAS_E5_STEP

#define HAS_E5_STEP (PIN_EXISTS(E5_STEP))

◆ HAS_E5_MICROSTEPS

#define HAS_E5_MICROSTEPS (PIN_EXISTS(E5_MS1))

◆ HAS_SOLENOID_5

#define HAS_SOLENOID_5 (PIN_EXISTS(SOL5))

◆ HAS_E_STEPPER_ENABLE

#define HAS_E_STEPPER_ENABLE

Value:

(HAS_E_DRIVER(TMC2660) \
  || ( E0_ENABLE_PIN != X_ENABLE_PIN && E1_ENABLE_PIN != X_ENABLE_PIN   \
    && E0_ENABLE_PIN != Y_ENABLE_PIN && E1_ENABLE_PIN != Y_ENABLE_PIN ) \
)

◆ _HAS_STOP

#define _HAS_STOP	(	A,
		M
	)	(PIN_EXISTS(A##_##M) && !IS_X2_ENDSTOP(A,M) && !IS_Y2_ENDSTOP(A,M) && !IS_Z2_OR_PROBE(A,M))

◆ HAS_X_MIN

#define HAS_X_MIN _HAS_STOP(X,MIN)

◆ HAS_X_MAX

#define HAS_X_MAX _HAS_STOP(X,MAX)

◆ HAS_Y_MIN

#define HAS_Y_MIN _HAS_STOP(Y,MIN)

◆ HAS_Y_MAX

#define HAS_Y_MAX _HAS_STOP(Y,MAX)

◆ HAS_Z_MIN

#define HAS_Z_MIN _HAS_STOP(Z,MIN)

◆ HAS_Z_MAX

#define HAS_Z_MAX _HAS_STOP(Z,MAX)

◆ HAS_X2_MIN

#define HAS_X2_MIN (PIN_EXISTS(X2_MIN))

◆ HAS_X2_MAX

#define HAS_X2_MAX (PIN_EXISTS(X2_MAX))

◆ HAS_Y2_MIN

#define HAS_Y2_MIN (PIN_EXISTS(Y2_MIN))

◆ HAS_Y2_MAX

#define HAS_Y2_MAX (PIN_EXISTS(Y2_MAX))

◆ HAS_Z2_MIN

#define HAS_Z2_MIN (PIN_EXISTS(Z2_MIN))

◆ HAS_Z2_MAX

#define HAS_Z2_MAX (PIN_EXISTS(Z2_MAX))

◆ HAS_Z3_MIN

#define HAS_Z3_MIN (PIN_EXISTS(Z3_MIN))

◆ HAS_Z3_MAX

#define HAS_Z3_MAX (PIN_EXISTS(Z3_MAX))

◆ HAS_Z_MIN_PROBE_PIN

#define HAS_Z_MIN_PROBE_PIN (HAS_CUSTOM_PROBE_PIN && PIN_EXISTS(Z_MIN_PROBE))

◆ HAS_CALIBRATION_PIN

#define HAS_CALIBRATION_PIN (PIN_EXISTS(CALIBRATION))

◆ HAS_ADC_TEST

#define HAS_ADC_TEST ( P ) (PIN_EXISTS(TEMP_##P) && TEMP_SENSOR_##P != 0 && DISABLED(HEATER_##P##_USES_MAX6675))

◆ HAS_TEMP_ADC_0

#define HAS_TEMP_ADC_0 HAS_ADC_TEST(0)

◆ HAS_TEMP_ADC_1

#define HAS_TEMP_ADC_1 HAS_ADC_TEST(1)

◆ HAS_TEMP_ADC_2

#define HAS_TEMP_ADC_2 HAS_ADC_TEST(2)

◆ HAS_TEMP_ADC_3

#define HAS_TEMP_ADC_3 HAS_ADC_TEST(3)

◆ HAS_TEMP_ADC_4

#define HAS_TEMP_ADC_4 HAS_ADC_TEST(4)

◆ HAS_TEMP_ADC_5

#define HAS_TEMP_ADC_5 HAS_ADC_TEST(5)

◆ HAS_TEMP_ADC_BED

#define HAS_TEMP_ADC_BED HAS_ADC_TEST(BED)

◆ HAS_TEMP_ADC_CHAMBER

#define HAS_TEMP_ADC_CHAMBER HAS_ADC_TEST(CHAMBER)

◆ HAS_TEMP_HOTEND

#define HAS_TEMP_HOTEND (HAS_TEMP_ADC_0 || ENABLED(HEATER_0_USES_MAX6675))

◆ HAS_TEMP_BED

#define HAS_TEMP_BED HAS_TEMP_ADC_BED

◆ HAS_TEMP_CHAMBER

#define HAS_TEMP_CHAMBER HAS_TEMP_ADC_CHAMBER

◆ HAS_HEATED_CHAMBER

#define HAS_HEATED_CHAMBER (HAS_TEMP_CHAMBER && PIN_EXISTS(HEATER_CHAMBER))

◆ HAS_HEATER_0

#define HAS_HEATER_0 (PIN_EXISTS(HEATER_0))

◆ HAS_HEATER_1

#define HAS_HEATER_1 (PIN_EXISTS(HEATER_1))

◆ HAS_HEATER_2

#define HAS_HEATER_2 (PIN_EXISTS(HEATER_2))

◆ HAS_HEATER_3

#define HAS_HEATER_3 (PIN_EXISTS(HEATER_3))

◆ HAS_HEATER_4

#define HAS_HEATER_4 (PIN_EXISTS(HEATER_4))

◆ HAS_HEATER_5

#define HAS_HEATER_5 (PIN_EXISTS(HEATER_5))

◆ HAS_HEATER_BED

#define HAS_HEATER_BED (PIN_EXISTS(HEATER_BED))

◆ HAS_HEATED_BED

#define HAS_HEATED_BED (HAS_TEMP_BED && HAS_HEATER_BED)

◆ BED_OR_CHAMBER

#define BED_OR_CHAMBER (HAS_HEATED_BED || HAS_TEMP_CHAMBER)

◆ HAS_TEMP_SENSOR

#define HAS_TEMP_SENSOR (HAS_TEMP_HOTEND || BED_OR_CHAMBER)

◆ HAS_PID_HEATING

#define HAS_PID_HEATING EITHER(PIDTEMP, PIDTEMPBED)

◆ HAS_PID_FOR_BOTH

#define HAS_PID_FOR_BOTH BOTH(PIDTEMP, PIDTEMPBED)

◆ HAS_THERMALLY_PROTECTED_BED

#define HAS_THERMALLY_PROTECTED_BED (HAS_HEATED_BED && ENABLED(THERMAL_PROTECTION_BED))

◆ WATCH_HOTENDS

#define WATCH_HOTENDS (ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0)

◆ WATCH_BED

#define WATCH_BED (HAS_THERMALLY_PROTECTED_BED && WATCH_BED_TEMP_PERIOD > 0)

◆ WATCH_CHAMBER

#define WATCH_CHAMBER (HAS_HEATED_CHAMBER && ENABLED(THERMAL_PROTECTION_CHAMBER) && WATCH_CHAMBER_TEMP_PERIOD > 0)

◆ HAS_AUTO_FAN_0

#define HAS_AUTO_FAN_0 (HOTENDS > 0 && PIN_EXISTS(E0_AUTO_FAN))

◆ HAS_AUTO_FAN_1

#define HAS_AUTO_FAN_1 (HOTENDS > 1 && PIN_EXISTS(E1_AUTO_FAN))

◆ HAS_AUTO_FAN_2

#define HAS_AUTO_FAN_2 (HOTENDS > 2 && PIN_EXISTS(E2_AUTO_FAN))

◆ HAS_AUTO_FAN_3

#define HAS_AUTO_FAN_3 (HOTENDS > 3 && PIN_EXISTS(E3_AUTO_FAN))

◆ HAS_AUTO_FAN_4

#define HAS_AUTO_FAN_4 (HOTENDS > 4 && PIN_EXISTS(E4_AUTO_FAN))

◆ HAS_AUTO_FAN_5

#define HAS_AUTO_FAN_5 (HOTENDS > 5 && PIN_EXISTS(E5_AUTO_FAN))

◆ HAS_AUTO_CHAMBER_FAN

#define HAS_AUTO_CHAMBER_FAN (HAS_TEMP_CHAMBER && PIN_EXISTS(CHAMBER_AUTO_FAN))

◆ HAS_AUTO_FAN

#define HAS_AUTO_FAN (HAS_AUTO_FAN_0 || HAS_AUTO_FAN_1 || HAS_AUTO_FAN_2 || HAS_AUTO_FAN_3 || HAS_AUTO_FAN_4 || HAS_AUTO_FAN_5 || HAS_AUTO_CHAMBER_FAN)

◆ _FANOVERLAP

#define _FANOVERLAP	(	A,
		B
	)	(A##_AUTO_FAN_PIN == E##B##_AUTO_FAN_PIN)

◆ HAS_FAN0

#define HAS_FAN0 (PIN_EXISTS(FAN))

◆ HAS_FAN1

#define HAS_FAN1 (PIN_EXISTS(FAN1) && CONTROLLER_FAN_PIN != FAN1_PIN && E0_AUTO_FAN_PIN != FAN1_PIN && E1_AUTO_FAN_PIN != FAN1_PIN && E2_AUTO_FAN_PIN != FAN1_PIN && E3_AUTO_FAN_PIN != FAN1_PIN && E4_AUTO_FAN_PIN != FAN1_PIN && E5_AUTO_FAN_PIN != FAN1_PIN)

◆ HAS_FAN2

#define HAS_FAN2 (PIN_EXISTS(FAN2) && CONTROLLER_FAN_PIN != FAN2_PIN && E0_AUTO_FAN_PIN != FAN2_PIN && E1_AUTO_FAN_PIN != FAN2_PIN && E2_AUTO_FAN_PIN != FAN2_PIN && E3_AUTO_FAN_PIN != FAN2_PIN && E4_AUTO_FAN_PIN != FAN2_PIN && E5_AUTO_FAN_PIN != FAN2_PIN)

◆ HAS_CONTROLLER_FAN

#define HAS_CONTROLLER_FAN (PIN_EXISTS(CONTROLLER_FAN))

◆ HAS_SERVO_0

#define HAS_SERVO_0 (PIN_EXISTS(SERVO0) && NUM_SERVOS > 0)

◆ HAS_SERVO_1

#define HAS_SERVO_1 (PIN_EXISTS(SERVO1) && NUM_SERVOS > 1)

◆ HAS_SERVO_2

#define HAS_SERVO_2 (PIN_EXISTS(SERVO2) && NUM_SERVOS > 2)

◆ HAS_SERVO_3

#define HAS_SERVO_3 (PIN_EXISTS(SERVO3) && NUM_SERVOS > 3)

◆ HAS_SERVOS

#define HAS_SERVOS (NUM_SERVOS > 0)

◆ HAS_SERVO_ANGLES

#define HAS_SERVO_ANGLES (EITHER(SWITCHING_EXTRUDER, SWITCHING_NOZZLE) || (HAS_Z_SERVO_PROBE && defined(Z_PROBE_SERVO_NR)))

◆ HAS_FILAMENT_WIDTH_SENSOR

#define HAS_FILAMENT_WIDTH_SENSOR (PIN_EXISTS(FILWIDTH))

◆ HAS_HOME

#define HAS_HOME (PIN_EXISTS(HOME))

◆ HAS_KILL

#define HAS_KILL (PIN_EXISTS(KILL))

◆ HAS_SUICIDE

#define HAS_SUICIDE (PIN_EXISTS(SUICIDE))

◆ HAS_PHOTOGRAPH

#define HAS_PHOTOGRAPH (PIN_EXISTS(PHOTOGRAPH))

◆ HAS_BUZZER

#define HAS_BUZZER (PIN_EXISTS(BEEPER) || EITHER(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))

◆ USE_BEEPER

#define USE_BEEPER (HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER, PCA9632_BUZZER))

◆ HAS_CASE_LIGHT

#define HAS_CASE_LIGHT (PIN_EXISTS(CASE_LIGHT) && ENABLED(CASE_LIGHT_ENABLE))

◆ HAS_STEPPER_RESET

#define HAS_STEPPER_RESET (PIN_EXISTS(STEPPER_RESET))

◆ HAS_DIGIPOTSS

#define HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS))

◆ HAS_MOTOR_CURRENT_PWM

#define HAS_MOTOR_CURRENT_PWM ANY_PIN(MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y, MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_Z, MOTOR_CURRENT_PWM_E)

◆ HAS_MICROSTEPS

#define HAS_MICROSTEPS (HAS_X_MICROSTEPS || HAS_X2_MICROSTEPS || HAS_Y_MICROSTEPS || HAS_Y2_MICROSTEPS || HAS_Z_MICROSTEPS || HAS_Z2_MICROSTEPS || HAS_Z3_MICROSTEPS || HAS_E0_MICROSTEPS || HAS_E1_MICROSTEPS || HAS_E2_MICROSTEPS || HAS_E3_MICROSTEPS || HAS_E4_MICROSTEPS || HAS_E5_MICROSTEPS)

◆ HAS_AUTO_REPORTING

#define HAS_AUTO_REPORTING EITHER(AUTO_REPORT_TEMPERATURES, AUTO_REPORT_SD_STATUS)

◆ EXTRUDE_MINTEMP

#define EXTRUDE_MINTEMP 170

This setting is also used by M109 when trying to calculate a ballpark safe margin to prevent wait-forever situation.

◆ WRITE_HEATER_0P

#define WRITE_HEATER_0P ( v ) WRITE(HEATER_0_PIN, (v) ^ HEATER_0_INVERTING)

Heater signal inversion defaults Helper Macros for heaters and extruder fan

◆ WRITE_HEATER_0

#define WRITE_HEATER_0 ( v ) WRITE_HEATER_0P(v)

◆ MIN_POWER

#define MIN_POWER 0

◆ FAN_INVERTING

#define FAN_INVERTING false

Heated bed requires settings Heated chamber requires settings Up to 3 PWM fans

◆ FAN_COUNT

#define FAN_COUNT 0

◆ HAS_FANMUX

#define HAS_FANMUX PIN_EXISTS(FANMUX0)

Part Cooling fan multipliexer

◆ FAN_MIN_PWM

#define FAN_MIN_PWM 0

MIN/MAX fan PWM scaling

◆ FAN_MAX_PWM

#define FAN_MAX_PWM 255

◆ UBL_SEGMENTED

#define UBL_SEGMENTED BOTH(AUTO_BED_LEVELING_UBL, DELTA)

FAST PWM FAN Settings MIN/MAX case light PWM scaling Bed Probe dependencies XYZ Bed Skew Correction Set granular options based on the specific type of leveling

◆ ABL_PLANAR

#define ABL_PLANAR EITHER(AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT)

◆ ABL_GRID

#define ABL_GRID EITHER(AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_BILINEAR)

◆ HAS_ABL_NOT_UBL

#define HAS_ABL_NOT_UBL (ABL_PLANAR || ABL_GRID)

◆ HAS_ABL_OR_UBL

#define HAS_ABL_OR_UBL (HAS_ABL_NOT_UBL || ENABLED(AUTO_BED_LEVELING_UBL))

◆ HAS_LEVELING

#define HAS_LEVELING (HAS_ABL_OR_UBL || ENABLED(MESH_BED_LEVELING))

◆ HAS_AUTOLEVEL

#define HAS_AUTOLEVEL (HAS_ABL_OR_UBL && DISABLED(PROBE_MANUALLY))

◆ HAS_MESH

#define HAS_MESH ANY(AUTO_BED_LEVELING_BILINEAR, AUTO_BED_LEVELING_UBL, MESH_BED_LEVELING)

◆ PLANNER_LEVELING

#define PLANNER_LEVELING (HAS_LEVELING && DISABLED(AUTO_BED_LEVELING_UBL))

◆ HAS_PROBING_PROCEDURE

#define HAS_PROBING_PROCEDURE (HAS_ABL_OR_UBL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))

◆ HAS_POSITION_MODIFIERS

#define HAS_POSITION_MODIFIERS (ENABLED(FWRETRACT) || HAS_LEVELING || ENABLED(SKEW_CORRECTION))

◆ QUIET_PROBING

#define QUIET_PROBING (HAS_BED_PROBE && (EITHER(PROBING_HEATERS_OFF, PROBING_FANS_OFF) || DELAY_BEFORE_PROBING > 0))

Heater, Fan, and Probe interactions

◆ HEATER_IDLE_HANDLER

#define HEATER_IDLE_HANDLER EITHER(ADVANCED_PAUSE_FEATURE, PROBING_HEATERS_OFF)

◆ MIN_PROBE_EDGE

#define MIN_PROBE_EDGE 0

Only constrain Z on DELTA / SCARA machines Bed Probing rectangular bounds These can be further constrained in code for Delta and SCARA

◆ MIN_PROBE_EDGE_LEFT

#define MIN_PROBE_EDGE_LEFT MIN_PROBE_EDGE

◆ MIN_PROBE_EDGE_RIGHT

#define MIN_PROBE_EDGE_RIGHT MIN_PROBE_EDGE

◆ MIN_PROBE_EDGE_FRONT

#define MIN_PROBE_EDGE_FRONT MIN_PROBE_EDGE

◆ MIN_PROBE_EDGE_BACK

#define MIN_PROBE_EDGE_BACK MIN_PROBE_EDGE

◆ NOZZLE_TO_PROBE_OFFSET

#define NOZZLE_TO_PROBE_OFFSET { 0, 0, 0 }

◆ Z_HOMING_HEIGHT

#define Z_HOMING_HEIGHT 0

Default mesh area is an area with an inset margin on the print area. Buzzer/Speaker Make sure DOGLCD_SCK and DOGLCD_MOSI are defined. Z_HOMING_HEIGHT / Z_CLEARANCE_BETWEEN_PROBES

◆ HAS_POSITION_SHIFT

#define HAS_POSITION_SHIFT DISABLED(NO_WORKSPACE_OFFSETS)

◆ HAS_HOME_OFFSET

#define HAS_HOME_OFFSET (DISABLED(NO_WORKSPACE_OFFSETS) && IS_CARTESIAN)

◆ HAS_SCARA_OFFSET

#define HAS_SCARA_OFFSET (DISABLED(NO_WORKSPACE_OFFSETS) && IS_SCARA)

◆ HAS_WORKSPACE_OFFSET

#define HAS_WORKSPACE_OFFSET (HAS_POSITION_SHIFT && HAS_HOME_OFFSET)

◆ HAS_M206_COMMAND

#define HAS_M206_COMMAND (HAS_HOME_OFFSET && !IS_SCARA)

◆ LCD_TIMEOUT_TO_STATUS

#define LCD_TIMEOUT_TO_STATUS 15000

◆ USE_GCODE_SUBCODES

#define USE_GCODE_SUBCODES ANY(G38_PROBE_TARGET, CNC_COORDINATE_SYSTEMS, POWER_LOSS_RECOVERY)

◆ MAX_VFAT_ENTRIES

#define MAX_VFAT_ENTRIES (2)

◆ EARLY_WATCHDOG

#define EARLY_WATCHDOG (ENABLED(USE_WATCHDOG) && defined(ARDUINO_ARCH_SAM))

◆ Z_STEPPER_COUNT

#define Z_STEPPER_COUNT 1

◆ Z_STEPPER_ALIGN_AMP

#define Z_STEPPER_ALIGN_AMP 1.0