diff --git a/.travis.yml b/.travis.yml index b3b96f212..c40017680 100644 --- a/.travis.yml +++ b/.travis.yml @@ -77,313 +77,7 @@ script: - cp Marlin/Configuration_adv.h Marlin/Configuration_adv.h.backup - cp Marlin/pins_RAMPS.h Marlin/pins_RAMPS.h.backup # - # Build with the default configurations + # Test Hangprinter only # + - use_example_configs hangprinter - build_marlin - # - # Test 2 extruders (one MAX6675) and heated bed on basic RAMPS 1.4 - # Test a "Fix Mounted" Probe with Safe Homing, some arc options, - # linear bed leveling, M48, leveling debug, and firmware retraction. - # - - opt_set MOTHERBOARD BOARD_RAMPS_14_EEB - - opt_set EXTRUDERS 2 - - opt_set TEMP_SENSOR_0 -2 - - opt_set TEMP_SENSOR_1 1 - - opt_set TEMP_SENSOR_BED 1 - - opt_set POWER_SUPPLY 1 - - opt_enable PIDTEMPBED FIX_MOUNTED_PROBE Z_SAFE_HOMING - - opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER SDSUPPORT EEPROM_SETTINGS PINS_DEBUGGING - - opt_enable BLINKM PCA9632 RGB_LED NEOPIXEL_LED AUTO_POWER_CONTROL NOZZLE_PARK_FEATURE FILAMENT_RUNOUT_SENSOR - - opt_enable AUTO_BED_LEVELING_LINEAR Z_MIN_PROBE_REPEATABILITY_TEST DEBUG_LEVELING_FEATURE SKEW_CORRECTION SKEW_CORRECTION_FOR_Z SKEW_CORRECTION_GCODE - - opt_enable_adv ARC_P_CIRCLES ADVANCED_PAUSE_FEATURE CNC_WORKSPACE_PLANES CNC_COORDINATE_SYSTEMS POWER_LOSS_RECOVERY POWER_LOSS_PIN POWER_LOSS_STATE - - opt_enable_adv FWRETRACT MAX7219_DEBUG LED_CONTROL_MENU CASE_LIGHT_ENABLE CASE_LIGHT_USE_NEOPIXEL CODEPENDENT_XY_HOMING - - opt_set GRID_MAX_POINTS_X 16 - - opt_set_adv FANMUX0_PIN 53 - - build_marlin - # - # Test a probeless build of AUTO_BED_LEVELING_UBL, with lots of extruders - # - - restore_configs - - opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO - - opt_set EXTRUDERS 5 - - opt_set TEMP_SENSOR_1 1 - - opt_set TEMP_SENSOR_2 5 - - opt_set TEMP_SENSOR_3 20 - - opt_set TEMP_SENSOR_4 999 - - opt_set TEMP_SENSOR_BED 1 - - opt_enable AUTO_BED_LEVELING_UBL RESTORE_LEVELING_AFTER_G28 DEBUG_LEVELING_FEATURE G26_MESH_EDITING ENABLE_LEVELING_FADE_HEIGHT SKEW_CORRECTION - - opt_enable EEPROM_SETTINGS EEPROM_CHITCHAT REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER - - opt_enable_adv CUSTOM_USER_MENUS I2C_POSITION_ENCODERS BABYSTEPPING BABYSTEP_XY LIN_ADVANCE NANODLP_Z_SYNC QUICK_HOME JUNCTION_DEVIATION MAX7219_DEBUG - - opt_set_adv MAX7219_ROTATE 270 - - build_marlin - # - # Add a Sled Z Probe, use UBL Cartesian moves, use Japanese language - # - - opt_enable Z_PROBE_SLED SKEW_CORRECTION SKEW_CORRECTION_FOR_Z SKEW_CORRECTION_GCODE S_CURVE_ACCELERATION - - opt_set LCD_LANGUAGE kana_utf8 - - opt_disable SEGMENT_LEVELED_MOVES - - opt_enable_adv BABYSTEP_ZPROBE_OFFSET DOUBLECLICK_FOR_Z_BABYSTEPPING - - build_marlin - # - # Test a Servo Probe - # ...with AUTO_BED_LEVELING_3POINT, DEBUG_LEVELING_FEATURE, EEPROM_SETTINGS, EEPROM_CHITCHAT, EXTENDED_CAPABILITIES_REPORT, and AUTO_REPORT_TEMPERATURES - # - - restore_configs - - opt_enable NUM_SERVOS Z_PROBE_SERVO_NR Z_SERVO_ANGLES DEACTIVATE_SERVOS_AFTER_MOVE - - opt_set NUM_SERVOS 1 - - opt_enable AUTO_BED_LEVELING_3POINT DEBUG_LEVELING_FEATURE EEPROM_SETTINGS EEPROM_CHITCHAT - - opt_enable_adv NO_VOLUMETRICS EXTENDED_CAPABILITIES_REPORT AUTO_REPORT_TEMPERATURES AUTOTEMP G38_PROBE_TARGET - - build_marlin - # - # Test MESH_BED_LEVELING feature, with LCD - # - - restore_configs - - opt_enable MESH_BED_LEVELING G26_MESH_EDITING MESH_G28_REST_ORIGIN LCD_BED_LEVELING ULTIMAKERCONTROLLER - - build_marlin - # - # Test MINIRAMBO for PWM_MOTOR_CURRENT - # PROBE_MANUALLY feature, with LCD support, - # ULTIMAKERCONTROLLER, FILAMENT_LCD_DISPLAY, FILAMENT_WIDTH_SENSOR, - # PRINTCOUNTER, NOZZLE_PARK_FEATURE, NOZZLE_CLEAN_FEATURE, PCA9632, - # Z_DUAL_ENDSTOPS, BEZIER_CURVE_SUPPORT, EXPERIMENTAL_I2CBUS, - # ADVANCED_PAUSE_FEATURE, ADVANCED_PAUSE_CONTINUOUS_PURGE, PARK_HEAD_ON_PAUSE, LCD_INFO_MENU, M114_DETAIL - # EEPROM_SETTINGS, EEPROM_CHITCHAT, M100_FREE_MEMORY_WATCHER, - # INCH_MODE_SUPPORT, TEMPERATURE_UNITS_SUPPORT - # - - restore_configs - - opt_set MOTHERBOARD BOARD_MINIRAMBO - - opt_enable PROBE_MANUALLY AUTO_BED_LEVELING_BILINEAR G26_MESH_EDITING LCD_BED_LEVELING ULTIMAKERCONTROLLER - - opt_enable EEPROM_SETTINGS EEPROM_CHITCHAT M100_FREE_MEMORY_WATCHER M100_FREE_MEMORY_DUMPER M100_FREE_MEMORY_CORRUPTOR INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT - - opt_enable ULTIMAKERCONTROLLER SDSUPPORT - - opt_enable PRINTCOUNTER NOZZLE_PARK_FEATURE NOZZLE_CLEAN_FEATURE PCA9632 - - opt_enable_adv BEZIER_CURVE_SUPPORT EXPERIMENTAL_I2CBUS - - opt_enable_adv ADVANCED_PAUSE_FEATURE ADVANCED_PAUSE_CONTINUOUS_PURGE FILAMENT_LOAD_UNLOAD_GCODES PARK_HEAD_ON_PAUSE LCD_INFO_MENU M114_DETAIL - - opt_set_adv PWM_MOTOR_CURRENT {1300,1300,1250} - - opt_set_adv I2C_SLAVE_ADDRESS 63 - - build_marlin - # - # Mixing Extruder with 5 steppers, Cyrillic - # - - restore_configs - - opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO - - opt_enable MIXING_EXTRUDER CR10_STOCKDISPLAY - - opt_set MIXING_STEPPERS 5 - - opt_set LCD_LANGUAGE ru - - build_marlin - # - # Test DUAL_X_CARRIAGE - # - - restore_configs - - opt_set MOTHERBOARD BOARD_RUMBA - - opt_set EXTRUDERS 2 - - opt_set TEMP_SENSOR_1 1 - - opt_enable USE_XMAX_PLUG - - opt_enable_adv DUAL_X_CARRIAGE - - build_marlin - # - # Test SPEAKER with BOARD_BQ_ZUM_MEGA_3D and BQ_LCD_SMART_CONTROLLER - # - #- restore_configs - #- opt_set MOTHERBOARD BOARD_BQ_ZUM_MEGA_3D - #- opt_set LCD_FEEDBACK_FREQUENCY_DURATION_MS 10 - #- opt_set LCD_FEEDBACK_FREQUENCY_HZ 100 - #- opt_enable BQ_LCD_SMART_CONTROLLER SPEAKER - # - # Test SWITCHING_EXTRUDER - # - - restore_configs - - opt_set MOTHERBOARD BOARD_RUMBA - - opt_set EXTRUDERS 2 - - opt_enable NUM_SERVOS - - opt_set NUM_SERVOS 1 - - opt_enable SWITCHING_EXTRUDER ULTIMAKERCONTROLLER - - build_marlin - # - # Enable COREXY - # - #- restore_configs - #- opt_enable COREXY - #- build_marlin - # - # Test many less common options - # - - restore_configs - - opt_enable COREYX - - opt_set_adv FAN_MIN_PWM 50 - - opt_set_adv FAN_KICKSTART_TIME 100 - - opt_set_adv XY_FREQUENCY_LIMIT 15 - - opt_enable_adv SHOW_TEMP_ADC_VALUES HOME_Y_BEFORE_X EMERGENCY_PARSER FAN_KICKSTART_TIME - - opt_enable_adv ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED ADVANCED_OK - - opt_enable_adv VOLUMETRIC_DEFAULT_ON NO_WORKSPACE_OFFSETS ACTION_ON_KILL - - opt_enable_adv EXTRA_FAN_SPEED FWERETRACT Z_DUAL_STEPPER_DRIVERS Z_DUAL_ENDSTOPS - - opt_enable_adv MENU_ADDAUTOSTART SDCARD_SORT_ALPHA - - opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER BABYSTEPPING DAC_MOTOR_CURRENT_DEFAULT - - opt_enable FILAMENT_LCD_DISPLAY FILAMENT_WIDTH_SENSOR - - opt_enable ENDSTOP_INTERRUPTS_FEATURE FAN_SOFT_PWM SDSUPPORT - - opt_enable USE_XMAX_PLUG - - build_marlin - # - ######## Other Standard LCD/Panels ############## - # - # ULTRA_LCD - # - #- restore_configs - #- opt_enable ULTRA_LCD - #- build_marlin - # - # DOGLCD - # - #- restore_configs - #- opt_enable DOGLCD - #- build_marlin - # - # MAKRPANEL - # Needs to use Melzi and Sanguino hardware - # - #- restore_configs - #- opt_enable MAKRPANEL - #- build_marlin - # - # REPRAP_DISCOUNT_SMART_CONTROLLER, SDSUPPORT, BABYSTEPPING, RIGIDBOARD_V2, and DAC_MOTOR_CURRENT_DEFAULT - # - #- restore_configs - #- opt_set MOTHERBOARD BOARD_RIGIDBOARD_V2 - #- opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER SDSUPPORT BABYSTEPPING DAC_MOTOR_CURRENT_DEFAULT - #- build_marlin - # # - # G3D_PANEL with SDCARD_SORT_ALPHA and STATUS_MESSAGE_SCROLLING - # - #- restore_configs - #- opt_enable G3D_PANEL SDSUPPORT - #- opt_enable_adv SDCARD_SORT_ALPHA STATUS_MESSAGE_SCROLLING SCROLL_LONG_FILENAMES - #- opt_set_adv SDSORT_GCODE true - #- opt_set_adv SDSORT_USES_RAM true - #- opt_set_adv SDSORT_USES_STACK true - #- opt_set_adv SDSORT_CACHE_NAMES true - #- build_marlin - # - # REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER with LIGHTWEIGHT_UI - # - - restore_configs - - opt_enable REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER SDSUPPORT - - opt_enable_adv SDCARD_SORT_ALPHA STATUS_MESSAGE_SCROLLING SCROLL_LONG_FILENAMES LIGHTWEIGHT_UI - - opt_set_adv SDSORT_GCODE true - - opt_set_adv SDSORT_USES_RAM true - - opt_set_adv SDSORT_USES_STACK true - - opt_set_adv SDSORT_CACHE_NAMES true - - build_marlin - # - # REPRAPWORLD_KEYPAD - # - # Cant find configuration details to get it to compile - #- restore_configs - #- opt_enable ULTRA_LCD REPRAPWORLD_KEYPAD REPRAPWORLD_KEYPAD_MOVE_STEP - #- build_marlin - # - # RA_CONTROL_PANEL - # - #- restore_configs - #- opt_enable RA_CONTROL_PANEL PINS_DEBUGGING - #- build_marlin - # - ######## I2C LCD/PANELS ############## - # - # !!!ATTENTION!!! - # Most I2C configurations are failing at the moment because they require - # a different Liquid Crystal library "LiquidTWI2". - # - # LCD_SAINSMART_I2C_1602 - # - #- restore_configs - #- opt_enable LCD_SAINSMART_I2C_1602 - #- build_marlin - # - # LCD_I2C_PANELOLU2 - # - #- restore_configs - #- opt_enable LCD_I2C_PANELOLU2 - #- build_marlin - # - # LCD_I2C_VIKI - # - #- restore_configs - #- opt_enable LCD_I2C_VIKI - #- build_marlin - # - # LCM1602 - # - #- restore_configs - #- opt_enable LCM1602 - #- build_marlin - # - # Language files test with REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER - # - #- restore_configs - #- opt_enable REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER SDSUPPORT - #- for lang in an bg ca zh_CN zh_TW cz da de el el-gr en es eu fi fr gl hr it jp-kana nl pl pt pt-br ru sk tr uk test; do opt_set LCD_LANGUAGE $lang; echo "compile with language $lang ..."; build_marlin - # - #- restore_configs - #- opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER SDSUPPORT - #- for lang in an bg ca zh_CN zh_TW cz da de el el-gr en es eu fi fr gl hr it jp-kana nl pl pt pt-br ru sk tr uk test; do opt_set LCD_LANGUAGE $lang; echo "compile with language $lang ..."; build_marlin - # - # - ######## Example Configurations ############## - # - # BQ Hephestos 2 - #- restore_configs - #- use_example_configs Hephestos_2 - #- build_marlin - # - # Delta Config (generic) + ABL bilinear + PROBE_MANUALLY - - use_example_configs delta/generic - - opt_enable REPRAP_DISCOUNT_SMART_CONTROLLER DELTA_CALIBRATION_MENU AUTO_BED_LEVELING_BILINEAR PROBE_MANUALLY - - build_marlin - # - # Delta Config (generic) + UBL + ALLEN_KEY + OLED_PANEL_TINYBOY2 + EEPROM_SETTINGS - # - - use_example_configs delta/generic - - opt_enable AUTO_BED_LEVELING_UBL RESTORE_LEVELING_AFTER_G28 Z_PROBE_ALLEN_KEY EEPROM_SETTINGS EEPROM_CHITCHAT - - opt_enable OLED_PANEL_TINYBOY2 MESH_EDIT_GFX_OVERLAY - - build_marlin - # - # Delta Config (FLSUN AC because it's complex) - # - - use_example_configs delta/FLSUN/auto_calibrate - - build_marlin - # - # Makibox Config need to check board type for Teensy++ 2.0 - # - #- use_example_configs makibox - #- build_marlin - # - # SCARA with TMC2130 - # - - use_example_configs SCARA - - opt_enable AUTO_BED_LEVELING_BILINEAR FIX_MOUNTED_PROBE USE_ZMIN_PLUG EEPROM_SETTINGS EEPROM_CHITCHAT ULTIMAKERCONTROLLER - - opt_set X_DRIVER_TYPE TMC2130 - - opt_set Y_DRIVER_TYPE TMC2130 - - opt_set Z_DRIVER_TYPE TMC2130 - - opt_set E0_DRIVER_TYPE TMC2130 - - opt_enable_adv MONITOR_DRIVER_STATUS STEALTHCHOP HYBRID_THRESHOLD SENSORLESS_HOMING - - build_marlin - # - # TMC2208 Config - # - - restore_configs - - opt_set X_DRIVER_TYPE TMC2208 - - opt_set Y_DRIVER_TYPE TMC2208 - - opt_set Z_DRIVER_TYPE TMC2208 - - opt_set E0_DRIVER_TYPE TMC2208 - - opt_enable_adv MONITOR_DRIVER_STATUS STEALTHCHOP HYBRID_THRESHOLD TMC_DEBUG - - build_marlin - # - # tvrrug Config need to check board type for sanguino atmega644p - # - #- use_example_configs tvrrug/Round2 - #- build_marlin - # - # - ######## Board Types ############# - # - # To be added in nightly test branch - # diff --git a/Marlin/Conditionals_LCD.h b/Marlin/Conditionals_LCD.h index a796e2466..7d8dabb31 100644 --- a/Marlin/Conditionals_LCD.h +++ b/Marlin/Conditionals_LCD.h @@ -439,10 +439,20 @@ */ #if ENABLED(DISTINCT_E_FACTORS) && E_STEPPERS > 1 #define XYZE_N (XYZ + E_STEPPERS) + #if ENABLED(HANGPRINTER) + #define NUM_AXIS_N (ABCD + E_STEPPERS) + #else + #define NUM_AXIS_N (XYZ + E_STEPPERS) + #endif #define E_AXIS_N (E_AXIS + extruder) #else #undef DISTINCT_E_FACTORS #define XYZE_N XYZE + #if ENABLED(HANGPRINTER) + #define NUM_AXIS_N ABCDE + #else + #define NUM_AXIS_N XYZE + #endif #define E_AXIS_N E_AXIS #endif diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h index a0877283d..3707d7741 100644 --- a/Marlin/Conditionals_post.h +++ b/Marlin/Conditionals_post.h @@ -29,7 +29,7 @@ #define CONDITIONALS_POST_H #define IS_SCARA (ENABLED(MORGAN_SCARA) || ENABLED(MAKERARM_SCARA)) -#define IS_KINEMATIC (ENABLED(DELTA) || IS_SCARA) +#define IS_KINEMATIC (ENABLED(DELTA) || IS_SCARA || ENABLED(HANGPRINTER)) #define IS_CARTESIAN !IS_KINEMATIC /** @@ -47,7 +47,7 @@ #define Y_BED_SIZE Y_MAX_LENGTH #endif -// Require 0,0 bed center for Delta and SCARA +// Require 0,0 bed center for Delta, SCARA, and HANGPRINTER #if IS_KINEMATIC #define BED_CENTER_AT_0_0 #endif @@ -129,7 +129,7 @@ #ifdef MANUAL_X_HOME_POS #define X_HOME_POS MANUAL_X_HOME_POS #elif ENABLED(BED_CENTER_AT_0_0) - #if ENABLED(DELTA) + #if ENABLED(DELTA) || ENABLED(HANGPRINTER) #define X_HOME_POS 0 #else #define X_HOME_POS ((X_BED_SIZE) * (X_HOME_DIR) * 0.5) @@ -145,7 +145,7 @@ #ifdef MANUAL_Y_HOME_POS #define Y_HOME_POS MANUAL_Y_HOME_POS #elif ENABLED(BED_CENTER_AT_0_0) - #if ENABLED(DELTA) + #if (ENABLED(DELTA) || ENABLED(HANGPRINTER)) #define Y_HOME_POS 0 #else #define Y_HOME_POS ((Y_BED_SIZE) * (Y_HOME_DIR) * 0.5) @@ -729,6 +729,28 @@ #define HAS_E4_MICROSTEPS (PIN_EXISTS(E4_MS1)) #define HAS_SOLENOID_4 (PIN_EXISTS(SOL4)) +#if ENABLED(HANGPRINTER) + #define HAS_A_ENABLE (PIN_EXISTS(A_ENABLE)) + #define HAS_A_DIR (PIN_EXISTS(A_DIR)) + #define HAS_A_STEP (PIN_EXISTS(A_STEP)) + #define HAS_A_MICROSTEPS (PIN_EXISTS(A_MS1)) + + #define HAS_B_ENABLE (PIN_EXISTS(B_ENABLE)) + #define HAS_B_DIR (PIN_EXISTS(B_DIR)) + #define HAS_B_STEP (PIN_EXISTS(B_STEP)) + #define HAS_B_MICROSTEPS (PIN_EXISTS(B_MS1)) + + #define HAS_C_ENABLE (PIN_EXISTS(C_ENABLE)) + #define HAS_C_DIR (PIN_EXISTS(C_DIR)) + #define HAS_C_STEP (PIN_EXISTS(C_STEP)) + #define HAS_C_MICROSTEPS (PIN_EXISTS(C_MS1)) + + #define HAS_D_ENABLE (PIN_EXISTS(D_ENABLE)) + #define HAS_D_DIR (PIN_EXISTS(D_DIR)) + #define HAS_D_STEP (PIN_EXISTS(D_STEP)) + #define HAS_D_MICROSTEPS (PIN_EXISTS(D_MS1)) +#endif + // Trinamic Stepper Drivers #define HAS_STEALTHCHOP (HAS_DRIVER(TMC2130) || HAS_DRIVER(TMC2208)) #define HAS_STALLGUARD HAS_DRIVER(TMC2130) @@ -1379,4 +1401,17 @@ #define HAS_FOLDER_SORTING (FOLDER_SORTING || ENABLED(SDSORT_GCODE)) #endif +/** + * MOV_AXIS: number of independent axes driving the tool head's translational movement + * NUM_AXIS: number of movement axes + 1 + * NUM_AXIS_N: number of movement axes + number of extruders (defined elsewhere) + */ +#if ENABLED(HANGPRINTER) + #define MOV_AXIS ABCD + #define NUM_AXIS ABCDE +#else + #define MOV_AXIS XYZ + #define NUM_AXIS XYZE +#endif + #endif // CONDITIONALS_POST_H diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index a03ea51b6..470f7d4ee 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -69,6 +69,13 @@ // example_configurations/SCARA and customize for your machine. // +//=========================================================================== +//============================= HANGPRINTER ================================= +//=========================================================================== +// For a Hangprinter start with the configuration file in the +// example_configurations/hangprinter directory and customize for your machine. +// + // @section info // User-specified version info of this build to display in [Pronterface, etc] terminal window during diff --git a/Marlin/G26_Mesh_Validation_Tool.cpp b/Marlin/G26_Mesh_Validation_Tool.cpp index 8a3f951c8..1d902f8dc 100644 --- a/Marlin/G26_Mesh_Validation_Tool.cpp +++ b/Marlin/G26_Mesh_Validation_Tool.cpp @@ -198,7 +198,7 @@ destination[X_AXIS] = current_position[X_AXIS]; destination[Y_AXIS] = current_position[Y_AXIS]; destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code. - destination[E_AXIS] = current_position[E_AXIS]; + destination[E_CART] = current_position[E_CART]; G26_line_to_destination(feed_value); set_destination_from_current(); @@ -212,7 +212,7 @@ destination[X_AXIS] = rx; destination[Y_AXIS] = ry; - destination[E_AXIS] += e_delta; + destination[E_CART] += e_delta; G26_line_to_destination(feed_value); set_destination_from_current(); @@ -254,7 +254,7 @@ while (!is_lcd_clicked()) { lcd_chirp(); - destination[E_AXIS] += 0.25; + destination[E_CART] += 0.25; #ifdef PREVENT_LENGTHY_EXTRUDE Total_Prime += 0.25; if (Total_Prime >= EXTRUDE_MAXLENGTH) return G26_ERR; @@ -283,7 +283,7 @@ lcd_quick_feedback(true); #endif set_destination_from_current(); - destination[E_AXIS] += g26_prime_length; + destination[E_CART] += g26_prime_length; G26_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0); set_destination_from_current(); retract_filament(destination); @@ -697,7 +697,7 @@ if (turn_on_heaters() != G26_OK) goto LEAVE; - current_position[E_AXIS] = 0.0; + current_position[E_CART] = 0.0; sync_plan_position_e(); if (g26_prime_flag && prime_nozzle() != G26_OK) goto LEAVE; @@ -812,7 +812,7 @@ const float endpoint[XYZE] = { ex, ey, g26_layer_height, - current_position[E_AXIS] + (arc_length * g26_e_axis_feedrate * g26_extrusion_multiplier) + current_position[E_CART] + (arc_length * g26_e_axis_feedrate * g26_extrusion_multiplier) }; if (dist_start > 2.0) { diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h index 1394c687a..46037b845 100644 --- a/Marlin/Marlin.h +++ b/Marlin/Marlin.h @@ -162,6 +162,42 @@ extern const char axis_codes[XYZE]; #endif // !MIXING_EXTRUDER +#if ENABLED(HANGPRINTER) + + #define enable_A() enable_X() + #define enable_B() enable_Y() + #define enable_C() enable_Z() + #define __D_ENABLE(p) E##p##_ENABLE_WRITE(E_ENABLE_ON) + #define _D_ENABLE(p) __D_ENABLE(p) + #define enable_D() _D_ENABLE(EXTRUDERS) + + // Don't allow any axes to be disabled + #undef disable_X + #undef disable_Y + #undef disable_Z + #define disable_X() NOOP + #define disable_Y() NOOP + #define disable_Z() NOOP + + #if EXTRUDERS >= 1 + #undef disable_E1 + #define disable_E1() NOOP + #if EXTRUDERS >= 2 + #undef disable_E2 + #define disable_E2() NOOP + #if EXTRUDERS >= 3 + #undef disable_E3 + #define disable_E3() NOOP + #if EXTRUDERS >= 4 + #undef disable_E4 + #define disable_E4() NOOP + #endif // EXTRUDERS >= 4 + #endif // EXTRUDERS >= 3 + #endif // EXTRUDERS >= 2 + #endif // EXTRUDERS >= 1 + +#endif // HANGPRINTER + #if ENABLED(G38_PROBE_TARGET) 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 @@ -304,12 +340,16 @@ extern float soft_endstop_min[XYZ], soft_endstop_max[XYZ]; void tool_change(const uint8_t tmp_extruder, const float fr_mm_s=0.0, bool no_move=false); -void home_all_axes(); +void home_all_axes(); void report_current_position(); #if IS_KINEMATIC - extern float delta[ABC]; + #if ENABLED(HANGPRINTER) + extern float line_lengths[ABCD]; + #else + extern float delta[ABC]; + #endif void inverse_kinematics(const float raw[XYZ]); #endif @@ -342,6 +382,51 @@ void report_current_position(); delta[C_AXIS] = DELTA_Z(V, C_AXIS); \ }while(0) +#elif ENABLED(HANGPRINTER) + + // Don't collect anchor positions in array because there are no A_x, D_x or D_y + extern float anchor_A_y, + anchor_A_z, + anchor_B_x, + anchor_B_y, + anchor_B_z, + anchor_C_x, + anchor_C_y, + anchor_C_z, + anchor_D_z, + delta_segments_per_second, + line_lengths_origin[ABCD]; + + void recalc_hangprinter_settings(); + + #define HANGPRINTER_IK(V) do { \ + line_lengths[A_AXIS] = SQRT(sq(anchor_A_z - V[Z_AXIS]) \ + + sq(anchor_A_y - V[Y_AXIS]) \ + + sq( V[X_AXIS])); \ + line_lengths[B_AXIS] = SQRT(sq(anchor_B_z - V[Z_AXIS]) \ + + sq(anchor_B_y - V[Y_AXIS]) \ + + sq(anchor_B_x - V[X_AXIS])); \ + line_lengths[C_AXIS] = SQRT(sq(anchor_C_z - V[Z_AXIS]) \ + + sq(anchor_C_y - V[Y_AXIS]) \ + + sq(anchor_C_x - V[X_AXIS])); \ + line_lengths[D_AXIS] = SQRT(sq( V[X_AXIS]) \ + + sq( V[Y_AXIS]) \ + + sq(anchor_D_z - V[Z_AXIS])); \ + }while(0) + + // Inverse kinematics at origin + #define HANGPRINTER_IK_ORIGIN(LL) do { \ + LL[A_AXIS] = SQRT(sq(anchor_A_z) \ + + sq(anchor_A_y)); \ + LL[B_AXIS] = SQRT(sq(anchor_B_z) \ + + sq(anchor_B_y) \ + + sq(anchor_B_x)); \ + LL[C_AXIS] = SQRT(sq(anchor_C_z) \ + + sq(anchor_C_y) \ + + sq(anchor_C_x)); \ + LL[D_AXIS] = anchor_D_z; \ + }while(0) + #elif IS_SCARA void forward_kinematics_SCARA(const float &a, const float &b); #endif @@ -506,6 +591,9 @@ void do_blocking_move_to_xy(const float &rx, const float &ry, const float &fr_mm inline bool position_is_reachable(const float &rx, const float &ry, const float inset=0) { #if ENABLED(DELTA) return HYPOT2(rx, ry) <= sq(DELTA_PRINTABLE_RADIUS - inset); + #elif ENABLED(HANGPRINTER) + // TODO: This is over simplified. Hangprinter's build volume is _not_ cylindrical. + return HYPOT2(rx, ry) <= sq(HANGPRINTER_PRINTABLE_RADIUS - inset); #elif IS_SCARA const float R2 = HYPOT2(rx - SCARA_OFFSET_X, ry - SCARA_OFFSET_Y); return ( diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index fba5180b4..6607f8305 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -51,6 +51,7 @@ * G3 - CCW ARC * G4 - Dwell S or P * G5 - Cubic B-spline with XYZE destination and IJPQ offsets + * G6 - Direct stepper move (Requires UNREGISTERED_MOVE_SUPPORT). Hangprinter defaults to relative moves. Others default to absolute moves. * G10 - Retract filament according to settings of M207 (Requires FWRETRACT) * G11 - Retract recover filament according to settings of M208 (Requires FWRETRACT) * G12 - Clean tool (Requires NOZZLE_CLEAN_FEATURE) @@ -72,6 +73,8 @@ * G90 - Use Absolute Coordinates * G91 - Use Relative Coordinates * G92 - Set current position to coordinates given + * G95 - Set torque mode (Requires MECHADUINO_I2C_COMMANDS enabled) + * G96 - Set encoder reference point (Requires MECHADUINO_I2C_COMMANDS enabled) * * "M" Codes * @@ -130,6 +133,7 @@ * M112 - Emergency stop. * M113 - Get or set the timeout interval for Host Keepalive "busy" messages. (Requires HOST_KEEPALIVE_FEATURE) * M114 - Report current position. + * - S1 Compute length traveled since last G96 using encoder position data (Requires MECHADUINO_I2C_COMMANDS, only kinematic axes) * M115 - Report capabilities. (Extended capabilities requires EXTENDED_CAPABILITIES_REPORT) * M117 - Display a message on the controller screen. (Requires an LCD) * M118 - Display a message in the host console. @@ -159,7 +163,7 @@ * M204 - Set default acceleration in units/sec^2: P R T * M205 - Set advanced settings. Current units apply: S T minimum speeds - B + Q X, Y, Z, E * M206 - Set additional homing offset. (Disabled by NO_WORKSPACE_OFFSETS or DELTA) * M207 - Set Retract Length: S, Feedrate: F, and Z lift: Z. (Requires FWRETRACT) @@ -206,7 +210,8 @@ * M600 - Pause for filament change: "M600 X Y Z E L". (Requires ADVANCED_PAUSE_FEATURE) * M603 - Configure filament change: "M603 T U L". (Requires ADVANCED_PAUSE_FEATURE) * M605 - Set Dual X-Carriage movement mode: "M605 S [X] [R]". (Requires DUAL_X_CARRIAGE) - * M665 - Set delta configurations: "M665 H L R S B X Y Z (Requires DELTA) + * M665 - Set Delta configurations: "M665 H L R S B X Y Z (Requires DELTA) + * M665 - Set Hangprinter configurations: "M665 W E R T Y U I O P S" (Requires HANGPRINTER) * M666 - Set/get endstop offsets for delta (Requires DELTA) or dual endstops (Requires [XYZ]_DUAL_ENDSTOPS). * M701 - Load filament (requires FILAMENT_LOAD_UNLOAD_GCODES) * M702 - Unload filament (requires FILAMENT_LOAD_UNLOAD_GCODES) @@ -437,12 +442,17 @@ static const char *injected_commands_P = NULL; * but the planner and stepper like mm/s units. */ static const float homing_feedrate_mm_s[] PROGMEM = { - #if ENABLED(DELTA) - MMM_TO_MMS(HOMING_FEEDRATE_Z), MMM_TO_MMS(HOMING_FEEDRATE_Z), + #if ENABLED(HANGPRINTER) + MMM_TO_MMS(DUMMY_HOMING_FEEDRATE), MMM_TO_MMS(DUMMY_HOMING_FEEDRATE), + MMM_TO_MMS(DUMMY_HOMING_FEEDRATE), MMM_TO_MMS(DUMMY_HOMING_FEEDRATE), 0 #else - MMM_TO_MMS(HOMING_FEEDRATE_XY), MMM_TO_MMS(HOMING_FEEDRATE_XY), + #if ENABLED(DELTA) + MMM_TO_MMS(HOMING_FEEDRATE_Z), MMM_TO_MMS(HOMING_FEEDRATE_Z), + #else + MMM_TO_MMS(HOMING_FEEDRATE_XY), MMM_TO_MMS(HOMING_FEEDRATE_XY), + #endif + MMM_TO_MMS(HOMING_FEEDRATE_Z), 0 #endif - MMM_TO_MMS(HOMING_FEEDRATE_Z), 0 }; FORCE_INLINE float homing_feedrate(const AxisEnum a) { return pgm_read_float(&homing_feedrate_mm_s[a]); } @@ -515,6 +525,13 @@ volatile bool wait_for_heatup = true; const char axis_codes[XYZE] = { 'X', 'Y', 'Z', 'E' }; +#if ENABLED(HANGPRINTER) + const char axis_codes_hangprinter[ABCDE] = { 'A', 'B', 'C', 'D', 'E' }; + #define RAW_AXIS_CODES(I) axis_codes_hangprinter[I] +#else + #define RAW_AXIS_CODES(I) axis_codes[I] +#endif + // Number of characters read in the current line of serial input static int serial_count; // = 0; @@ -617,6 +634,21 @@ uint8_t target_extruder; float delta_safe_distance_from_top(); +#elif ENABLED(HANGPRINTER) + + float anchor_A_y, + anchor_A_z, + anchor_B_x, + anchor_B_y, + anchor_B_z, + anchor_C_x, + anchor_C_y, + anchor_C_z, + anchor_D_z, + line_lengths[ABCD], + line_lengths_origin[ABCD], + delta_segments_per_second; + #endif #if ENABLED(AUTO_BED_LEVELING_BILINEAR) @@ -769,14 +801,18 @@ void report_current_position_detail(); * * Set the planner/stepper positions directly from current_position with * no kinematic translation. Used for homing axes and cartesian/core syncing. + * + * This is not possible for Hangprinter because current_position and position are different sizes */ void sync_plan_position() { - #if ENABLED(DEBUG_LEVELING_FEATURE) - if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position); + #if DISABLED(HANGPRINTER) + #if ENABLED(DEBUG_LEVELING_FEATURE) + if (DEBUGGING(LEVELING)) DEBUG_POS("sync_plan_position", current_position); + #endif + planner.set_position_mm(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART]); #endif - planner.set_position_mm(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); } -void sync_plan_position_e() { planner.set_e_position_mm(current_position[E_AXIS]); } +void sync_plan_position_e() { planner.set_e_position_mm(current_position[E_CART]); } #if IS_KINEMATIC inline void sync_plan_position_kinematic() { @@ -1553,9 +1589,13 @@ inline float get_homing_bump_feedrate(const AxisEnum axis) { /** * Move the planner to the current position from wherever it last moved * (or from wherever it has been told it is located). + * + * Impossible on Hangprinter because current_position and position are of different sizes */ inline void buffer_line_to_current_position() { - planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate_mm_s, active_extruder); + #if DISABLED(HANGPRINTER) // emptying this function probably breaks do_blocking_move_to() + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART], feedrate_mm_s, active_extruder); + #endif } /** @@ -1563,7 +1603,11 @@ inline void buffer_line_to_current_position() { * used by G0/G1/G2/G3/G5 and many other functions to set a destination. */ inline void buffer_line_to_destination(const float &fr_mm_s) { - planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], fr_mm_s, active_extruder); + #if ENABLED(HANGPRINTER) + UNUSED(fr_mm_s); + #else + planner.buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_CART], fr_mm_s, active_extruder); + #endif } #if IS_KINEMATIC @@ -1582,7 +1626,7 @@ inline void buffer_line_to_destination(const float &fr_mm_s) { if ( current_position[X_AXIS] == destination[X_AXIS] && current_position[Y_AXIS] == destination[Y_AXIS] && current_position[Z_AXIS] == destination[Z_AXIS] - && current_position[E_AXIS] == destination[E_AXIS] + && current_position[E_CART] == destination[E_CART] ) return; planner.buffer_line_kinematic(destination, MMS_SCALED(fr_mm_s ? fr_mm_s : feedrate_mm_s), active_extruder); @@ -2987,11 +3031,16 @@ static void do_homing_move(const AxisEnum axis, const float distance, const floa SYNC_PLAN_POSITION_KINEMATIC(); current_position[axis] = distance; inverse_kinematics(current_position); - planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], current_position[E_AXIS], fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder); + planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], current_position[E_CART], fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder); + #elif ENABLED(HANGPRINTER) // TODO: Hangprinter homing is not finished (Jan 7, 2018) + SYNC_PLAN_POSITION_KINEMATIC(); + current_position[axis] = distance; + inverse_kinematics(current_position); + planner.buffer_line(line_lengths[A_AXIS], line_lengths[B_AXIS], line_lengths[C_AXIS], line_lengths[D_AXIS], current_position[E_CART], fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder); #else sync_plan_position(); current_position[axis] = distance; // Set delta/cartesian axes directly - planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder); + planner.buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART], fr_mm_s ? fr_mm_s : homing_feedrate(axis), active_extruder); #endif planner.synchronize(); @@ -3285,7 +3334,7 @@ void gcode_get_destination() { const float v = parser.value_axis_units((AxisEnum)i); destination[i] = (axis_relative_modes[i] || relative_mode) ? current_position[i] + v - : (i == E_AXIS) ? v : LOGICAL_TO_NATIVE(v, i); + : (i == E_CART) ? v : LOGICAL_TO_NATIVE(v, i); } else destination[i] = current_position[i]; @@ -3296,7 +3345,7 @@ void gcode_get_destination() { #if ENABLED(PRINTCOUNTER) if (!DEBUGGING(DRYRUN)) - print_job_timer.incFilamentUsed(destination[E_AXIS] - current_position[E_AXIS]); + print_job_timer.incFilamentUsed(destination[E_CART] - current_position[E_CART]); #endif // Get ABCDHI mixing factors @@ -3364,10 +3413,10 @@ inline void gcode_G0_G1( if (MIN_AUTORETRACT <= MAX_AUTORETRACT) { // When M209 Autoretract is enabled, convert E-only moves to firmware retract/prime moves if (fwretract.autoretract_enabled && parser.seen('E') && !(parser.seen('X') || parser.seen('Y') || parser.seen('Z'))) { - const float echange = destination[E_AXIS] - current_position[E_AXIS]; + const float echange = destination[E_CART] - current_position[E_CART]; // Is this a retract or prime move? if (WITHIN(ABS(echange), MIN_AUTORETRACT, MAX_AUTORETRACT) && fwretract.retracted[active_extruder] == (echange > 0.0)) { - current_position[E_AXIS] = destination[E_AXIS]; // Hide a G1-based retract/prime from calculations + current_position[E_CART] = destination[E_CART]; // Hide a G1-based retract/prime from calculations sync_plan_position_e(); // AND from the planner return fwretract.retract(echange < 0.0); // Firmware-based retract/prime (double-retract ignored) } @@ -3555,6 +3604,74 @@ inline void gcode_G4() { #endif // BEZIER_CURVE_SUPPORT +#if ENABLED(UNREGISTERED_MOVE_SUPPORT) + + /** + * G6 implementation for Hangprinter based on + * http://reprap.org/wiki/GCodes#G6:_Direct_Stepper_Move + * Accessed Jan 8, 2018 + * + * G6 is used frequently to tighten lines with Hangprinter, so Hangprinter default is relative moves. + * Hangprinter uses switches + * S1 for absolute moves + * S2 for saving recording new line length after unregistered move + * (typically used while tuning LINE_BUILDUP_COMPENSATION_FEATURE parameters) + */ + + /** + * G6: Direct Stepper Move + */ + inline void gcode_G6() { + bool count_it = false; + #if ENABLED(NO_MOTION_BEFORE_HOMING) + if (axis_unhomed_error()) return; + #endif + if (IsRunning()) { + float go[MOV_AXIS] = { 0.0 }, + tmp_fr_mm_s = 0.0; + + LOOP_MOV_AXIS(i) + if (parser.seen(RAW_AXIS_CODES(i))) + go[i] = parser.value_axis_units((AxisEnum)i); + + #if ENABLED(HANGPRINTER) + #define GO_SRC line_lengths + #elif ENABLED(DELTA) + #define GO_SRC delta + #else + #define GO_SRC current_position + #endif + + if ( + #if ENABLED(HANGPRINTER) // Sending R to another machine is the same as not sending S1 to Hangprinter + parser.byteval('S') != 2 + #else + parser.seen('R') + #endif + ) + LOOP_MOV_AXIS(i) go[i] += GO_SRC[i]; + else + LOOP_MOV_AXIS(i) if (!parser.seen(RAW_AXIS_CODES(i))) go[i] += GO_SRC[i]; + + tmp_fr_mm_s = parser.linearval('F') > 0.0 ? MMM_TO_MMS(parser.value_feedrate()) : feedrate_mm_s; + + #if ENABLED(HANGPRINTER) + if (parser.byteval('S') == 2) { + LOOP_MOV_AXIS(i) line_lengths[i] = go[i]; + count_it = true; + } + #endif + + planner.buffer_segment(go[A_AXIS], go[B_AXIS], go[C_AXIS] + #if ENABLED(HANGPRINTER) + , go[D_AXIS] + #endif + , current_position[E_CART], tmp_fr_mm_s, active_extruder, 0.0, count_it + ); + } + } +#endif + #if ENABLED(FWRETRACT) /** @@ -3967,7 +4084,15 @@ inline void gcode_G4() { #endif } -#endif // DELTA +#elif ENABLED(HANGPRINTER) + /** + * A hangprinter cannot home itself + */ + inline void home_hangprinter() { + SERIAL_ECHOLNPGM("Warning: G28 is not implemented for Hangprinter."); + } + +#endif #ifdef Z_AFTER_PROBING void move_z_after_probing() { @@ -4145,7 +4270,12 @@ inline void gcode_G28(const bool always_home_all) { home_delta(); UNUSED(always_home_all); - #else // NOT DELTA + #elif ENABLED(HANGPRINTER) + + home_hangprinter(); + UNUSED(always_home_all); + + #else // NOT Delta or Hangprinter const bool homeX = always_home_all || parser.seen('X'), homeY = always_home_all || parser.seen('Y'), @@ -6361,7 +6491,7 @@ inline void gcode_G92() { #endif bool didE = false; - #if IS_SCARA || !HAS_POSITION_SHIFT + #if IS_SCARA || !HAS_POSITION_SHIFT || ENABLED(HANGPRINTER) bool didXYZ = false; #else constexpr bool didXYZ = false; @@ -6370,16 +6500,20 @@ inline void gcode_G92() { if (IS_G92_0) LOOP_XYZE(i) { if (parser.seenval(axis_codes[i])) { const float l = parser.value_axis_units((AxisEnum)i), - v = i == E_AXIS ? l : LOGICAL_TO_NATIVE(l, i), + v = i == E_CART ? l : LOGICAL_TO_NATIVE(l, i), d = v - current_position[i]; - if (!NEAR_ZERO(d)) { - #if IS_SCARA || !HAS_POSITION_SHIFT - if (i == E_AXIS) didE = true; else didXYZ = true; + if (!NEAR_ZERO(d) + #if ENABLED(HANGPRINTER) + || true // Hangprinter needs to update its line lengths whether current_position changed or not + #endif + ) { + #if IS_SCARA || !HAS_POSITION_SHIFT || ENABLED(HANGPRINTER) + if (i == E_CART) didE = true; else didXYZ = true; current_position[i] = v; // Without workspaces revert to Marlin 1.0 behavior #elif HAS_POSITION_SHIFT - if (i == E_AXIS) { + if (i == E_CART) { didE = true; - current_position[E_AXIS] = v; // When using coordinate spaces, only E is set directly + current_position[E_CART] = v; // When using coordinate spaces, only E is set directly } else { position_shift[i] += d; // Other axes simply offset the coordinate space @@ -6403,6 +6537,184 @@ inline void gcode_G92() { report_current_position(); } +#if ENABLED(MECHADUINO_I2C_COMMANDS) + /** + * G95: Set torque mode + */ + inline void gcode_G95() { + i2cFloat torques[NUM_AXIS]; // Assumes 4-byte floats here and in Mechaduino firmware + LOOP_NUM_AXIS(i) + torques[i].fval = parser.floatval(RAW_AXIS_CODES(i), 999.9); // 999.9 chosen to satisfy fabs(999.9) > 255.0 + + // 0x5f == 95 + #define G95_SEND(LETTER) do { \ + if (fabs(torques[_AXIS(LETTER)].fval) < 255.0){ \ + torques[_AXIS(LETTER)].fval = -fabs(torques[_AXIS(LETTER)].fval); \ + if(!INVERT_##LETTER##_DIR) torques[_AXIS(LETTER)].fval = -torques[_AXIS(LETTER)].fval; \ + i2c.address(LETTER##_MOTOR_I2C_ADDR); \ + i2c.reset(); \ + i2c.addbyte(0x5f); \ + i2c.addbytes(torques[_AXIS(LETTER)].bval, sizeof(float)); \ + i2c.send(); \ + }} while(0) + + #if ENABLED(HANGPRINTER) + #if ENABLED(A_IS_MECHADUINO) + G95_SEND(A); + #endif + #if ENABLED(B_IS_MECHADUINO) + G95_SEND(B); + #endif + #if ENABLED(C_IS_MECHADUINO) + G95_SEND(C); + #endif + #if ENABLED(D_IS_MECHADUINO) + G95_SEND(D); + #endif + #else + #if ENABLED(X_IS_MECHADUINO) + G95_SEND(X); + #endif + #if ENABLED(Y_IS_MECHADUINO) + G95_SEND(Y); + #endif + #if ENABLED(Z_IS_MECHADUINO) + G95_SEND(Z); + #endif + #endif + #if ENABLED(E_IS_MECHADUINO) + G95_SEND(E); + #endif + } + + /** + * G96: Mark encoder reference point + */ + inline void gcode_G96() { + bool mark[NUM_AXIS] = { false }; + if (!parser.seen_any()) + LOOP_NUM_AXIS(i) + mark[i] = true; + else + LOOP_NUM_AXIS(i) + if (parser.seen(RAW_AXIS_CODES(i))) + mark[i] = true; + + // 0x60 == 96 + #define G96_SEND(LETTER) do {\ + if (mark[LETTER##_AXIS]){ \ + i2c.address(LETTER##_MOTOR_I2C_ADDR); \ + i2c.reset(); \ + i2c.addbyte(0x60); \ + i2c.send(); \ + }} while(0) + + #if ENABLED(HANGPRINTER) + #if ENABLED(A_IS_MECHADUINO) + G96_SEND(A); + #endif + #if ENABLED(B_IS_MECHADUINO) + G96_SEND(B); + #endif + #if ENABLED(C_IS_MECHADUINO) + G96_SEND(C); + #endif + #if ENABLED(D_IS_MECHADUINO) + G96_SEND(D); + #endif + #else + #if ENABLED(X_IS_MECHADUINO) + G96_SEND(X); + #endif + #if ENABLED(Y_IS_MECHADUINO) + G96_SEND(Y); + #endif + #if ENABLED(Z_IS_MECHADUINO) + G96_SEND(Z); + #endif + #endif + #if ENABLED(E_IS_MECHADUINO) + G96_SEND(E); // E ref point not used by any other commands (Feb 7, 2018) + #endif + } + + float ang_to_mm(float ang, const AxisEnum axis) { + const float abs_step_in_origin = + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + planner.k0[axis] * (SQRT(planner.k1[axis] + planner.k2[axis] * line_lengths_origin[axis]) - planner.sqrtk1[axis]) + #else + line_lengths_origin[axis] * planner.axis_steps_per_mm[axis] + #endif + ; + const float c = abs_step_in_origin + ang * float(STEPS_PER_MOTOR_REVOLUTION) / 360.0; // current step count + return + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + // Inverse function found in planner.cpp, where target[AXIS_A] is calculated + ((c / planner.k0[axis] + planner.sqrtk1[axis]) * (c / planner.k0[axis] + planner.sqrtk1[axis]) - planner.k1[axis]) / planner.k2[axis] - line_lengths_origin[axis] + #else + c / planner.axis_steps_per_mm[axis] - line_lengths_origin[axis] + #endif + ; + } + + void report_axis_position_from_encoder_data() { + i2cFloat ang; + + #define M114_S1_RECEIVE(LETTER) do { \ + i2c.address(LETTER##_MOTOR_I2C_ADDR); \ + i2c.request(sizeof(float)); \ + i2c.capture(ang.bval, sizeof(float)); \ + if(LETTER##_INVERT_REPORTED_ANGLE == INVERT_##LETTER##_DIR) ang.fval = -ang.fval; \ + SERIAL_PROTOCOL(ang_to_mm(ang.fval, LETTER##_AXIS)); \ + } while(0) + + SERIAL_CHAR('['); + #if ENABLED(HANGPRINTER) + #if ENABLED(A_IS_MECHADUINO) + M114_S1_RECEIVE(A); + #endif + #if ENABLED(B_IS_MECHADUINO) + SERIAL_PROTOCOLPGM(", "); + M114_S1_RECEIVE(B); + #endif + #if ENABLED(C_IS_MECHADUINO) + SERIAL_PROTOCOLPGM(", "); + M114_S1_RECEIVE(C); + #endif + #if ENABLED(D_IS_MECHADUINO) + SERIAL_PROTOCOLPGM(", "); + M114_S1_RECEIVE(D); + #endif + #else + #if ENABLED(X_IS_MECHADUINO) + M114_S1_RECEIVE(X); + #endif + #if ENABLED(Y_IS_MECHADUINO) + SERIAL_PROTOCOLPGM(", "); + M114_S1_RECEIVE(Y); + #endif + #if ENABLED(Z_IS_MECHADUINO) + SERIAL_PROTOCOLPGM(", "); + M114_S1_RECEIVE(Z); + #endif + #endif + SERIAL_CHAR(']'); + SERIAL_EOL(); + } + +#endif // MECHADUINO_I2C_COMMANDS + + +void report_xyz_from_stepper_position() { + get_cartesian_from_steppers(); // writes to cartes[XYZ] + SERIAL_CHAR('['); + SERIAL_PROTOCOL(cartes[X_AXIS]); + SERIAL_PROTOCOLPAIR(", ", cartes[Y_AXIS]); + SERIAL_PROTOCOLPAIR(", ", cartes[Z_AXIS]); + SERIAL_CHAR(']'); + SERIAL_EOL(); +} + #if HAS_RESUME_CONTINUE /** @@ -6598,7 +6910,7 @@ inline void gcode_M17() { void do_pause_e_move(const float &length, const float &fr) { set_destination_from_current(); - destination[E_AXIS] += length / planner.e_factor[active_extruder]; + destination[E_CART] += length / planner.e_factor[active_extruder]; planner.buffer_line_kinematic(destination, fr, active_extruder); set_current_from_destination(); planner.synchronize(); @@ -7049,7 +7361,7 @@ inline void gcode_M17() { #endif // If resume_position is negative - if (resume_position[E_AXIS] < 0) do_pause_e_move(resume_position[E_AXIS], PAUSE_PARK_RETRACT_FEEDRATE); + if (resume_position[E_CART] < 0) do_pause_e_move(resume_position[E_CART], PAUSE_PARK_RETRACT_FEEDRATE); // Move XY to starting position, then Z do_blocking_move_to_xy(resume_position[X_AXIS], resume_position[Y_AXIS], NOZZLE_PARK_XY_FEEDRATE); @@ -7059,7 +7371,7 @@ inline void gcode_M17() { // Now all extrusion positions are resumed and ready to be confirmed // Set extruder to saved position - planner.set_e_position_mm((destination[E_AXIS] = current_position[E_AXIS] = resume_position[E_AXIS])); + planner.set_e_position_mm((destination[E_CART] = current_position[E_CART] = resume_position[E_CART])); #if ENABLED(FILAMENT_RUNOUT_SENSOR) runout.reset(); @@ -8614,12 +8926,12 @@ inline void gcode_M81() { /** * M82: Set E codes absolute (default) */ -inline void gcode_M82() { axis_relative_modes[E_AXIS] = false; } +inline void gcode_M82() { axis_relative_modes[E_CART] = false; } /** * M83: Set E codes relative while in Absolute Coordinates (G90) mode */ -inline void gcode_M83() { axis_relative_modes[E_AXIS] = true; } +inline void gcode_M83() { axis_relative_modes[E_CART] = true; } /** * M18, M84: Disable stepper motors @@ -8669,20 +8981,20 @@ inline void gcode_M85() { /** * M92: Set axis steps-per-unit for one or more axes, X, Y, Z, and E. + * (for Hangprinter: A, B, C, D, and E) * (Follows the same syntax as G92) * * With multiple extruders use T to specify which one. */ inline void gcode_M92() { - GET_TARGET_EXTRUDER(92); - LOOP_XYZE(i) { - if (parser.seen(axis_codes[i])) { + LOOP_NUM_AXIS(i) { + if (parser.seen(RAW_AXIS_CODES(i))) { if (i == E_AXIS) { const float value = parser.value_per_axis_unit((AxisEnum)(E_AXIS + TARGET_EXTRUDER)); if (value < 20) { - float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab. + const float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab. #if DISABLED(JUNCTION_DEVIATION) planner.max_jerk[E_AXIS] *= factor; #endif @@ -8692,6 +9004,11 @@ inline void gcode_M92() { planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] = value; } else { + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + SERIAL_ECHOLNPGM("Warning: " + "M92 A, B, C, and D only affect acceleration planning " + "when BUILDUP_COMPENSATION_FEATURE is enabled."); + #endif planner.axis_steps_per_mm[i] = parser.value_per_axis_unit((AxisEnum)i); } } @@ -8703,14 +9020,18 @@ inline void gcode_M92() { * Output the current position to serial */ void report_current_position() { - SERIAL_PROTOCOLPGM("X:"); - SERIAL_PROTOCOL(LOGICAL_X_POSITION(current_position[X_AXIS])); - SERIAL_PROTOCOLPGM(" Y:"); - SERIAL_PROTOCOL(LOGICAL_Y_POSITION(current_position[Y_AXIS])); - SERIAL_PROTOCOLPGM(" Z:"); - SERIAL_PROTOCOL(LOGICAL_Z_POSITION(current_position[Z_AXIS])); - SERIAL_PROTOCOLPGM(" E:"); - SERIAL_PROTOCOL(current_position[E_AXIS]); + SERIAL_PROTOCOLPAIR("X:", LOGICAL_X_POSITION(current_position[X_AXIS])); + SERIAL_PROTOCOLPAIR(" Y:", LOGICAL_Y_POSITION(current_position[Y_AXIS])); + SERIAL_PROTOCOLPAIR(" Z:", LOGICAL_Z_POSITION(current_position[Z_AXIS])); + SERIAL_PROTOCOLPAIR(" E:", current_position[E_CART]); + + #if ENABLED(HANGPRINTER) + SERIAL_EOL(); + SERIAL_PROTOCOLPAIR("A:", line_lengths[A_AXIS]); + SERIAL_PROTOCOLPAIR(" B:", line_lengths[B_AXIS]); + SERIAL_PROTOCOLPAIR(" C:", line_lengths[C_AXIS]); + SERIAL_PROTOCOLLNPAIR(" D:", line_lengths[D_AXIS]); + #endif stepper.report_positions(); @@ -8775,9 +9096,9 @@ void report_current_position() { planner.synchronize(); SERIAL_PROTOCOLPGM("Stepper:"); - LOOP_XYZE(i) { + LOOP_NUM_AXIS(i) { SERIAL_CHAR(' '); - SERIAL_CHAR(axis_codes[i]); + SERIAL_CHAR(RAW_AXIS_CODES(i)); SERIAL_CHAR(':'); SERIAL_PROTOCOL(stepper.position((AxisEnum)i)); } @@ -8801,7 +9122,7 @@ void report_current_position() { from_steppers[X_AXIS] - leveled[X_AXIS], from_steppers[Y_AXIS] - leveled[Y_AXIS], from_steppers[Z_AXIS] - leveled[Z_AXIS], - from_steppers[E_AXIS] - current_position[E_AXIS] + from_steppers[E_CART] - current_position[E_CART] }; SERIAL_PROTOCOLPGM("Differ: "); report_xyze(diff); @@ -8814,13 +9135,19 @@ void report_current_position() { inline void gcode_M114() { #ifdef M114_DETAIL - if (parser.seen('D')) { - report_current_position_detail(); - return; - } + if (parser.seen('D')) return report_current_position_detail(); #endif planner.synchronize(); + + const uint16_t sval = parser.ushortval('S'); + + #if ENABLED(MECHADUINO_I2C_COMMANDS) + if (sval == 1) return report_axis_position_from_encoder_data(); + #endif + + if (sval == 2) return report_xyz_from_stepper_position(); + report_current_position(); } @@ -9116,8 +9443,8 @@ inline void gcode_M201() { GET_TARGET_EXTRUDER(201); - LOOP_XYZE(i) { - if (parser.seen(axis_codes[i])) { + LOOP_NUM_AXIS(i) { + if (parser.seen(RAW_AXIS_CODES(i))) { const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0); planner.max_acceleration_mm_per_s2[a] = parser.value_axis_units((AxisEnum)a); } @@ -9144,8 +9471,8 @@ inline void gcode_M203() { GET_TARGET_EXTRUDER(203); - LOOP_XYZE(i) - if (parser.seen(axis_codes[i])) { + LOOP_NUM_AXIS(i) + if (parser.seen(RAW_AXIS_CODES(i))) { const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0); planner.max_feedrate_mm_s[a] = parser.value_axis_units((AxisEnum)a); } @@ -9186,7 +9513,7 @@ inline void gcode_M204() { /** * M205: Set Advanced Settings * - * B = Min Segment Time (µs) + * Q = Min Segment Time (µs) * S = Min Feed Rate (units/s) * T = Min Travel Feed Rate (units/s) * X = Max X Jerk (units/sec^2) @@ -9196,7 +9523,7 @@ inline void gcode_M204() { * J = Junction Deviation (mm) (Requires JUNCTION_DEVIATION) */ inline void gcode_M205() { - if (parser.seen('B')) planner.min_segment_time_us = parser.value_ulong(); + if (parser.seen('Q')) planner.min_segment_time_us = parser.value_ulong(); if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units(); if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units(); #if ENABLED(JUNCTION_DEVIATION) @@ -9212,15 +9539,22 @@ inline void gcode_M205() { } } #else - if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units(); - if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units(); - if (parser.seen('Z')) { - planner.max_jerk[Z_AXIS] = parser.value_linear_units(); - #if HAS_MESH - if (planner.max_jerk[Z_AXIS] <= 0.1f) - SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses."); - #endif - } + #if ENABLED(HANGPRINTER) + if (parser.seen('A')) planner.max_jerk[A_AXIS] = parser.value_linear_units(); + if (parser.seen('B')) planner.max_jerk[B_AXIS] = parser.value_linear_units(); + if (parser.seen('C')) planner.max_jerk[C_AXIS] = parser.value_linear_units(); + if (parser.seen('D')) planner.max_jerk[D_AXIS] = parser.value_linear_units(); + #else + if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units(); + if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units(); + if (parser.seen('Z')) { + planner.max_jerk[Z_AXIS] = parser.value_linear_units(); + #if HAS_MESH + if (planner.max_jerk[Z_AXIS] <= 0.1f) + SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses."); + #endif + } + #endif if (parser.seen('E')) planner.max_jerk[E_AXIS] = parser.value_linear_units(); #endif } @@ -9339,6 +9673,42 @@ inline void gcode_M205() { } } +#elif ENABLED(HANGPRINTER) + /** + * M665: Set HANGPRINTER settings + * + * Parameters: + * + * W[anchor_A_y] - A-anchor's y coordinate (see note) + * E[anchor_A_z] - A-anchor's z coordinate (see note) + * R[anchor_B_x] - B-anchor's x coordinate (see note) + * T[anchor_B_y] - B-anchor's y coordinate (see note) + * Y[anchor_B_z] - B-anchor's z coordinate (see note) + * U[anchor_C_x] - C-anchor's x coordinate (see note) + * I[anchor_C_y] - C-anchor's y coordinate (see note) + * O[anchor_C_z] - C-anchor's z coordinate (see note) + * P[anchor_D_z] - D-anchor's z coordinate (see note) + * S[segments-per-second] - Segments-per-second + * + * Note: All xyz coordinates are measured relative to the line's pivot point in the mover, + * when it is at its home position (nozzle in (0,0,0), and lines tight). + * The y-axis is defined to be horizontal right above/below the A-lines when mover is at home. + * The z-axis is along the vertical direction. + */ + inline void gcode_M665() { + if (parser.seen('W')) anchor_A_y = parser.value_float(); + if (parser.seen('E')) anchor_A_z = parser.value_float(); + if (parser.seen('R')) anchor_B_x = parser.value_float(); + if (parser.seen('T')) anchor_B_y = parser.value_float(); + if (parser.seen('Y')) anchor_B_z = parser.value_float(); + if (parser.seen('U')) anchor_C_x = parser.value_float(); + if (parser.seen('I')) anchor_C_y = parser.value_float(); + if (parser.seen('O')) anchor_C_z = parser.value_float(); + if (parser.seen('P')) anchor_D_z = parser.value_float(); + if (parser.seen('S')) delta_segments_per_second = parser.value_float(); + recalc_hangprinter_settings(); + } + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) /** @@ -10995,6 +11365,7 @@ inline void gcode_M502() { /** * M906: Set motor current in milliamps using axis codes X, Y, Z, E + * Uses axis codes A, B, C, D, E for Hangprinter * Report driver currents when no axis specified */ inline void gcode_M906() { @@ -11003,9 +11374,11 @@ inline void gcode_M502() { bool report = true; const uint8_t index = parser.byteval('I'); - LOOP_XYZE(i) if (uint16_t value = parser.intval(axis_codes[i])) { + LOOP_NUM_AXIS(i) if (uint16_t value = parser.intval(RAW_AXIS_CODES(i))) { + report = false; switch (i) { + // Assumes {A_AXIS, B_AXIS, C_AXIS} == {X_AXIS, Y_AXIS, Z_AXIS} case X_AXIS: #if AXIS_IS_TMC(X) if (index < 2) TMC_SET_CURRENT(X); @@ -11036,20 +11409,52 @@ inline void gcode_M502() { #if AXIS_IS_TMC(E0) case 0: TMC_SET_CURRENT(E0); break; #endif - #if AXIS_IS_TMC(E1) - case 1: TMC_SET_CURRENT(E1); break; - #endif - #if AXIS_IS_TMC(E2) - case 2: TMC_SET_CURRENT(E2); break; - #endif - #if AXIS_IS_TMC(E3) - case 3: TMC_SET_CURRENT(E3); break; - #endif - #if AXIS_IS_TMC(E4) - case 4: TMC_SET_CURRENT(E4); break; + #if ENABLED(HANGPRINTER) + // Avoid setting the D-current + #if AXIS_IS_TMC(E1) && EXTRUDERS > 1 + case 1: TMC_SET_CURRENT(E1); break; + #endif + #if AXIS_IS_TMC(E2) && EXTRUDERS > 2 + case 2: TMC_SET_CURRENT(E2); break; + #endif + #if AXIS_IS_TMC(E3) && EXTRUDERS > 3 + case 3: TMC_SET_CURRENT(E3); break; + #endif + #if AXIS_IS_TMC(E4) && EXTRUDERS > 4 + case 4: TMC_SET_CURRENT(E4); break; + #endif + #else + #if AXIS_IS_TMC(E1) + case 1: TMC_SET_CURRENT(E1); break; + #endif + #if AXIS_IS_TMC(E2) + case 2: TMC_SET_CURRENT(E2); break; + #endif + #if AXIS_IS_TMC(E3) + case 3: TMC_SET_CURRENT(E3); break; + #endif + #if AXIS_IS_TMC(E4) + case 4: TMC_SET_CURRENT(E4); break; + #endif #endif } } break; + #if ENABLED(HANGPRINTER) + case D_AXIS: + // D is connected on the first of E1, E2, E3, E4 output that is not an extruder + #if AXIS_IS_TMC(E1) && EXTRUDERS == 1 + TMC_SET_CURRENT(E1); break; + #endif + #if AXIS_IS_TMC(E2) && EXTRUDERS == 2 + TMC_SET_CURRENT(E2); break; + #endif + #if AXIS_IS_TMC(E3) && EXTRUDERS == 3 + TMC_SET_CURRENT(E3); break; + #endif + #if AXIS_IS_TMC(E4) && EXTRUDERS == 4 + TMC_SET_CURRENT(E4); break; + #endif + #endif } } @@ -11075,17 +11480,33 @@ inline void gcode_M502() { #if AXIS_IS_TMC(E0) TMC_SAY_CURRENT(E0); #endif - #if AXIS_IS_TMC(E1) - TMC_SAY_CURRENT(E1); - #endif - #if AXIS_IS_TMC(E2) - TMC_SAY_CURRENT(E2); - #endif - #if AXIS_IS_TMC(E3) - TMC_SAY_CURRENT(E3); - #endif - #if AXIS_IS_TMC(E4) - TMC_SAY_CURRENT(E4); + #if ENABLED(HANGPRINTER) + // D is connected on the first of E1, E2, E3, E4 output that is not an extruder + #if AXIS_IS_TMC(E1) && EXTRUDERS == 1 + TMC_SAY_CURRENT(E1); + #endif + #if AXIS_IS_TMC(E2) && EXTRUDERS == 2 + TMC_SAY_CURRENT(E2); + #endif + #if AXIS_IS_TMC(E3) && EXTRUDERS == 3 + TMC_SAY_CURRENT(E3); + #endif + #if AXIS_IS_TMC(E4) && EXTRUDERS == 4 + TMC_SAY_CURRENT(E4); + #endif + #else + #if AXIS_IS_TMC(E1) + TMC_SAY_CURRENT(E1); + #endif + #if AXIS_IS_TMC(E2) + TMC_SAY_CURRENT(E2); + #endif + #if AXIS_IS_TMC(E3) + TMC_SAY_CURRENT(E3); + #endif + #if AXIS_IS_TMC(E4) + TMC_SAY_CURRENT(E4); + #endif #endif } } @@ -11149,7 +11570,7 @@ inline void gcode_M502() { const bool hasX = parser.seen(axis_codes[X_AXIS]), hasY = parser.seen(axis_codes[Y_AXIS]), hasZ = parser.seen(axis_codes[Z_AXIS]), - hasE = parser.seen(axis_codes[E_AXIS]), + hasE = parser.seen(axis_codes[E_CART]), hasNone = !hasX && !hasY && !hasZ && !hasE; #if M91x_USE(X) || M91x_USE(X2) @@ -11182,6 +11603,7 @@ inline void gcode_M502() { #endif #endif + // TODO: If this is a Hangprinter, E_AXIS will not correspond to E0, E1, etc in this way #if M91x_USE_E(0) || M91x_USE_E(1) || M91x_USE_E(2) || M91x_USE_E(3) || M91x_USE_E(4) const uint8_t eval = parser.byteval(axis_codes[E_AXIS], 10); #if M91x_USE_E(0) @@ -11241,7 +11663,7 @@ inline void gcode_M502() { if (!(index & 1)) TMC_SET_PWMTHRS(Z,Z2); #endif break; - case E_AXIS: { + case E_CART: { if (get_target_extruder_from_command(913)) return; switch (target_extruder) { #if AXIS_HAS_STEALTHCHOP(E0) @@ -11817,7 +12239,7 @@ inline void invalid_extruder_error(const uint8_t e) { i == 0 ? current_position[X_AXIS] : xhome, current_position[Y_AXIS], i == 2 ? current_position[Z_AXIS] : raised_z, - current_position[E_AXIS], + current_position[E_CART], planner.max_feedrate_mm_s[i == 1 ? X_AXIS : Z_AXIS], active_extruder ); @@ -12238,6 +12660,10 @@ void process_parsed_command() { case 5: gcode_G5(); break; // G5: Cubic B_spline #endif + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + case 6: gcode_G6(); break; // G6: Direct stepper move + #endif + #if ENABLED(FWRETRACT) case 10: gcode_G10(); break; // G10: Retract case 11: gcode_G11(); break; // G11: Prime @@ -12300,6 +12726,10 @@ void process_parsed_command() { case 91: relative_mode = true; break; // G91: Relative coordinates case 92: gcode_G92(); break; // G92: Set Position + #if ENABLED(MECHADUINO_I2C_COMMANDS) + case 95: gcode_G95(); break; // G95: Set torque mode + case 96: gcode_G96(); break; // G96: Mark encoder reference point + #endif #if ENABLED(DEBUG_GCODE_PARSER) case 800: parser.debug(); break; // G800: GCode Parser Test for G @@ -12595,8 +13025,8 @@ void process_parsed_command() { case 605: gcode_M605(); break; // M605: Set Dual X Carriage movement mode #endif - #if ENABLED(DELTA) - case 665: gcode_M665(); break; // M665: Delta Configuration + #if ENABLED(DELTA) || ENABLED(HANGPRINTER) + case 665: gcode_M665(); break; // M665: Delta / Hangprinter Configuration #endif #if ENABLED(DELTA) || ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) case 666: gcode_M666(); break; // M666: DELTA/Dual Endstop Adjustment @@ -13047,6 +13477,115 @@ void ok_to_send() { #endif // DELTA +#if ENABLED(HANGPRINTER) + + /** + * Recalculate factors used for hangprinter kinematics whenever + * settings have been changed (e.g., by M665). + */ + void recalc_hangprinter_settings(){ + HANGPRINTER_IK_ORIGIN(line_lengths_origin); + + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + + const uint8_t mech_adv_tmp[MOV_AXIS] = MECHANICAL_ADVANTAGE, + actn_pts_tmp[MOV_AXIS] = ACTION_POINTS; + const uint16_t m_g_t_tmp[MOV_AXIS] = MOTOR_GEAR_TEETH, + s_g_t_tmp[MOV_AXIS] = SPOOL_GEAR_TEETH; + const float mnt_l_tmp[MOV_AXIS] = MOUNTED_LINE; + float s_r2_tmp[MOV_AXIS] = SPOOL_RADII, + steps_per_unit_times_r_tmp[MOV_AXIS]; + uint8_t nr_lines_dir_tmp[MOV_AXIS]; + + LOOP_MOV_AXIS(i){ + steps_per_unit_times_r_tmp[i] = (float(mech_adv_tmp[i])*STEPS_PER_MOTOR_REVOLUTION*s_g_t_tmp[i])/(2*M_PI*m_g_t_tmp[i]); + nr_lines_dir_tmp[i] = mech_adv_tmp[i]*actn_pts_tmp[i]; + s_r2_tmp[i] *= s_r2_tmp[i]; + planner.k2[i] = -(float)nr_lines_dir_tmp[i]*SPOOL_BUILDUP_FACTOR; + planner.k0[i] = 2.0*steps_per_unit_times_r_tmp[i]/planner.k2[i]; + } + + // Assumes spools are mounted near D-anchor in ceiling + #define HYP3D(x,y,z) SQRT(sq(x) + sq(y) + sq(z)) + float line_on_spool_origin_tmp[MOV_AXIS]; + line_on_spool_origin_tmp[A_AXIS] = actn_pts_tmp[A_AXIS] * mnt_l_tmp[A_AXIS] + - actn_pts_tmp[A_AXIS] * HYPOT(anchor_A_y, anchor_D_z - anchor_A_z) + - nr_lines_dir_tmp[A_AXIS] * line_lengths_origin[A_AXIS]; + line_on_spool_origin_tmp[B_AXIS] = actn_pts_tmp[B_AXIS] * mnt_l_tmp[B_AXIS] + - actn_pts_tmp[B_AXIS] * HYP3D(anchor_B_x, anchor_B_y, anchor_D_z - anchor_B_z) + - nr_lines_dir_tmp[B_AXIS] * line_lengths_origin[B_AXIS]; + line_on_spool_origin_tmp[C_AXIS] = actn_pts_tmp[C_AXIS] * mnt_l_tmp[C_AXIS] + - actn_pts_tmp[C_AXIS] * HYP3D(anchor_C_x, anchor_C_y, anchor_D_z - anchor_C_z) + - nr_lines_dir_tmp[C_AXIS] * line_lengths_origin[C_AXIS]; + line_on_spool_origin_tmp[D_AXIS] = actn_pts_tmp[D_AXIS] * mnt_l_tmp[D_AXIS] + - nr_lines_dir_tmp[D_AXIS] * line_lengths_origin[D_AXIS]; + + LOOP_MOV_AXIS(i) { + planner.axis_steps_per_mm[i] = steps_per_unit_times_r_tmp[i] / + SQRT((SPOOL_BUILDUP_FACTOR) * line_on_spool_origin_tmp[i] + s_r2_tmp[i]); + planner.k1[i] = (SPOOL_BUILDUP_FACTOR) * + (line_on_spool_origin_tmp[i] + nr_lines_dir_tmp[i] * line_lengths_origin[i]) + s_r2_tmp[i]; + + planner.sqrtk1[i] = SQRT(planner.k1[i]); + } + planner.axis_steps_per_mm[E_AXIS] = DEFAULT_E_AXIS_STEPS_PER_UNIT; + + #endif // LINE_BUILDUP_COMPENSATION_FEATURE + + SYNC_PLAN_POSITION_KINEMATIC(); // recalcs line lengths in case anchor was moved + } + + /** + * Hangprinter inverse kinematics + */ + void inverse_kinematics(const float raw[XYZ]) { + HANGPRINTER_IK(raw); + } + + /** + * Hangprinter forward kinematics + * Basic idea is to subtract squared line lengths to get linear equations. + * Subtracting d*d from a*a, b*b, and c*c gives the cleanest derivation: + * + * a*a - d*d = k1 + k2*y + k3*z <---- a line (I) + * b*b - d*d = k4 + k5*x + k6*y + k7*z <---- a plane (II) + * c*c - d*d = k8 + k9*x + k10*y + k11*z <---- a plane (III) + * + * Use (I) to reduce (II) and (III) into lines. Eliminate y, keep z. + * + * (II): b*b - d*d = k12 + k13*x + k14*z + * <=> x = k0b + k1b*z, <---- a line (IV) + * + * (III): c*c - d*d = k15 + k16*x + k17*z + * <=> x = k0c + k1c*z, <---- a line (V) + * + * where k1, k2, ..., k17, k0b, k0c, k1b, and k1c are known constants. + * + * These two straight lines are not parallel, so they will cross in exactly one point. + * Find z by setting (IV) = (V) + * Find x by inserting z into (V) + * Find y by inserting z into (I) + * + * Warning: truncation errors will typically be in the order of a few tens of microns. + */ + void forward_kinematics_HANGPRINTER(float a, float b, float c, float d){ + const float Asq = sq(anchor_A_y) + sq(anchor_A_z), + Bsq = sq(anchor_B_x) + sq(anchor_B_y) + sq(anchor_B_z), + Csq = sq(anchor_C_x) + sq(anchor_C_y) + sq(anchor_C_z), + Dsq = sq(anchor_D_z), + aa = sq(a), + dd = sq(d), + k0b = (-sq(b) + Bsq - Dsq + dd) / (2.0 * anchor_B_x) + (anchor_B_y / (2.0 * anchor_A_y * anchor_B_x)) * (Dsq - Asq + aa - dd), + k0c = (-sq(c) + Csq - Dsq + dd) / (2.0 * anchor_C_x) + (anchor_C_y / (2.0 * anchor_A_y * anchor_C_x)) * (Dsq - Asq + aa - dd), + k1b = (anchor_B_y * (anchor_A_z - anchor_D_z)) / (anchor_A_y * anchor_B_x) + (anchor_D_z - anchor_B_z) / anchor_B_x, + k1c = (anchor_C_y * (anchor_A_z - anchor_D_z)) / (anchor_A_y * anchor_C_x) + (anchor_D_z - anchor_C_z) / anchor_C_x; + + cartes[Z_AXIS] = (k0b - k0c) / (k1c - k1b); + cartes[X_AXIS] = k0c + k1c * cartes[Z_AXIS]; + cartes[Y_AXIS] = (Asq - Dsq - aa + dd) / (2.0 * anchor_A_y) + ((anchor_D_z - anchor_A_z) / anchor_A_y) * cartes[Z_AXIS]; + } +#endif // HANGPRINTER + /** * Get the stepper positions in the cartes[] array. * Forward kinematics are applied for DELTA and SCARA. @@ -13063,6 +13602,13 @@ void get_cartesian_from_steppers() { planner.get_axis_position_mm(B_AXIS), planner.get_axis_position_mm(C_AXIS) ); + #elif ENABLED(HANGPRINTER) + forward_kinematics_HANGPRINTER( + planner.get_axis_position_mm(A_AXIS), + planner.get_axis_position_mm(B_AXIS), + planner.get_axis_position_mm(C_AXIS), + planner.get_axis_position_mm(D_AXIS) + ); #else #if IS_SCARA forward_kinematics_SCARA( @@ -13122,7 +13668,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { // Remaining cartesian distances const float zdiff = destination[Z_AXIS] - current_position[Z_AXIS], - ediff = destination[E_AXIS] - current_position[E_AXIS]; + ediff = destination[E_CART] - current_position[E_CART]; // Get the linear distance in XYZ // If the move is very short, check the E move distance @@ -13197,6 +13743,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } #define MBL_SEGMENT_END(A) (current_position[_AXIS(A)] + (destination[_AXIS(A)] - current_position[_AXIS(A)]) * normalized_dist) + #define MBL_SEGMENT_END_E (current_position[E_CART] + (destination[E_CART] - current_position[E_CART]) * normalized_dist) float normalized_dist, end[XYZE]; const int8_t gcx = MAX(cx1, cx2), gcy = MAX(cy1, cy2); @@ -13228,7 +13775,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } destination[Z_AXIS] = MBL_SEGMENT_END(Z); - destination[E_AXIS] = MBL_SEGMENT_END(E); + destination[E_CART] = MBL_SEGMENT_END_E; // Do the split and look for more borders mesh_line_to_destination(fr_mm_s, x_splits, y_splits); @@ -13265,6 +13812,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } #define LINE_SEGMENT_END(A) (current_position[_AXIS(A)] + (destination[_AXIS(A)] - current_position[_AXIS(A)]) * normalized_dist) + #define LINE_SEGMENT_END_E (current_position[E_CART] + (destination[E_CART] - current_position[E_CART]) * normalized_dist) float normalized_dist, end[XYZE]; const int8_t gcx = MAX(cx1, cx2), gcy = MAX(cy1, cy2); @@ -13296,7 +13844,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } destination[Z_AXIS] = LINE_SEGMENT_END(Z); - destination[E_AXIS] = LINE_SEGMENT_END(E); + destination[E_CART] = LINE_SEGMENT_END_E; // Do the split and look for more borders bilinear_line_to_destination(fr_mm_s, x_splits, y_splits); @@ -13327,10 +13875,10 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { #endif /** - * Prepare a linear move in a DELTA or SCARA setup. + * Prepare a linear move in a DELTA, SCARA or HANGPRINTER setup. * * This calls planner.buffer_line several times, adding - * small incremental moves for DELTA or SCARA. + * small incremental moves for DELTA, SCARA or HANGPRINTER. * * For Unified Bed Leveling (Delta or Segmented Cartesian) * the ubl.prepare_segmented_line_to method replaces this. @@ -13341,10 +13889,18 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { const float _feedrate_mm_s = MMS_SCALED(feedrate_mm_s); const float xdiff = rtarget[X_AXIS] - current_position[X_AXIS], - ydiff = rtarget[Y_AXIS] - current_position[Y_AXIS]; + ydiff = rtarget[Y_AXIS] - current_position[Y_AXIS] + #if ENABLED(HANGPRINTER) + , zdiff = rtarget[Z_AXIS] - current_position[Z_AXIS] + #endif + ; - // If the move is only in Z/E don't split up the move - if (!xdiff && !ydiff) { + // If the move is only in Z/E (for Hangprinter only in E) don't split up the move + if (!xdiff && !ydiff + #if ENABLED(HANGPRINTER) + && !zdiff + #endif + ) { planner.buffer_line_kinematic(rtarget, _feedrate_mm_s, active_extruder); return false; // caller will update current_position } @@ -13353,8 +13909,11 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { if (!position_is_reachable(rtarget[X_AXIS], rtarget[Y_AXIS])) return true; // Remaining cartesian distances - const float zdiff = rtarget[Z_AXIS] - current_position[Z_AXIS], - ediff = rtarget[E_AXIS] - current_position[E_AXIS]; + const float + #if DISABLED(HANGPRINTER) + zdiff = rtarget[Z_AXIS] - current_position[Z_AXIS], + #endif + ediff = rtarget[E_CART] - current_position[E_CART]; // Get the linear distance in XYZ // If the move is very short, check the E move distance @@ -13448,6 +14007,8 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { LOOP_XYZE(i) raw[i] += segment_distance[i]; #if ENABLED(DELTA) && HOTENDS < 2 DELTA_IK(raw); // Delta can inline its kinematics + #elif ENABLED(HANGPRINTER) + HANGPRINTER_IK(raw); // Modifies line_lengths[ABCD] #else inverse_kinematics(raw); #endif @@ -13457,7 +14018,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { #if ENABLED(SCARA_FEEDRATE_SCALING) // For SCARA scale the feed rate from mm/s to degrees/s // i.e., Complete the angular vector in the given time. - if (!planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], raw[Z_AXIS], raw[E_AXIS], HYPOT(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB) * inverse_secs, active_extruder, segment_length)) + if (!planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], raw[Z_AXIS], raw[E_CART], HYPOT(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB) * inverse_secs, active_extruder, segment_length)) break; /* SERIAL_ECHO(segments); @@ -13480,8 +14041,11 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { safe_delay(5); //*/ oldA = delta[A_AXIS]; oldB = delta[B_AXIS]; oldC = delta[C_AXIS]; + #elif ENABLED(HANGPRINTER) + if (!planner.buffer_line(line_lengths[A_AXIS], line_lengths[B_AXIS], line_lengths[C_AXIS], line_lengths[D_AXIS], raw[E_CART], _feedrate_mm_s, active_extruder, cartesian_segment_mm)) + break; #else - if (!planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], raw[E_AXIS], _feedrate_mm_s, active_extruder, cartesian_segment_mm)) + if (!planner.buffer_line(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], raw[E_CART], _feedrate_mm_s, active_extruder, cartesian_segment_mm)) break; #endif } @@ -13495,7 +14059,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { #if ENABLED(SCARA_FEEDRATE_SCALING) const float diff2 = HYPOT2(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB); if (diff2) { - planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], rtarget[Z_AXIS], rtarget[E_AXIS], SQRT(diff2) * inverse_secs, active_extruder, segment_length); + planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], rtarget[Z_AXIS], rtarget[E_CART], SQRT(diff2) * inverse_secs, active_extruder, segment_length); /* SERIAL_ECHOPAIR("final: A=", delta[A_AXIS]); SERIAL_ECHOPAIR(" B=", delta[B_AXIS]); SERIAL_ECHOPAIR(" adiff=", delta[A_AXIS] - oldA); SERIAL_ECHOPAIR(" bdiff=", delta[B_AXIS] - oldB); @@ -13578,7 +14142,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { case DXC_FULL_CONTROL_MODE: break; case DXC_AUTO_PARK_MODE: - if (current_position[E_AXIS] == destination[E_AXIS]) { + if (current_position[E_CART] == destination[E_CART]) { // This is a travel move (with no extrusion) // Skip it, but keep track of the current position // (so it can be used as the start of the next non-travel move) @@ -13595,7 +14159,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { i == 0 ? raised_parked_position[X_AXIS] : current_position[X_AXIS], i == 0 ? raised_parked_position[Y_AXIS] : current_position[Y_AXIS], i == 2 ? current_position[Z_AXIS] : raised_parked_position[Z_AXIS], - current_position[E_AXIS], + current_position[E_CART], i == 1 ? PLANNER_XY_FEEDRATE() : planner.max_feedrate_mm_s[Z_AXIS], active_extruder) ) break; @@ -13615,10 +14179,10 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { } #endif // move duplicate extruder into correct duplication position. - planner.set_position_mm(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); + planner.set_position_mm(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART]); if (!planner.buffer_line( current_position[X_AXIS] + duplicate_extruder_x_offset, - current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], + current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART], planner.max_feedrate_mm_s[X_AXIS], 1) ) break; planner.synchronize(); @@ -13645,7 +14209,7 @@ void set_current_from_steppers_for_axis(const AxisEnum axis) { * Prepare a single move and get ready for the next one * * This may result in several calls to planner.buffer_line to - * do smaller moves for DELTA, SCARA, mesh moves, etc. + * do smaller moves for DELTA, SCARA, HANGPRINTER, mesh moves, etc. * * Make sure current_position[E] and destination[E] are good * before calling or cold/lengthy extrusion may get missed. @@ -13656,17 +14220,17 @@ void prepare_move_to_destination() { #if ENABLED(PREVENT_COLD_EXTRUSION) || ENABLED(PREVENT_LENGTHY_EXTRUDE) if (!DEBUGGING(DRYRUN)) { - if (destination[E_AXIS] != current_position[E_AXIS]) { + if (destination[E_CART] != current_position[E_CART]) { #if ENABLED(PREVENT_COLD_EXTRUSION) if (thermalManager.tooColdToExtrude(active_extruder)) { - current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part + current_position[E_CART] = destination[E_CART]; // Behave as if the move really took place, but ignore E part SERIAL_ECHO_START(); SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP); } #endif // PREVENT_COLD_EXTRUSION #if ENABLED(PREVENT_LENGTHY_EXTRUDE) - if (ABS(destination[E_AXIS] - current_position[E_AXIS]) * planner.e_factor[active_extruder] > (EXTRUDE_MAXLENGTH)) { - current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part + if (ABS(destination[E_CART] - current_position[E_CART]) * planner.e_factor[active_extruder] > (EXTRUDE_MAXLENGTH)) { + current_position[E_CART] = destination[E_CART]; // Behave as if the move really took place, but ignore E part SERIAL_ECHO_START(); SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP); } @@ -13735,7 +14299,7 @@ void prepare_move_to_destination() { rt_X = cart[p_axis] - center_P, rt_Y = cart[q_axis] - center_Q, linear_travel = cart[l_axis] - current_position[l_axis], - extruder_travel = cart[E_AXIS] - current_position[E_AXIS]; + extruder_travel = cart[E_CART] - current_position[E_CART]; // CCW angle of rotation between position and target from the circle center. Only one atan2() trig computation required. float angular_travel = ATAN2(r_P * rt_Y - r_Q * rt_X, r_P * rt_X + r_Q * rt_Y); @@ -13791,7 +14355,7 @@ void prepare_move_to_destination() { raw[l_axis] = current_position[l_axis]; // Initialize the extruder axis - raw[E_AXIS] = current_position[E_AXIS]; + raw[E_CART] = current_position[E_CART]; const float fr_mm_s = MMS_SCALED(feedrate_mm_s); @@ -13848,7 +14412,7 @@ void prepare_move_to_destination() { raw[p_axis] = center_P + r_P; raw[q_axis] = center_Q + r_Q; raw[l_axis] += linear_per_segment; - raw[E_AXIS] += extruder_per_segment; + raw[E_CART] += extruder_per_segment; clamp_to_software_endstops(raw); @@ -13860,7 +14424,7 @@ void prepare_move_to_destination() { #if ENABLED(SCARA_FEEDRATE_SCALING) // For SCARA scale the feed rate from mm/s to degrees/s // i.e., Complete the angular vector in the given time. - if (!planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], raw[Z_AXIS], raw[E_AXIS], HYPOT(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT)) + if (!planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], raw[Z_AXIS], raw[E_CART], HYPOT(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT)) break; oldA = delta[A_AXIS]; oldB = delta[B_AXIS]; #elif ENABLED(DELTA_FEEDRATE_SCALING) @@ -13872,7 +14436,7 @@ void prepare_move_to_destination() { #elif HAS_UBL_AND_CURVES float pos[XYZ] = { raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS] }; planner.apply_leveling(pos); - if (!planner.buffer_segment(pos[X_AXIS], pos[Y_AXIS], pos[Z_AXIS], raw[E_AXIS], fr_mm_s, active_extruder, MM_PER_ARC_SEGMENT)) + if (!planner.buffer_segment(pos[X_AXIS], pos[Y_AXIS], pos[Z_AXIS], raw[E_CART], fr_mm_s, active_extruder, MM_PER_ARC_SEGMENT)) break; #else if (!planner.buffer_line_kinematic(raw, fr_mm_s, active_extruder)) @@ -13889,15 +14453,15 @@ void prepare_move_to_destination() { #if ENABLED(SCARA_FEEDRATE_SCALING) const float diff2 = HYPOT2(delta[A_AXIS] - oldA, delta[B_AXIS] - oldB); if (diff2) - planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], cart[Z_AXIS], cart[E_AXIS], SQRT(diff2) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT); + planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], cart[Z_AXIS], cart[E_CART], SQRT(diff2) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT); #elif ENABLED(DELTA_FEEDRATE_SCALING) const float diff2 = sq(delta[A_AXIS] - oldA) + sq(delta[B_AXIS] - oldB) + sq(delta[C_AXIS] - oldC); if (diff2) - planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_AXIS], SQRT(diff2) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT); + planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_CART], SQRT(diff2) * inverse_secs, active_extruder, MM_PER_ARC_SEGMENT); #elif HAS_UBL_AND_CURVES float pos[XYZ] = { cart[X_AXIS], cart[Y_AXIS], cart[Z_AXIS] }; planner.apply_leveling(pos); - planner.buffer_segment(pos[X_AXIS], pos[Y_AXIS], pos[Z_AXIS], cart[E_AXIS], fr_mm_s, active_extruder, MM_PER_ARC_SEGMENT); + planner.buffer_segment(pos[X_AXIS], pos[Y_AXIS], pos[Z_AXIS], cart[E_CART], fr_mm_s, active_extruder, MM_PER_ARC_SEGMENT); #else planner.buffer_line_kinematic(cart, fr_mm_s, active_extruder); #endif @@ -14084,14 +14648,21 @@ void enable_all_steppers() { #if ENABLED(AUTO_POWER_CONTROL) powerManager.power_on(); #endif - enable_X(); - enable_Y(); - enable_Z(); + #if ENABLED(HANGPRINTER) + enable_A(); + enable_B(); + enable_C(); + enable_D(); + #else + enable_X(); + enable_Y(); + enable_Z(); + enable_E4(); + #endif enable_E0(); enable_E1(); enable_E2(); enable_E3(); - enable_E4(); } void disable_e_stepper(const uint8_t e) { @@ -14265,10 +14836,10 @@ void manage_inactivity(const bool ignore_stepper_queue/*=false*/) { } #endif // !SWITCHING_EXTRUDER - const float olde = current_position[E_AXIS]; - current_position[E_AXIS] += EXTRUDER_RUNOUT_EXTRUDE; + const float olde = current_position[E_CART]; + current_position[E_CART] += EXTRUDER_RUNOUT_EXTRUDE; planner.buffer_line_kinematic(current_position, MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED), active_extruder); - current_position[E_AXIS] = olde; + current_position[E_CART] = olde; planner.set_e_position_mm(olde); planner.synchronize(); @@ -14690,6 +15261,13 @@ void setup() { #if ENABLED(USE_WATCHDOG) watchdog_init(); #endif + + #if ENABLED(HANGPRINTER) + enable_A(); + enable_B(); + enable_C(); + enable_D(); + #endif } /** diff --git a/Marlin/SanityCheck.h b/Marlin/SanityCheck.h index 62ac22132..7538ac49d 100644 --- a/Marlin/SanityCheck.h +++ b/Marlin/SanityCheck.h @@ -465,6 +465,8 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, #if ENABLED(BABYSTEPPING) #if ENABLED(SCARA) #error "BABYSTEPPING is not implemented for SCARA yet." + #elif ENABLED(HANGPRINTER) + #error "BABYSTEPPING is not implemented for HANGPRINTER." #elif ENABLED(DELTA) && ENABLED(BABYSTEP_XY) #error "BABYSTEPPING only implemented for Z axis on deltabots." #elif ENABLED(BABYSTEP_ZPROBE_OFFSET) && ENABLED(MESH_BED_LEVELING) @@ -527,8 +529,12 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, /** * Individual axis homing is useless for DELTAS */ -#if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU) && ENABLED(DELTA) - #error "INDIVIDUAL_AXIS_HOMING_MENU is incompatible with DELTA kinematics." +#if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU) + #if ENABLED(DELTA) + #error "INDIVIDUAL_AXIS_HOMING_MENU is incompatible with DELTA kinematics." + #elif ENABLED(HANGPRINTER) + #error "INDIVIDUAL_AXIS_HOMING_MENU is incompatible with HANGPRINTER kinematics." + #endif #endif /** @@ -686,6 +692,7 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, * Allow only one kinematic type to be defined */ #if 1 < 0 \ + + ENABLED(HANGPRINTER) \ + ENABLED(DELTA) \ + ENABLED(MORGAN_SCARA) \ + ENABLED(MAKERARM_SCARA) \ @@ -695,7 +702,7 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, + ENABLED(COREYX) \ + ENABLED(COREZX) \ + ENABLED(COREZY) - #error "Please enable only one of DELTA, MORGAN_SCARA, MAKERARM_SCARA, COREXY, COREYX, COREXZ, COREZX, COREYZ, or COREZY." + #error "Please enable only one of HANGPRINTER, DELTA, MORGAN_SCARA, MAKERARM_SCARA, COREXY, COREYX, COREXZ, COREZX, COREYZ, or COREZY." #endif /** @@ -717,6 +724,42 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, #endif #endif +/** + * Hangprinter requirements + */ +#if ENABLED(HANGPRINTER) + #if EXTRUDERS > 4 + #error "Marlin supports a maximum of 4 EXTRUDERS when driving a Hangprinter." + #elif ENABLED(CONVENTIONAL_GEOMETRY) + #if ANCHOR_A_Y > 0 + #error "ANCHOR_A_Y should be negative by convention." + #elif (ANCHOR_B_X) * (ANCHOR_C_X) > 0 + #error "ANCHOR_B_X and ANCHOR_C_X should have opposite signs by convention." + #elif ANCHOR_B_Y < 0 + #error "ANCHOR_B_Y should be positive by convention." + #elif ANCHOR_C_Y < 0 + #error "ANCHOR_C_Y should be positive by convention." + #elif ANCHOR_A_Z > 0 + #error "ANCHOR_A_Z should be negative by convention." + #elif ANCHOR_B_Z > 0 + #error "ANCHOR_B_Z should be negative by convention." + #elif ANCHOR_C_Z > 0 + #error "ANCHOR_C_Z should be negative by convention." + #elif ANCHOR_D_Z < 0 + #error "ANCHOR_D_Z should be positive by convention." + #endif + #endif +#elif ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + #error "LINE_BUILDUP_COMPENSATION_FEATURE is only compatible with HANGPRINTER." +#endif + +/** + * Mechaduino requirements + */ +#if ENABLED(MECHADUINO_I2C_COMMANDS) && DISABLED(EXPERIMENTAL_I2CBUS) + #error "MECHADUINO_I2C_COMMANDS requires EXPERIMENTAL_I2CBUS to be enabled." +#endif + /** * Probes */ @@ -1211,6 +1254,7 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, #endif #endif #endif + /** * Endstop Tests */ @@ -1218,33 +1262,33 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, #define _PLUG_UNUSED_TEST(AXIS,PLUG) (DISABLED(USE_##PLUG##MIN_PLUG) && DISABLED(USE_##PLUG##MAX_PLUG) && !(ENABLED(AXIS##_DUAL_ENDSTOPS) && WITHIN(AXIS##2_USE_ENDSTOP, _##PLUG##MAX_, _##PLUG##MIN_))) #define _AXIS_PLUG_UNUSED_TEST(AXIS) (_PLUG_UNUSED_TEST(AXIS,X) && _PLUG_UNUSED_TEST(AXIS,Y) && _PLUG_UNUSED_TEST(AXIS,Z)) -// At least 3 endstop plugs must be used -#if _AXIS_PLUG_UNUSED_TEST(X) - #error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG." -#endif -#if _AXIS_PLUG_UNUSED_TEST(Y) - #error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG." -#endif -#if _AXIS_PLUG_UNUSED_TEST(Z) - #error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG." -#endif - -// Delta and Cartesian use 3 homing endstops -#if !IS_SCARA - #if X_HOME_DIR < 0 && DISABLED(USE_XMIN_PLUG) - #error "Enable USE_XMIN_PLUG when homing X to MIN." - #elif X_HOME_DIR > 0 && DISABLED(USE_XMAX_PLUG) - #error "Enable USE_XMAX_PLUG when homing X to MAX." - #elif Y_HOME_DIR < 0 && DISABLED(USE_YMIN_PLUG) - #error "Enable USE_YMIN_PLUG when homing Y to MIN." - #elif Y_HOME_DIR > 0 && DISABLED(USE_YMAX_PLUG) - #error "Enable USE_YMAX_PLUG when homing Y to MAX." +#if DISABLED(HANGPRINTER) + // At least 3 endstop plugs must be used + #if _AXIS_PLUG_UNUSED_TEST(X) + #error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG." + #elif _AXIS_PLUG_UNUSED_TEST(Y) + #error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG." + #elif _AXIS_PLUG_UNUSED_TEST(Z) + #error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG." + #endif + + // Delta and Cartesian use 3 homing endstops + #if !IS_SCARA + #if X_HOME_DIR < 0 && DISABLED(USE_XMIN_PLUG) + #error "Enable USE_XMIN_PLUG when homing X to MIN." + #elif X_HOME_DIR > 0 && DISABLED(USE_XMAX_PLUG) + #error "Enable USE_XMAX_PLUG when homing X to MAX." + #elif Y_HOME_DIR < 0 && DISABLED(USE_YMIN_PLUG) + #error "Enable USE_YMIN_PLUG when homing Y to MIN." + #elif Y_HOME_DIR > 0 && DISABLED(USE_YMAX_PLUG) + #error "Enable USE_YMAX_PLUG when homing Y to MAX." + #endif + #endif + #if Z_HOME_DIR < 0 && DISABLED(USE_ZMIN_PLUG) + #error "Enable USE_ZMIN_PLUG when homing Z to MIN." + #elif Z_HOME_DIR > 0 && DISABLED(USE_ZMAX_PLUG) + #error "Enable USE_ZMAX_PLUG when homing Z to MAX." #endif -#endif -#if Z_HOME_DIR < 0 && DISABLED(USE_ZMIN_PLUG) - #error "Enable USE_ZMIN_PLUG when homing Z to MIN." -#elif Z_HOME_DIR > 0 && DISABLED(USE_ZMAX_PLUG) - #error "Enable USE_ZMAX_PLUG when homing Z to MAX." #endif // Dual endstops requirements @@ -1544,17 +1588,24 @@ static_assert(X_MAX_LENGTH >= X_BED_SIZE && Y_MAX_LENGTH >= Y_BED_SIZE, #endif /** - * Require 4 or more elements in per-axis initializers + * Require 5/4 or more elements in per-axis initializers */ +#if ENABLED(HANGPRINTER) + #define MIN_ELEMENTS "5" +#else + #define MIN_ELEMENTS "4" +#endif + constexpr float sanity_arr_1[] = DEFAULT_AXIS_STEPS_PER_UNIT, sanity_arr_2[] = DEFAULT_MAX_FEEDRATE, sanity_arr_3[] = DEFAULT_MAX_ACCELERATION; -static_assert(COUNT(sanity_arr_1) >= XYZE, "DEFAULT_AXIS_STEPS_PER_UNIT requires 4 (or more) elements."); -static_assert(COUNT(sanity_arr_2) >= XYZE, "DEFAULT_MAX_FEEDRATE requires 4 (or more) elements."); -static_assert(COUNT(sanity_arr_3) >= XYZE, "DEFAULT_MAX_ACCELERATION requires 4 (or more) elements."); -static_assert(COUNT(sanity_arr_1) <= XYZE_N, "DEFAULT_AXIS_STEPS_PER_UNIT has too many elements."); -static_assert(COUNT(sanity_arr_2) <= XYZE_N, "DEFAULT_MAX_FEEDRATE has too many elements."); -static_assert(COUNT(sanity_arr_3) <= XYZE_N, "DEFAULT_MAX_ACCELERATION has too many elements."); + +static_assert(COUNT(sanity_arr_1) >= NUM_AXIS, "DEFAULT_AXIS_STEPS_PER_UNIT requires " MIN_ELEMENTS " (or more) elements for HANGPRINTER."); +static_assert(COUNT(sanity_arr_2) >= NUM_AXIS, "DEFAULT_MAX_FEEDRATE requires " MIN_ELEMENTS " (or more) elements for HANGPRINTER."); +static_assert(COUNT(sanity_arr_3) >= NUM_AXIS, "DEFAULT_MAX_ACCELERATION requires " MIN_ELEMENTS " (or more) elements for HANGPRINTER."); +static_assert(COUNT(sanity_arr_1) <= NUM_AXIS_N, "DEFAULT_AXIS_STEPS_PER_UNIT has too many elements."); +static_assert(COUNT(sanity_arr_2) <= NUM_AXIS_N, "DEFAULT_MAX_FEEDRATE has too many elements."); +static_assert(COUNT(sanity_arr_3) <= NUM_AXIS_N, "DEFAULT_MAX_ACCELERATION has too many elements."); /** * Sanity checks for Spindle / Laser diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp index 56ed9171e..6ec8f53e4 100644 --- a/Marlin/configuration_store.cpp +++ b/Marlin/configuration_store.cpp @@ -95,19 +95,19 @@ typedef struct SettingsDataStruct { // // DISTINCT_E_FACTORS // - uint8_t esteppers; // XYZE_N - XYZ + uint8_t esteppers; // NUM_AXIS_N - MOV_AXIS - uint32_t planner_max_acceleration_mm_per_s2[XYZE_N], // M201 XYZE planner.max_acceleration_mm_per_s2[XYZE_N] - planner_min_segment_time_us; // M205 B planner.min_segment_time_us - float planner_axis_steps_per_mm[XYZE_N], // M92 XYZE planner.axis_steps_per_mm[XYZE_N] - planner_max_feedrate_mm_s[XYZE_N], // M203 XYZE planner.max_feedrate_mm_s[XYZE_N] - planner_acceleration, // M204 P planner.acceleration - planner_retract_acceleration, // M204 R planner.retract_acceleration - planner_travel_acceleration, // M204 T planner.travel_acceleration - planner_min_feedrate_mm_s, // M205 S planner.min_feedrate_mm_s - planner_min_travel_feedrate_mm_s, // M205 T planner.min_travel_feedrate_mm_s - planner_max_jerk[XYZE], // M205 XYZE planner.max_jerk[XYZE] - planner_junction_deviation_mm; // M205 J planner.junction_deviation_mm + uint32_t planner_max_acceleration_mm_per_s2[NUM_AXIS_N], // M201 XYZE/ABCDE planner.max_acceleration_mm_per_s2[NUM_AXIS_N] + planner_min_segment_time_us; // M205 Q planner.min_segment_time_us + float planner_axis_steps_per_mm[NUM_AXIS_N], // M92 XYZE/ABCDE planner.axis_steps_per_mm[NUM_AXIS_N] + planner_max_feedrate_mm_s[NUM_AXIS_N], // M203 XYZE/ABCDE planner.max_feedrate_mm_s[NUM_AXIS_N] + planner_acceleration, // M204 P planner.acceleration + planner_retract_acceleration, // M204 R planner.retract_acceleration + planner_travel_acceleration, // M204 T planner.travel_acceleration + planner_min_feedrate_mm_s, // M205 S planner.min_feedrate_mm_s + planner_min_travel_feedrate_mm_s, // M205 T planner.min_travel_feedrate_mm_s + planner_max_jerk[NUM_AXIS], // M205 XYZE/ABCDE planner.max_jerk[NUM_AXIS] + planner_junction_deviation_mm; // M205 J planner.junction_deviation_mm float home_offset[XYZ]; // M206 XYZ @@ -163,6 +163,7 @@ typedef struct SettingsDataStruct { // DELTA / [XYZ]_DUAL_ENDSTOPS // #if ENABLED(DELTA) + float delta_height, // M666 H delta_endstop_adj[ABC], // M666 XYZ delta_radius, // M665 R @@ -170,10 +171,27 @@ typedef struct SettingsDataStruct { delta_segments_per_second, // M665 S delta_calibration_radius, // M665 B delta_tower_angle_trim[ABC]; // M665 XYZ + + #elif ENABLED(HANGPRINTER) + + float anchor_A_y, // M665 W + anchor_A_z, // M665 E + anchor_B_x, // M665 R + anchor_B_y, // M665 T + anchor_B_z, // M665 Y + anchor_C_x, // M665 U + anchor_C_y, // M665 I + anchor_C_z, // M665 O + anchor_D_z, // M665 P + delta_segments_per_second, // M665 S + hangprinter_calibration_radius_placeholder; + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) + float x_endstop_adj, // M666 X y_endstop_adj, // M666 Y z_endstop_adj; // M666 Z + #endif // @@ -285,6 +303,8 @@ void MarlinSettings::postprocess() { // planner position so the stepper counts will be set correctly. #if ENABLED(DELTA) recalc_delta_settings(); + #elif ENABLED(HANGPRINTER) + recalc_hangprinter_settings(); #endif #if ENABLED(PIDTEMP) @@ -418,7 +438,7 @@ void MarlinSettings::postprocess() { _FIELD_TEST(esteppers); - const uint8_t esteppers = COUNT(planner.axis_steps_per_mm) - XYZ; + const uint8_t esteppers = NUM_AXIS_N - MOV_AXIS; EEPROM_WRITE(esteppers); EEPROM_WRITE(planner.max_acceleration_mm_per_s2); @@ -432,7 +452,13 @@ void MarlinSettings::postprocess() { EEPROM_WRITE(planner.min_travel_feedrate_mm_s); #if ENABLED(JUNCTION_DEVIATION) - const float planner_max_jerk[] = { float(DEFAULT_XJERK), float(DEFAULT_YJERK), float(DEFAULT_ZJERK), float(DEFAULT_EJERK) }; + const float planner_max_jerk[] = { + #if ENABLED(HANGPRINTER) + float(DEFAULT_AJERK), float(DEFAULT_BJERK), float(DEFAULT_CJERK), float(DEFAULT_DJERK), float(DEFAULT_EJERK) + #else + float(DEFAULT_XJERK), float(DEFAULT_YJERK), float(DEFAULT_ZJERK), float(DEFAULT_EJERK) + #endif + }; EEPROM_WRITE(planner_max_jerk); EEPROM_WRITE(planner.junction_deviation_mm); #else @@ -560,6 +586,22 @@ void MarlinSettings::postprocess() { EEPROM_WRITE(delta_calibration_radius); // 1 float EEPROM_WRITE(delta_tower_angle_trim); // 3 floats + #elif ENABLED(HANGPRINTER) + + dummy = 0.0f; + _FIELD_TEST(anchor_A_y); + EEPROM_WRITE(anchor_A_y); // 1 float + EEPROM_WRITE(anchor_A_z); // 1 float + EEPROM_WRITE(anchor_B_x); // 1 float + EEPROM_WRITE(anchor_B_y); // 1 float + EEPROM_WRITE(anchor_B_z); // 1 float + EEPROM_WRITE(anchor_C_x); // 1 float + EEPROM_WRITE(anchor_C_y); // 1 float + EEPROM_WRITE(anchor_C_z); // 1 float + EEPROM_WRITE(anchor_D_z); // 1 float + EEPROM_WRITE(delta_segments_per_second); // 1 float + EEPROM_WRITE(dummy); // 1 float + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) _FIELD_TEST(x_endstop_adj); @@ -1010,17 +1052,17 @@ void MarlinSettings::postprocess() { const uint32_t def1[] = DEFAULT_MAX_ACCELERATION; const float def2[] = DEFAULT_AXIS_STEPS_PER_UNIT, def3[] = DEFAULT_MAX_FEEDRATE; - uint32_t tmp1[XYZ + esteppers]; + uint32_t tmp1[MOV_AXIS + esteppers]; EEPROM_READ(tmp1); // max_acceleration_mm_per_s2 EEPROM_READ(planner.min_segment_time_us); - float tmp2[XYZ + esteppers], tmp3[XYZ + esteppers]; + float tmp2[MOV_AXIS + esteppers], tmp3[MOV_AXIS + esteppers]; EEPROM_READ(tmp2); // axis_steps_per_mm EEPROM_READ(tmp3); // max_feedrate_mm_s - if (!validating) LOOP_XYZE_N(i) { - planner.max_acceleration_mm_per_s2[i] = i < XYZ + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1]; - planner.axis_steps_per_mm[i] = i < XYZ + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1]; - planner.max_feedrate_mm_s[i] = i < XYZ + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1]; + if (!validating) LOOP_NUM_AXIS_N(i) { + planner.max_acceleration_mm_per_s2[i] = i < MOV_AXIS + esteppers ? tmp1[i] : def1[i < COUNT(def1) ? i : COUNT(def1) - 1]; + planner.axis_steps_per_mm[i] = i < MOV_AXIS + esteppers ? tmp2[i] : def2[i < COUNT(def2) ? i : COUNT(def2) - 1]; + planner.max_feedrate_mm_s[i] = i < MOV_AXIS + esteppers ? tmp3[i] : def3[i < COUNT(def3) ? i : COUNT(def3) - 1]; } EEPROM_READ(planner.acceleration); @@ -1165,6 +1207,19 @@ void MarlinSettings::postprocess() { EEPROM_READ(delta_calibration_radius); // 1 float EEPROM_READ(delta_tower_angle_trim); // 3 floats + #elif ENABLED(HANGPRINTER) + EEPROM_READ(anchor_A_y); // 1 float + EEPROM_READ(anchor_A_z); // 1 float + EEPROM_READ(anchor_B_x); // 1 float + EEPROM_READ(anchor_B_y); // 1 float + EEPROM_READ(anchor_B_z); // 1 float + EEPROM_READ(anchor_C_x); // 1 float + EEPROM_READ(anchor_C_y); // 1 float + EEPROM_READ(anchor_C_z); // 1 float + EEPROM_READ(anchor_D_z); // 1 float + EEPROM_READ(delta_segments_per_second); // 1 float + EEPROM_READ(dummy); // 1 float + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) _FIELD_TEST(x_endstop_adj); @@ -1714,8 +1769,9 @@ void MarlinSettings::postprocess() { */ void MarlinSettings::reset() { static const float tmp1[] PROGMEM = DEFAULT_AXIS_STEPS_PER_UNIT, tmp2[] PROGMEM = DEFAULT_MAX_FEEDRATE; + static const uint32_t tmp3[] PROGMEM = DEFAULT_MAX_ACCELERATION; - LOOP_XYZE_N(i) { + LOOP_NUM_AXIS_N(i) { planner.axis_steps_per_mm[i] = pgm_read_float(&tmp1[i < COUNT(tmp1) ? i : COUNT(tmp1) - 1]); planner.max_feedrate_mm_s[i] = pgm_read_float(&tmp2[i < COUNT(tmp2) ? i : COUNT(tmp2) - 1]); planner.max_acceleration_mm_per_s2[i] = pgm_read_dword_near(&tmp3[i < COUNT(tmp3) ? i : COUNT(tmp3) - 1]); @@ -1731,9 +1787,16 @@ void MarlinSettings::reset() { #if ENABLED(JUNCTION_DEVIATION) planner.junction_deviation_mm = float(JUNCTION_DEVIATION_MM); #else - planner.max_jerk[X_AXIS] = DEFAULT_XJERK; - planner.max_jerk[Y_AXIS] = DEFAULT_YJERK; - planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK; + #if ENABLED(HANGPRINTER) + planner.max_jerk[A_AXIS] = DEFAULT_AJERK; + planner.max_jerk[B_AXIS] = DEFAULT_BJERK; + planner.max_jerk[C_AXIS] = DEFAULT_CJERK; + planner.max_jerk[D_AXIS] = DEFAULT_DJERK; + #else + planner.max_jerk[X_AXIS] = DEFAULT_XJERK; + planner.max_jerk[Y_AXIS] = DEFAULT_YJERK; + planner.max_jerk[Z_AXIS] = DEFAULT_ZJERK; + #endif planner.max_jerk[E_AXIS] = DEFAULT_EJERK; #endif @@ -1785,6 +1848,19 @@ void MarlinSettings::reset() { delta_calibration_radius = DELTA_CALIBRATION_RADIUS; COPY(delta_tower_angle_trim, dta); + #elif ENABLED(HANGPRINTER) + + anchor_A_y = float(ANCHOR_A_Y); + anchor_A_z = float(ANCHOR_A_Z); + anchor_B_x = float(ANCHOR_B_X); + anchor_B_y = float(ANCHOR_B_Y); + anchor_B_z = float(ANCHOR_B_Z); + anchor_C_x = float(ANCHOR_C_X); + anchor_C_y = float(ANCHOR_C_Y); + anchor_C_z = float(ANCHOR_C_Z); + anchor_D_z = float(ANCHOR_D_Z); + delta_segments_per_second = KINEMATIC_SEGMENTS_PER_SECOND; + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(X_DUAL_ENDSTOPS) @@ -1814,7 +1890,6 @@ void MarlinSettings::reset() { #endif ); #endif - #endif #if ENABLED(ULTIPANEL) @@ -2038,9 +2113,16 @@ void MarlinSettings::reset() { SERIAL_ECHOLNPGM("Steps per unit:"); } CONFIG_ECHO_START; - SERIAL_ECHOPAIR(" M92 X", LINEAR_UNIT(planner.axis_steps_per_mm[X_AXIS])); - SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.axis_steps_per_mm[Y_AXIS])); - SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.axis_steps_per_mm[Z_AXIS])); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPAIR(" M92 A", LINEAR_UNIT(planner.axis_steps_per_mm[A_AXIS])); + SERIAL_ECHOPAIR(" B", LINEAR_UNIT(planner.axis_steps_per_mm[B_AXIS])); + SERIAL_ECHOPAIR(" C", LINEAR_UNIT(planner.axis_steps_per_mm[C_AXIS])); + SERIAL_ECHOPAIR(" D", LINEAR_UNIT(planner.axis_steps_per_mm[D_AXIS])); + #else + SERIAL_ECHOPAIR(" M92 X", LINEAR_UNIT(planner.axis_steps_per_mm[X_AXIS])); + SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.axis_steps_per_mm[Y_AXIS])); + SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.axis_steps_per_mm[Z_AXIS])); + #endif #if DISABLED(DISTINCT_E_FACTORS) SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS])); #endif @@ -2058,9 +2140,16 @@ void MarlinSettings::reset() { SERIAL_ECHOLNPGM("Maximum feedrates (units/s):"); } CONFIG_ECHO_START; - SERIAL_ECHOPAIR(" M203 X", LINEAR_UNIT(planner.max_feedrate_mm_s[X_AXIS])); - SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_feedrate_mm_s[Y_AXIS])); - SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_feedrate_mm_s[Z_AXIS])); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPAIR(" M203 A", LINEAR_UNIT(planner.max_feedrate_mm_s[A_AXIS])); + SERIAL_ECHOPAIR(" B", LINEAR_UNIT(planner.max_feedrate_mm_s[B_AXIS])); + SERIAL_ECHOPAIR(" C", LINEAR_UNIT(planner.max_feedrate_mm_s[C_AXIS])); + SERIAL_ECHOPAIR(" D", LINEAR_UNIT(planner.max_feedrate_mm_s[D_AXIS])); + #else + SERIAL_ECHOPAIR(" M203 X", LINEAR_UNIT(planner.max_feedrate_mm_s[X_AXIS])); + SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_feedrate_mm_s[Y_AXIS])); + SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_feedrate_mm_s[Z_AXIS])); + #endif #if DISABLED(DISTINCT_E_FACTORS) SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS])); #endif @@ -2078,9 +2167,16 @@ void MarlinSettings::reset() { SERIAL_ECHOLNPGM("Maximum Acceleration (units/s2):"); } CONFIG_ECHO_START; - SERIAL_ECHOPAIR(" M201 X", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[X_AXIS])); - SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Y_AXIS])); - SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Z_AXIS])); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPAIR(" M201 A", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[A_AXIS])); + SERIAL_ECHOPAIR(" B", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[B_AXIS])); + SERIAL_ECHOPAIR(" C", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[C_AXIS])); + SERIAL_ECHOPAIR(" D", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[D_AXIS])); + #else + SERIAL_ECHOPAIR(" M201 X", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[X_AXIS])); + SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Y_AXIS])); + SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_acceleration_mm_per_s2[Z_AXIS])); + #endif #if DISABLED(DISTINCT_E_FACTORS) SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS])); #endif @@ -2104,11 +2200,15 @@ void MarlinSettings::reset() { if (!forReplay) { CONFIG_ECHO_START; - SERIAL_ECHOPGM("Advanced: B S T"); + SERIAL_ECHOPGM("Advanced: Q S T"); #if ENABLED(JUNCTION_DEVIATION) SERIAL_ECHOPGM(" J"); #else - SERIAL_ECHOPGM(" X Y Z"); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPGM(" A B C D"); + #else + SERIAL_ECHOPGM(" X Y Z"); + #endif #endif #if DISABLED(JUNCTION_DEVIATION) || ENABLED(LIN_ADVANCE) SERIAL_ECHOPGM(" E"); @@ -2116,19 +2216,25 @@ void MarlinSettings::reset() { SERIAL_EOL(); } CONFIG_ECHO_START; - SERIAL_ECHOPAIR(" M205 B", LINEAR_UNIT(planner.min_segment_time_us)); + SERIAL_ECHOPAIR(" M205 Q", LINEAR_UNIT(planner.min_segment_time_us)); SERIAL_ECHOPAIR(" S", LINEAR_UNIT(planner.min_feedrate_mm_s)); SERIAL_ECHOPAIR(" T", LINEAR_UNIT(planner.min_travel_feedrate_mm_s)); #if ENABLED(JUNCTION_DEVIATION) SERIAL_ECHOPAIR(" J", LINEAR_UNIT(planner.junction_deviation_mm)); #else - SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS])); - SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS])); - SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS])); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPAIR(" A", LINEAR_UNIT(planner.max_jerk[A_AXIS])); + SERIAL_ECHOPAIR(" B", LINEAR_UNIT(planner.max_jerk[B_AXIS])); + SERIAL_ECHOPAIR(" C", LINEAR_UNIT(planner.max_jerk[C_AXIS])); + SERIAL_ECHOPAIR(" D", LINEAR_UNIT(planner.max_jerk[D_AXIS])); + #else + SERIAL_ECHOPAIR(" X", LINEAR_UNIT(planner.max_jerk[X_AXIS])); + SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(planner.max_jerk[Y_AXIS])); + SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.max_jerk[Z_AXIS])); + #endif SERIAL_ECHOPAIR(" E", LINEAR_UNIT(planner.max_jerk[E_AXIS])); #endif - SERIAL_EOL(); #if HAS_M206_COMMAND @@ -2266,6 +2372,24 @@ void MarlinSettings::reset() { SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(delta_tower_angle_trim[C_AXIS])); SERIAL_EOL(); + #elif ENABLED(HANGPRINTER) + if (!forReplay) { + CONFIG_ECHO_START; + SERIAL_ECHOLNPGM("Hangprinter settings: W E R T Y U I O P S"); + } + CONFIG_ECHO_START; + SERIAL_ECHOPAIR(" M665 W", anchor_A_y); + SERIAL_ECHOPAIR(" E", anchor_A_z); + SERIAL_ECHOPAIR(" R", anchor_B_x); + SERIAL_ECHOPAIR(" T", anchor_B_y); + SERIAL_ECHOPAIR(" Y", anchor_B_z); + SERIAL_ECHOPAIR(" U", anchor_C_x); + SERIAL_ECHOPAIR(" I", anchor_C_y); + SERIAL_ECHOPAIR(" O", anchor_C_z); + SERIAL_ECHOPAIR(" P", anchor_D_z); + SERIAL_ECHOPAIR(" S", delta_segments_per_second); + SERIAL_EOL(); + #elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) if (!forReplay) { diff --git a/Marlin/enum.h b/Marlin/enum.h index d525e8ee9..470afef1d 100644 --- a/Marlin/enum.h +++ b/Marlin/enum.h @@ -39,10 +39,14 @@ enum AxisEnum : unsigned char { B_AXIS = 1, Z_AXIS = 2, C_AXIS = 2, - E_AXIS = 3, - X_HEAD = 4, - Y_HEAD = 5, - Z_HEAD = 6, + E_CART = 3, + #if ENABLED(HANGPRINTER) // Hangprinter order: A_AXIS, B_AXIS, C_AXIS, D_AXIS, E_AXIS + D_AXIS = 3, + E_AXIS = 4, + #else + E_AXIS = 3, + #endif + X_HEAD, Y_HEAD, Z_HEAD, ALL_AXES = 0xFE, NO_AXIS = 0xFF }; @@ -54,11 +58,11 @@ enum AxisEnum : unsigned char { #define LOOP_NA(VAR) LOOP_L_N(VAR, NUM_AXIS) #define LOOP_XYZ(VAR) LOOP_S_LE_N(VAR, X_AXIS, Z_AXIS) -#define LOOP_XYZE(VAR) LOOP_S_LE_N(VAR, X_AXIS, E_AXIS) +#define LOOP_XYZE(VAR) LOOP_S_LE_N(VAR, X_AXIS, E_CART) #define LOOP_XYZE_N(VAR) LOOP_S_L_N(VAR, X_AXIS, XYZE_N) -#define LOOP_ABC(VAR) LOOP_S_LE_N(VAR, A_AXIS, C_AXIS) -#define LOOP_ABCE(VAR) LOOP_S_LE_N(VAR, A_AXIS, E_AXIS) -#define LOOP_ABCE_N(VAR) LOOP_S_L_N(VAR, A_AXIS, XYZE_N) +#define LOOP_MOV_AXIS(VAR) LOOP_S_L_N(VAR, A_AXIS, MOV_AXIS) +#define LOOP_NUM_AXIS(VAR) LOOP_S_L_N(VAR, A_AXIS, NUM_AXIS) +#define LOOP_NUM_AXIS_N(VAR) LOOP_S_L_N(VAR, A_AXIS, NUM_AXIS_N) typedef enum { LINEARUNIT_MM, diff --git a/Marlin/example_configurations/hangprinter/Configuration.h b/Marlin/example_configurations/hangprinter/Configuration.h new file mode 100644 index 000000000..5d3956047 --- /dev/null +++ b/Marlin/example_configurations/hangprinter/Configuration.h @@ -0,0 +1,2096 @@ +/** + * 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 . + * + */ + +/** + * Configuration.h + * + * Basic settings such as: + * + * - Type of electronics + * - Type of temperature sensor + * - Printer geometry + * - Endstop configuration + * - LCD controller + * - Extra features + * + * Advanced settings can be found in Configuration_adv.h + * + */ +#ifndef CONFIGURATION_H +#define CONFIGURATION_H +#define CONFIGURATION_H_VERSION 010109 + +//=========================================================================== +//============================= Getting Started ============================= +//=========================================================================== + +/** + * Here are some standard links for getting your machine calibrated: + * + * http://reprap.org/wiki/Calibration + * http://youtu.be/wAL9d7FgInk + * http://calculator.josefprusa.cz + * http://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide + * http://www.thingiverse.com/thing:5573 + * https://sites.google.com/site/repraplogphase/calibration-of-your-reprap + * http://www.thingiverse.com/thing:298812 + */ + +//=========================================================================== +//============================= DELTA Printer =============================== +//=========================================================================== +// For a Delta printer start with one of the configuration files in the +// example_configurations/delta directory and customize for your machine. +// + +//=========================================================================== +//============================= SCARA Printer =============================== +//=========================================================================== +// For a SCARA printer start with the configuration files in +// example_configurations/SCARA and customize for your machine. +// + +//=========================================================================== +//============================= HANGPRINTER ================================= +//=========================================================================== +// For a Hangprinter start with the configuration file in the +// example_configurations/hangprinter directory and customize for your machine. +// + +// @section info + +// User-specified version info of this build to display in [Pronterface, etc] terminal window during +// startup. Implementation of an idea by Prof Braino to inform user that any changes made to this +// build by the user have been successfully uploaded into firmware. +#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes. +#define SHOW_BOOTSCREEN +#define STRING_SPLASH_LINE1 SHORT_BUILD_VERSION // will be shown during bootup in line 1 +#define STRING_SPLASH_LINE2 WEBSITE_URL // will be shown during bootup in line 2 + +/** + * *** VENDORS PLEASE READ *** + * + * Marlin allows you to add a custom boot image for Graphical LCDs. + * With this option Marlin will first show your custom screen followed + * by the standard Marlin logo with version number and web URL. + * + * We encourage you to take advantage of this new feature and we also + * respectfully request that you retain the unmodified Marlin boot screen. + */ + +// Enable to show the bitmap in Marlin/_Bootscreen.h on startup. +//#define SHOW_CUSTOM_BOOTSCREEN + +// Enable to show the bitmap in Marlin/_Statusscreen.h on the status screen. +//#define CUSTOM_STATUS_SCREEN_IMAGE + +// @section machine + +/** + * Select the serial port on the board to use for communication with the host. + * This allows the connection of wireless adapters (for instance) to non-default port pins. + * Serial port 0 is always used by the Arduino bootloader regardless of this setting. + * + * :[0, 1, 2, 3, 4, 5, 6, 7] + */ +#define SERIAL_PORT 0 + +/** + * This setting determines the communication speed of the printer. + * + * 250000 works in most cases, but you might try a lower speed if + * you commonly experience drop-outs during host printing. + * You may try up to 1000000 to speed up SD file transfer. + * + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000, 500000, 1000000] + */ +#define BAUDRATE 250000 + +// Enable the Bluetooth serial interface on AT90USB devices +//#define BLUETOOTH + +// The following define selects which electronics board you have. +// Please choose the name from boards.h that matches your setup +#ifndef MOTHERBOARD + #define MOTHERBOARD BOARD_RAMPS_14_EFB +#endif + +// Optional custom name for your RepStrap or other custom machine +// Displayed in the LCD "Ready" message +#define CUSTOM_MACHINE_NAME "Hangprinter" + +// Define this to set a unique identifier for this printer, (Used by some programs to differentiate between machines) +// You can use an online service to generate a random UUID. (eg http://www.uuidgenerator.net/version4) +//#define MACHINE_UUID "00000000-0000-0000-0000-000000000000" + +// @section extruder + +// This defines the number of extruders +// With Hangprinter, max number of extruders is 4 +// :[1, 2, 3, 4, 5] +#define EXTRUDERS 1 + +// Generally expected filament diameter (1.75, 2.85, 3.0, ...). Used for Volumetric, Filament Width Sensor, etc. +#define DEFAULT_NOMINAL_FILAMENT_DIA 1.75 + +// For Cyclops or any "multi-extruder" that shares a single nozzle. +//#define SINGLENOZZLE + +/** + * Průša MK2 Single Nozzle Multi-Material Multiplexer, and variants. + * + * This device allows one stepper driver on a control board to drive + * two to eight stepper motors, one at a time, in a manner suitable + * for extruders. + * + * This option only allows the multiplexer to switch on tool-change. + * Additional options to configure custom E moves are pending. + */ +//#define MK2_MULTIPLEXER +#if ENABLED(MK2_MULTIPLEXER) + // Override the default DIO selector pins here, if needed. + // Some pins files may provide defaults for these pins. + //#define E_MUX0_PIN 40 // Always Required + //#define E_MUX1_PIN 42 // Needed for 3 to 8 steppers + //#define E_MUX2_PIN 44 // Needed for 5 to 8 steppers +#endif + +// A dual extruder that uses a single stepper motor +//#define SWITCHING_EXTRUDER +#if ENABLED(SWITCHING_EXTRUDER) + #define SWITCHING_EXTRUDER_SERVO_NR 0 + #define SWITCHING_EXTRUDER_SERVO_ANGLES { 0, 90 } // Angles for E0, E1[, E2, E3] + #if EXTRUDERS > 3 + #define SWITCHING_EXTRUDER_E23_SERVO_NR 1 + #endif +#endif + +// A dual-nozzle that uses a servomotor to raise/lower one of the nozzles +//#define SWITCHING_NOZZLE +#if ENABLED(SWITCHING_NOZZLE) + #define SWITCHING_NOZZLE_SERVO_NR 0 + #define SWITCHING_NOZZLE_SERVO_ANGLES { 0, 90 } // Angles for E0, E1 + //#define HOTEND_OFFSET_Z { 0.0, 0.0 } +#endif + +/** + * Two separate X-carriages with extruders that connect to a moving part + * via a magnetic docking mechanism. Requires SOL1_PIN and SOL2_PIN. + */ +//#define PARKING_EXTRUDER +#if ENABLED(PARKING_EXTRUDER) + #define PARKING_EXTRUDER_SOLENOIDS_INVERT // If enabled, the solenoid is NOT magnetized with applied voltage + #define PARKING_EXTRUDER_SOLENOIDS_PINS_ACTIVE LOW // LOW or HIGH pin signal energizes the coil + #define PARKING_EXTRUDER_SOLENOIDS_DELAY 250 // Delay (ms) for magnetic field. No delay if 0 or not defined. + #define PARKING_EXTRUDER_PARKING_X { -78, 184 } // X positions for parking the extruders + #define PARKING_EXTRUDER_GRAB_DISTANCE 1 // mm to move beyond the parking point to grab the extruder + #define PARKING_EXTRUDER_SECURITY_RAISE 5 // Z-raise before parking + #define HOTEND_OFFSET_Z { 0.0, 1.3 } // Z-offsets of the two hotends. The first must be 0. +#endif + +/** + * "Mixing Extruder" + * - Adds a new code, M165, to set the current mix factors. + * - Extends the stepping routines to move multiple steppers in proportion to the mix. + * - Optional support for Repetier Firmware M163, M164, and virtual extruder. + * - This implementation supports only a single extruder. + * - Enable DIRECT_MIXING_IN_G1 for Pia Taubert's reference implementation + */ +//#define MIXING_EXTRUDER +#if ENABLED(MIXING_EXTRUDER) + #define MIXING_STEPPERS 2 // Number of steppers in your mixing extruder + #define MIXING_VIRTUAL_TOOLS 16 // Use the Virtual Tool method with M163 and M164 + //#define DIRECT_MIXING_IN_G1 // Allow ABCDHI mix factors in G1 movement commands +#endif + +// Offset of the extruders (uncomment if using more than one and relying on firmware to position when changing). +// The offset has to be X=0, Y=0 for the extruder 0 hotend (default extruder). +// For the other hotends it is their distance from the extruder 0 hotend. +//#define HOTEND_OFFSET_X {0.0, 20.00} // (in mm) for each extruder, offset of the hotend on the X axis +//#define HOTEND_OFFSET_Y {0.0, 5.00} // (in mm) for each extruder, offset of the hotend on the Y axis + +// @section machine + +/** + * Select your power supply here. Use 0 if you haven't connected the PS_ON_PIN + * + * 0 = No Power Switch + * 1 = ATX + * 2 = X-Box 360 203Watts (the blue wire connected to PS_ON and the red wire to VCC) + * + * :{ 0:'No power switch', 1:'ATX', 2:'X-Box 360' } + */ +#define POWER_SUPPLY 1 + +#if POWER_SUPPLY > 0 + // Enable this option to leave the PSU off at startup. + // Power to steppers and heaters will need to be turned on with M80. + //#define PS_DEFAULT_OFF + + //#define AUTO_POWER_CONTROL // Enable automatic control of the PS_ON pin + #if ENABLED(AUTO_POWER_CONTROL) + #define AUTO_POWER_FANS // Turn on PSU if fans need power + #define AUTO_POWER_E_FANS + #define AUTO_POWER_CONTROLLERFAN + #define POWER_TIMEOUT 30 + #endif + +#endif + +// @section temperature + +//=========================================================================== +//============================= Thermal Settings ============================ +//=========================================================================== + +/** + * --NORMAL IS 4.7kohm PULLUP!-- 1kohm pullup can be used on hotend sensor, using correct resistor and table + * + * Temperature sensors available: + * + * -4 : thermocouple with AD8495 + * -3 : thermocouple with MAX31855 (only for sensor 0) + * -2 : thermocouple with MAX6675 (only for sensor 0) + * -1 : thermocouple with AD595 + * 0 : not used + * 1 : 100k thermistor - best choice for EPCOS 100k (4.7k pullup) + * 2 : 200k thermistor - ATC Semitec 204GT-2 (4.7k pullup) + * 3 : Mendel-parts thermistor (4.7k pullup) + * 4 : 10k thermistor !! do not use it for a hotend. It gives bad resolution at high temp. !! + * 5 : 100K thermistor - ATC Semitec 104GT-2/104NT-4-R025H42G (Used in ParCan & J-Head) (4.7k pullup) + * 501 : 100K Zonestar (Tronxy X3A) Thermistor + * 6 : 100k EPCOS - Not as accurate as table 1 (created using a fluke thermocouple) (4.7k pullup) + * 7 : 100k Honeywell thermistor 135-104LAG-J01 (4.7k pullup) + * 71 : 100k Honeywell thermistor 135-104LAF-J01 (4.7k pullup) + * 8 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) + * 9 : 100k GE Sensing AL03006-58.2K-97-G1 (4.7k pullup) + * 10 : 100k RS thermistor 198-961 (4.7k pullup) + * 11 : 100k beta 3950 1% thermistor (4.7k pullup) + * 12 : 100k 0603 SMD Vishay NTCS0603E3104FXT (4.7k pullup) (calibrated for Makibox hot bed) + * 13 : 100k Hisens 3950 1% up to 300°C for hotend "Simple ONE " & "Hotend "All In ONE" + * 15 : 100k thermistor calibration for JGAurora A5 hotend + * 20 : the PT100 circuit found in the Ultimainboard V2.x + * 60 : 100k Maker's Tool Works Kapton Bed Thermistor beta=3950 + * 66 : 4.7M High Temperature thermistor from Dyze Design + * 70 : the 100K thermistor found in the bq Hephestos 2 + * 75 : 100k Generic Silicon Heat Pad with NTC 100K MGB18-104F39050L32 thermistor + * + * 1k ohm pullup tables - This is atypical, and requires changing out the 4.7k pullup for 1k. + * (but gives greater accuracy and more stable PID) + * 51 : 100k thermistor - EPCOS (1k pullup) + * 52 : 200k thermistor - ATC Semitec 204GT-2 (1k pullup) + * 55 : 100k thermistor - ATC Semitec 104GT-2 (Used in ParCan & J-Head) (1k pullup) + * + * 1047 : Pt1000 with 4k7 pullup + * 1010 : Pt1000 with 1k pullup (non standard) + * 147 : Pt100 with 4k7 pullup + * 110 : Pt100 with 1k pullup (non standard) + * + * Use these for Testing or Development purposes. NEVER for production machine. + * 998 : Dummy Table that ALWAYS reads 25°C or the temperature defined below. + * 999 : Dummy Table that ALWAYS reads 100°C or the temperature defined below. + * + * :{ '0': "Not used", '1':"100k / 4.7k - EPCOS", '2':"200k / 4.7k - ATC Semitec 204GT-2", '3':"Mendel-parts / 4.7k", '4':"10k !! do not use for a hotend. Bad resolution at high temp. !!", '5':"100K / 4.7k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '501':"100K Zonestar (Tronxy X3A)", '6':"100k / 4.7k EPCOS - Not as accurate as Table 1", '7':"100k / 4.7k Honeywell 135-104LAG-J01", '8':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT", '9':"100k / 4.7k GE Sensing AL03006-58.2K-97-G1", '10':"100k / 4.7k RS 198-961", '11':"100k / 4.7k beta 3950 1%", '12':"100k / 4.7k 0603 SMD Vishay NTCS0603E3104FXT (calibrated for Makibox hot bed)", '13':"100k Hisens 3950 1% up to 300°C for hotend 'Simple ONE ' & hotend 'All In ONE'", '20':"PT100 (Ultimainboard V2.x)", '51':"100k / 1k - EPCOS", '52':"200k / 1k - ATC Semitec 204GT-2", '55':"100k / 1k - ATC Semitec 104GT-2 (Used in ParCan & J-Head)", '60':"100k Maker's Tool Works Kapton Bed Thermistor beta=3950", '66':"Dyze Design 4.7M High Temperature thermistor", '70':"the 100K thermistor found in the bq Hephestos 2", '71':"100k / 4.7k Honeywell 135-104LAF-J01", '147':"Pt100 / 4.7k", '1047':"Pt1000 / 4.7k", '110':"Pt100 / 1k (non-standard)", '1010':"Pt1000 / 1k (non standard)", '-4':"Thermocouple + AD8495", '-3':"Thermocouple + MAX31855 (only for sensor 0)", '-2':"Thermocouple + MAX6675 (only for sensor 0)", '-1':"Thermocouple + AD595",'998':"Dummy 1", '999':"Dummy 2" } + */ +#define TEMP_SENSOR_0 5 // Setting gotten from wiki.e3d-online.net instructions for V6 hot end +#define TEMP_SENSOR_1 0 +#define TEMP_SENSOR_2 0 +#define TEMP_SENSOR_3 0 +#define TEMP_SENSOR_4 0 +#define TEMP_SENSOR_BED 0 +#define TEMP_SENSOR_CHAMBER 0 + +// Dummy thermistor constant temperature readings, for use with 998 and 999 +#define DUMMY_THERMISTOR_998_VALUE 25 +#define DUMMY_THERMISTOR_999_VALUE 100 + +// Use temp sensor 1 as a redundant sensor with sensor 0. If the readings +// from the two sensors differ too much the print will be aborted. +//#define TEMP_SENSOR_1_AS_REDUNDANT +#define MAX_REDUNDANT_TEMP_SENSOR_DIFF 10 + +// Extruder temperature must be close to target for this long before M109 returns success +#define TEMP_RESIDENCY_TIME 10 // (seconds) +#define TEMP_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// Bed temperature must be close to target for this long before M190 returns success +#define TEMP_BED_RESIDENCY_TIME 10 // (seconds) +#define TEMP_BED_HYSTERESIS 3 // (degC) range of +/- temperatures considered "close" to the target one +#define TEMP_BED_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. + +// The minimal temperature defines the temperature below which the heater will not be enabled It is used +// to check that the wiring to the thermistor is not broken. +// Otherwise this would lead to the heater being powered on all the time. +#define HEATER_0_MINTEMP 5 +#define HEATER_1_MINTEMP 5 +#define HEATER_2_MINTEMP 5 +#define HEATER_3_MINTEMP 5 +#define HEATER_4_MINTEMP 5 +#define BED_MINTEMP 5 + +// When temperature exceeds max temp, your heater will be switched off. +// This feature exists to protect your hotend from overheating accidentally, but *NOT* from thermistor short/failure! +// You should use MINTEMP for thermistor short/failure protection. +#define HEATER_0_MAXTEMP 275 +#define HEATER_1_MAXTEMP 275 +#define HEATER_2_MAXTEMP 275 +#define HEATER_3_MAXTEMP 275 +#define HEATER_4_MAXTEMP 275 +#define BED_MAXTEMP 150 + +//=========================================================================== +//============================= PID Settings ================================ +//=========================================================================== +// PID Tuning Guide here: http://reprap.org/wiki/PID_Tuning + +// Comment the following line to disable PID and enable bang-bang. +#define PIDTEMP +#define BANG_MAX 255 // Limits current to nozzle while in bang-bang mode; 255=full current +#define PID_MAX BANG_MAX // Limits current to nozzle while PID is active (see PID_FUNCTIONAL_RANGE below); 255=full current +#define PID_K1 0.95 // Smoothing factor within any PID loop +#if ENABLED(PIDTEMP) + //#define PID_AUTOTUNE_MENU // Add PID Autotune to the LCD "Temperature" menu to run M303 and apply the result. + //#define PID_DEBUG // Sends debug data to the serial port. + //#define PID_OPENLOOP 1 // Puts PID in open loop. M104/M140 sets the output power from 0 to PID_MAX + //#define SLOW_PWM_HEATERS // PWM with very low frequency (roughly 0.125Hz=8s) and minimum state time of approximately 1s useful for heaters driven by a relay + //#define PID_PARAMS_PER_HOTEND // Uses separate PID parameters for each extruder (useful for mismatched extruders) + // Set/get with gcode: M301 E[extruder number, 0-2] + #define PID_FUNCTIONAL_RANGE 10 // If the temperature difference between the target temperature and the actual temperature + // is more than PID_FUNCTIONAL_RANGE then the PID will be shut off and the heater will be set to min/max. + + // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it + + // Hangprinter (Volcano, e3d V6, RAMPS, 120W power supply) + #define DEFAULT_Kp 39.76 + #define DEFAULT_Ki 3.26 + #define DEFAULT_Kd 121.18 + + // Ultimaker + //#define DEFAULT_Kp 22.2 + //#define DEFAULT_Ki 1.08 + //#define DEFAULT_Kd 114 + + // MakerGear + //#define DEFAULT_Kp 7.0 + //#define DEFAULT_Ki 0.1 + //#define DEFAULT_Kd 12 + + // Mendel Parts V9 on 12V + //#define DEFAULT_Kp 63.0 + //#define DEFAULT_Ki 2.25 + //#define DEFAULT_Kd 440 + +#endif // PIDTEMP + +//=========================================================================== +//============================= PID > Bed Temperature Control =============== +//=========================================================================== + +/** + * PID Bed Heating + * + * If this option is enabled set PID constants below. + * If this option is disabled, bang-bang will be used and BED_LIMIT_SWITCHING will enable hysteresis. + * + * The PID frequency will be the same as the extruder PWM. + * If PID_dT is the default, and correct for the hardware/configuration, that means 7.689Hz, + * which is fine for driving a square wave into a resistive load and does not significantly + * impact FET heating. This also works fine on a Fotek SSR-10DA Solid State Relay into a 250W + * heater. If your configuration is significantly different than this and you don't understand + * the issues involved, don't use bed PID until someone else verifies that your hardware works. + */ +//#define PIDTEMPBED + +//#define BED_LIMIT_SWITCHING + +/** + * Max Bed Power + * Applies to all forms of bed control (PID, bang-bang, and bang-bang with hysteresis). + * When set to any value below 255, enables a form of PWM to the bed that acts like a divider + * so don't use it unless you are OK with PWM on your bed. (See the comment on enabling PIDTEMPBED) + */ +#define MAX_BED_POWER 255 // limits duty cycle to bed; 255=full current + +#if ENABLED(PIDTEMPBED) + + //#define PID_BED_DEBUG // Sends debug data to the serial port. + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10) + #define DEFAULT_bedKp 10.00 + #define DEFAULT_bedKi .023 + #define DEFAULT_bedKd 305.4 + + //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+) + //from pidautotune + //#define DEFAULT_bedKp 97.1 + //#define DEFAULT_bedKi 1.41 + //#define DEFAULT_bedKd 1675.16 + + // FIND YOUR OWN: "M303 E-1 C8 S90" to run autotune on the bed at 90 degreesC for 8 cycles. +#endif // PIDTEMPBED + +// @section extruder + +/** + * Prevent extrusion if the temperature is below EXTRUDE_MINTEMP. + * Add M302 to set the minimum extrusion temperature and/or turn + * cold extrusion prevention on and off. + * + * *** IT IS HIGHLY RECOMMENDED TO LEAVE THIS OPTION ENABLED! *** + */ +#define PREVENT_COLD_EXTRUSION +#define EXTRUDE_MINTEMP 170 + +/** + * Prevent a single extrusion longer than EXTRUDE_MAXLENGTH. + * Note: For Bowden Extruders make this large enough to allow load/unload. + */ +#define PREVENT_LENGTHY_EXTRUDE +#define EXTRUDE_MAXLENGTH 200 + +//=========================================================================== +//======================== Thermal Runaway Protection ======================= +//=========================================================================== + +/** + * Thermal Protection provides additional protection to your printer from damage + * and fire. Marlin always includes safe min and max temperature ranges which + * protect against a broken or disconnected thermistor wire. + * + * The issue: If a thermistor falls out, it will report the much lower + * temperature of the air in the room, and the the firmware will keep + * the heater on. + * + * If you get "Thermal Runaway" or "Heating failed" errors the + * details can be tuned in Configuration_adv.h + */ + +#define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders +#define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed + +//=========================================================================== +//============================= Mechanical Settings ========================= +//=========================================================================== + +// @section machine + +// Uncomment one of these options to enable CoreXY, CoreXZ, or CoreYZ kinematics +// either in the usual order or reversed +//#define COREXY +//#define COREXZ +//#define COREYZ +//#define COREYX +//#define COREZX +//#define COREZY + +//=========================================================================== +//============================== Hangprinter Settings ======================= +//=========================================================================== + +// This value is used whether LINE_BUILDUP_COMPENSATION_FEATURE is enabled or not. +#define DEFAULT_E_AXIS_STEPS_PER_UNIT 410.0 // 410.0 set quite at random + +// Enable HANGPRINTER kinematics and most of the default configuration for Hangprinters +#define HANGPRINTER +#if ENABLED(HANGPRINTER) + #define KINEMATIC_SEGMENTS_PER_SECOND 40 + #define HANGPRINTER_PRINTABLE_RADIUS 1500.0 + // Anchor position coordinates + // ANCHOR_A_X = 0 by definition. Left out of all calculations + #define ANCHOR_A_Y -1234 + #define ANCHOR_A_Z -12 + #define ANCHOR_B_X 1234 + #define ANCHOR_B_Y 123 + #define ANCHOR_B_Z -12 + #define ANCHOR_C_X -1234 + #define ANCHOR_C_Y 1234 + #define ANCHOR_C_Z -12 + #define ANCHOR_D_Z 1234 + + // Disable this if you plan to place your anchors at unconventional places + // See SanityCheck.h for exact definition of the tested convention + // Warning: For this to work, don't use decimal points in the ANCHOR_ABCD_XYZ definitions. + #define CONVENTIONAL_GEOMETRY + + /** + * Line buildup compensation feature + * For documentation of theory behind, see: + * https://vitana.se/opr3d/tbear/2017.html#hangprinter_project_29 + * + * Lets you use more info about your lines and spools to improve accuracy and print volume. + * The amount of D-compensation at 3 m height is ~75 mm for a 0.5 mm line setup. + * + * If you plan on printing > 2 m you should definitely enable this + * and check that your motors wind/unwind close to exact amounts. + * + * Check by putting your printer in home position and wind/unwind using + * G6 S2 A2000 + * Note that this requires UNREGISTERED_MOVE_SUPPORT, + * and that your printer will be confused about where it is after a G6 move + */ + #define LINE_BUILDUP_COMPENSATION_FEATURE + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + // Allows gearing down with pulley principle + #define MECHANICAL_ADVANTAGE { 1, 1, 1, 1 } + + // The point where line meets mover is called action point + #define ACTION_POINTS { 2, 2, 2, 3 } + + /** + * Naive buildup factor calculation (assumes cylindrical, straight line) + * line diameter: 0.5 mm + * spool height: 8.0 mm + * (line_cross_section_area)/(height*pi): ((0.5/2)*(0.5/2)*pi)/(8.0*pi) = 0.0078 mm + * + * Default buildup factor for 0.50 mm FireLine: 0.0078 + * Default buildup factor for 0.39 mm FireLine: 0.00475 + * In practice you might want to compensate a bit more or a bit less + */ + #define SPOOL_BUILDUP_FACTOR 0.0078 + + /** + * Total length of lines on each spool + * Default assumes all nine lines are cut to length 7500 mm. + * Change to whatever length you have cut your different lines to. + */ + #define MOUNTED_LINE { 7500.0, 7500.0, 7500.0, 4000.0 } + + // Measuring your spool radii and adjusting this number will improve your Hangprinter's precision + #define SPOOL_RADII { 55.0, 55.0, 55.0, 55.0 } + + // Used for calculating steps per spool radian and the static steps per mm used in acceleration planning + #define MOTOR_GEAR_TEETH { 10, 10, 10, 10 } + #define SPOOL_GEAR_TEETH { 100, 100, 100, 100 } + + #endif // LINE_BUILDUP_COMPENSATION_FEATURE +#endif // HANGPRINTER + +// Activate G6: Direct Stepper Move +// Super useful when Hangprinting +#define UNREGISTERED_MOVE_SUPPORT + +/** + * == Torque mode: G95 [ A B C D ] == + * Sets your Mechaduino-driven and i2c-connected Mechaduino in torque mode. + * Parameters: A, B, C, and D, each with argument +-[1-254] for specifying magnitude of torque. + * The argument 0 is special and places motor back into position mode. + * + * Changing the sign of the argument changes the torque direction. + * A positive sign or no sign should tigthen line by winding line inwards, onto the spool. + * + * If several motors are simultaneously in torque mode, the mover can be pushed around by hand. + * This is useful when homing manually (placing nozzle in origin and tightening lines). + * + * Try for example: + * G95 A40 B40 C40 D30 + * Now push mover until nozzle is in origo. + * Then go back to position mode: + * G95 A0 B0 C0 D0 + * Re-establish correct G0/G1-moves + * G92 X0 Y0 Z0 + * + * Your Hangprinter will be confused about where it is during/after G95. + * This is the reason for the G92 in the above example. + * + * == Mark reference point: G96 [ A B C D ] == + * Tells the Mechaduino to read it's encoder value and remember it. + * This encoder position will be used as reference point when issuing M114 S1 later. + * If one or several of [ A B C D ] parameters are issued, then only those axes get their reference points marked. + * + * == Get line length from encoder: M114 S1 == + * Asks all Mechaduinos how much encoders have rotated since the last G96. + * Uses that data to calculate how much line has been wound in or out. + * Takes line buildup into account if LINE_BUILDUP_COMPENSATION_FEATURE is enabled, + * but the compensation will be imperfect if configured anchor positions are imperfect + * or if the machine was not at the origin with tight lines when the previous G96 was issued. + */ +#define MECHADUINO_I2C_COMMANDS + +//=========================================================================== +//============================== Endstop Settings =========================== +//=========================================================================== + +// @section homing + +// Specify here all the endstop connectors that are connected to any endstop or probe. +// Almost all printers will be using one per axis. Probes will use one or more of the +// extra connectors. Leave undefined any used for non-endstop and non-probe purposes. +//#define USE_XMIN_PLUG +//#define USE_YMIN_PLUG +//#define USE_ZMIN_PLUG // a Z probe +//#define USE_XMAX_PLUG +//#define USE_YMAX_PLUG +//#define USE_ZMAX_PLUG + +// Enable pullup for all endstops to prevent a floating state +#define ENDSTOPPULLUPS +#if DISABLED(ENDSTOPPULLUPS) + // Disable ENDSTOPPULLUPS to set pullups individually + //#define ENDSTOPPULLUP_XMAX + //#define ENDSTOPPULLUP_YMAX + //#define ENDSTOPPULLUP_ZMAX + //#define ENDSTOPPULLUP_XMIN + //#define ENDSTOPPULLUP_YMIN + //#define ENDSTOPPULLUP_ZMIN + //#define ENDSTOPPULLUP_ZMIN_PROBE +#endif + +// Mechanical endstop with COM to ground and NC to Signal uses "false" here (most common setup). +#define X_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Y_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Z_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define X_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Y_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Z_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. +#define Z_MIN_PROBE_ENDSTOP_INVERTING true // set to true to invert the logic of the probe. + +/** + * Stepper Drivers + * + * These settings allow Marlin to tune stepper driver timing and enable advanced options for + * stepper drivers that support them. You may also override timing options in Configuration_adv.h. + * + * A4988 is assumed for unspecified drivers. + * + * Options: A4988, DRV8825, LV8729, L6470, TB6560, TB6600, TMC2100, + * TMC2130, TMC2130_STANDALONE, TMC2208, TMC2208_STANDALONE, + * TMC26X, TMC26X_STANDALONE, TMC2660, TMC2660_STANDALONE, + * TMC5130, TMC5130_STANDALONE + * :['A4988', 'DRV8825', 'LV8729', 'L6470', 'TB6560', 'TB6600', 'TMC2100', 'TMC2130', 'TMC2130_STANDALONE', 'TMC2208', 'TMC2208_STANDALONE', 'TMC26X', 'TMC26X_STANDALONE', 'TMC2660', 'TMC2660_STANDALONE', 'TMC5130', 'TMC5130_STANDALONE'] + */ +//#define X_DRIVER_TYPE A4988 +//#define Y_DRIVER_TYPE A4988 +//#define Z_DRIVER_TYPE A4988 +//#define X2_DRIVER_TYPE A4988 +//#define Y2_DRIVER_TYPE A4988 +//#define Z2_DRIVER_TYPE A4988 +//#define E0_DRIVER_TYPE A4988 +//#define E1_DRIVER_TYPE A4988 +//#define E2_DRIVER_TYPE A4988 +//#define E3_DRIVER_TYPE A4988 +//#define E4_DRIVER_TYPE A4988 + +// Enable this feature if all enabled endstop pins are interrupt-capable. +// This will remove the need to poll the interrupt pins, saving many CPU cycles. +//#define ENDSTOP_INTERRUPTS_FEATURE + +/** + * Endstop Noise Filter + * + * Enable this option if endstops falsely trigger due to noise. + * NOTE: Enabling this feature means adds an error of +/-0.2mm, so homing + * will end up at a slightly different position on each G28. This will also + * reduce accuracy of some bed probes. + * For mechanical switches, the better approach to reduce noise is to install + * a 100 nanofarads ceramic capacitor in parallel with the switch, making it + * essentially noise-proof without sacrificing accuracy. + * This option also increases MCU load when endstops or the probe are enabled. + * So this is not recommended. USE AT YOUR OWN RISK. + * (This feature is not required for common micro-switches mounted on PCBs + * based on the Makerbot design, since they already include the 100nF capacitor.) + */ +//#define ENDSTOP_NOISE_FILTER + +//============================================================================= +//============================== Movement Settings ============================ +//============================================================================= +// @section motion + +/** + * Default Settings + * + * These settings can be reset by M502 + * + * Note that if EEPROM is enabled, saved values will override these. + */ + +/** + * With this option each E stepper can have its own factors for the + * following movement settings. If fewer factors are given than the + * total number of extruders, the last value applies to the rest. + */ +//#define DISTINCT_E_FACTORS + +/** + * Default Axis Steps Per Unit (steps/mm) + * Override with M92 + * LINE_BUILDUP_COMPENSATION_FEATURE overrides ABCD values + * A B C D + */ +#define DEFAULT_AXIS_STEPS_PER_UNIT { 92.599, 92.599, 92.599, 92.599, DEFAULT_E_AXIS_STEPS_PER_UNIT } + +/** + * Default Max Feed Rate (mm/s) + * Override with M203 + * A B C D E + */ +#define DEFAULT_MAX_FEEDRATE { 500, 500, 500, 300, 25 } + +/** + * Default Max Acceleration (change/s) change = mm/s + * (Maximum start speed for accelerated moves) + * Override with M201 + * A B C D E + */ +#define DEFAULT_MAX_ACCELERATION { 1000, 1000, 1000, 1000, 10000 } + +/** + * Default Acceleration (change/s) change = mm/s + * Override with M204 + * + * M204 P Acceleration + * M204 R Retract Acceleration + * M204 T Travel Acceleration + */ +#define DEFAULT_ACCELERATION 900 // X, Y, Z and E acceleration for printing moves +#define DEFAULT_RETRACT_ACCELERATION 3000 // E acceleration for retracts +#define DEFAULT_TRAVEL_ACCELERATION 900 // X, Y, Z acceleration for travel (non printing) moves + +/** + * Default Jerk (mm/s) + * Override with M205 X Y Z E + * + * "Jerk" specifies the minimum speed change that requires acceleration. + * When changing speed and direction, if the difference is less than the + * value set here, it may happen instantaneously. + */ +#define DEFAULT_AJERK 13.0 +#define DEFAULT_BJERK 13.0 +#define DEFAULT_CJERK 13.0 +#define DEFAULT_DJERK 13.0 +#define DEFAULT_EJERK 5.0 + +/** + * S-Curve Acceleration + * + * This option eliminates vibration during printing by fitting a Bézier + * curve to move acceleration, producing much smoother direction changes. + * + * See https://github.com/synthetos/TinyG/wiki/Jerk-Controlled-Motion-Explained + */ +//#define S_CURVE_ACCELERATION + +//=========================================================================== +//============================= Z Probe Options ============================= +//=========================================================================== +// @section probes + +// +// See http://marlinfw.org/docs/configuration/probes.html +// + +/** + * Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN + * + * Enable this option for a probe connected to the Z Min endstop pin. + */ +#define Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN + +/** + * Z_MIN_PROBE_ENDSTOP + * + * Enable this option for a probe connected to any pin except Z-Min. + * (By default Marlin assumes the Z-Max endstop pin.) + * To use a custom Z Probe pin, set Z_MIN_PROBE_PIN below. + * + * - The simplest option is to use a free endstop connector. + * - Use 5V for powered (usually inductive) sensors. + * + * - RAMPS 1.3/1.4 boards may use the 5V, GND, and Aux4->D32 pin: + * - For simple switches connect... + * - normally-closed switches to GND and D32. + * - normally-open switches to 5V and D32. + * + * WARNING: Setting the wrong pin may have unexpected and potentially + * disastrous consequences. Use with caution and do your homework. + * + */ +//#define Z_MIN_PROBE_ENDSTOP + +/** + * Probe Type + * + * Allen Key Probes, Servo Probes, Z-Sled Probes, FIX_MOUNTED_PROBE, etc. + * Activate one of these to use Auto Bed Leveling below. + */ + +/** + * The "Manual Probe" provides a means to do "Auto" Bed Leveling without a probe. + * Use G29 repeatedly, adjusting the Z height at each point with movement commands + * or (with LCD_BED_LEVELING) the LCD controller. + */ +//#define PROBE_MANUALLY +//#define MANUAL_PROBE_START_Z 0.2 + +/** + * A Fix-Mounted Probe either doesn't deploy or needs manual deployment. + * (e.g., an inductive probe or a nozzle-based probe-switch.) + */ +//#define FIX_MOUNTED_PROBE + +/** + * Z Servo Probe, such as an endstop switch on a rotating arm. + */ +//#define Z_PROBE_SERVO_NR 0 // Defaults to SERVO 0 connector. +//#define Z_SERVO_ANGLES {70,0} // Z Servo Deploy and Stow angles + +/** + * The BLTouch probe uses a Hall effect sensor and emulates a servo. + */ +//#define BLTOUCH +#if ENABLED(BLTOUCH) + //#define BLTOUCH_DELAY 375 // (ms) Enable and increase if needed +#endif + +/** + * Enable one or more of the following if probing seems unreliable. + * Heaters and/or fans can be disabled during probing to minimize electrical + * noise. A delay can also be added to allow noise and vibration to settle. + * These options are most useful for the BLTouch probe, but may also improve + * readings with inductive probes and piezo sensors. + */ +//#define PROBING_HEATERS_OFF // Turn heaters off when probing +#if ENABLED(PROBING_HEATERS_OFF) + //#define WAIT_FOR_BED_HEATER // Wait for bed to heat back up between probes (to improve accuracy) +#endif +//#define PROBING_FANS_OFF // Turn fans off when probing +//#define DELAY_BEFORE_PROBING 200 // (ms) To prevent vibrations from triggering piezo sensors + +// A probe that is deployed and stowed with a solenoid pin (SOL1_PIN) +//#define SOLENOID_PROBE + +// A sled-mounted probe like those designed by Charles Bell. +//#define Z_PROBE_SLED +//#define SLED_DOCKING_OFFSET 5 // The extra distance the X axis must travel to pickup the sled. 0 should be fine but you can push it further if you'd like. + +// +// For Z_PROBE_ALLEN_KEY see the Delta example configurations. +// + +/** + * Z Probe to nozzle (X,Y) offset, relative to (0, 0). + * X and Y offsets must be integers. + * + * In the following example the X and Y offsets are both positive: + * #define X_PROBE_OFFSET_FROM_EXTRUDER 10 + * #define Y_PROBE_OFFSET_FROM_EXTRUDER 10 + * + * +-- BACK ---+ + * | | + * L | (+) P | R <-- probe (20,20) + * E | | I + * F | (-) N (+) | G <-- nozzle (10,10) + * T | | H + * | (-) | T + * | | + * O-- FRONT --+ + * (0,0) + */ +#define X_PROBE_OFFSET_FROM_EXTRUDER 0 // X offset: -left +right [of the nozzle] +#define Y_PROBE_OFFSET_FROM_EXTRUDER -10 // Y offset: -front +behind [the nozzle] +#define Z_PROBE_OFFSET_FROM_EXTRUDER -3.5 // Z offset: -below +above [the nozzle] + +// Certain types of probes need to stay away from edges +#define MIN_PROBE_EDGE 10 + +// X and Y axis travel speed (mm/m) between probes +#define XY_PROBE_SPEED 4000 + +// Feedrate (mm/m) for the first approach when double-probing (MULTIPLE_PROBING == 2) +#define Z_PROBE_SPEED_FAST DUMMY_HOMING_FEEDRATE + +// Feedrate (mm/m) for the "accurate" probe of each point +#define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2) + +// The number of probes to perform at each point. +// Set to 2 for a fast/slow probe, using the second probe result. +// Set to 3 or more for slow probes, averaging the results. +//#define MULTIPLE_PROBING 2 + +/** + * Z probes require clearance when deploying, stowing, and moving between + * probe points to avoid hitting the bed and other hardware. + * Servo-mounted probes require extra space for the arm to rotate. + * Inductive probes need space to keep from triggering early. + * + * Use these settings to specify the distance (mm) to raise the probe (or + * lower the bed). The values set here apply over and above any (negative) + * probe Z Offset set with Z_PROBE_OFFSET_FROM_EXTRUDER, M851, or the LCD. + * Only integer values >= 1 are valid here. + * + * Example: `M851 Z-5` with a CLEARANCE of 4 => 9mm from bed to nozzle. + * But: `M851 Z+1` with a CLEARANCE of 2 => 2mm from bed to nozzle. + */ +#define Z_CLEARANCE_DEPLOY_PROBE 15 // Z Clearance for Deploy/Stow +#define Z_CLEARANCE_BETWEEN_PROBES 5 // Z Clearance between probe points +#define Z_CLEARANCE_MULTI_PROBE 5 // Z Clearance between multiple probes +//#define Z_AFTER_PROBING 5 // Z position after probing is done + +#define Z_PROBE_LOW_POINT -2 // Farthest distance below the trigger-point to go before stopping + +// For M851 give a range for adjusting the Z probe offset +#define Z_PROBE_OFFSET_RANGE_MIN -20 +#define Z_PROBE_OFFSET_RANGE_MAX 20 + +// Enable the M48 repeatability test to test probe accuracy +//#define Z_MIN_PROBE_REPEATABILITY_TEST + +// For Inverting Stepper Enable Pins (Active Low) use 0, Non Inverting (Active High) use 1 +// :{ 0:'Low', 1:'High' } +#define X_ENABLE_ON 0 +#define Y_ENABLE_ON 0 +#define Z_ENABLE_ON 0 +#define E_ENABLE_ON 0 // For all extruders + +// Disables axis stepper immediately when it's not being used. +// WARNING: When motors turn off there is a chance of losing position accuracy! +// Never disable any motors on a Hangprinter +#define DISABLE_X false +#define DISABLE_Y false +#define DISABLE_Z false +// Warn on display about possibly reduced accuracy +//#define DISABLE_REDUCED_ACCURACY_WARNING + +// @section extruder + +#define DISABLE_E false // For all extruders +#define DISABLE_INACTIVE_EXTRUDER false // Keep only the active extruder enabled. + +// @section machine + +// Invert the stepper direction. Change (or reverse the motor connector) if an axis goes the wrong way. +#define INVERT_A_DIR false +#define INVERT_B_DIR true +#define INVERT_C_DIR false +#define INVERT_D_DIR false + +#define INVERT_X_DIR INVERT_A_DIR +#define INVERT_Y_DIR INVERT_B_DIR +#define INVERT_Z_DIR INVERT_C_DIR +#if EXTRUDERS == 1 + #define INVERT_E1_DIR INVERT_D_DIR +#elif EXTRUDERS == 2 + #define INVERT_E2_DIR INVERT_D_DIR +#elif EXTRUDERS == 3 + #define INVERT_E3_DIR INVERT_D_DIR +#elif EXTRUDERS == 4 + #define INVERT_E4_DIR INVERT_D_DIR +#endif + +// Enable this option for Toshiba stepper drivers +//#define CONFIG_STEPPERS_TOSHIBA + +// @section extruder + +// For direct drive extruder v9 set to true, for geared extruder set to false. +#define INVERT_E0_DIR false +#if EXTRUDERS != 1 + #define INVERT_E1_DIR false +#endif +#if EXTRUDERS != 2 + #define INVERT_E2_DIR false +#endif +#if EXTRUDERS != 3 + #define INVERT_E3_DIR false +#endif +#if EXTRUDERS != 4 + #define INVERT_E4_DIR false +#endif + +// @section homing + +//#define NO_MOTION_BEFORE_HOMING // Inhibit movement until all axes have been homed. Don't use with Hangprinter + +//#define UNKNOWN_Z_NO_RAISE // Don't raise Z (lower the bed) if Z is "unknown." For beds that fall when Z is powered off. + +//#define Z_HOMING_HEIGHT 4 // (in mm) Minimal z height before homing (G28) for Z clearance above the bed, clamps, ... + // Be sure you have this distance over your Z_MAX_POS in case. + +// Direction of endstops when homing; 1=MAX, -1=MIN +// :[-1,1] +#define X_HOME_DIR 1 // Doesn't make sense for Hangprinter since it doesn't move while homing +#define Y_HOME_DIR 1 +#define Z_HOME_DIR 1 + +// @section machine + +// The size of the print bed +#define X_BED_SIZE ((HANGPRINTER_PRINTABLE_RADIUS) * 2) +#define Y_BED_SIZE ((HANGPRINTER_PRINTABLE_RADIUS) * 2) + +// Travel limits (mm) after homing, corresponding to endstop positions. +#define X_MIN_POS -(HANGPRINTER_PRINTABLE_RADIUS) +#define Y_MIN_POS -(HANGPRINTER_PRINTABLE_RADIUS) +#define Z_MIN_POS 0 +#define X_MAX_POS HANGPRINTER_PRINTABLE_RADIUS +#define Y_MAX_POS HANGPRINTER_PRINTABLE_RADIUS +#define Z_MAX_POS (ANCHOR_D_Z - 300.0) + +/** + * Software Endstops + * + * - Prevent moves outside the set machine bounds. + * - Individual axes can be disabled, if desired. + * - X and Y only apply to Cartesian robots. + * - Use 'M211' to set software endstops on/off or report current state + */ + +// Min software endstops constrain movement within minimum coordinate bounds +// Don't use with Hangprinter +//#define MIN_SOFTWARE_ENDSTOPS +#if ENABLED(MIN_SOFTWARE_ENDSTOPS) + #define MIN_SOFTWARE_ENDSTOP_X + #define MIN_SOFTWARE_ENDSTOP_Y + #define MIN_SOFTWARE_ENDSTOP_Z +#endif + +// Max software endstops constrain movement within maximum coordinate bounds +// Don't use with Hangprinter +//#define MAX_SOFTWARE_ENDSTOPS +#if ENABLED(MAX_SOFTWARE_ENDSTOPS) + #define MAX_SOFTWARE_ENDSTOP_X + #define MAX_SOFTWARE_ENDSTOP_Y + #define MAX_SOFTWARE_ENDSTOP_Z +#endif + +#if ENABLED(MIN_SOFTWARE_ENDSTOPS) || ENABLED(MAX_SOFTWARE_ENDSTOPS) + //#define SOFT_ENDSTOPS_MENU_ITEM // Enable/Disable software endstops from the LCD +#endif + +/** + * Filament Runout Sensors + * Mechanical or opto endstops are used to check for the presence of filament. + * + * RAMPS-based boards use SERVO3_PIN for the first runout sensor. + * For other boards you may need to define FIL_RUNOUT_PIN, FIL_RUNOUT2_PIN, etc. + * By default the firmware assumes HIGH=FILAMENT PRESENT. + */ +//#define FILAMENT_RUNOUT_SENSOR +#if ENABLED(FILAMENT_RUNOUT_SENSOR) + #define NUM_RUNOUT_SENSORS 1 // Number of sensors, up to one per extruder. Define a FIL_RUNOUT#_PIN for each. + #define FIL_RUNOUT_INVERTING false // set to true to invert the logic of the sensor. + #define FIL_RUNOUT_PULLUP // Use internal pullup for filament runout pins. + #define FILAMENT_RUNOUT_SCRIPT "M600" +#endif + +//=========================================================================== +//=============================== Bed Leveling ============================== +//=========================================================================== +// @section calibrate + +/** + * Choose one of the options below to enable G29 Bed Leveling. The parameters + * and behavior of G29 will change depending on your selection. + * + * If using a Probe for Z Homing, enable Z_SAFE_HOMING also! + * + * - AUTO_BED_LEVELING_3POINT + * Probe 3 arbitrary points on the bed (that aren't collinear) + * You specify the XY coordinates of all 3 points. + * The result is a single tilted plane. Best for a flat bed. + * + * - AUTO_BED_LEVELING_LINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a single tilted plane. Best for a flat bed. + * + * - AUTO_BED_LEVELING_BILINEAR + * Probe several points in a grid. + * You specify the rectangle and the density of sample points. + * The result is a mesh, best for large or uneven beds. + * + * - AUTO_BED_LEVELING_UBL (Unified Bed Leveling) + * A comprehensive bed leveling system combining the features and benefits + * of other systems. UBL also includes integrated Mesh Generation, Mesh + * Validation and Mesh Editing systems. + * + * - MESH_BED_LEVELING + * Probe a grid manually + * The result is a mesh, suitable for large or uneven beds. (See BILINEAR.) + * For machines without a probe, Mesh Bed Leveling provides a method to perform + * leveling in steps so you can manually adjust the Z height at each grid-point. + * With an LCD controller the process is guided step-by-step. + */ +//#define AUTO_BED_LEVELING_3POINT +//#define AUTO_BED_LEVELING_LINEAR +//#define AUTO_BED_LEVELING_BILINEAR +//#define AUTO_BED_LEVELING_UBL +//#define MESH_BED_LEVELING + +/** + * Normally G28 leaves leveling disabled on completion. Enable + * this option to have G28 restore the prior leveling state. + */ +//#define RESTORE_LEVELING_AFTER_G28 + +/** + * Enable detailed logging of G28, G29, M48, etc. + * Turn on with the command 'M111 S32'. + * NOTE: Requires a lot of PROGMEM! + */ +//#define DEBUG_LEVELING_FEATURE + +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(AUTO_BED_LEVELING_UBL) + // Gradually reduce leveling correction until a set height is reached, + // at which point movement will be level to the machine's XY plane. + // The height can be set with M420 Z + //#define ENABLE_LEVELING_FADE_HEIGHT + + // Set the boundaries for probing (where the probe can reach). + #define HANGPRINTER_PROBEABLE_RADIUS (HANGPRINTER_PRINTABLE_RADIUS - 10) + + // For Cartesian machines, instead of dividing moves on mesh boundaries, + // split up moves into short segments like a Delta. This follows the + // contours of the bed more closely than edge-to-edge straight moves. + #define SEGMENT_LEVELED_MOVES + #define LEVELED_SEGMENT_LENGTH 5.0 // (mm) Length of all segments (except the last one) + + /** + * Enable the G26 Mesh Validation Pattern tool. + */ + //#define G26_MESH_VALIDATION + #if ENABLED(G26_MESH_VALIDATION) + #define MESH_TEST_NOZZLE_SIZE 0.4 // (mm) Diameter of primary nozzle. + #define MESH_TEST_LAYER_HEIGHT 0.2 // (mm) Default layer height for the G26 Mesh Validation Tool. + #define MESH_TEST_HOTEND_TEMP 205.0 // (°C) Default nozzle temperature for the G26 Mesh Validation Tool. + #define MESH_TEST_BED_TEMP 60.0 // (°C) Default bed temperature for the G26 Mesh Validation Tool. + #endif + +#endif + +#if ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // Set the number of grid points per dimension. + #define GRID_MAX_POINTS_X 9 + #define GRID_MAX_POINTS_Y GRID_MAX_POINTS_X + + // Set the boundaries for probing (where the probe can reach). + #define LEFT_PROBE_BED_POSITION -(HANGPRINTER_PROBEABLE_RADIUS) + #define RIGHT_PROBE_BED_POSITION HANGPRINTER_PROBEABLE_RADIUS + #define FRONT_PROBE_BED_POSITION -(HANGPRINTER_PROBEABLE_RADIUS) + #define BACK_PROBE_BED_POSITION HANGPRINTER_PROBEABLE_RADIUS + + // Probe along the Y axis, advancing X after each column + //#define PROBE_Y_FIRST + + #if ENABLED(AUTO_BED_LEVELING_BILINEAR) + + // Beyond the probed grid, continue the implied tilt? + // Default is to maintain the height of the nearest edge. + //#define EXTRAPOLATE_BEYOND_GRID + + // + // Experimental Subdivision of the grid by Catmull-Rom method. + // Synthesizes intermediate points to produce a more detailed mesh. + // + //#define ABL_BILINEAR_SUBDIVISION + #if ENABLED(ABL_BILINEAR_SUBDIVISION) + // Number of subdivisions between probe points + #define BILINEAR_SUBDIVISIONS 3 + #endif + + #endif + +#elif ENABLED(AUTO_BED_LEVELING_UBL) + + //=========================================================================== + //========================= Unified Bed Leveling ============================ + //=========================================================================== + + //#define MESH_EDIT_GFX_OVERLAY // Display a graphics overlay while editing the mesh + + #define MESH_INSET 1 // Set Mesh bounds as an inset region of the bed + #define GRID_MAX_POINTS_X 10 // Don't use more than 15 points per axis, implementation limited. + #define GRID_MAX_POINTS_Y GRID_MAX_POINTS_X + + #define UBL_MESH_EDIT_MOVES_Z // Sophisticated users prefer no movement of nozzle + #define UBL_SAVE_ACTIVE_ON_M500 // Save the currently active mesh in the current slot on M500 + + //#define UBL_Z_RAISE_WHEN_OFF_MESH 2.5 // When the nozzle is off the mesh, this value is used + // as the Z-Height correction value. + +#elif ENABLED(MESH_BED_LEVELING) + + //=========================================================================== + //=================================== Mesh ================================== + //=========================================================================== + + #define MESH_INSET 10 // Set Mesh bounds as an inset region of the bed + #define GRID_MAX_POINTS_X 3 // Don't use more than 7 points per axis, implementation limited. + #define GRID_MAX_POINTS_Y GRID_MAX_POINTS_X + + //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS + +#endif // BED_LEVELING + +/** + * Points to probe for all 3-point Leveling procedures. + * Override if the automatically selected points are inadequate. + */ +#if ENABLED(AUTO_BED_LEVELING_3POINT) || ENABLED(AUTO_BED_LEVELING_UBL) + #define _PX(R,A) (R) * cos(RADIANS(A)) + #define _PY(R,A) (R) * sin(RADIANS(A)) + #define UBL_PROBE_PT_1_X _PX(HANGPRINTER_PROBEABLE_RADIUS, 0) // Probing points for 3-Point leveling of the mesh + #define UBL_PROBE_PT_1_Y _PY(HANGPRINTER_PROBEABLE_RADIUS, 0) + #define UBL_PROBE_PT_2_X _PX(HANGPRINTER_PROBEABLE_RADIUS, 120) + #define UBL_PROBE_PT_2_Y _PY(HANGPRINTER_PROBEABLE_RADIUS, 120) + #define UBL_PROBE_PT_3_X _PX(HANGPRINTER_PROBEABLE_RADIUS, 240) + #define UBL_PROBE_PT_3_Y _PY(HANGPRINTER_PROBEABLE_RADIUS, 240) +#endif + +/** + * Add a bed leveling sub-menu for ABL or MBL. + * Include a guided procedure if manual probing is enabled. + */ +//#define LCD_BED_LEVELING + +#if ENABLED(LCD_BED_LEVELING) + #define MBL_Z_STEP 0.025 // Step size while manually probing Z axis. + #define LCD_PROBE_Z_RANGE 4 // Z Range centered on Z_MIN_POS for LCD Z adjustment +#endif + +// Add a menu item to move between bed corners for manual bed adjustment +//#define LEVEL_BED_CORNERS + +#if ENABLED(LEVEL_BED_CORNERS) + #define LEVEL_CORNERS_INSET 30 // (mm) An inset for corner leveling + //#define LEVEL_CENTER_TOO // Move to the center after the last corner +#endif + +/** + * Commands to execute at the end of G29 probing. + * Useful to retract or move the Z probe out of the way. + */ +//#define Z_PROBE_END_SCRIPT "G1 Z10 F12000\nG1 X15 Y330\nG1 Z0.5\nG1 Z10" + + +// @section homing + +// The center of the bed is at (X=0, Y=0) +#define BED_CENTER_AT_0_0 + +// Manually set the home position. Leave these undefined for automatic settings. +// For HANGPRINTER this is the bottom-center of the Cartesian print volume. +//#define MANUAL_X_HOME_POS 0 +//#define MANUAL_Y_HOME_POS 0 +//#define MANUAL_Z_HOME_POS 0 + +// Use "Z Safe Homing" to avoid homing with a Z probe outside the bed area. +// +// With this feature enabled: +// +// - Allow Z homing only after X and Y homing AND stepper drivers still enabled. +// - If stepper drivers time out, it will need X and Y homing again before Z homing. +// - Move the Z probe (or nozzle) to a defined XY point before Z Homing when homing all axes (G28). +// - Prevent Z homing when the Z probe is outside bed area. +// +//#define Z_SAFE_HOMING + +#if ENABLED(Z_SAFE_HOMING) + #define Z_SAFE_HOMING_X_POINT ((X_BED_SIZE) / 2) // X point for Z homing when homing all axes (G28). + #define Z_SAFE_HOMING_Y_POINT ((Y_BED_SIZE) / 2) // Y point for Z homing when homing all axes (G28). +#endif + +// Hangprinter doesn't have automatic homing +#define DUMMY_HOMING_FEEDRATE (200*60) + +// Homing speeds (mm/m) +#define HOMING_FEEDRATE_XY (50*60) +#define HOMING_FEEDRATE_Z (4*60) + +// @section calibrate + +/** + * Bed Skew Compensation + * + * This feature corrects for misalignment in the XYZ axes. + * + * Take the following steps to get the bed skew in the XY plane: + * 1. Print a test square (e.g., https://www.thingiverse.com/thing:2563185) + * 2. For XY_DIAG_AC measure the diagonal A to C + * 3. For XY_DIAG_BD measure the diagonal B to D + * 4. For XY_SIDE_AD measure the edge A to D + * + * Marlin automatically computes skew factors from these measurements. + * Skew factors may also be computed and set manually: + * + * - Compute AB : SQRT(2*AC*AC+2*BD*BD-4*AD*AD)/2 + * - XY_SKEW_FACTOR : TAN(PI/2-ACOS((AC*AC-AB*AB-AD*AD)/(2*AB*AD))) + * + * If desired, follow the same procedure for XZ and YZ. + * Use these diagrams for reference: + * + * Y Z Z + * ^ B-------C ^ B-------C ^ B-------C + * | / / | / / | / / + * | / / | / / | / / + * | A-------D | A-------D | A-------D + * +-------------->X +-------------->X +-------------->Y + * XY_SKEW_FACTOR XZ_SKEW_FACTOR YZ_SKEW_FACTOR + */ +//#define SKEW_CORRECTION + +#if ENABLED(SKEW_CORRECTION) + // Input all length measurements here: + #define XY_DIAG_AC 282.8427124746 + #define XY_DIAG_BD 282.8427124746 + #define XY_SIDE_AD 200 + + // Or, set the default skew factors directly here + // to override the above measurements: + #define XY_SKEW_FACTOR 0.0 + + //#define SKEW_CORRECTION_FOR_Z + #if ENABLED(SKEW_CORRECTION_FOR_Z) + #define XZ_DIAG_AC 282.8427124746 + #define XZ_DIAG_BD 282.8427124746 + #define YZ_DIAG_AC 282.8427124746 + #define YZ_DIAG_BD 282.8427124746 + #define YZ_SIDE_AD 200 + #define XZ_SKEW_FACTOR 0.0 + #define YZ_SKEW_FACTOR 0.0 + #endif + + // Enable this option for M852 to set skew at runtime + //#define SKEW_CORRECTION_GCODE +#endif + +//============================================================================= +//============================= Additional Features =========================== +//============================================================================= + +// @section extras + +// +// EEPROM +// +// The microcontroller can store settings in the EEPROM, e.g. max velocity... +// M500 - stores parameters in EEPROM +// M501 - reads parameters from EEPROM (if you need reset them after you changed them temporarily). +// M502 - reverts to the default "factory settings". You still need to store them in EEPROM afterwards if you want to. +// +#define EEPROM_SETTINGS // Enable for M500 and M501 commands +//#define DISABLE_M503 // Saves ~2700 bytes of PROGMEM. Disable for release! +#define EEPROM_CHITCHAT // Give feedback on EEPROM commands. Disable to save PROGMEM. + +// +// Host Keepalive +// +// When enabled Marlin will send a busy status message to the host +// every couple of seconds when it can't accept commands. +// +#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages +#define DEFAULT_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113. +#define BUSY_WHILE_HEATING // Some hosts require "busy" messages even during heating + +// +// M100 Free Memory Watcher +// +//#define M100_FREE_MEMORY_WATCHER // Add M100 (Free Memory Watcher) to debug memory usage + +// +// G20/G21 Inch mode support +// +//#define INCH_MODE_SUPPORT + +// +// M149 Set temperature units support +// +//#define TEMPERATURE_UNITS_SUPPORT + +// @section temperature + +// Preheat Constants +#define PREHEAT_1_TEMP_HOTEND 180 +#define PREHEAT_1_TEMP_BED 70 +#define PREHEAT_1_FAN_SPEED 255 // Value from 0 to 255 + +#define PREHEAT_2_TEMP_HOTEND 240 +#define PREHEAT_2_TEMP_BED 100 +#define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255 + +/** + * Nozzle Park + * + * Park the nozzle at the given XYZ position on idle or G27. + * + * The "P" parameter controls the action applied to the Z axis: + * + * P0 (Default) If Z is below park Z raise the nozzle. + * P1 Raise the nozzle always to Z-park height. + * P2 Raise the nozzle by Z-park amount, limited to Z_MAX_POS. + */ +//#define NOZZLE_PARK_FEATURE + +#if ENABLED(NOZZLE_PARK_FEATURE) + // Specify a park position as { X, Y, Z } + #define NOZZLE_PARK_POINT { (X_MIN_POS + 10), (Y_MAX_POS - 10), 20 } + #define NOZZLE_PARK_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) + #define NOZZLE_PARK_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) +#endif + +/** + * Clean Nozzle Feature -- EXPERIMENTAL + * + * Adds the G12 command to perform a nozzle cleaning process. + * + * Parameters: + * P Pattern + * S Strokes / Repetitions + * T Triangles (P1 only) + * + * Patterns: + * P0 Straight line (default). This process requires a sponge type material + * at a fixed bed location. "S" specifies strokes (i.e. back-forth motions) + * between the start / end points. + * + * P1 Zig-zag pattern between (X0, Y0) and (X1, Y1), "T" specifies the + * number of zig-zag triangles to do. "S" defines the number of strokes. + * Zig-zags are done in whichever is the narrower dimension. + * For example, "G12 P1 S1 T3" will execute: + * + * -- + * | (X0, Y1) | /\ /\ /\ | (X1, Y1) + * | | / \ / \ / \ | + * A | | / \ / \ / \ | + * | | / \ / \ / \ | + * | (X0, Y0) | / \/ \/ \ | (X1, Y0) + * -- +--------------------------------+ + * |________|_________|_________| + * T1 T2 T3 + * + * P2 Circular pattern with middle at NOZZLE_CLEAN_CIRCLE_MIDDLE. + * "R" specifies the radius. "S" specifies the stroke count. + * Before starting, the nozzle moves to NOZZLE_CLEAN_START_POINT. + * + * Caveats: The ending Z should be the same as starting Z. + * Attention: EXPERIMENTAL. G-code arguments may change. + * + */ +//#define NOZZLE_CLEAN_FEATURE + +#if ENABLED(NOZZLE_CLEAN_FEATURE) + // Default number of pattern repetitions + #define NOZZLE_CLEAN_STROKES 12 + + // Default number of triangles + #define NOZZLE_CLEAN_TRIANGLES 3 + + // Specify positions as { X, Y, Z } + #define NOZZLE_CLEAN_START_POINT { 30, 30, (Z_MIN_POS + 1)} + #define NOZZLE_CLEAN_END_POINT {100, 60, (Z_MIN_POS + 1)} + + // Circular pattern radius + #define NOZZLE_CLEAN_CIRCLE_RADIUS 6.5 + // Circular pattern circle fragments number + #define NOZZLE_CLEAN_CIRCLE_FN 10 + // Middle point of circle + #define NOZZLE_CLEAN_CIRCLE_MIDDLE NOZZLE_CLEAN_START_POINT + + // Moves the nozzle to the initial position + #define NOZZLE_CLEAN_GOBACK +#endif + +/** + * Print Job Timer + * + * Automatically start and stop the print job timer on M104/M109/M190. + * + * M104 (hotend, no wait) - high temp = none, low temp = stop timer + * M109 (hotend, wait) - high temp = start timer, low temp = stop timer + * M190 (bed, wait) - high temp = start timer, low temp = none + * + * The timer can also be controlled with the following commands: + * + * M75 - Start the print job timer + * M76 - Pause the print job timer + * M77 - Stop the print job timer + */ +#define PRINTJOB_TIMER_AUTOSTART + +/** + * Print Counter + * + * Track statistical data such as: + * + * - Total print jobs + * - Total successful print jobs + * - Total failed print jobs + * - Total time printing + * + * View the current statistics with M78. + */ +//#define PRINTCOUNTER + +//============================================================================= +//============================= LCD and SD support ============================ +//============================================================================= + +// @section lcd + +/** + * LCD LANGUAGE + * + * Select the language to display on the LCD. These languages are available: + * + * en, an, bg, ca, cn, cz, cz_utf8, de, el, el-gr, es, es_utf8, + * eu, fi, fr, fr_utf8, gl, hr, it, kana, kana_utf8, nl, pl, pt, + * pt_utf8, pt-br, pt-br_utf8, ru, sk_utf8, tr, uk, zh_CN, zh_TW, test + * + * :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cn':'Chinese', 'cz':'Czech', 'cz_utf8':'Czech (UTF8)', 'de':'German', 'el':'Greek', 'el-gr':'Greek (Greece)', 'es':'Spanish', 'es_utf8':'Spanish (UTF8)', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'fr_utf8':'French (UTF8)', 'gl':'Galician', 'hr':'Croatian', 'it':'Italian', 'kana':'Japanese', 'kana_utf8':'Japanese (UTF8)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt-br':'Portuguese (Brazilian)', 'pt-br_utf8':'Portuguese (Brazilian UTF8)', 'pt_utf8':'Portuguese (UTF8)', 'ru':'Russian', 'sk_utf8':'Slovak (UTF8)', 'tr':'Turkish', 'uk':'Ukrainian', 'zh_CN':'Chinese (Simplified)', 'zh_TW':'Chinese (Taiwan)', 'test':'TEST' } + */ +#define LCD_LANGUAGE en + +/** + * LCD Character Set + * + * Note: This option is NOT applicable to Graphical Displays. + * + * All character-based LCDs provide ASCII plus one of these + * language extensions: + * + * - JAPANESE ... the most common + * - WESTERN ... with more accented characters + * - CYRILLIC ... for the Russian language + * + * To determine the language extension installed on your controller: + * + * - Compile and upload with LCD_LANGUAGE set to 'test' + * - Click the controller to view the LCD menu + * - The LCD will display Japanese, Western, or Cyrillic text + * + * See http://marlinfw.org/docs/development/lcd_language.html + * + * :['JAPANESE', 'WESTERN', 'CYRILLIC'] + */ +#define DISPLAY_CHARSET_HD44780 JAPANESE + +/** + * SD CARD + * + * SD Card support is disabled by default. If your controller has an SD slot, + * you must uncomment the following option or it won't work. + * + */ +//#define SDSUPPORT + +/** + * SD CARD: SPI SPEED + * + * Enable one of the following items for a slower SPI transfer speed. + * This may be required to resolve "volume init" errors. + */ +//#define SPI_SPEED SPI_HALF_SPEED +//#define SPI_SPEED SPI_QUARTER_SPEED +//#define SPI_SPEED SPI_EIGHTH_SPEED + +/** + * SD CARD: ENABLE CRC + * + * Use CRC checks and retries on the SD communication. + */ +//#define SD_CHECK_AND_RETRY + +/** + * LCD Menu Items + * + * Disable all menus and only display the Status Screen, or + * just remove some extraneous menu items to recover space. + */ +//#define NO_LCD_MENUS +//#define SLIM_LCD_MENUS + +// +// ENCODER SETTINGS +// +// This option overrides the default number of encoder pulses needed to +// produce one step. Should be increased for high-resolution encoders. +// +//#define ENCODER_PULSES_PER_STEP 4 + +// +// Use this option to override the number of step signals required to +// move between next/prev menu items. +// +//#define ENCODER_STEPS_PER_MENU_ITEM 1 + +/** + * Encoder Direction Options + * + * Test your encoder's behavior first with both options disabled. + * + * Reversed Value Edit and Menu Nav? Enable REVERSE_ENCODER_DIRECTION. + * Reversed Menu Navigation only? Enable REVERSE_MENU_DIRECTION. + * Reversed Value Editing only? Enable BOTH options. + */ + +// +// This option reverses the encoder direction everywhere. +// +// Set this option if CLOCKWISE causes values to DECREASE +// +//#define REVERSE_ENCODER_DIRECTION + +// +// This option reverses the encoder direction for navigating LCD menus. +// +// If CLOCKWISE normally moves DOWN this makes it go UP. +// If CLOCKWISE normally moves UP this makes it go DOWN. +// +//#define REVERSE_MENU_DIRECTION + +// +// Individual Axis Homing +// +// Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu. +// +//#define INDIVIDUAL_AXIS_HOMING_MENU + +// +// SPEAKER/BUZZER +// +// If you have a speaker that can produce tones, enable it here. +// By default Marlin assumes you have a buzzer with a fixed frequency. +// +//#define SPEAKER + +// +// The duration and frequency for the UI feedback sound. +// Set these to 0 to disable audio feedback in the LCD menus. +// +// Note: Test audio output with the G-Code: +// M300 S P +// +//#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2 +//#define LCD_FEEDBACK_FREQUENCY_HZ 5000 + +//============================================================================= +//======================== LCD / Controller Selection ========================= +//======================== (Character-based LCDs) ========================= +//============================================================================= + +// +// RepRapDiscount Smart Controller. +// http://reprap.org/wiki/RepRapDiscount_Smart_Controller +// +// Note: Usually sold with a white PCB. +// +//#define REPRAP_DISCOUNT_SMART_CONTROLLER + +// +// ULTIMAKER Controller. +// +//#define ULTIMAKERCONTROLLER + +// +// ULTIPANEL as seen on Thingiverse. +// +//#define ULTIPANEL + +// +// PanelOne from T3P3 (via RAMPS 1.4 AUX2/AUX3) +// http://reprap.org/wiki/PanelOne +// +//#define PANEL_ONE + +// +// GADGETS3D G3D LCD/SD Controller +// http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel +// +// Note: Usually sold with a blue PCB. +// +//#define G3D_PANEL + +// +// RigidBot Panel V1.0 +// http://www.inventapart.com/ +// +//#define RIGIDBOT_PANEL + +// +// Makeboard 3D Printer Parts 3D Printer Mini Display 1602 Mini Controller +// https://www.aliexpress.com/item/Micromake-Makeboard-3D-Printer-Parts-3D-Printer-Mini-Display-1602-Mini-Controller-Compatible-with-Ramps-1/32765887917.html +// +//#define MAKEBOARD_MINI_2_LINE_DISPLAY_1602 + +// +// ANET and Tronxy 20x4 Controller +// +//#define ZONESTAR_LCD // Requires ADC_KEYPAD_PIN to be assigned to an analog pin. + // This LCD is known to be susceptible to electrical interference + // which scrambles the display. Pressing any button clears it up. + // This is a LCD2004 display with 5 analog buttons. + +// +// Generic 16x2, 16x4, 20x2, or 20x4 character-based LCD. +// +//#define ULTRA_LCD + +//============================================================================= +//======================== LCD / Controller Selection ========================= +//===================== (I2C and Shift-Register LCDs) ===================== +//============================================================================= + +// +// CONTROLLER TYPE: I2C +// +// Note: These controllers require the installation of Arduino's LiquidCrystal_I2C +// library. For more info: https://github.com/kiyoshigawa/LiquidCrystal_I2C +// + +// +// Elefu RA Board Control Panel +// http://www.elefu.com/index.php?route=product/product&product_id=53 +// +//#define RA_CONTROL_PANEL + +// +// Sainsmart (YwRobot) LCD Displays +// +// These require F.Malpartida's LiquidCrystal_I2C library +// https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home +// +//#define LCD_SAINSMART_I2C_1602 +//#define LCD_SAINSMART_I2C_2004 + +// +// Generic LCM1602 LCD adapter +// +//#define LCM1602 + +// +// PANELOLU2 LCD with status LEDs, +// separate encoder and click inputs. +// +// Note: This controller requires Arduino's LiquidTWI2 library v1.2.3 or later. +// For more info: https://github.com/lincomatic/LiquidTWI2 +// +// Note: The PANELOLU2 encoder click input can either be directly connected to +// a pin (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). +// +//#define LCD_I2C_PANELOLU2 + +// +// Panucatt VIKI LCD with status LEDs, +// integrated click & L/R/U/D buttons, separate encoder inputs. +// +//#define LCD_I2C_VIKI + +// +// CONTROLLER TYPE: Shift register panels +// + +// +// 2 wire Non-latching LCD SR from https://goo.gl/aJJ4sH +// LCD configuration: http://reprap.org/wiki/SAV_3D_LCD +// +//#define SAV_3DLCD + +//============================================================================= +//======================= LCD / Controller Selection ======================= +//========================= (Graphical LCDs) ======================== +//============================================================================= + +// +// CONTROLLER TYPE: Graphical 128x64 (DOGM) +// +// IMPORTANT: The U8glib library is required for Graphical Display! +// https://github.com/olikraus/U8glib_Arduino +// + +// +// RepRapDiscount FULL GRAPHIC Smart Controller +// http://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller +// +//#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER + +// +// ReprapWorld Graphical LCD +// https://reprapworld.com/?products_details&products_id/1218 +// +//#define REPRAPWORLD_GRAPHICAL_LCD + +// +// Activate one of these if you have a Panucatt Devices +// Viki 2.0 or mini Viki with Graphic LCD +// http://panucatt.com +// +//#define VIKI2 +//#define miniVIKI + +// +// MakerLab Mini Panel with graphic +// controller and SD support - http://reprap.org/wiki/Mini_panel +// +//#define MINIPANEL + +// +// MaKr3d Makr-Panel with graphic controller and SD support. +// http://reprap.org/wiki/MaKr3d_MaKrPanel +// +//#define MAKRPANEL + +// +// Adafruit ST7565 Full Graphic Controller. +// https://github.com/eboston/Adafruit-ST7565-Full-Graphic-Controller/ +// +//#define ELB_FULL_GRAPHIC_CONTROLLER + +// +// BQ LCD Smart Controller shipped by +// default with the BQ Hephestos 2 and Witbox 2. +// +//#define BQ_LCD_SMART_CONTROLLER + +// +// Cartesio UI +// http://mauk.cc/webshop/cartesio-shop/electronics/user-interface +// +//#define CARTESIO_UI + +// +// LCD for Melzi Card with Graphical LCD +// +//#define LCD_FOR_MELZI + +// +// SSD1306 OLED full graphics generic display +// +//#define U8GLIB_SSD1306 + +// +// SAV OLEd LCD module support using either SSD1306 or SH1106 based LCD modules +// +//#define SAV_3DGLCD +#if ENABLED(SAV_3DGLCD) + //#define U8GLIB_SSD1306 + #define U8GLIB_SH1106 +#endif + +// +// Original Ulticontroller from Ultimaker 2 printer with SSD1309 I2C display and encoder +// https://github.com/Ultimaker/Ultimaker2/tree/master/1249_Ulticontroller_Board_(x1) +// +//#define ULTI_CONTROLLER + +// +// TinyBoy2 128x64 OLED / Encoder Panel +// +//#define OLED_PANEL_TINYBOY2 + +// +// MKS MINI12864 with graphic controller and SD support +// http://reprap.org/wiki/MKS_MINI_12864 +// +//#define MKS_MINI_12864 + +// +// Factory display for Creality CR-10 +// https://www.aliexpress.com/item/Universal-LCD-12864-3D-Printer-Display-Screen-With-Encoder-For-CR-10-CR-7-Model/32833148327.html +// +// This is RAMPS-compatible using a single 10-pin connector. +// (For CR-10 owners who want to replace the Melzi Creality board but retain the display) +// +//#define CR10_STOCKDISPLAY + +// +// ANET and Tronxy Graphical Controller +// +//#define ANET_FULL_GRAPHICS_LCD // Anet 128x64 full graphics lcd with rotary encoder as used on Anet A6 + // A clone of the RepRapDiscount full graphics display but with + // different pins/wiring (see pins_ANET_10.h). + +// +// MKS OLED 1.3" 128 × 64 FULL GRAPHICS CONTROLLER +// http://reprap.org/wiki/MKS_12864OLED +// +// Tiny, but very sharp OLED display +// +//#define MKS_12864OLED // Uses the SH1106 controller (default) +//#define MKS_12864OLED_SSD1306 // Uses the SSD1306 controller + +// +// Silvergate GLCD controller +// http://github.com/android444/Silvergate +// +//#define SILVER_GATE_GLCD_CONTROLLER + +//============================================================================= +//============================ Other Controllers ============================ +//============================================================================= + +// +// CONTROLLER TYPE: Standalone / Serial +// + +// +// LCD for Malyan M200 printers. +// This requires SDSUPPORT to be enabled +// +//#define MALYAN_LCD + +// +// CONTROLLER TYPE: Keypad / Add-on +// + +// +// RepRapWorld REPRAPWORLD_KEYPAD v1.1 +// http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 +// +// REPRAPWORLD_KEYPAD_MOVE_STEP sets how much should the robot move when a key +// is pressed, a value of 10.0 means 10mm per click. +// +//#define REPRAPWORLD_KEYPAD +//#define REPRAPWORLD_KEYPAD_MOVE_STEP 10.0 + +//============================================================================= +//=============================== Extra Features ============================== +//============================================================================= + +// @section extras + +// Increase the FAN PWM frequency. Removes the PWM noise but increases heating in the FET/Arduino +//#define FAST_PWM_FAN + +// Use software PWM to drive the fan, as for the heaters. This uses a very low frequency +// which is not as annoying as with the hardware PWM. On the other hand, if this frequency +// is too low, you should also increment SOFT_PWM_SCALE. +//#define FAN_SOFT_PWM + +// Incrementing this by 1 will double the software PWM frequency, +// affecting heaters, and the fan if FAN_SOFT_PWM is enabled. +// However, control resolution will be halved for each increment; +// at zero value, there are 128 effective control positions. +#define SOFT_PWM_SCALE 0 + +// If SOFT_PWM_SCALE is set to a value higher than 0, dithering can +// be used to mitigate the associated resolution loss. If enabled, +// some of the PWM cycles are stretched so on average the desired +// duty cycle is attained. +//#define SOFT_PWM_DITHER + +// Temperature status LEDs that display the hotend and bed temperature. +// If all hotends, bed temperature, and target temperature are under 54C +// then the BLUE led is on. Otherwise the RED led is on. (1C hysteresis) +//#define TEMP_STAT_LEDS + +// M240 Triggers a camera by emulating a Canon RC-1 Remote +// Data from: http://www.doc-diy.net/photo/rc-1_hacked/ +//#define PHOTOGRAPH_PIN 23 + +// SkeinForge sends the wrong arc g-codes when using Arc Point as fillet procedure +//#define SF_ARC_FIX + +// Support for the BariCUDA Paste Extruder +//#define BARICUDA + +// Support for BlinkM/CyzRgb +//#define BLINKM + +// Support for PCA9632 PWM LED driver +//#define PCA9632 + +/** + * RGB LED / LED Strip Control + * + * Enable support for an RGB LED connected to 5V digital pins, or + * an RGB Strip connected to MOSFETs controlled by digital pins. + * + * Adds the M150 command to set the LED (or LED strip) color. + * If pins are PWM capable (e.g., 4, 5, 6, 11) then a range of + * luminance values can be set from 0 to 255. + * For Neopixel LED an overall brightness parameter is also available. + * + * *** CAUTION *** + * LED Strips require a MOSFET Chip between PWM lines and LEDs, + * as the Arduino cannot handle the current the LEDs will require. + * Failure to follow this precaution can destroy your Arduino! + * NOTE: A separate 5V power supply is required! The Neopixel LED needs + * more current than the Arduino 5V linear regulator can produce. + * *** CAUTION *** + * + * LED Type. Enable only one of the following two options. + * + */ +//#define RGB_LED +//#define RGBW_LED + +#if ENABLED(RGB_LED) || ENABLED(RGBW_LED) + #define RGB_LED_R_PIN 34 + #define RGB_LED_G_PIN 43 + #define RGB_LED_B_PIN 35 + #define RGB_LED_W_PIN -1 +#endif + +// Support for Adafruit Neopixel LED driver +//#define NEOPIXEL_LED +#if ENABLED(NEOPIXEL_LED) + #define NEOPIXEL_TYPE NEO_GRBW // NEO_GRBW / NEO_GRB - four/three channel driver type (defined in Adafruit_NeoPixel.h) + #define NEOPIXEL_PIN 4 // LED driving pin on motherboard 4 => D4 (EXP2-5 on Printrboard) / 30 => PC7 (EXP3-13 on Rumba) + #define NEOPIXEL_PIXELS 30 // Number of LEDs in the strip + #define NEOPIXEL_IS_SEQUENTIAL // Sequential display for temperature change - LED by LED. Disable to change all LEDs at once. + #define NEOPIXEL_BRIGHTNESS 127 // Initial brightness (0-255) + //#define NEOPIXEL_STARTUP_TEST // Cycle through colors at startup +#endif + +/** + * Printer Event LEDs + * + * During printing, the LEDs will reflect the printer status: + * + * - Gradually change from blue to violet as the heated bed gets to target temp + * - Gradually change from violet to red as the hotend gets to temperature + * - Change to white to illuminate work surface + * - Change to green once print has finished + * - Turn off after the print has finished and the user has pushed a button + */ +#if ENABLED(BLINKM) || ENABLED(RGB_LED) || ENABLED(RGBW_LED) || ENABLED(PCA9632) || ENABLED(NEOPIXEL_LED) + #define PRINTER_EVENT_LEDS +#endif + +/** + * R/C SERVO support + * Sponsored by TrinityLabs, Reworked by codexmas + */ + +/** + * Number of servos + * + * For some servo-related options NUM_SERVOS will be set automatically. + * Set this manually if there are extra servos needing manual control. + * Leave undefined or set to 0 to entirely disable the servo subsystem. + */ +//#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command + +// Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. +// 300ms is a good value but you can try less delay. +// If the servo can't reach the requested position, increase it. +#define SERVO_DELAY { 300 } + +// Servo deactivation +// +// With this option servos are powered only during movement, then turned off to prevent jitter. +//#define DEACTIVATE_SERVOS_AFTER_MOVE + +#endif // CONFIGURATION_H diff --git a/Marlin/example_configurations/hangprinter/Configuration_adv.h b/Marlin/example_configurations/hangprinter/Configuration_adv.h new file mode 100644 index 000000000..282c03d98 --- /dev/null +++ b/Marlin/example_configurations/hangprinter/Configuration_adv.h @@ -0,0 +1,1704 @@ +/** + * 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 . + * + */ + +/** + * Configuration_adv.h + * + * Advanced settings. + * Only change these if you know exactly what you're doing. + * Some of these settings can damage your printer if improperly set! + * + * Basic settings can be found in Configuration.h + * + */ +#ifndef CONFIGURATION_ADV_H +#define CONFIGURATION_ADV_H +#define CONFIGURATION_ADV_H_VERSION 010109 + +// @section temperature + +//=========================================================================== +//=============================Thermal Settings ============================ +//=========================================================================== + +// +// Hephestos 2 24V heated bed upgrade kit. +// https://store.bq.com/en/heated-bed-kit-hephestos2 +// +//#define HEPHESTOS2_HEATED_BED_KIT +#if ENABLED(HEPHESTOS2_HEATED_BED_KIT) + #undef TEMP_SENSOR_BED + #define TEMP_SENSOR_BED 70 + #define HEATER_BED_INVERTING true +#endif + +#if DISABLED(PIDTEMPBED) + #define BED_CHECK_INTERVAL 5000 // ms between checks in bang-bang control + #if ENABLED(BED_LIMIT_SWITCHING) + #define BED_HYSTERESIS 2 // Only disable heating if T>target+BED_HYSTERESIS and enable heating if T>target-BED_HYSTERESIS + #endif +#endif + +/** + * Thermal Protection provides additional protection to your printer from damage + * and fire. Marlin always includes safe min and max temperature ranges which + * protect against a broken or disconnected thermistor wire. + * + * The issue: If a thermistor falls out, it will report the much lower + * temperature of the air in the room, and the the firmware will keep + * the heater on. + * + * The solution: Once the temperature reaches the target, start observing. + * If the temperature stays too far below the target (hysteresis) for too + * long (period), the firmware will halt the machine as a safety precaution. + * + * 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 + + /** + * Whenever an M104, M109, or M303 increases the target temperature, the + * firmware will wait for the WATCH_TEMP_PERIOD to expire. If the temperature + * hasn't increased by WATCH_TEMP_INCREASE degrees, the machine is halted and + * requires a hard reset. This test restarts with any M104/M109/M303, but only + * if the current temperature is far enough below the target for a reliable + * test. + * + * If you get false positives for "Heating failed", increase WATCH_TEMP_PERIOD + * and/or decrease WATCH_TEMP_INCREASE. WATCH_TEMP_INCREASE should not be set + * below 2. + */ + #define WATCH_TEMP_PERIOD 20 // Seconds + #define WATCH_TEMP_INCREASE 2 // Degrees Celsius +#endif + +/** + * 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 + + /** + * As described above, except for the bed (M140/M190/M303). + */ + #define WATCH_BED_TEMP_PERIOD 60 // Seconds + #define WATCH_BED_TEMP_INCREASE 2 // Degrees Celsius +#endif + +#if ENABLED(PIDTEMP) + // this adds an experimental additional term to the heating power, proportional to the extrusion speed. + // if Kc is chosen well, the additional required power due to increased melting should be compensated. + //#define PID_EXTRUSION_SCALING + #if ENABLED(PID_EXTRUSION_SCALING) + #define DEFAULT_Kc (100) //heating power=Kc*(e_speed) + #define LPQ_MAX_LEN 50 + #endif +#endif + +/** + * Automatic Temperature: + * The hotend target temperature is calculated by all the buffered lines of gcode. + * The maximum buffered steps/sec of the extruder motor is called "se". + * Start autotemp mode with M109 S B F + * The target temperature is set to mintemp+factor*se[steps/sec] and is limited by + * mintemp and maxtemp. Turn this off by executing M109 without F* + * 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 +#if ENABLED(AUTOTEMP) + #define AUTOTEMP_OLDWEIGHT 0.98 +#endif + +// Show extra position information in M114 +//#define M114_DETAIL + +// Show Temperature ADC value +// Enable for M105 to include ADC values read from temperature sensors. +//#define SHOW_TEMP_ADC_VALUES + +/** + * High Temperature Thermistor Support + * + * Thermistors able to support high temperature tend to have a hard time getting + * good readings at room and lower temperatures. This means HEATER_X_RAW_LO_TEMP + * will probably be caught when the heating element first turns on during the + * preheating process, which will trigger a min_temp_error as a safety measure + * and force stop everything. + * To circumvent this limitation, we allow for a preheat time (during which, + * min_temp_error won't be triggered) and add a min_temp buffer to handle + * aberrant readings. + * + * If you want to enable this feature for your hotend thermistor(s) + * uncomment and set values > 0 in the constants below + */ + +// The number of consecutive low temperature errors that can occur +// before a min_temp_error is triggered. (Shouldn't be more than 10.) +//#define MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED 0 + +// The number of milliseconds a hotend will preheat before starting to check +// the temperature. This value should NOT be set to the time it takes the +// hot end to reach the target temperature, but the time it takes to reach +// the minimum temperature your thermistor can read. The lower the better/safer. +// This shouldn't need to be more than 30 seconds (30000) +//#define MILLISECONDS_PREHEAT_TIME 0 + +// @section extruder + +// Extruder runout prevention. +// If the machine is idle and the temperature over MINTEMP +// then extrude some filament every couple of SECONDS. +//#define EXTRUDER_RUNOUT_PREVENT +#if ENABLED(EXTRUDER_RUNOUT_PREVENT) + #define EXTRUDER_RUNOUT_MINTEMP 190 + #define EXTRUDER_RUNOUT_SECONDS 30 + #define EXTRUDER_RUNOUT_SPEED 1500 // mm/m + #define EXTRUDER_RUNOUT_EXTRUDE 5 // mm +#endif + +// @section temperature + +// Calibration for AD595 / AD8495 sensor to adjust temperature measurements. +// The final temperature is calculated as (measuredTemp * GAIN) + OFFSET. +#define TEMP_SENSOR_AD595_OFFSET 0.0 +#define TEMP_SENSOR_AD595_GAIN 1.0 +#define TEMP_SENSOR_AD8495_OFFSET 0.0 +#define TEMP_SENSOR_AD8495_GAIN 1.0 + +/** + * Controller Fan + * To cool down the stepper drivers and MOSFETs. + * + * 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 +#if ENABLED(USE_CONTROLLER_FAN) + //#define CONTROLLER_FAN_PIN -1 // 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 + +// 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 + +/** + * PWM Fan Scaling + * + * Define the min/max speeds for PWM fans (as set with M106). + * + * With these options the M106 0-255 value range is scaled to a subset + * to ensure that the fan has enough power to spin, or to run lower + * current fans with higher current. (e.g., 5V/12V fans with 12V/24V) + * Value 0 always turns off the fan. + * + * Define one or both of these to override the default 0-255 range. + */ +//#define FAN_MIN_PWM 50 +//#define FAN_MAX_PWM 128 + +// @section extruder + +/** + * Extruder cooling fans + * + * Extruder auto fans automatically turn on when their extruders' + * temperatures go above EXTRUDER_AUTO_FAN_TEMPERATURE. + * + * Your board's pins file specifies the recommended pins. Override those here + * or set to -1 to disable completely. + * + * Multiple extruders can be assigned to the same pin in which case + * the fan will turn on when any selected extruder is above the threshold. + */ +#define E0_AUTO_FAN_PIN -1 +#define E1_AUTO_FAN_PIN -1 +#define E2_AUTO_FAN_PIN -1 +#define E3_AUTO_FAN_PIN -1 +#define E4_AUTO_FAN_PIN -1 +#define CHAMBER_AUTO_FAN_PIN -1 +#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 +#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed + +/** + * Part-Cooling Fan Multiplexer + * + * This feature allows you to digitally multiplex the fan output. + * The multiplexer is automatically switched at tool-change. + * Set FANMUX[012]_PINs below for up to 2, 4, or 8 multiplexed fans. + */ +#define FANMUX0_PIN -1 +#define FANMUX1_PIN -1 +#define FANMUX2_PIN -1 + +/** + * M355 Case Light on-off / brightness + */ +//#define CASE_LIGHT_ENABLE +#if ENABLED(CASE_LIGHT_ENABLE) + //#define CASE_LIGHT_PIN 4 // Override the default pin if needed + #define INVERT_CASE_LIGHT false // Set true if Case Light is ON when pin is LOW + #define CASE_LIGHT_DEFAULT_ON true // Set default power-up state on + #define CASE_LIGHT_DEFAULT_BRIGHTNESS 105 // Set default power-up brightness (0-255, requires PWM pin) + //#define MENU_ITEM_CASE_LIGHT // Add a Case Light option to the LCD main menu + //#define CASE_LIGHT_USE_NEOPIXEL // Use Neopixel LED as case light, requires NEOPIXEL_LED. + #if ENABLED(CASE_LIGHT_USE_NEOPIXEL) + #define CASE_LIGHT_NEOPIXEL_COLOR { 255, 255, 255, 255 } // { Red, Green, Blue, White } + #endif +#endif + +//=========================================================================== +//============================ Mechanical Settings ========================== +//=========================================================================== + +// @section homing + +// If you want endstops to stay on (by default) even when not homing +// enable this option. Override at any time with M120, M121. +//#define ENDSTOPS_ALWAYS_ON_DEFAULT + +// @section extras + +//#define Z_LATE_ENABLE // Enable Z the last moment. Never uncomment this on a Hangprinter. + +/** + * Dual Steppers / Dual Endstops + * + * This section will allow you to use extra E drivers to drive a second motor for X, Y, or Z axes. + * (A, B, C, or D for Hangprinter). + * + * For example, set X_DUAL_STEPPER_DRIVERS setting to use a second motor. If the motors need to + * spin in opposite directions set INVERT_X2_VS_X_DIR. If the second motor needs its own endstop + * set X_DUAL_ENDSTOPS. This can adjust for "racking." Use X2_USE_ENDSTOP to set the endstop plug + * that should be used for the second endstop. Extra endstops will appear in the output of 'M119'. + * + * Use X_DUAL_ENDSTOP_ADJUSTMENT to adjust for mechanical imperfection. After homing both motors + * this offset is applied to the X2 motor. To find the offset home the X axis, and measure the error + * in X2. Dual endstop offsets can be set at runtime with 'M666 X Y Z'. + */ + +// This is the A motor on Hangprinter +//#define X_DUAL_STEPPER_DRIVERS +#if ENABLED(X_DUAL_STEPPER_DRIVERS) + #define INVERT_X2_VS_X_DIR true // Set 'true' if X motors should rotate in opposite directions + //#define X_DUAL_ENDSTOPS + #if ENABLED(X_DUAL_ENDSTOPS) + #define X2_USE_ENDSTOP _XMAX_ + #define X_DUAL_ENDSTOPS_ADJUSTMENT 0 + #endif +#endif + +// This is the B motor on Hangprinter +//#define Y_DUAL_STEPPER_DRIVERS +#if ENABLED(Y_DUAL_STEPPER_DRIVERS) + #define INVERT_Y2_VS_Y_DIR true // Set 'true' if Y motors should rotate in opposite directions + //#define Y_DUAL_ENDSTOPS + #if ENABLED(Y_DUAL_ENDSTOPS) + #define Y2_USE_ENDSTOP _YMAX_ + #define Y_DUAL_ENDSTOPS_ADJUSTMENT 0 + #endif +#endif + +// This is the C motor on Hangprinter +//#define Z_DUAL_STEPPER_DRIVERS +#if ENABLED(Z_DUAL_STEPPER_DRIVERS) + //#define Z_DUAL_ENDSTOPS + #if ENABLED(Z_DUAL_ENDSTOPS) + #define Z2_USE_ENDSTOP _XMAX_ + #define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 + #endif +#endif + +// Enable this for dual x-carriage printers. +// A dual x-carriage design has the advantage that the inactive extruder can be parked which +// prevents hot-end ooze contaminating the print. It also reduces the weight of each x-carriage +// allowing faster printing speeds. Connect your X2 stepper to the first unused E plug. +//#define DUAL_X_CARRIAGE +#if ENABLED(DUAL_X_CARRIAGE) + // Configuration for second X-carriage + // Note: the first x-carriage is defined as the x-carriage which homes to the minimum endstop; + // the second x-carriage always homes to the maximum endstop. + #define X1_MIN_POS X_MIN_POS // set minimum to ensure first x-carriage doesn't hit the parked second X-carriage + #define X1_MAX_POS X_BED_SIZE // set maximum to ensure first x-carriage doesn't hit the parked second X-carriage + #define X2_MIN_POS 80 // set minimum to ensure second x-carriage doesn't hit the parked first X-carriage + #define X2_MAX_POS 353 // set maximum to the distance between toolheads when both heads are homed + #define X2_HOME_DIR 1 // the second X-carriage always homes to the maximum endstop position + #define X2_HOME_POS X2_MAX_POS // default home position is the maximum carriage position + // However: In this mode the HOTEND_OFFSET_X value for the second extruder provides a software + // override for X2_HOME_POS. This also allow recalibration of the distance between the two endstops + // without modifying the firmware (through the "M218 T1 X???" command). + // Remember: you should set the second extruder x-offset to 0 in your slicer. + + // There are a few selectable movement modes for dual x-carriages using M605 S + // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results + // as long as it supports dual x-carriages. (M605 S0) + // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so + // that additional slicer support is not required. (M605 S1) + // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all + // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at + // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) + + // This is the default power-up mode which can be later using M605. + #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE + + // Default settings in "Auto-park Mode" + #define TOOLCHANGE_PARK_ZLIFT 0.2 // the distance to raise Z axis when parking an extruder + #define TOOLCHANGE_UNPARK_ZLIFT 1 // the distance to raise Z axis when unparking an extruder + + // Default x offset in duplication mode (typically set to half print bed width) + #define DEFAULT_DUPLICATION_X_OFFSET 100 + +#endif // DUAL_X_CARRIAGE + +// Activate a solenoid on the active extruder with M380. Disable all with M381. +// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid. +//#define EXT_SOLENOID + +// @section homing + +// Homing hits each endstop, retracts by these distances, then does a slower bump. +#define X_HOME_BUMP_MM 5 +#define Y_HOME_BUMP_MM 5 +#define Z_HOME_BUMP_MM 5 +#define HOMING_BUMP_DIVISOR { 10, 10, 10 } // Re-Bump Speed Divisor (Divides the Homing Feedrate) +//#define QUICK_HOME // If homing includes X and Y, do a diagonal move initially + +// When G28 is called, this option will make Y home before X +//#define HOME_Y_BEFORE_X + +// Enable this if X or Y can't home without homing the other axis first. +//#define CODEPENDENT_XY_HOMING + +// @section machine + +#define AXIS_RELATIVE_MODES {false, false, false, false} + +// Allow duplication mode with a basic dual-nozzle extruder +//#define DUAL_NOZZLE_DUPLICATION_MODE + +// By default pololu step drivers require an active high signal. However, some high power drivers require an active low signal as step. +#define INVERT_X_STEP_PIN false +#define INVERT_Y_STEP_PIN false +#define INVERT_Z_STEP_PIN false +#if ENABLED(HANGPRINTER) + #define INVERT_A_STEP_PIN false + #define INVERT_B_STEP_PIN false + #define INVERT_C_STEP_PIN false + #define INVERT_D_STEP_PIN false +#endif +#define INVERT_E_STEP_PIN false + +// Default stepper release if idle. Set to 0 to deactivate. +// Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true. +// Time can be set by M18 and M84. +#define DEFAULT_STEPPER_DEACTIVE_TIME 60 +#define DISABLE_INACTIVE_X false // Hangprinter is hard coded to never disable its ABCD-motors, even if true would be specified here +#define DISABLE_INACTIVE_Y false +#define DISABLE_INACTIVE_Z false +#define DISABLE_INACTIVE_E true // Enabling/disabling E-stepper works as normal with Hangprinter + +#define DEFAULT_MINIMUMFEEDRATE 0.0 // minimum feedrate +#define DEFAULT_MINTRAVELFEEDRATE 0.0 + +//#define HOME_AFTER_DEACTIVATE // Require rehoming after steppers are deactivated + +// @section lcd + +#if ENABLED(ULTIPANEL) + #define MANUAL_FEEDRATE_XYZ 50*60 + #define MANUAL_FEEDRATE { MANUAL_FEEDRATE_XYZ, MANUAL_FEEDRATE_XYZ, MANUAL_FEEDRATE_XYZ, 60 } // Feedrates for manual moves along X, Y, Z, E from panel + #define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder +#endif + +// @section extras + +// minimum time in microseconds that a movement needs to take if the buffer is emptied. +#define DEFAULT_MINSEGMENTTIME 20000 + +// If defined the movements slow down when the look ahead buffer is only half full +// (don't use SLOWDOWN with DELTA because DELTA generates hundreds of segments per second) +//#define SLOWDOWN + +// Frequency limit +// See nophead's blog for more info +// Not working O +//#define XY_FREQUENCY_LIMIT 15 + +// Minimum planner junction speed. Sets the default minimum speed the planner plans for at the end +// of the buffer and all stops. This should not be much greater than zero and should only be changed +// if unwanted behavior is observed on a user's machine when running at very slow speeds. +#define MINIMUM_PLANNER_SPEED 0.05 // (mm/sec) + +// +// Use Junction Deviation instead of traditional Jerk Limiting +// +//#define JUNCTION_DEVIATION +#if ENABLED(JUNCTION_DEVIATION) + #define JUNCTION_DEVIATION_MM 0.02 // (mm) Distance from real junction edge +#endif + +/** + * Adaptive Step Smoothing increases the resolution of multi-axis moves, particularly at step frequencies + * below 1kHz (for AVR) or 10kHz (for ARM), where aliasing between axes in multi-axis moves causes audible + * vibration and surface artifacts. The algorithm adapts to provide the best possible step smoothing at the + * lowest stepping frequencies. + */ +//#define ADAPTIVE_STEP_SMOOTHING + +// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. +#define MICROSTEP_MODES { 16, 16, 16, 16, 16 } // [1,2,4,8,16] + +/** + * @section stepper motor current + * + * Some boards have a means of setting the stepper motor current via firmware. + * + * The power on motor currents are set by: + * PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2 + * known compatible chips: A4982 + * DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H + * known compatible chips: AD5206 + * DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2 + * known compatible chips: MCP4728 + * DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE + * known compatible chips: MCP4451, MCP4018 + * + * Motor currents can also be set by M907 - M910 and by the LCD. + * M907 - applies to all. + * M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H + * M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2 + * + * Hangprinter note: the below arrays might need another element to match ABCD/ABCDE + */ +//#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 DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis + +// Use an I2C based DIGIPOT (e.g., Azteeg X3 Pro) +//#define DIGIPOT_I2C +#if ENABLED(DIGIPOT_I2C) && !defined(DIGIPOT_I2C_ADDRESS_A) + /** + * Common slave addresses: + * + * A (A shifted) B (B shifted) IC + * Smoothie 0x2C (0x58) 0x2D (0x5A) MCP4451 + * AZTEEG_X3_PRO 0x2C (0x58) 0x2E (0x5C) MCP4451 + * MIGHTYBOARD_REVE 0x2F (0x5E) MCP4018 + */ + #define DIGIPOT_I2C_ADDRESS_A 0x2C // unshifted slave address for first DIGIPOT + #define DIGIPOT_I2C_ADDRESS_B 0x2D // unshifted slave address for second DIGIPOT +#endif + +//#define DIGIPOT_MCP4018 // Requires library from https://github.com/stawel/SlowSoftI2CMaster +#define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8 +// Actual motor currents in Amps. The number of entries must match DIGIPOT_I2C_NUM_CHANNELS. +// These correspond to the physical drivers, so be mindful if the order is changed. +#define DIGIPOT_I2C_MOTOR_CURRENTS { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 } // AZTEEG_X3_PRO + +//=========================================================================== +//=============================Additional Features=========================== +//=========================================================================== + +#define ENCODER_RATE_MULTIPLIER // If defined, certain menu edit operations automatically multiply the steps when the encoder is moved quickly +#define ENCODER_10X_STEPS_PER_SEC 75 // If the encoder steps per sec exceeds this value, multiply steps moved x10 to quickly advance the value +#define ENCODER_100X_STEPS_PER_SEC 160 // If the encoder steps per sec exceeds this value, multiply steps moved x100 to really quickly advance the value + +//#define CHDK 4 //Pin for triggering CHDK to take a picture see how to use it here http://captain-slow.dk/2014/03/09/3d-printing-timelapses/ +#define CHDK_DELAY 50 //How long in ms the pin should stay HIGH before going LOW again + +// @section lcd + +// Include a page of printer information in the LCD Main Menu +//#define LCD_INFO_MENU + +// Scroll a longer status message into view +//#define STATUS_MESSAGE_SCROLLING + +// On the Info Screen, display XY with one decimal place when possible +//#define LCD_DECIMAL_SMALL_XY + +// The timeout (in ms) to return to the status screen from sub-menus +//#define LCD_TIMEOUT_TO_STATUS 15000 + +// Add an 'M73' G-code to set the current percentage +//#define LCD_SET_PROGRESS_MANUALLY + +#if ENABLED(SDSUPPORT) || ENABLED(LCD_SET_PROGRESS_MANUALLY) + //#define LCD_PROGRESS_BAR // Show a progress bar on HD44780 LCDs for SD printing + #if ENABLED(LCD_PROGRESS_BAR) + #define PROGRESS_BAR_BAR_TIME 2000 // (ms) Amount of time to show the bar + #define PROGRESS_BAR_MSG_TIME 3000 // (ms) Amount of time to show the status message + #define PROGRESS_MSG_EXPIRE 0 // (ms) Amount of time to retain the status message (0=forever) + //#define PROGRESS_MSG_ONCE // Show the message for MSG_TIME then clear it + //#define LCD_PROGRESS_BAR_TEST // Add a menu item to test the progress bar + #endif +#endif // SDSUPPORT || LCD_SET_PROGRESS_MANUALLY + +/** + * LED Control Menu + * Enable this feature to add LED Control to the LCD menu + */ +//#define LED_CONTROL_MENU +#if ENABLED(LED_CONTROL_MENU) + #define LED_COLOR_PRESETS // Enable the Preset Color menu option + #if ENABLED(LED_COLOR_PRESETS) + #define LED_USER_PRESET_RED 255 // User defined RED value + #define LED_USER_PRESET_GREEN 128 // User defined GREEN value + #define LED_USER_PRESET_BLUE 0 // User defined BLUE value + #define LED_USER_PRESET_WHITE 255 // User defined WHITE value + #define LED_USER_PRESET_BRIGHTNESS 255 // User defined intensity + //#define LED_USER_PRESET_STARTUP // Have the printer display the user preset color on startup + #endif +#endif // LED_CONTROL_MENU + +#if ENABLED(SDSUPPORT) + + // Some RAMPS and other boards don't detect when an SD card is inserted. You can work + // around this by connecting a push button or single throw switch to the pin defined + // as SD_DETECT_PIN in your board's pins definitions. + // This setting should be disabled unless you are using a push button, pulling the pin to ground. + // Note: This is always disabled for ULTIPANEL (except ELB_FULL_GRAPHIC_CONTROLLER). + #define SD_DETECT_INVERTED + + #define SD_FINISHED_STEPPERRELEASE true // Disable steppers when SD Print is finished + #define SD_FINISHED_RELEASECOMMAND "M84 X Y Z E" // You might want to keep the z enabled so your bed stays in place. + + // Reverse SD sort to show "more recent" files first, according to the card's FAT. + // Since the FAT gets out of order with usage, SDCARD_SORT_ALPHA is recommended. + #define SDCARD_RATHERRECENTFIRST + + // Add an option in the menu to run all auto#.g files + //#define MENU_ADDAUTOSTART + + /** + * Continue after Power-Loss (Creality3D) + * + * Store the current state to the SD Card at the start of each layer + * during SD printing. If the recovery file is found at boot time, present + * an option on the LCD screen to continue the print from the last-known + * point in the file. + */ + //#define POWER_LOSS_RECOVERY + #if ENABLED(POWER_LOSS_RECOVERY) + //#define POWER_LOSS_PIN 44 // Pin to detect power loss + //#define POWER_LOSS_STATE HIGH // State of pin indicating power loss + #endif + + /** + * Sort SD file listings in alphabetical order. + * + * With this option enabled, items on SD cards will be sorted + * by name for easier navigation. + * + * By default... + * + * - Use the slowest -but safest- method for sorting. + * - Folders are sorted to the top. + * - The sort key is statically allocated. + * - No added G-code (M34) support. + * - 40 item sorting limit. (Items after the first 40 are unsorted.) + * + * SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the + * compiler to calculate the worst-case usage and throw an error if the SRAM + * limit is exceeded. + * + * - SDSORT_USES_RAM provides faster sorting via a static directory buffer. + * - SDSORT_USES_STACK does the same, but uses a local stack-based buffer. + * - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!) + * - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!) + */ + //#define SDCARD_SORT_ALPHA + + // SD Card Sorting options + #if ENABLED(SDCARD_SORT_ALPHA) + #define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256). Costs 27 bytes each. + #define FOLDER_SORTING -1 // -1=above 0=none 1=below + #define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code. + #define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting. + #define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.) + #define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option. + #define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use! + #define SDSORT_CACHE_VFATS 2 // Maximum number of 13-byte VFAT entries to use for sorting. + // Note: Only affects SCROLL_LONG_FILENAMES with SDSORT_CACHE_NAMES but not SDSORT_DYNAMIC_RAM. + #endif + + // This allows hosts to request long names for files and folders with M33 + //#define LONG_FILENAME_HOST_SUPPORT + + // Enable this option to scroll long filenames in the SD card menu + //#define SCROLL_LONG_FILENAMES + + /** + * This option allows you to abort SD printing when any endstop is triggered. + * This feature must be enabled with "M540 S1" or from the LCD menu. + * To have any effect, endstops must be enabled during SD printing. + */ + //#define ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED + + /** + * This option makes it easier to print the same SD Card file again. + * On print completion the LCD Menu will open with the file selected. + * You can just click to start the print, or navigate elsewhere. + */ + //#define SD_REPRINT_LAST_SELECTED_FILE + + /** + * Auto-report SdCard status with M27 S + */ + //#define AUTO_REPORT_SD_STATUS + +#endif // SDSUPPORT + +/** + * Additional options for Graphical Displays + * + * Use the optimizations here to improve printing performance, + * which can be adversely affected by graphical display drawing, + * especially when doing several short moves, and when printing + * on DELTA and SCARA machines. + * + * Some of these options may result in the display lagging behind + * controller events, as there is a trade-off between reliable + * printing performance versus fast display updates. + */ +#if ENABLED(DOGLCD) + // Show SD percentage next to the progress bar + //#define DOGM_SD_PERCENT + + // Enable to save many cycles by drawing a hollow frame on the Info Screen + #define XYZ_HOLLOW_FRAME + + // Enable to save many cycles by drawing a hollow frame on Menu Screens + #define MENU_HOLLOW_FRAME + + // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. + // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. + //#define USE_BIG_EDIT_FONT + + // 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 + + // 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. + //#define DOGM_SPI_DELAY_US 5 + + // Swap the CW/CCW indicators in the graphics overlay + //#define OVERLAY_GFX_REVERSE + + #if ENABLED(U8GLIB_ST7920) + /** + * ST7920-based LCDs can emulate a 16 x 4 character display using + * the ST7920 character-generator for very fast screen updates. + * Enable LIGHTWEIGHT_UI to use this special display mode. + * + * Since LIGHTWEIGHT_UI has limited space, the position and status + * message occupy the same line. Set STATUS_EXPIRE_SECONDS to the + * length of time to display the status message before clearing. + * + * Set STATUS_EXPIRE_SECONDS to zero to never clear the status. + * This will prevent position updates from being displayed. + */ + //#define LIGHTWEIGHT_UI + #if ENABLED(LIGHTWEIGHT_UI) + #define STATUS_EXPIRE_SECONDS 20 + #endif + #endif + +#endif // DOGLCD + +// @section safety + +// The hardware watchdog should reset the microcontroller disabling all outputs, +// in case the firmware gets stuck and doesn't do temperature regulation. +#define USE_WATCHDOG + +#if ENABLED(USE_WATCHDOG) + // If you have a watchdog reboot in an ArduinoMega2560 then the device will hang forever, as a watchdog reset will leave the watchdog on. + // The "WATCHDOG_RESET_MANUAL" goes around this by not using the hardware reset. + // However, THIS FEATURE IS UNSAFE!, as it will only work if interrupts are disabled. And the code could hang in an interrupt routine with interrupts disabled. + //#define WATCHDOG_RESET_MANUAL +#endif + +// @section lcd + +/** + * Babystepping enables movement of the axes by tiny increments without changing + * the current position values. This feature is used primarily to adjust the Z + * axis in the first layer of a print in real-time. + * + * Warning: Does not respect endstops! + */ +//#define BABYSTEPPING +#if ENABLED(BABYSTEPPING) + //#define BABYSTEP_XY // 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 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. + //#define BABYSTEP_ZPROBE_GFX_OVERLAY // Enable graphical overlay on Z-offset editor +#endif + +// @section extruder + +/** + * Linear Pressure Control v1.5 + * + * Assumption: advance [steps] = k * (delta velocity [steps/s]) + * K=0 means advance disabled. + * + * NOTE: K values for LIN_ADVANCE 1.5 differ from earlier versions! + * + * Set K around 0.22 for 3mm PLA Direct Drive with ~6.5cm between the drive gear and heatbreak. + * Larger K values will be needed for flexible filament and greater distances. + * If this algorithm produces a higher speed offset than the extruder can handle (compared to E jerk) + * print acceleration will be reduced during the affected moves to keep within the limit. + * + * See http://marlinfw.org/docs/features/lin_advance.html for full instructions. + * Mention @Sebastianv650 on GitHub to alert the author of any issues. + */ +//#define LIN_ADVANCE +#if ENABLED(LIN_ADVANCE) + #define LIN_ADVANCE_K 0.22 // Unit: mm compression per 1mm/s extruder speed + //#define LA_DEBUG // If enabled, this will generate debug information output over USB. +#endif + +// @section leveling + +#if ENABLED(MESH_BED_LEVELING) || ENABLED(AUTO_BED_LEVELING_UBL) + // Override the mesh area if the automatic (max) area is too large + //#define MESH_MIN_X MESH_INSET + //#define MESH_MIN_Y MESH_INSET + //#define MESH_MAX_X X_BED_SIZE - (MESH_INSET) + //#define MESH_MAX_Y Y_BED_SIZE - (MESH_INSET) +#endif + +// @section extras + +// +// G2/G3 Arc Support +// +#define ARC_SUPPORT // Disable this feature to save ~3226 bytes +#if ENABLED(ARC_SUPPORT) + #define MM_PER_ARC_SEGMENT 1 // Length of each arc segment + #define N_ARC_CORRECTION 25 // Number of intertpolated segments between corrections + //#define ARC_P_CIRCLES // Enable the 'P' parameter to specify complete circles + //#define CNC_WORKSPACE_PLANES // Allow G2/G3 to operate in XY, ZX, or YZ planes +#endif + +// Support for G5 with XYZE destination and IJPQ offsets. Requires ~2666 bytes. +//#define BEZIER_CURVE_SUPPORT + +// G38.2 and G38.3 Probe Target +// Set MULTIPLE_PROBING if you want G38 to double touch +//#define G38_PROBE_TARGET +#if ENABLED(G38_PROBE_TARGET) + #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) +#endif + +// Moves (or segments) with fewer steps than this will be joined with the next move +#define MIN_STEPS_PER_SEGMENT 6 + +/** + * Minimum delay after setting the stepper DIR (in ns) + * 0 : No delay (Expect at least 10µS since one Stepper ISR must transpire) + * 20 : Minimum for TMC2xxx drivers + * 200 : Minimum for A4988 drivers + * 500 : Minimum for LV8729 drivers (guess, no info in datasheet) + * 650 : Minimum for DRV8825 drivers + * 1500 : Minimum for TB6600 drivers (guess, no info in datasheet) + * 15000 : Minimum for TB6560 drivers (guess, no info in datasheet) + * + * Override the default value based on the driver type set in Configuration.h. + */ +//#define MINIMUM_STEPPER_DIR_DELAY 650 + +/** + * Minimum stepper driver pulse width (in µs) + * 0 : Smallest possible width the MCU can produce, compatible with TMC2xxx drivers + * 1 : Minimum for A4988 stepper drivers + * 1 : Minimum for LV8729 stepper drivers + * 2 : Minimum for DRV8825 stepper drivers + * 3 : Minimum for TB6600 stepper drivers + * 30 : Minimum for TB6560 stepper drivers + * + * Override the default value based on the driver type set in Configuration.h. + */ +//#define MINIMUM_STEPPER_PULSE 2 + +/** + * Maximum stepping rate (in Hz) the stepper driver allows + * If undefined, defaults to 1MHz / (2 * MINIMUM_STEPPER_PULSE) + * 500000 : Maximum for A4988 stepper driver + * 400000 : Maximum for TMC2xxx stepper drivers + * 250000 : Maximum for DRV8825 stepper driver + * 150000 : Maximum for TB6600 stepper driver + * 130000 : Maximum for LV8729 stepper driver + * 15000 : Maximum for TB6560 stepper driver + * + * Override the default value based on the driver type set in Configuration.h. + */ +//#define MAXIMUM_STEPPER_RATE 250000 + +// @section temperature + +// Control heater 0 and heater 1 in parallel. +//#define HEATERS_PARALLEL + +//=========================================================================== +//================================= Buffers ================================= +//=========================================================================== + +// @section hidden + +// The number of linear motions that can be in the plan at any give time. +// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2 (e.g. 8, 16, 32) because shifts and ors are used to do the ring-buffering. +#if ENABLED(SDSUPPORT) + #define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller +#else + #define BLOCK_BUFFER_SIZE 16 // maximize block buffer +#endif + +// @section serial + +// The ASCII buffer for serial input +#define MAX_CMD_SIZE 96 +#define BUFSIZE 4 + +// Transmission to Host Buffer Size +// To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0. +// To buffer a simple "ok" you need 4 bytes. +// For ADVANCED_OK (M105) you need 32 bytes. +// For debug-echo: 128 bytes for the optimal speed. +// Other output doesn't need to be that speedy. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256] +#define TX_BUFFER_SIZE 0 + +// Host Receive Buffer Size +// Without XON/XOFF flow control (see SERIAL_XON_XOFF below) 32 bytes should be enough. +// To use flow control, set this buffer size to at least 1024 bytes. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048] +//#define RX_BUFFER_SIZE 1024 + +#if RX_BUFFER_SIZE >= 1024 + // Enable to have the controller send XON/XOFF control characters to + // the host to signal the RX buffer is becoming full. + //#define SERIAL_XON_XOFF +#endif + +#if ENABLED(SDSUPPORT) + // Enable this option to collect and display the maximum + // RX queue usage after transferring a file to SD. + //#define SERIAL_STATS_MAX_RX_QUEUED + + // Enable this option to collect and display the number + // of dropped bytes after a file transfer to SD. + //#define SERIAL_STATS_DROPPED_RX +#endif + +// Enable an emergency-command parser to intercept certain commands as they +// enter the serial receive buffer, so they cannot be blocked. +// Currently handles M108, M112, M410 +// Does not work on boards using AT90USB (USBCON) processors! +//#define EMERGENCY_PARSER + +// Bad Serial-connections can miss a received command by sending an 'ok' +// Therefore some clients abort after 30 seconds in a timeout. +// Some other clients start sending commands while receiving a 'wait'. +// This "wait" is only sent when the buffer is empty. 1 second is a good value here. +//#define NO_TIMEOUTS 1000 // Milliseconds + +// Some clients will have this feature soon. This could make the NO_TIMEOUTS unnecessary. +//#define ADVANCED_OK + +// @section extras + +/** + * Firmware-based and LCD-controlled retract + * + * Add G10 / G11 commands for automatic firmware-based retract / recover. + * Use M207 and M208 to define parameters for retract / recover. + * + * Use M209 to enable or disable auto-retract. + * With auto-retract enabled, all G1 E moves within the set range + * will be converted to firmware-based retract/recover moves. + * + * Be sure to turn off auto-retract during filament change. + * + * Note that M207 / M208 / M209 settings are saved to EEPROM. + * + */ +//#define FWRETRACT // ONLY PARTIALLY TESTED +#if ENABLED(FWRETRACT) + #define MIN_AUTORETRACT 0.1 // When auto-retract is on, convert E moves of this length and over + #define MAX_AUTORETRACT 10.0 // Upper limit for auto-retract conversion + #define RETRACT_LENGTH 3 // Default retract length (positive mm) + #define RETRACT_LENGTH_SWAP 13 // Default swap retract length (positive mm), for extruder change + #define RETRACT_FEEDRATE 45 // Default feedrate for retracting (mm/s) + #define RETRACT_ZLIFT 0 // Default retract Z-lift + #define RETRACT_RECOVER_LENGTH 0 // Default additional recover length (mm, added to retract length when recovering) + #define RETRACT_RECOVER_LENGTH_SWAP 0 // Default additional swap recover length (mm, added to retract length when recovering from extruder change) + #define RETRACT_RECOVER_FEEDRATE 8 // Default feedrate for recovering from retraction (mm/s) + #define RETRACT_RECOVER_FEEDRATE_SWAP 8 // Default feedrate for recovering from swap retraction (mm/s) +#endif + +/** + * Extra Fan Speed + * Adds a secondary fan speed for each print-cooling fan. + * 'M106 P T3-255' : Set a secondary speed for + * 'M106 P T2' : Use the set secondary speed + * 'M106 P T1' : Restore the previous fan speed + */ +//#define EXTRA_FAN_SPEED + +/** + * Advanced Pause + * Experimental feature for filament change support and for parking the nozzle when paused. + * Adds the GCode M600 for initiating filament change. + * If PARK_HEAD_ON_PAUSE enabled, adds the GCode M125 to pause printing and park the nozzle. + * + * Requires an LCD display. + * Requires NOZZLE_PARK_FEATURE. + * This feature is required for the default FILAMENT_RUNOUT_SCRIPT. + */ +//#define ADVANCED_PAUSE_FEATURE +#if ENABLED(ADVANCED_PAUSE_FEATURE) + #define PAUSE_PARK_RETRACT_FEEDRATE 60 // (mm/s) Initial retract feedrate. + #define PAUSE_PARK_RETRACT_LENGTH 2 // (mm) Initial retract. + // This short retract is done immediately, before parking the nozzle. + #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // (mm/s) Unload filament feedrate. This can be pretty fast. + #define FILAMENT_CHANGE_UNLOAD_ACCEL 25 // (mm/s^2) Lower acceleration may allow a faster feedrate. + #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // (mm) The length of filament for a complete unload. + // For Bowden, the full length of the tube and nozzle. + // For direct drive, the full length of the nozzle. + // Set to 0 for manual unloading. + #define FILAMENT_CHANGE_SLOW_LOAD_FEEDRATE 6 // (mm/s) Slow move when starting load. + #define FILAMENT_CHANGE_SLOW_LOAD_LENGTH 0 // (mm) Slow length, to allow time to insert material. + // 0 to disable start loading and skip to fast load only + #define FILAMENT_CHANGE_FAST_LOAD_FEEDRATE 6 // (mm/s) Load filament feedrate. This can be pretty fast. + #define FILAMENT_CHANGE_FAST_LOAD_ACCEL 25 // (mm/s^2) Lower acceleration may allow a faster feedrate. + #define FILAMENT_CHANGE_FAST_LOAD_LENGTH 0 // (mm) Load length of filament, from extruder gear to nozzle. + // For Bowden, the full length of the tube and nozzle. + // For direct drive, the full length of the nozzle. + //#define ADVANCED_PAUSE_CONTINUOUS_PURGE // Purge continuously up to the purge length until interrupted. + #define ADVANCED_PAUSE_PURGE_FEEDRATE 3 // (mm/s) Extrude feedrate (after loading). Should be slower than load feedrate. + #define ADVANCED_PAUSE_PURGE_LENGTH 50 // (mm) Length to extrude after loading. + // Set to 0 for manual extrusion. + // Filament can be extruded repeatedly from the Filament Change menu + // until extrusion is consistent, and to purge old filament. + + // Filament Unload does a Retract, Delay, and Purge first: + #define FILAMENT_UNLOAD_RETRACT_LENGTH 13 // (mm) Unload initial retract length. + #define FILAMENT_UNLOAD_DELAY 5000 // (ms) Delay for the filament to cool after retract. + #define FILAMENT_UNLOAD_PURGE_LENGTH 8 // (mm) An unretract is done, then this length is purged. + + #define PAUSE_PARK_NOZZLE_TIMEOUT 45 // (seconds) Time limit before the nozzle is turned off for safety. + #define FILAMENT_CHANGE_ALERT_BEEPS 10 // Number of alert beeps to play when a response is needed. + #define PAUSE_PARK_NO_STEPPER_TIMEOUT // Enable for XYZ steppers to stay powered on during filament change. + + //#define PARK_HEAD_ON_PAUSE // Park the nozzle during pause and filament change. + //#define HOME_BEFORE_FILAMENT_CHANGE // Ensure homing has been completed prior to parking for filament change + + //#define FILAMENT_LOAD_UNLOAD_GCODES // Add M701/M702 Load/Unload G-codes, plus Load/Unload in the LCD Prepare menu. + //#define FILAMENT_UNLOAD_ALL_EXTRUDERS // Allow M702 to unload all extruders above a minimum target temp (as set by M302) +#endif + +// @section tmc + +/** + * TMC26X Stepper Driver options + * + * The TMC26XStepper library is required for this stepper driver. + * https://github.com/trinamic/TMC26XStepper + */ +#if HAS_DRIVER(TMC26X) + + #define X_MAX_CURRENT 1000 // in mA + #define X_SENSE_RESISTOR 91 // in mOhms + #define X_MICROSTEPS 16 // number of microsteps + + #define X2_MAX_CURRENT 1000 + #define X2_SENSE_RESISTOR 91 + #define X2_MICROSTEPS 16 + + #define Y_MAX_CURRENT 1000 + #define Y_SENSE_RESISTOR 91 + #define Y_MICROSTEPS 16 + + #define Y2_MAX_CURRENT 1000 + #define Y2_SENSE_RESISTOR 91 + #define Y2_MICROSTEPS 16 + + #define Z_MAX_CURRENT 1000 + #define Z_SENSE_RESISTOR 91 + #define Z_MICROSTEPS 16 + + #define Z2_MAX_CURRENT 1000 + #define Z2_SENSE_RESISTOR 91 + #define Z2_MICROSTEPS 16 + + #define E0_MAX_CURRENT 1000 + #define E0_SENSE_RESISTOR 91 + #define E0_MICROSTEPS 16 + + #define E1_MAX_CURRENT 1000 + #define E1_SENSE_RESISTOR 91 + #define E1_MICROSTEPS 16 + + #define E2_MAX_CURRENT 1000 + #define E2_SENSE_RESISTOR 91 + #define E2_MICROSTEPS 16 + + #define E3_MAX_CURRENT 1000 + #define E3_SENSE_RESISTOR 91 + #define E3_MICROSTEPS 16 + + #define E4_MAX_CURRENT 1000 + #define E4_SENSE_RESISTOR 91 + #define E4_MICROSTEPS 16 + +#endif // TMC26X + +// @section tmc_smart + +/** + * To use TMC2130 stepper drivers in SPI mode connect your SPI pins to + * the hardware SPI interface on your board and define the required CS pins + * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). + * You may also use software SPI if you wish to use general purpose IO pins. + * + * You'll also need the TMC2130Stepper Arduino library + * (https://github.com/teemuatlut/TMC2130Stepper). + * + * To use TMC2208 stepper UART-configurable stepper drivers + * connect #_SERIAL_TX_PIN to the driver side PDN_UART pin with a 1K resistor. + * To use the reading capabilities, also connect #_SERIAL_RX_PIN + * to PDN_UART without a resistor. + * The drivers can also be used with hardware serial. + * + * You'll also need the TMC2208Stepper Arduino library + * (https://github.com/teemuatlut/TMC2208Stepper). + */ +#if HAS_TRINAMIC + + #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130 + #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current + #define INTERPOLATE true // Interpolate X/Y/Z_MICROSTEPS to 256 + + #define X_CURRENT 800 // rms current in mA. Multiply by 1.41 for peak current. + #define X_MICROSTEPS 16 // 0..256 + + #define Y_CURRENT 800 + #define Y_MICROSTEPS 16 + + #define Z_CURRENT 800 + #define Z_MICROSTEPS 16 + + #define X2_CURRENT 800 + #define X2_MICROSTEPS 16 + + #define Y2_CURRENT 800 + #define Y2_MICROSTEPS 16 + + #define Z2_CURRENT 800 + #define Z2_MICROSTEPS 16 + + #define E0_CURRENT 800 + #define E0_MICROSTEPS 16 + + #define E1_CURRENT 800 + #define E1_MICROSTEPS 16 + + #define E2_CURRENT 800 + #define E2_MICROSTEPS 16 + + #define E3_CURRENT 800 + #define E3_MICROSTEPS 16 + + #define E4_CURRENT 800 + #define E4_MICROSTEPS 16 + + /** + * Use software SPI for TMC2130. + * The default SW SPI pins are defined the respective pins files, + * but you can override or define them here. + */ + //#define TMC_USE_SW_SPI + //#define TMC_SW_MOSI -1 + //#define TMC_SW_MISO -1 + //#define TMC_SW_SCK -1 + + /** + * Use Trinamic's ultra quiet stepping mode. + * When disabled, Marlin will use spreadCycle stepping mode. + */ + #define STEALTHCHOP + + /** + * Monitor Trinamic TMC2130 and TMC2208 drivers for error conditions, + * like overtemperature and short to ground. TMC2208 requires hardware serial. + * In the case of overtemperature Marlin can decrease the driver current until error condition clears. + * Other detected conditions can be used to stop the current print. + * Relevant g-codes: + * M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given. + * M911 - Report stepper driver overtemperature pre-warn condition. + * M912 - Clear stepper driver overtemperature pre-warn condition flag. + * M122 S0/1 - Report driver parameters (Requires TMC_DEBUG) + */ + //#define MONITOR_DRIVER_STATUS + + #if ENABLED(MONITOR_DRIVER_STATUS) + #define CURRENT_STEP_DOWN 50 // [mA] + #define REPORT_CURRENT_CHANGE + #define STOP_ON_ERROR + #endif + + /** + * The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD. + * This mode allows for faster movements at the expense of higher noise levels. + * STEALTHCHOP needs to be enabled. + * M913 X/Y/Z/E to live tune the setting + */ + //#define HYBRID_THRESHOLD + + #define X_HYBRID_THRESHOLD 100 // [mm/s] + #define X2_HYBRID_THRESHOLD 100 + #define Y_HYBRID_THRESHOLD 100 + #define Y2_HYBRID_THRESHOLD 100 + #define Z_HYBRID_THRESHOLD 3 + #define Z2_HYBRID_THRESHOLD 3 + #define E0_HYBRID_THRESHOLD 30 + #define E1_HYBRID_THRESHOLD 30 + #define E2_HYBRID_THRESHOLD 30 + #define E3_HYBRID_THRESHOLD 30 + #define E4_HYBRID_THRESHOLD 30 + + /** + * Use stallGuard2 to sense an obstacle and trigger an endstop. + * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin. + * X, Y, and Z homing will always be done in spreadCycle mode. + * + * X/Y/Z_HOMING_SENSITIVITY is used for tuning the trigger sensitivity. + * Higher values make the system LESS sensitive. + * Lower value make the system MORE sensitive. + * Too low values can lead to false positives, while too high values will collide the axis without triggering. + * It is advised to set X/Y/Z_HOME_BUMP_MM to 0. + * M914 X/Y/Z to live tune the setting + */ + //#define SENSORLESS_HOMING // TMC2130 only + + #if ENABLED(SENSORLESS_HOMING) + #define X_HOMING_SENSITIVITY 8 + #define Y_HOMING_SENSITIVITY 8 + #define Z_HOMING_SENSITIVITY 8 + #endif + + /** + * Enable M122 debugging command for TMC stepper drivers. + * M122 S0/1 will enable continous reporting. + */ + //#define TMC_DEBUG + + /** + * M915 Z Axis Calibration + * + * - Adjust Z stepper current, + * - Drive the Z axis to its physical maximum, and + * - Home Z to account for the lost steps. + * + * Use M915 Snn to specify the current. + * Use M925 Znn to add extra Z height to Z_MAX_POS. + */ + //#define TMC_Z_CALIBRATION + #if ENABLED(TMC_Z_CALIBRATION) + #define CALIBRATION_CURRENT 250 + #define CALIBRATION_EXTRA_HEIGHT 10 + #endif + + /** + * You can set your own advanced settings by filling in predefined functions. + * A list of available functions can be found on the library github page + * https://github.com/teemuatlut/TMC2130Stepper + * https://github.com/teemuatlut/TMC2208Stepper + * + * Example: + * #define TMC_ADV() { \ + * stepperX.diag0_temp_prewarn(1); \ + * stepperY.interpolate(0); \ + * } + */ + #define TMC_ADV() { } + +#endif // TMC2130 || TMC2208 + +// @section L6470 + +/** + * L6470 Stepper Driver options + * + * The Arduino-L6470 library is required for this stepper driver. + * https://github.com/ameyer/Arduino-L6470 + */ +#if HAS_DRIVER(L6470) + + #define X_MICROSTEPS 16 // number of microsteps + #define X_OVERCURRENT 2000 // maxc current in mA. If the current goes over this value, the driver will switch off + #define X_STALLCURRENT 1500 // current in mA where the driver will detect a stall + + #define X2_MICROSTEPS 16 + #define X2_OVERCURRENT 2000 + #define X2_STALLCURRENT 1500 + + #define Y_MICROSTEPS 16 + #define Y_OVERCURRENT 2000 + #define Y_STALLCURRENT 1500 + + #define Y2_MICROSTEPS 16 + #define Y2_OVERCURRENT 2000 + #define Y2_STALLCURRENT 1500 + + #define Z_MICROSTEPS 16 + #define Z_OVERCURRENT 2000 + #define Z_STALLCURRENT 1500 + + #define Z2_MICROSTEPS 16 + #define Z2_OVERCURRENT 2000 + #define Z2_STALLCURRENT 1500 + + #define E0_MICROSTEPS 16 + #define E0_OVERCURRENT 2000 + #define E0_STALLCURRENT 1500 + + #define E1_MICROSTEPS 16 + #define E1_OVERCURRENT 2000 + #define E1_STALLCURRENT 1500 + + #define E2_MICROSTEPS 16 + #define E2_OVERCURRENT 2000 + #define E2_STALLCURRENT 1500 + + #define E3_MICROSTEPS 16 + #define E3_OVERCURRENT 2000 + #define E3_STALLCURRENT 1500 + + #define E4_MICROSTEPS 16 + #define E4_OVERCURRENT 2000 + #define E4_STALLCURRENT 1500 + +#endif // L6470 + +/** + * TWI/I2C BUS + * + * This feature is an EXPERIMENTAL feature so it shall not be used on production + * machines. Enabling this will allow you to send and receive I2C data from slave + * devices on the bus. + * + * ; Example #1 + * ; This macro send the string "Marlin" to the slave device with address 0x63 (99) + * ; It uses multiple M260 commands with one B arg + * M260 A99 ; Target slave address + * M260 B77 ; M + * M260 B97 ; a + * M260 B114 ; r + * M260 B108 ; l + * M260 B105 ; i + * M260 B110 ; n + * M260 S1 ; Send the current buffer + * + * ; Example #2 + * ; Request 6 bytes from slave device with address 0x63 (99) + * M261 A99 B5 + * + * ; Example #3 + * ; Example serial output of a M261 request + * echo:i2c-reply: from:99 bytes:5 data:hello + */ + +// @section i2cbus + +//#define EXPERIMENTAL_I2CBUS +#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave + +// @section extras + +/** + * Spindle & Laser control + * + * Add the M3, M4, and M5 commands to turn the spindle/laser on and off, and + * to set spindle speed, spindle direction, and laser power. + * + * SuperPid is a router/spindle speed controller used in the CNC milling community. + * Marlin can be used to turn the spindle on and off. It can also be used to set + * the spindle speed from 5,000 to 30,000 RPM. + * + * You'll need to select a pin for the ON/OFF function and optionally choose a 0-5V + * hardware PWM pin for the speed control and a pin for the rotation direction. + * + * See http://marlinfw.org/docs/configuration/laser_spindle.html for more config details. + */ +//#define SPINDLE_LASER_ENABLE +#if ENABLED(SPINDLE_LASER_ENABLE) + + #define SPINDLE_LASER_ENABLE_INVERT false // set to "true" if the on/off function is reversed + #define SPINDLE_LASER_PWM true // set to true if your controller supports setting the speed/power + #define SPINDLE_LASER_PWM_INVERT true // set to "true" if the speed/power goes up when you want it to go slower + #define SPINDLE_LASER_POWERUP_DELAY 5000 // delay in milliseconds to allow the spindle/laser to come up to speed/power + #define SPINDLE_LASER_POWERDOWN_DELAY 5000 // delay in milliseconds to allow the spindle to stop + #define SPINDLE_DIR_CHANGE true // set to true if your spindle controller supports changing spindle direction + #define SPINDLE_INVERT_DIR false + #define SPINDLE_STOP_ON_DIR_CHANGE true // set to true if Marlin should stop the spindle before changing rotation direction + + /** + * The M3 & M4 commands use the following equation to convert PWM duty cycle to speed/power + * + * SPEED/POWER = PWM duty cycle * SPEED_POWER_SLOPE + SPEED_POWER_INTERCEPT + * where PWM duty cycle varies from 0 to 255 + * + * set the following for your controller (ALL MUST BE SET) + */ + + #define SPEED_POWER_SLOPE 118.4 + #define SPEED_POWER_INTERCEPT 0 + #define SPEED_POWER_MIN 5000 + #define SPEED_POWER_MAX 30000 // SuperPID router controller 0 - 30,000 RPM + + //#define SPEED_POWER_SLOPE 0.3922 + //#define SPEED_POWER_INTERCEPT 0 + //#define SPEED_POWER_MIN 10 + //#define SPEED_POWER_MAX 100 // 0-100% +#endif + +/** + * Filament Width Sensor + * + * Measures the filament width in real-time and adjusts + * flow rate to compensate for any irregularities. + * + * Also allows the measured filament diameter to set the + * extrusion rate, so the slicer only has to specify the + * volume. + * + * Only a single extruder is supported at this time. + * + * 34 RAMPS_14 : Analog input 5 on the AUX2 connector + * 81 PRINTRBOARD : Analog input 2 on the Exp1 connector (version B,C,D,E) + * 301 RAMBO : Analog input 3 + * + * Note: May require analog pins to be defined for other boards. + */ +//#define FILAMENT_WIDTH_SENSOR + +#if ENABLED(FILAMENT_WIDTH_SENSOR) + #define FILAMENT_SENSOR_EXTRUDER_NUM 0 // Index of the extruder that has the filament sensor. :[0,1,2,3,4] + #define MEASUREMENT_DELAY_CM 14 // (cm) The distance from the filament sensor to the melting chamber + + #define FILWIDTH_ERROR_MARGIN 1.0 // (mm) If a measurement differs too much from nominal width ignore it + #define MAX_MEASUREMENT_DELAY 20 // (bytes) Buffer size for stored measurements (1 byte per cm). Must be larger than MEASUREMENT_DELAY_CM. + + #define DEFAULT_MEASURED_FILAMENT_DIA DEFAULT_NOMINAL_FILAMENT_DIA // Set measured to nominal initially + + // Display filament width on the LCD status line. Status messages will expire after 5 seconds. + //#define FILAMENT_LCD_DISPLAY +#endif + +/** + * CNC Coordinate Systems + * + * Enables G53 and G54-G59.3 commands to select coordinate systems + * and G92.1 to reset the workspace to native machine space. + */ +//#define CNC_COORDINATE_SYSTEMS + +/** + * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins + */ +//#define PINS_DEBUGGING + +/** + * Auto-report temperatures with M155 S + */ +#define AUTO_REPORT_TEMPERATURES + +/** + * Include capabilities in M115 output + */ +#define EXTENDED_CAPABILITIES_REPORT + +/** + * Disable all Volumetric extrusion options + */ +//#define NO_VOLUMETRICS + +#if DISABLED(NO_VOLUMETRICS) + /** + * Volumetric extrusion default state + * Activate to make volumetric extrusion the default method, + * with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter. + * + * M200 D0 to disable, M200 Dn to set a new diameter. + */ + //#define VOLUMETRIC_DEFAULT_ON +#endif + +/** + * Enable this option for a leaner build of Marlin that removes all + * workspace offsets, simplifying coordinate transformations, leveling, etc. + * + * - M206 and M428 are disabled. + * - G92 will revert to its behavior from Marlin 1.0. + */ +//#define NO_WORKSPACE_OFFSETS + +/** + * Set the number of proportional font spaces required to fill up a typical character space. + * This can help to better align the output of commands like `G29 O` Mesh Output. + * + * For clients that use a fixed-width font (like OctoPrint), leave this set to 1.0. + * Otherwise, adjust according to your client and font. + */ +#define PROPORTIONAL_FONT_RATIO 1.0 + +/** + * Spend 28 bytes of SRAM to optimize the GCode parser + */ +#define FASTER_GCODE_PARSER + +/** + * User-defined menu items that execute custom GCode + */ +//#define CUSTOM_USER_MENUS +#if ENABLED(CUSTOM_USER_MENUS) + #define USER_SCRIPT_DONE "M117 User Script Done" + #define USER_SCRIPT_AUDIBLE_FEEDBACK + //#define USER_SCRIPT_RETURN // Return to status screen after a script + + #define USER_DESC_1 "Home & UBL Info" + #define USER_GCODE_1 "G28\nG29 W" + + #define USER_DESC_2 "Preheat for PLA" + #define USER_GCODE_2 "M140 S" STRINGIFY(PREHEAT_1_TEMP_BED) "\nM104 S" STRINGIFY(PREHEAT_1_TEMP_HOTEND) + + #define USER_DESC_3 "Preheat for ABS" + #define USER_GCODE_3 "M140 S" STRINGIFY(PREHEAT_2_TEMP_BED) "\nM104 S" STRINGIFY(PREHEAT_2_TEMP_HOTEND) + + #define USER_DESC_4 "Heat Bed/Home/Level" + #define USER_GCODE_4 "M140 S" STRINGIFY(PREHEAT_2_TEMP_BED) "\nG28\nG29" + + #define USER_DESC_5 "Home & Info" + #define USER_GCODE_5 "G28\nM503" +#endif + +/** + * Specify an action command to send to the host when the printer is killed. + * Will be sent in the form '//action:ACTION_ON_KILL', e.g. '//action:poweroff'. + * The host must be configured to handle the action command. + */ +//#define ACTION_ON_KILL "poweroff" + +/** + * Specify an action command to send to the host on pause and resume. + * Will be sent in the form '//action:ACTION_ON_PAUSE', e.g. '//action:pause'. + * The host must be configured to handle the action command. + */ +//#define ACTION_ON_PAUSE "pause" +//#define ACTION_ON_RESUME "resume" + +//=========================================================================== +//====================== I2C Position Encoder Settings ====================== +//=========================================================================== + +/** + * I2C position encoders for closed loop control. + * Developed by Chris Barr at Aus3D. + * + * Wiki: http://wiki.aus3d.com.au/Magnetic_Encoder + * Github: https://github.com/Aus3D/MagneticEncoder + * + * Supplier: http://aus3d.com.au/magnetic-encoder-module + * Alternative Supplier: http://reliabuild3d.com/ + * + * Reilabuild encoders have been modified to improve reliability. + */ + +//#define I2C_POSITION_ENCODERS +#if ENABLED(I2C_POSITION_ENCODERS) + + #define I2CPE_ENCODER_CNT 1 // The number of encoders installed; max of 5 + // encoders supported currently. + + #define I2CPE_ENC_1_ADDR I2CPE_PRESET_ADDR_X // I2C address of the encoder. 30-200. + #define I2CPE_ENC_1_AXIS X_AXIS // Axis the encoder module is installed on. _AXIS. + #define I2CPE_ENC_1_TYPE I2CPE_ENC_TYPE_LINEAR // Type of encoder: I2CPE_ENC_TYPE_LINEAR -or- + // I2CPE_ENC_TYPE_ROTARY. + #define I2CPE_ENC_1_TICKS_UNIT 2048 // 1024 for magnetic strips with 2mm poles; 2048 for + // 1mm poles. For linear encoders this is ticks / mm, + // for rotary encoders this is ticks / revolution. + //#define I2CPE_ENC_1_TICKS_REV (16 * 200) // Only needed for rotary encoders; number of stepper + // steps per full revolution (motor steps/rev * microstepping) + //#define I2CPE_ENC_1_INVERT // Invert the direction of axis travel. + #define I2CPE_ENC_1_EC_METHOD I2CPE_ECM_MICROSTEP // Type of error error correction. + #define I2CPE_ENC_1_EC_THRESH 0.10 // Threshold size for error (in mm) above which the + // printer will attempt to correct the error; errors + // smaller than this are ignored to minimize effects of + // measurement noise / latency (filter). + + #define I2CPE_ENC_2_ADDR I2CPE_PRESET_ADDR_Y // Same as above, but for encoder 2. + #define I2CPE_ENC_2_AXIS Y_AXIS + #define I2CPE_ENC_2_TYPE I2CPE_ENC_TYPE_LINEAR + #define I2CPE_ENC_2_TICKS_UNIT 2048 + //#define I2CPE_ENC_2_TICKS_REV (16 * 200) + //#define I2CPE_ENC_2_INVERT + #define I2CPE_ENC_2_EC_METHOD I2CPE_ECM_MICROSTEP + #define I2CPE_ENC_2_EC_THRESH 0.10 + + #define I2CPE_ENC_3_ADDR I2CPE_PRESET_ADDR_Z // Encoder 3. Add additional configuration options + #define I2CPE_ENC_3_AXIS Z_AXIS // as above, or use defaults below. + + #define I2CPE_ENC_4_ADDR I2CPE_PRESET_ADDR_E // Encoder 4. + #define I2CPE_ENC_4_AXIS E_AXIS + + #define I2CPE_ENC_5_ADDR 34 // Encoder 5. + #define I2CPE_ENC_5_AXIS E_AXIS + + // Default settings for encoders which are enabled, but without settings configured above. + #define I2CPE_DEF_TYPE I2CPE_ENC_TYPE_LINEAR + #define I2CPE_DEF_ENC_TICKS_UNIT 2048 + #define I2CPE_DEF_TICKS_REV (16 * 200) + #define I2CPE_DEF_EC_METHOD I2CPE_ECM_NONE + #define I2CPE_DEF_EC_THRESH 0.1 + + //#define I2CPE_ERR_THRESH_ABORT 100.0 // Threshold size for error (in mm) error on any given + // axis after which the printer will abort. Comment out to + // disable abort behaviour. + + #define I2CPE_TIME_TRUSTED 10000 // After an encoder fault, there must be no further fault + // for this amount of time (in ms) before the encoder + // is trusted again. + + /** + * Position is checked every time a new command is executed from the buffer but during long moves, + * this setting determines the minimum update time between checks. A value of 100 works well with + * error rolling average when attempting to correct only for skips and not for vibration. + */ + #define I2CPE_MIN_UPD_TIME_MS 4 // (ms) Minimum time between encoder checks. + + // Use a rolling average to identify persistant errors that indicate skips, as opposed to vibration and noise. + #define I2CPE_ERR_ROLLING_AVERAGE + +#endif // I2C_POSITION_ENCODERS + +/** + * MAX7219 Debug Matrix + * + * Add support for a low-cost 8x8 LED Matrix based on the Max7219 chip as a realtime status display. + * Requires 3 signal wires. Some useful debug options are included to demonstrate its usage. + */ +//#define MAX7219_DEBUG +#if ENABLED(MAX7219_DEBUG) + #define MAX7219_CLK_PIN 64 + #define MAX7219_DIN_PIN 57 + #define MAX7219_LOAD_PIN 44 + + //#define MAX7219_GCODE // Add the M7219 G-code to control the LED matrix + #define MAX7219_INIT_TEST 2 // Do a test pattern at initialization (Set to 2 for spiral) + #define MAX7219_NUMBER_UNITS 1 // Number of Max7219 units in chain. + #define MAX7219_ROTATE 0 // Rotate the display clockwise (in multiples of +/- 90°) + // connector at: right=0 bottom=-90 top=90 left=180 + /** + * Sample debug features + * If you add more debug displays, be careful to avoid conflicts! + */ + #define MAX7219_DEBUG_PRINTER_ALIVE // Blink corner LED of 8x8 matrix to show that the firmware is functioning + #define MAX7219_DEBUG_PLANNER_HEAD 3 // Show the planner queue head position on this and the next LED matrix row + #define MAX7219_DEBUG_PLANNER_TAIL 5 // Show the planner queue tail position on this and the next LED matrix row + + #define MAX7219_DEBUG_PLANNER_QUEUE 0 // Show the current planner queue depth on this and the next LED matrix row + // If you experience stuttering, reboots, etc. this option can reveal how + // tweaks made to the configuration are affecting the printer in real-time. +#endif + +/** + * NanoDLP Sync support + * + * Add support for Synchronized Z moves when using with NanoDLP. G0/G1 axis moves will output "Z_move_comp" + * string to enable synchronization with DLP projector exposure. This change will allow to use + * [[WaitForDoneMessage]] instead of populating your gcode with M400 commands + */ +//#define NANODLP_Z_SYNC +#if ENABLED(NANODLP_Z_SYNC) + //#define NANODLP_ALL_AXIS // Enables "Z_move_comp" output on any axis move. + // Default behaviour is limited to Z axis only. +#endif + +// @section Mechaduino + +#if ENABLED(MECHADUINO_I2C_COMMANDS) + #define EXPERIMENTAL_I2CBUS + #define I2C_SLAVE_ADDRESS 0 // Do not act as a slave + #if ENABLED(HANGPRINTER) + #define A_IS_MECHADUINO + #define B_IS_MECHADUINO + #define C_IS_MECHADUINO + #define D_IS_MECHADUINO + #define A_MOTOR_I2C_ADDR 0x0A + #define B_MOTOR_I2C_ADDR 0x0B + #define C_MOTOR_I2C_ADDR 0x0C + #define D_MOTOR_I2C_ADDR 0x0D + #define A_INVERT_REPORTED_ANGLE false // Angle reports from Mechaduino encoder sent via i2c are used by + #define B_INVERT_REPORTED_ANGLE false // M114 S1 + #define C_INVERT_REPORTED_ANGLE false // which is used in Hangprinter auto anchor localization + #define D_INVERT_REPORTED_ANGLE false + #else + #define X_IS_MECHADUINO + #define Y_IS_MECHADUINO + #define Z_IS_MECHADUINO + #define X_MOTOR_I2C_ADDR 0x0A + #define Y_MOTOR_I2C_ADDR 0x0B + #define Z_MOTOR_I2C_ADDR 0x0C + #define X_INVERT_REPORTED_ANGLE false + #define Y_INVERT_REPORTED_ANGLE false + #define Z_INVERT_REPORTED_ANGLE false + #endif + //#define E_IS_MECHADUINO + //#define E_MOTOR_I2C_ADDR 0x0E + //#define E_INVERT_REPORTED_ANGLE false +#endif + +#if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) || ENABLED(MECHADUINO_I2C_COMMANDS) + // 1/16 microstepping on 200 step/rev motor gives 16*200=3200 microsteps/rev + #define STEPS_PER_MOTOR_REVOLUTION 3200 +#endif + +// Enable Marlin dev mode which adds some special commands +//#define MARLIN_DEV_MODE + +#endif // CONFIGURATION_ADV_H diff --git a/Marlin/fwretract.cpp b/Marlin/fwretract.cpp index 997e49a7f..7723fcd1c 100644 --- a/Marlin/fwretract.cpp +++ b/Marlin/fwretract.cpp @@ -123,7 +123,7 @@ void FWRetract::retract(const bool retracting #endif } SERIAL_ECHOLNPAIR("current_position[z] ", current_position[Z_AXIS]); - SERIAL_ECHOLNPAIR("current_position[e] ", current_position[E_AXIS]); + SERIAL_ECHOLNPAIR("current_position[e] ", current_position[E_CART]); SERIAL_ECHOLNPAIR("hop_amount ", hop_amount); //*/ @@ -131,7 +131,7 @@ void FWRetract::retract(const bool retracting renormalize = RECIPROCAL(planner.e_factor[active_extruder]), base_retract = swapping ? swap_retract_length : retract_length, old_z = current_position[Z_AXIS], - old_e = current_position[E_AXIS]; + old_e = current_position[E_CART]; // The current position will be the destination for E and Z moves set_destination_from_current(); @@ -139,7 +139,7 @@ void FWRetract::retract(const bool retracting if (retracting) { // Retract by moving from a faux E position back to the current E position feedrate_mm_s = retract_feedrate_mm_s; - destination[E_AXIS] -= base_retract * renormalize; + destination[E_CART] -= base_retract * renormalize; prepare_move_to_destination(); // set_current_to_destination // Is a Z hop set, and has the hop not yet been done? @@ -160,14 +160,14 @@ void FWRetract::retract(const bool retracting hop_amount = 0.0; // Clear the hop amount } - destination[E_AXIS] += (base_retract + (swapping ? swap_retract_recover_length : retract_recover_length)) * renormalize; + destination[E_CART] += (base_retract + (swapping ? swap_retract_recover_length : retract_recover_length)) * renormalize; feedrate_mm_s = swapping ? swap_retract_recover_feedrate_mm_s : retract_recover_feedrate_mm_s; prepare_move_to_destination(); // Recover E, set_current_to_destination } feedrate_mm_s = old_feedrate_mm_s; // Restore original feedrate current_position[Z_AXIS] = old_z; // Restore Z and E positions - current_position[E_AXIS] = old_e; + current_position[E_CART] = old_e; SYNC_PLAN_POSITION_KINEMATIC(); // As if the move never took place retracted[active_extruder] = retracting; // Active extruder now retracted / recovered @@ -190,7 +190,7 @@ void FWRetract::retract(const bool retracting #endif } SERIAL_ECHOLNPAIR("current_position[z] ", current_position[Z_AXIS]); - SERIAL_ECHOLNPAIR("current_position[e] ", current_position[E_AXIS]); + SERIAL_ECHOLNPAIR("current_position[e] ", current_position[E_CART]); SERIAL_ECHOLNPAIR("hop_amount ", hop_amount); //*/ diff --git a/Marlin/macros.h b/Marlin/macros.h index 9479788aa..a081744f7 100644 --- a/Marlin/macros.h +++ b/Marlin/macros.h @@ -23,13 +23,18 @@ #ifndef MACROS_H #define MACROS_H -#define NUM_AXIS 4 -#define ABCE 4 -#define XYZE 4 -#define ABC 3 -#define XYZ 3 +#define XYZ 3 +#define XYZE 4 +#define ABC 3 +#define ABCD 4 +#define ABCE 4 +#define ABCDE 5 -// For use in macros that take a single axis letter +/** + * For use in macros that take a single axis letter + * The axis order in all axis related arrays is X, Y, Z, E + * For Hangprinter it is A, B, C, D, E + */ #define _AXIS(A) (A##_AXIS) #define _XMIN_ 100 diff --git a/Marlin/pins.h b/Marlin/pins.h index 20ba513a5..b32eeb75b 100644 --- a/Marlin/pins.h +++ b/Marlin/pins.h @@ -696,6 +696,7 @@ // Dual X-carriage, Dual Y, Dual Z support // +#define _D_PINS #define _X2_PINS #define _Y2_PINS #define _Z2_PINS @@ -703,16 +704,64 @@ #define __EPIN(p,q) E##p##_##q##_PIN #define _EPIN(p,q) __EPIN(p,q) +// The HANGPRINTER A, B, C, D axes +#if ENABLED(HANGPRINTER) + #define A_ENABLE_PIN X_ENABLE_PIN + #define A_DIR_PIN X_DIR_PIN + #define A_STEP_PIN X_STEP_PIN + #define A_MS1_PIN X_MS1_PIN + + #define B_ENABLE_PIN Y_ENABLE_PIN + #define B_DIR_PIN Y_DIR_PIN + #define B_STEP_PIN Y_STEP_PIN + #define B_MS1_PIN Y_MS1_PIN + + #define C_ENABLE_PIN Z_ENABLE_PIN + #define C_DIR_PIN Z_DIR_PIN + #define C_STEP_PIN Z_STEP_PIN + #define C_MS1_PIN Z_MS1_PIN + + #ifndef D_STEP_PIN + #define D_STEP_PIN _EPIN(E_STEPPERS, STEP) + #define D_DIR_PIN _EPIN(E_STEPPERS, DIR) + #define D_ENABLE_PIN _EPIN(E_STEPPERS, ENABLE) + #ifndef D_CS_PIN + #define D_CS_PIN _EPIN(E_STEPPERS, CS) + #endif + #ifndef D_MS1_PIN + #define D_MS1_PIN _EPIN(E_STEPPERS, MS1) + #endif + #if E_STEPPERS >= MAX_EXTRUDERS || !PIN_EXISTS(D_ENABLE) + #error "No E stepper plug left for D Axis!" + #endif + #endif + #undef _D_PINS + #define ___D_PINS D_STEP_PIN, D_DIR_PIN, D_ENABLE_PIN, + #ifdef D_CS_PIN + #define __D_PINS ___D_PINS D_CS_PIN, + #else + #define __D_PINS ___D_PINS + #endif + #ifdef D_MS1_PIN + #define _D_PINS __D_PINS D_MS1_PIN, + #else + #define _D_PINS __D_PINS + #endif + #define X2_E_INDEX INCREMENT(E_STEPPERS) +#else + #define X2_E_INDEX E_STEPPERS +#endif + // The X2 axis, if any, should be the next open extruder port #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(X_DUAL_STEPPER_DRIVERS) #ifndef X2_STEP_PIN - #define X2_STEP_PIN _EPIN(E_STEPPERS, STEP) - #define X2_DIR_PIN _EPIN(E_STEPPERS, DIR) - #define X2_ENABLE_PIN _EPIN(E_STEPPERS, ENABLE) + #define X2_STEP_PIN _EPIN(X2_E_INDEX, STEP) + #define X2_DIR_PIN _EPIN(X2_E_INDEX, DIR) + #define X2_ENABLE_PIN _EPIN(X2_E_INDEX, ENABLE) #ifndef X2_CS_PIN - #define X2_CS_PIN _EPIN(E_STEPPERS, CS) + #define X2_CS_PIN _EPIN(X2_E_INDEX, CS) #endif - #if E_STEPPERS > 4 || !PIN_EXISTS(X2_ENABLE) + #if X2_E_INDEX >= MAX_EXTRUDERS || !PIN_EXISTS(X2_ENABLE) #error "No E stepper plug left for X2!" #endif #endif @@ -723,9 +772,9 @@ #else #define _X2_PINS __X2_PINS #endif - #define Y2_E_INDEX INCREMENT(E_STEPPERS) + #define Y2_E_INDEX INCREMENT(X2_E_INDEX) #else - #define Y2_E_INDEX E_STEPPERS + #define Y2_E_INDEX X2_E_INDEX #endif // The Y2 axis, if any, should be the next open extruder port @@ -737,7 +786,7 @@ #ifndef Y2_CS_PIN #define Y2_CS_PIN _EPIN(Y2_E_INDEX, CS) #endif - #if Y2_E_INDEX > 4 || !PIN_EXISTS(Y2_ENABLE) + #if Y2_E_INDEX >= MAX_EXTRUDERS || !PIN_EXISTS(Y2_ENABLE) #error "No E stepper plug left for Y2!" #endif #endif @@ -762,7 +811,7 @@ #ifndef Z2_CS_PIN #define Z2_CS_PIN _EPIN(Z2_E_INDEX, CS) #endif - #if Z2_E_INDEX > 4 || !PIN_EXISTS(Z2_ENABLE) + #if Z2_E_INDEX >= MAX_EXTRUDERS || !PIN_EXISTS(Z2_ENABLE) #error "No E stepper plug left for Z2!" #endif #endif @@ -782,7 +831,7 @@ PS_ON_PIN, HEATER_BED_PIN, FAN_PIN, FAN1_PIN, FAN2_PIN, CONTROLLER_FAN_PIN, \ _E0_PINS _E1_PINS _E2_PINS _E3_PINS _E4_PINS BED_PINS \ _H0_PINS _H1_PINS _H2_PINS _H3_PINS _H4_PINS \ - _X2_PINS _Y2_PINS _Z2_PINS \ + _D_PINS _X2_PINS _Y2_PINS _Z2_PINS \ } #define HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS)) diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp index 515ddc33a..59d49c635 100644 --- a/Marlin/planner.cpp +++ b/Marlin/planner.cpp @@ -100,13 +100,13 @@ volatile uint8_t Planner::block_buffer_head, // Index of the next block to be uint16_t Planner::cleaning_buffer_counter; // A counter to disable queuing of blocks uint8_t Planner::delay_before_delivering; // This counter delays delivery of blocks when queue becomes empty to allow the opportunity of merging blocks -uint32_t Planner::max_acceleration_mm_per_s2[XYZE_N], // (mm/s^2) M201 XYZE - Planner::max_acceleration_steps_per_s2[XYZE_N], // (steps/s^2) Derived from mm_per_s2 - Planner::min_segment_time_us; // (µs) M205 B +uint32_t Planner::max_acceleration_mm_per_s2[NUM_AXIS_N], // (mm/s^2) M201 XYZE + Planner::max_acceleration_steps_per_s2[NUM_AXIS_N], // (steps/s^2) Derived from mm_per_s2 + Planner::min_segment_time_us; // (µs) M205 Q -float Planner::max_feedrate_mm_s[XYZE_N], // (mm/s) M203 XYZE - Max speeds - Planner::axis_steps_per_mm[XYZE_N], // (steps) M92 XYZE - Steps per millimeter - Planner::steps_to_mm[XYZE_N], // (mm) Millimeters per step +float Planner::max_feedrate_mm_s[NUM_AXIS_N], // (mm/s) M203 XYZE - Max speeds + Planner::axis_steps_per_mm[NUM_AXIS_N], // (steps) M92 XYZE - Steps per millimeter + Planner::steps_to_mm[NUM_AXIS_N], // (mm) Millimeters per step Planner::min_feedrate_mm_s, // (mm/s) M205 S - Minimum linear feedrate Planner::acceleration, // (mm/s^2) M204 S - Normal acceleration. DEFAULT ACCELERATION for all printing moves. Planner::retract_acceleration, // (mm/s^2) M204 R - Retract acceleration. Filament pull-back and push-forward while standing still in the other axes @@ -123,7 +123,14 @@ float Planner::max_feedrate_mm_s[XYZE_N], // (mm/s) M203 XYZE - Max speeds #endif #endif #else - float Planner::max_jerk[XYZE]; // (mm/s^2) M205 XYZE - The largest speed change requiring no acceleration. + float Planner::max_jerk[NUM_AXIS]; // (mm/s^2) M205 XYZE - The largest speed change requiring no acceleration. +#endif + +#if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + float Planner::k0[MOV_AXIS], + Planner::k1[MOV_AXIS], + Planner::k2[MOV_AXIS], + Planner::sqrtk1[MOV_AXIS]; #endif #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) @@ -206,7 +213,7 @@ float Planner::previous_speed[NUM_AXIS], #endif #if HAS_POSITION_FLOAT - float Planner::position_float[XYZE]; // Needed for accurate maths. Steps cannot be used! + float Planner::position_float[NUM_AXIS]; // Needed for accurate maths. Steps cannot be used! #endif #if ENABLED(ULTRA_LCD) @@ -1137,7 +1144,13 @@ void Planner::recalculate() { float high = 0.0; for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) { block_t* block = &block_buffer[b]; - if (block->steps[X_AXIS] || block->steps[Y_AXIS] || block->steps[Z_AXIS]) { + if ( + #if ENABLED(HANGPRINTER) + block->steps[A_AXIS] || block->steps[B_AXIS] || block->steps[C_AXIS] || block->steps[D_AXIS] + #else + block->steps[X_AXIS] || block->steps[Y_AXIS] || block->steps[Z_AXIS] + #endif + ) { const float se = (float)block->steps[E_AXIS] / block->step_event_count * SQRT(block->nominal_speed_sqr); // mm/sec; NOLESS(high, se); } @@ -1514,6 +1527,9 @@ float Planner::get_axis_position_mm(const AxisEnum axis) { #else axis_steps = stepper.position(axis); #endif + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + if (axis != E_AXIS) return (sq(axis_steps / k0[axis] + sqrtk1[axis]) - k1[axis]) / k2[axis]; + #endif return axis_steps * steps_to_mm[axis]; } @@ -1522,23 +1538,34 @@ float Planner::get_axis_position_mm(const AxisEnum axis) { */ void Planner::synchronize() { while (has_blocks_queued() || cleaning_buffer_counter) idle(); } +#if ENABLED(UNREGISTERED_MOVE_SUPPORT) + #define COUNT_MOVE count_it +#else + #define COUNT_MOVE true +#endif + /** * Planner::_buffer_steps * * Add a new linear movement to the planner queue (in terms of steps). * - * target - target position in steps units - * fr_mm_s - (target) speed of the move - * extruder - target extruder - * millimeters - the length of the movement, if known + * target - target position in steps units + * target_float - target position in mm (HAS_POSITION_FLOAT) + * fr_mm_s - (target) speed of the move + * extruder - target extruder + * millimeters - the length of the movement, if known + * count_it - apply this move to the counters (UNREGISTERED_MOVE_SUPPORT) * * Returns true if movement was properly queued, false otherwise */ -bool Planner::_buffer_steps(const int32_t (&target)[XYZE] +bool Planner::_buffer_steps(const int32_t (&target)[NUM_AXIS] #if HAS_POSITION_FLOAT - , const float (&target_float)[XYZE] + , const float (&target_float)[NUM_AXIS] + #endif + , float fr_mm_s, const uint8_t extruder, const float &millimeters/*=0.0*/ + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , const bool count_it/*=true*/ #endif - , float fr_mm_s, const uint8_t extruder, const float &millimeters ) { // If we are cleaning, do not accept queuing of movements @@ -1554,6 +1581,9 @@ bool Planner::_buffer_steps(const int32_t (&target)[XYZE] , target_float #endif , fr_mm_s, extruder, millimeters + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , count_it + #endif )) { // Movement was not queued, probably because it was too short. // Simply accept that as movement queued and done @@ -1585,24 +1615,33 @@ bool Planner::_buffer_steps(const int32_t (&target)[XYZE] * * Fills a new linear movement in the block (in terms of steps). * - * target - target position in steps units - * fr_mm_s - (target) speed of the move - * extruder - target extruder + * target - target position in steps units + * target_float - target position in mm (HAS_POSITION_FLOAT) + * fr_mm_s - (target) speed of the move + * extruder - target extruder + * millimeters - the length of the movement, if known + * count_it - apply this move to the counters (UNREGISTERED_MOVE_SUPPORT) * * Returns true is movement is acceptable, false otherwise */ bool Planner::_populate_block(block_t * const block, bool split_move, - const int32_t (&target)[XYZE] + const int32_t (&target)[NUM_AXIS] #if HAS_POSITION_FLOAT - , const float (&target_float)[XYZE] + , const float (&target_float)[NUM_AXIS] #endif , float fr_mm_s, const uint8_t extruder, const float &millimeters/*=0.0*/ + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , const bool count_it/*=true*/ + #endif ) { const int32_t da = target[A_AXIS] - position[A_AXIS], db = target[B_AXIS] - position[B_AXIS], - dc = target[C_AXIS] - position[C_AXIS]; - + dc = target[C_AXIS] - position[C_AXIS] + #if ENABLED(HANGPRINTER) + , dd = target[D_AXIS] - position[D_AXIS] + #endif + ; int32_t de = target[E_AXIS] - position[E_AXIS]; /* <-- add a slash to enable @@ -1622,10 +1661,12 @@ bool Planner::_populate_block(block_t * const block, bool split_move, if (de) { #if ENABLED(PREVENT_COLD_EXTRUSION) if (thermalManager.tooColdToExtrude(extruder)) { - position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part - #if HAS_POSITION_FLOAT - position_float[E_AXIS] = target_float[E_AXIS]; - #endif + if (COUNT_MOVE) { + position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part + #if HAS_POSITION_FLOAT + position_float[E_AXIS] = target_float[E_AXIS]; + #endif + } de = 0; // no difference SERIAL_ECHO_START(); SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP); @@ -1633,10 +1674,12 @@ bool Planner::_populate_block(block_t * const block, bool split_move, #endif // PREVENT_COLD_EXTRUSION #if ENABLED(PREVENT_LENGTHY_EXTRUDE) if (ABS(de * e_factor[extruder]) > (int32_t)axis_steps_per_mm[E_AXIS_N] * (EXTRUDE_MAXLENGTH)) { // It's not important to get max. extrusion length in a precision < 1mm, so save some cycles and cast to int - position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part - #if HAS_POSITION_FLOAT - position_float[E_AXIS] = target_float[E_AXIS]; - #endif + if (COUNT_MOVE) { + position[E_AXIS] = target[E_AXIS]; // Behave as if the move really took place, but ignore E part + #if HAS_POSITION_FLOAT + position_float[E_AXIS] = target_float[E_AXIS]; + #endif + } de = 0; // no difference SERIAL_ECHO_START(); SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP); @@ -1665,6 +1708,11 @@ bool Planner::_populate_block(block_t * const block, bool split_move, if (dc < 0) SBI(dm, Z_HEAD); // ...and Z if (db + dc < 0) SBI(dm, B_AXIS); // Motor B direction if (CORESIGN(db - dc) < 0) SBI(dm, C_AXIS); // Motor C direction + #elif ENABLED(HANGPRINTER) + if (da < 0) SBI(dm, A_AXIS); + if (db < 0) SBI(dm, B_AXIS); + if (dc < 0) SBI(dm, C_AXIS); + if (dd < 0) SBI(dm, D_AXIS); #else if (da < 0) SBI(dm, X_AXIS); if (db < 0) SBI(dm, Y_AXIS); @@ -1681,6 +1729,11 @@ bool Planner::_populate_block(block_t * const block, bool split_move, // Set direction bits block->direction_bits = dm; + // Specify if block is to be counted or not + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + block->count_it = count_it; + #endif + // Number of steps for each axis // See http://www.corexy.com/theory.html #if CORE_IS_XY @@ -1699,6 +1752,11 @@ bool Planner::_populate_block(block_t * const block, bool split_move, block->steps[A_AXIS] = ABS(da); block->steps[B_AXIS] = ABS(db); block->steps[Z_AXIS] = ABS(dc); + #elif ENABLED(HANGPRINTER) + block->steps[A_AXIS] = ABS(da); + block->steps[B_AXIS] = ABS(db); + block->steps[C_AXIS] = ABS(dc); + block->steps[D_AXIS] = ABS(dd); #else // default non-h-bot planning block->steps[A_AXIS] = ABS(da); @@ -1707,7 +1765,14 @@ bool Planner::_populate_block(block_t * const block, bool split_move, #endif block->steps[E_AXIS] = esteps; - block->step_event_count = MAX4(block->steps[A_AXIS], block->steps[B_AXIS], block->steps[C_AXIS], esteps); + + block->step_event_count = ( + #if ENABLED(HANGPRINTER) + MAX5(block->steps[A_AXIS], block->steps[B_AXIS], block->steps[C_AXIS], block->steps[D_AXIS], esteps) + #else + MAX4(block->steps[A_AXIS], block->steps[B_AXIS], block->steps[C_AXIS], esteps) + #endif + ); // Bail if this is a zero-length block if (block->step_event_count < MIN_STEPS_PER_SEGMENT) return false; @@ -1761,7 +1826,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move, enable_Z(); } if (block->steps[X_AXIS]) enable_X(); - #else + #elif DISABLED(HANGPRINTER) // Hangprinters X, Y, Z, E0 axes should always be enabled anyways if (block->steps[X_AXIS]) enable_X(); if (block->steps[Y_AXIS]) enable_Y(); #if DISABLED(Z_LATE_ENABLE) @@ -1902,14 +1967,21 @@ bool Planner::_populate_block(block_t * const block, bool split_move, delta_mm[C_AXIS] = CORESIGN(db - dc) * steps_to_mm[C_AXIS]; #endif #else - float delta_mm[ABCE]; + float delta_mm[NUM_AXIS]; delta_mm[A_AXIS] = da * steps_to_mm[A_AXIS]; delta_mm[B_AXIS] = db * steps_to_mm[B_AXIS]; delta_mm[C_AXIS] = dc * steps_to_mm[C_AXIS]; + #if ENABLED(HANGPRINTER) + delta_mm[D_AXIS] = dd * steps_to_mm[D_AXIS]; + #endif #endif delta_mm[E_AXIS] = esteps_float * steps_to_mm[E_AXIS_N]; - if (block->steps[A_AXIS] < MIN_STEPS_PER_SEGMENT && block->steps[B_AXIS] < MIN_STEPS_PER_SEGMENT && block->steps[C_AXIS] < MIN_STEPS_PER_SEGMENT) { + if (block->steps[A_AXIS] < MIN_STEPS_PER_SEGMENT && block->steps[B_AXIS] < MIN_STEPS_PER_SEGMENT && block->steps[C_AXIS] < MIN_STEPS_PER_SEGMENT + #if ENABLED(HANGPRINTER) + && block->steps[D_AXIS] < MIN_STEPS_PER_SEGMENT + #endif + ) { block->millimeters = ABS(delta_mm[E_AXIS]); } else if (!millimeters) { @@ -1920,6 +1992,8 @@ bool Planner::_populate_block(block_t * const block, bool split_move, sq(delta_mm[X_HEAD]) + sq(delta_mm[Y_AXIS]) + sq(delta_mm[Z_HEAD]) #elif CORE_IS_YZ sq(delta_mm[X_AXIS]) + sq(delta_mm[Y_HEAD]) + sq(delta_mm[Z_HEAD]) + #elif ENABLED(HANGPRINTER) + sq(delta_mm[A_AXIS]) + sq(delta_mm[B_AXIS]) + sq(delta_mm[C_AXIS]) + sq(delta_mm[D_AXIS]) #else sq(delta_mm[X_AXIS]) + sq(delta_mm[Y_AXIS]) + sq(delta_mm[Z_AXIS]) #endif @@ -2005,7 +2079,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move, // Calculate and limit speed in mm/sec for each axis float current_speed[NUM_AXIS], speed_factor = 1.0f; // factor <1 decreases speed - LOOP_XYZE(i) { + LOOP_NUM_AXIS(i) { const float cs = ABS((current_speed[i] = delta_mm[i] * inverse_secs)); #if ENABLED(DISTINCT_E_FACTORS) if (i == E_AXIS) i += extruder; @@ -2053,7 +2127,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move, // Correct the speed if (speed_factor < 1.0f) { - LOOP_XYZE(i) current_speed[i] *= speed_factor; + LOOP_NUM_AXIS(i) current_speed[i] *= speed_factor; block->nominal_rate *= speed_factor; block->nominal_speed_sqr = block->nominal_speed_sqr * sq(speed_factor); } @@ -2061,7 +2135,11 @@ bool Planner::_populate_block(block_t * const block, bool split_move, // Compute and limit the acceleration rate for the trapezoid generator. const float steps_per_mm = block->step_event_count * inverse_millimeters; uint32_t accel; - if (!block->steps[A_AXIS] && !block->steps[B_AXIS] && !block->steps[C_AXIS]) { + if (!block->steps[A_AXIS] && !block->steps[B_AXIS] && !block->steps[C_AXIS] + #if ENABLED(HANGPRINTER) + && !block->steps[D_AXIS] + #endif + ) { // convert to: acceleration steps/sec^2 accel = CEIL(retract_acceleration * steps_per_mm); #if ENABLED(LIN_ADVANCE) @@ -2148,12 +2226,18 @@ bool Planner::_populate_block(block_t * const block, bool split_move, LIMIT_ACCEL_LONG(A_AXIS, 0); LIMIT_ACCEL_LONG(B_AXIS, 0); LIMIT_ACCEL_LONG(C_AXIS, 0); + #if ENABLED(HANGPRINTER) + LIMIT_ACCEL_LONG(D_AXIS, 0); + #endif LIMIT_ACCEL_LONG(E_AXIS, ACCEL_IDX); } else { LIMIT_ACCEL_FLOAT(A_AXIS, 0); LIMIT_ACCEL_FLOAT(B_AXIS, 0); LIMIT_ACCEL_FLOAT(C_AXIS, 0); + #if ENABLED(HANGPRINTER) + LIMIT_ACCEL_FLOAT(D_AXIS, 0); + #endif LIMIT_ACCEL_FLOAT(E_AXIS, ACCEL_IDX); } } @@ -2289,7 +2373,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move, float safe_speed = nominal_speed; uint8_t limited = 0; - LOOP_XYZE(i) { + LOOP_NUM_AXIS(i) { const float jerk = ABS(current_speed[i]), // cs : Starting from zero, change in speed for this axis maxj = max_jerk[i]; // mj : The max jerk setting for this axis if (jerk > maxj) { // cs > mj : New current speed too fast? @@ -2321,7 +2405,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move, // Now limit the jerk in all axes. const float smaller_speed_factor = vmax_junction / previous_nominal_speed; - LOOP_XYZE(axis) { + LOOP_NUM_AXIS(axis) { // Limit an axis. We have to differentiate: coasting, reversal of an axis, full stop. float v_exit = previous_speed[axis] * smaller_speed_factor, v_entry = current_speed[axis]; @@ -2381,12 +2465,22 @@ bool Planner::_populate_block(block_t * const block, bool split_move, COPY(previous_speed, current_speed); previous_nominal_speed_sqr = block->nominal_speed_sqr; - // Update the position - static_assert(COUNT(target) > 1, "Parameter to _buffer_steps must be (&target)[XYZE]!"); - COPY(position, target); - #if HAS_POSITION_FLOAT - COPY(position_float, target_float); - #endif + // Update the position (only when a move was queued) + static_assert(COUNT(target) > 1, "Parameter to _populate_block must be (&target)[" + #if ENABLED(HANGPRINTER) + "ABCD" + #else + "XYZ" + #endif + "E]!" + ); + + if (COUNT_MOVE) { + COPY(position, target); + #if HAS_POSITION_FLOAT + COPY(position_float, target_float); + #endif + } // Movement was accepted return true; @@ -2409,6 +2503,9 @@ void Planner::buffer_sync_block() { block->position[A_AXIS] = position[A_AXIS]; block->position[B_AXIS] = position[B_AXIS]; block->position[C_AXIS] = position[C_AXIS]; + #if ENABLED(HANGPRINTER) + block->position[D_AXIS] = position[D_AXIS]; + #endif block->position[E_AXIS] = position[E_AXIS]; // If this is the first added movement, reload the delay, otherwise, cancel it. @@ -2438,7 +2535,15 @@ void Planner::buffer_sync_block() { * extruder - target extruder * millimeters - the length of the movement, if known */ -bool Planner::buffer_segment(const float &a, const float &b, const float &c, const float &e, const float &fr_mm_s, const uint8_t extruder, const float &millimeters/*=0.0*/) { +bool Planner::buffer_segment(const float &a, const float &b, const float &c + #if ENABLED(HANGPRINTER) + , const float &d + #endif + , const float &e, const float &fr_mm_s, const uint8_t extruder, const float &millimeters/*=0.0*/ + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , bool count_it /* = true */ + #endif +) { // If we are cleaning, do not accept queuing of movements if (cleaning_buffer_counter) return false; @@ -2453,23 +2558,40 @@ bool Planner::buffer_segment(const float &a, const float &b, const float &c, con // The target position of the tool in absolute steps // Calculate target position in absolute steps - const int32_t target[ABCE] = { - LROUND(a * axis_steps_per_mm[A_AXIS]), - LROUND(b * axis_steps_per_mm[B_AXIS]), - LROUND(c * axis_steps_per_mm[C_AXIS]), + const int32_t target[NUM_AXIS] = { + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + LROUND(k0[A_AXIS] * (SQRT(k1[A_AXIS] + a * k2[A_AXIS]) - sqrtk1[A_AXIS])), + LROUND(k0[B_AXIS] * (SQRT(k1[B_AXIS] + b * k2[B_AXIS]) - sqrtk1[B_AXIS])), + LROUND(k0[C_AXIS] * (SQRT(k1[C_AXIS] + c * k2[C_AXIS]) - sqrtk1[C_AXIS])), + LROUND(k0[D_AXIS] * (SQRT(k1[D_AXIS] + d * k2[D_AXIS]) - sqrtk1[D_AXIS])), + #else + LROUND(a * axis_steps_per_mm[A_AXIS]), + LROUND(b * axis_steps_per_mm[B_AXIS]), + LROUND(c * axis_steps_per_mm[C_AXIS]), + #if ENABLED(HANGPRINTER) + LROUND(d * axis_steps_per_mm[D_AXIS]), + #endif + #endif LROUND(e * axis_steps_per_mm[E_AXIS_N]) }; #if HAS_POSITION_FLOAT - const float target_float[XYZE] = { a, b, c, e }; + const float target_float[NUM_AXIS] = { a, b, c + #if ENABLED(HANGPRINTER) + , d + #endif + , e + }; #endif // DRYRUN prevents E moves from taking place if (DEBUGGING(DRYRUN)) { - position[E_AXIS] = target[E_AXIS]; - #if HAS_POSITION_FLOAT - position_float[E_AXIS] = e; - #endif + if (COUNT_MOVE) { + position[E_AXIS] = target[E_AXIS]; + #if HAS_POSITION_FLOAT + position_float[E_AXIS] = e; + #endif + } } /* <-- add a slash to enable @@ -2487,13 +2609,18 @@ bool Planner::buffer_segment(const float &a, const float &b, const float &c, con #endif SERIAL_ECHOPAIR(" (", position[Y_AXIS]); SERIAL_ECHOPAIR("->", target[Y_AXIS]); - #if ENABLED(DELTA) + #if ENABLED(DELTA) || ENABLED(HANGPRINTER) SERIAL_ECHOPAIR(") C:", c); #else SERIAL_ECHOPAIR(") Z:", c); #endif SERIAL_ECHOPAIR(" (", position[Z_AXIS]); SERIAL_ECHOPAIR("->", target[Z_AXIS]); + #if ENABLED(HANGPRINTER) + SERIAL_ECHOPAIR(") D:", d); + SERIAL_ECHOPAIR(" (", position[D_AXIS]); + SERIAL_ECHOPAIR("->", target[D_AXIS]); + #endif SERIAL_ECHOPAIR(") E:", e); SERIAL_ECHOPAIR(" (", position[E_AXIS]); SERIAL_ECHOPAIR("->", target[E_AXIS]); @@ -2501,12 +2628,15 @@ bool Planner::buffer_segment(const float &a, const float &b, const float &c, con //*/ // Queue the movement - if ( + if ( !_buffer_steps(target #if HAS_POSITION_FLOAT , target_float #endif , fr_mm_s, extruder, millimeters + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , count_it + #endif ) ) return false; @@ -2521,23 +2651,41 @@ bool Planner::buffer_segment(const float &a, const float &b, const float &c, con * On CORE machines stepper ABC will be translated from the given XYZ. */ -void Planner::_set_position_mm(const float &a, const float &b, const float &c, const float &e) { +void Planner::_set_position_mm(const float &a, const float &b, const float &c + #if ENABLED(HANGPRINTER) + , const float &d + #endif + , const float &e +) { #if ENABLED(DISTINCT_E_FACTORS) last_extruder = active_extruder; #endif - position[A_AXIS] = LROUND(a * axis_steps_per_mm[A_AXIS]); - position[B_AXIS] = LROUND(b * axis_steps_per_mm[B_AXIS]); - position[C_AXIS] = LROUND(axis_steps_per_mm[C_AXIS] * (c + ( - #if !IS_KINEMATIC && ENABLED(AUTO_BED_LEVELING_UBL) - leveling_active ? ubl.get_z_correction(a, b) : + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + position[A_AXIS] = LROUND(k0[A_AXIS] * (SQRT(k1[A_AXIS] + a * k2[A_AXIS]) - sqrtk1[A_AXIS])), + position[B_AXIS] = LROUND(k0[B_AXIS] * (SQRT(k1[B_AXIS] + b * k2[B_AXIS]) - sqrtk1[B_AXIS])), + position[C_AXIS] = LROUND(k0[C_AXIS] * (SQRT(k1[C_AXIS] + c * k2[C_AXIS]) - sqrtk1[C_AXIS])), + position[D_AXIS] = LROUND(k0[D_AXIS] * (SQRT(k1[D_AXIS] + d * k2[D_AXIS]) - sqrtk1[D_AXIS])), + #else + position[A_AXIS] = LROUND(a * axis_steps_per_mm[A_AXIS]); + position[B_AXIS] = LROUND(b * axis_steps_per_mm[B_AXIS]); + position[C_AXIS] = LROUND(axis_steps_per_mm[C_AXIS] * (c + ( + #if !IS_KINEMATIC && ENABLED(AUTO_BED_LEVELING_UBL) + leveling_active ? ubl.get_z_correction(a, b) : + #endif + 0) + )); + #if ENABLED(HANGPRINTER) + position[D_AXIS] = LROUND(d * axis_steps_per_mm[D_AXIS]), #endif - 0 - ))); + #endif position[E_AXIS] = LROUND(e * axis_steps_per_mm[_EINDEX]); #if HAS_POSITION_FLOAT position_float[A_AXIS] = a; position_float[B_AXIS] = b; position_float[C_AXIS] = c; + #if ENABLED(HANGPRINTER) + position_float[D_AXIS] = d; + #endif position_float[E_AXIS] = e; #endif if (has_blocks_queued()) { @@ -2546,21 +2694,32 @@ void Planner::_set_position_mm(const float &a, const float &b, const float &c, c buffer_sync_block(); } else - stepper.set_position(position[A_AXIS], position[B_AXIS], position[C_AXIS], position[E_AXIS]); + stepper.set_position(position[A_AXIS], position[B_AXIS], position[C_AXIS], + #if ENABLED(HANGPRINTER) + position[D_AXIS], + #endif + position[E_AXIS] + ); } void Planner::set_position_mm_kinematic(const float (&cart)[XYZE]) { #if PLANNER_LEVELING float raw[XYZ] = { cart[X_AXIS], cart[Y_AXIS], cart[Z_AXIS] }; apply_leveling(raw); + #elif ENABLED(HANGPRINTER) + float raw[XYZ] = { cart[X_AXIS], cart[Y_AXIS], cart[Z_AXIS] }; #else const float (&raw)[XYZE] = cart; #endif #if IS_KINEMATIC inverse_kinematics(raw); - _set_position_mm(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_AXIS]); + #if ENABLED(HANGPRINTER) + _set_position_mm(line_lengths[A_AXIS], line_lengths[B_AXIS], line_lengths[C_AXIS], line_lengths[D_AXIS], cart[E_CART]); + #else + _set_position_mm(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_CART]); + #endif #else - _set_position_mm(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], cart[E_AXIS]); + _set_position_mm(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], cart[E_CART]); #endif } @@ -2597,7 +2756,7 @@ void Planner::reset_acceleration_rates() { #define AXIS_CONDITION true #endif uint32_t highest_rate = 1; - LOOP_XYZE_N(i) { + LOOP_NUM_AXIS_N(i) { max_acceleration_steps_per_s2[i] = max_acceleration_mm_per_s2[i] * axis_steps_per_mm[i]; if (AXIS_CONDITION) NOLESS(highest_rate, max_acceleration_steps_per_s2[i]); } @@ -2609,7 +2768,7 @@ void Planner::reset_acceleration_rates() { // Recalculate position, steps_to_mm if axis_steps_per_mm changes! void Planner::refresh_positioning() { - LOOP_XYZE_N(i) steps_to_mm[i] = 1.0f / axis_steps_per_mm[i]; + LOOP_NUM_AXIS_N(i) steps_to_mm[i] = 1.0f / axis_steps_per_mm[i]; set_position_mm_kinematic(current_position); reset_acceleration_rates(); } diff --git a/Marlin/planner.h b/Marlin/planner.h index fd06be588..c4d459de9 100644 --- a/Marlin/planner.h +++ b/Marlin/planner.h @@ -76,6 +76,10 @@ typedef struct { volatile uint8_t flag; // Block flags (See BlockFlag enum above) - Modified by ISR and main thread! + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + bool count_it; + #endif + // Fields used by the motion planner to manage acceleration float nominal_speed_sqr, // The nominal speed for this block in (mm/sec)^2 entry_speed_sqr, // Entry speed at previous-current junction in (mm/sec)^2 @@ -188,12 +192,12 @@ class Planner { // May be auto-adjusted by a filament width sensor #endif - static uint32_t max_acceleration_mm_per_s2[XYZE_N], // (mm/s^2) M201 XYZE - max_acceleration_steps_per_s2[XYZE_N], // (steps/s^2) Derived from mm_per_s2 - min_segment_time_us; // (µs) M205 B - static float max_feedrate_mm_s[XYZE_N], // (mm/s) M203 XYZE - Max speeds - axis_steps_per_mm[XYZE_N], // (steps) M92 XYZE - Steps per millimeter - steps_to_mm[XYZE_N], // (mm) Millimeters per step + static uint32_t max_acceleration_mm_per_s2[NUM_AXIS_N], // (mm/s^2) M201 XYZE + max_acceleration_steps_per_s2[NUM_AXIS_N], // (steps/s^2) Derived from mm_per_s2 + min_segment_time_us; // (µs) M205 Q + static float max_feedrate_mm_s[NUM_AXIS_N], // (mm/s) M203 XYZE - Max speeds + axis_steps_per_mm[NUM_AXIS_N], // (steps) M92 XYZE - Steps per millimeter + steps_to_mm[NUM_AXIS_N], // (mm) Millimeters per step min_feedrate_mm_s, // (mm/s) M205 S - Minimum linear feedrate acceleration, // (mm/s^2) M204 S - Normal acceleration. DEFAULT ACCELERATION for all printing moves. retract_acceleration, // (mm/s^2) M204 R - Retract acceleration. Filament pull-back and push-forward while standing still in the other axes @@ -210,7 +214,19 @@ class Planner { #endif #endif #else - static float max_jerk[XYZE]; // (mm/s^2) M205 XYZE - The largest speed change requiring no acceleration. + static float max_jerk[NUM_AXIS]; // (mm/s^2) M205 XYZE - The largest speed change requiring no acceleration. + #endif + + #if ENABLED(LINE_BUILDUP_COMPENSATION_FEATURE) + /* + * Parameters for calculating target[] + * See buildup compensation theory: + * https://vitana.se/opr3d/tbear/2017.html#hangprinter_project_29 + */ + static float k0[MOV_AXIS], + k1[MOV_AXIS], + k2[MOV_AXIS], + sqrtk1[MOV_AXIS]; #endif #if HAS_LEVELING @@ -230,7 +246,7 @@ class Planner { #endif #if HAS_POSITION_FLOAT - static float position_float[XYZE]; + static float position_float[NUM_AXIS]; #endif #if ENABLED(SKEW_CORRECTION) @@ -429,11 +445,17 @@ class Planner { #define ARG_X float rx #define ARG_Y float ry #define ARG_Z float rz + #if ENABLED(HANGPRINTER) + #define ARG_E1 float re1 + #endif static void unapply_leveling(float raw[XYZ]); #else #define ARG_X const float &rx #define ARG_Y const float &ry #define ARG_Z const float &rz + #if ENABLED(HANGPRINTER) + #define ARG_E1 const float &re1 + #endif #endif // Number of moves currently in the planner including the busy block, if any @@ -477,14 +499,18 @@ class Planner { * fr_mm_s - (target) speed of the move * extruder - target extruder * millimeters - the length of the movement, if known + * count_it - apply this move to the counters (UNREGISTERED_MOVE_SUPPORT) * * Returns true if movement was buffered, false otherwise */ - static bool _buffer_steps(const int32_t (&target)[XYZE] + static bool _buffer_steps(const int32_t (&target)[NUM_AXIS] #if HAS_POSITION_FLOAT - , const float (&target_float)[XYZE] + , const float (&target_float)[NUM_AXIS] #endif , float fr_mm_s, const uint8_t extruder, const float &millimeters=0.0 + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , const bool count_it=true + #endif ); /** @@ -496,15 +522,19 @@ class Planner { * fr_mm_s - (target) speed of the move * extruder - target extruder * millimeters - the length of the movement, if known + * count_it - apply this move to the counters (UNREGISTERED_MOVE_SUPPORT) * * Returns true is movement is acceptable, false otherwise */ static bool _populate_block(block_t * const block, bool split_move, - const int32_t (&target)[XYZE] + const int32_t (&target)[NUM_AXIS] #if HAS_POSITION_FLOAT - , const float (&target_float)[XYZE] + , const float (&target_float)[NUM_AXIS] #endif , float fr_mm_s, const uint8_t extruder, const float &millimeters=0.0 + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , const bool count_it=true + #endif ); /** @@ -521,13 +551,28 @@ class Planner { * Leveling and kinematics should be applied ahead of calling this. * * a,b,c,e - target positions in mm and/or degrees + * (a, b, c, d, e for Hangprinter) * fr_mm_s - (target) speed of the move * extruder - target extruder * millimeters - the length of the movement, if known + * count_it - remember this move in its counters (UNREGISTERED_MOVE_SUPPORT) */ - static bool buffer_segment(const float &a, const float &b, const float &c, const float &e, const float &fr_mm_s, const uint8_t extruder, const float &millimeters=0.0); + static bool buffer_segment(const float &a, const float &b, const float &c, + #if ENABLED(HANGPRINTER) + const float &d, + #endif + const float &e, const float &fr_mm_s, const uint8_t extruder, const float &millimeters=0.0 + #if ENABLED(UNREGISTERED_MOVE_SUPPORT) + , bool count_it=true + #endif + ); - static void _set_position_mm(const float &a, const float &b, const float &c, const float &e); + static void _set_position_mm(const float &a, const float &b, const float &c, + #if ENABLED(HANGPRINTER) + const float &d, + #endif + const float &e + ); /** * Add a new linear movement to the buffer. @@ -538,15 +583,26 @@ class Planner { * (Cartesians may also call buffer_line_kinematic.) * * rx,ry,rz,e - target position in mm or degrees + * (rx, ry, rz, re1 for Hangprinter) * fr_mm_s - (target) speed of the move (mm/s) * extruder - target extruder * millimeters - the length of the movement, if known */ - FORCE_INLINE static bool buffer_line(ARG_X, ARG_Y, ARG_Z, const float &e, const float &fr_mm_s, const uint8_t extruder, const float millimeters = 0.0) { + FORCE_INLINE static bool buffer_line(ARG_X, ARG_Y, ARG_Z, + #if ENABLED(HANGPRINTER) + ARG_E1, + #endif + const float &e, const float &fr_mm_s, const uint8_t extruder, const float millimeters = 0.0 + ) { #if PLANNER_LEVELING && IS_CARTESIAN apply_leveling(rx, ry, rz); #endif - return buffer_segment(rx, ry, rz, e, fr_mm_s, extruder, millimeters); + return buffer_segment(rx, ry, rz, + #if ENABLED(HANGPRINTER) + re1, + #endif + e, fr_mm_s, extruder, millimeters + ); } /** @@ -568,9 +624,16 @@ class Planner { #endif #if IS_KINEMATIC inverse_kinematics(raw); - return buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], cart[E_AXIS], fr_mm_s, extruder, millimeters); + return buffer_segment( + #if ENABLED(HANGPRINTER) + line_lengths[A_AXIS], line_lengths[B_AXIS], line_lengths[C_AXIS], line_lengths[D_AXIS] + #else + delta[A_AXIS], delta[B_AXIS], delta[C_AXIS] + #endif + , cart[E_CART], fr_mm_s, extruder, millimeters + ); #else - return buffer_segment(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], cart[E_AXIS], fr_mm_s, extruder, millimeters); + return buffer_segment(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], cart[E_CART], fr_mm_s, extruder, millimeters); #endif } @@ -583,11 +646,21 @@ class Planner { * * Clears previous speed values. */ - FORCE_INLINE static void set_position_mm(ARG_X, ARG_Y, ARG_Z, const float &e) { + FORCE_INLINE static void set_position_mm(ARG_X, ARG_Y, ARG_Z, + #if ENABLED(HANGPRINTER) + ARG_E1, + #endif + const float &e + ) { #if PLANNER_LEVELING && IS_CARTESIAN apply_leveling(rx, ry, rz); #endif - _set_position_mm(rx, ry, rz, e); + _set_position_mm(rx, ry, rz, + #if ENABLED(HANGPRINTER) + re1, + #endif + e + ); } static void set_position_mm_kinematic(const float (&cart)[XYZE]); static void set_position_mm(const AxisEnum axis, const float &v); diff --git a/Marlin/planner_bezier.cpp b/Marlin/planner_bezier.cpp index fdb4bab86..6edc02b56 100644 --- a/Marlin/planner_bezier.cpp +++ b/Marlin/planner_bezier.cpp @@ -105,17 +105,17 @@ inline static float dist1(float x1, float y1, float x2, float y2) { return ABS(x * the mitigation offered by MIN_STEP and the small computational * power available on Arduino, I think it is not wise to implement it. */ -void cubic_b_spline(const float position[NUM_AXIS], const float target[NUM_AXIS], const float offset[4], float fr_mm_s, uint8_t extruder) { +void cubic_b_spline(const float pos[XYZE], const float cart_target[XYZE], const float offset[4], float fr_mm_s, uint8_t extruder) { // Absolute first and second control points are recovered. - const float first0 = position[X_AXIS] + offset[0], - first1 = position[Y_AXIS] + offset[1], - second0 = target[X_AXIS] + offset[2], - second1 = target[Y_AXIS] + offset[3]; + const float first0 = pos[X_AXIS] + offset[0], + first1 = pos[Y_AXIS] + offset[1], + second0 = cart_target[X_AXIS] + offset[2], + second1 = cart_target[Y_AXIS] + offset[3]; float t = 0; - float bez_target[4]; - bez_target[X_AXIS] = position[X_AXIS]; - bez_target[Y_AXIS] = position[Y_AXIS]; + float bez_target[XYZE]; + bez_target[X_AXIS] = pos[X_AXIS]; + bez_target[Y_AXIS] = pos[Y_AXIS]; float step = MAX_STEP; millis_t next_idle_ms = millis() + 200UL; @@ -134,13 +134,13 @@ void cubic_b_spline(const float position[NUM_AXIS], const float target[NUM_AXIS] bool did_reduce = false; float new_t = t + step; NOMORE(new_t, 1); - float new_pos0 = eval_bezier(position[X_AXIS], first0, second0, target[X_AXIS], new_t), - new_pos1 = eval_bezier(position[Y_AXIS], first1, second1, target[Y_AXIS], new_t); + float new_pos0 = eval_bezier(pos[X_AXIS], first0, second0, cart_target[X_AXIS], new_t), + new_pos1 = eval_bezier(pos[Y_AXIS], first1, second1, cart_target[Y_AXIS], new_t); for (;;) { if (new_t - t < (MIN_STEP)) break; const float candidate_t = 0.5f * (t + new_t), - candidate_pos0 = eval_bezier(position[X_AXIS], first0, second0, target[X_AXIS], candidate_t), - candidate_pos1 = eval_bezier(position[Y_AXIS], first1, second1, target[Y_AXIS], candidate_t), + candidate_pos0 = eval_bezier(pos[X_AXIS], first0, second0, cart_target[X_AXIS], candidate_t), + candidate_pos1 = eval_bezier(pos[Y_AXIS], first1, second1, cart_target[Y_AXIS], candidate_t), interp_pos0 = 0.5f * (bez_target[X_AXIS] + new_pos0), interp_pos1 = 0.5f * (bez_target[Y_AXIS] + new_pos1); if (dist1(candidate_pos0, candidate_pos1, interp_pos0, interp_pos1) <= (SIGMA)) break; @@ -155,8 +155,8 @@ void cubic_b_spline(const float position[NUM_AXIS], const float target[NUM_AXIS] if (new_t - t > MAX_STEP) break; const float candidate_t = t + 2 * (new_t - t); if (candidate_t >= 1) break; - const float candidate_pos0 = eval_bezier(position[X_AXIS], first0, second0, target[X_AXIS], candidate_t), - candidate_pos1 = eval_bezier(position[Y_AXIS], first1, second1, target[Y_AXIS], candidate_t), + const float candidate_pos0 = eval_bezier(pos[X_AXIS], first0, second0, cart_target[X_AXIS], candidate_t), + candidate_pos1 = eval_bezier(pos[Y_AXIS], first1, second1, cart_target[Y_AXIS], candidate_t), interp_pos0 = 0.5f * (bez_target[X_AXIS] + candidate_pos0), interp_pos1 = 0.5f * (bez_target[Y_AXIS] + candidate_pos1); if (dist1(new_pos0, new_pos1, interp_pos0, interp_pos1) > (SIGMA)) break; @@ -184,14 +184,14 @@ void cubic_b_spline(const float position[NUM_AXIS], const float target[NUM_AXIS] bez_target[Y_AXIS] = new_pos1; // FIXME. The following two are wrong, since the parameter t is // not linear in the distance. - bez_target[Z_AXIS] = interp(position[Z_AXIS], target[Z_AXIS], t); - bez_target[E_AXIS] = interp(position[E_AXIS], target[E_AXIS], t); + bez_target[Z_AXIS] = interp(pos[Z_AXIS], cart_target[Z_AXIS], t); + bez_target[E_CART] = interp(pos[E_CART], cart_target[E_CART], t); clamp_to_software_endstops(bez_target); #if HAS_UBL_AND_CURVES - float pos[XYZ] = { bez_target[X_AXIS], bez_target[Y_AXIS], bez_target[Z_AXIS] }; - planner.apply_leveling(pos); - if (!planner.buffer_segment(pos[X_AXIS], pos[Y_AXIS], pos[Z_AXIS], bez_target[E_AXIS], fr_mm_s, active_extruder)) + float bez_copy[XYZ] = { bez_target[X_AXIS], bez_target[Y_AXIS], bez_target[Z_AXIS] }; + planner.apply_leveling(bez_copy); + if (!planner.buffer_segment(bez_copy[X_AXIS], bez_copy[Y_AXIS], bez_copy[Z_AXIS], bez_target[E_CART], fr_mm_s, active_extruder)) break; #else if (!planner.buffer_line_kinematic(bez_target, fr_mm_s, extruder)) diff --git a/Marlin/power_loss_recovery.cpp b/Marlin/power_loss_recovery.cpp index 19acc6e01..fef41f3a4 100644 --- a/Marlin/power_loss_recovery.cpp +++ b/Marlin/power_loss_recovery.cpp @@ -159,7 +159,7 @@ void check_print_job_recovery() { #endif dtostrf(job_recovery_info.current_position[Z_AXIS] + 2, 1, 3, str_1); - dtostrf(job_recovery_info.current_position[E_AXIS] + dtostrf(job_recovery_info.current_position[E_CART] #if ENABLED(SAVE_EACH_CMD_MODE) - 5 #endif diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp index 825c02d07..768ae6e90 100644 --- a/Marlin/stepper.cpp +++ b/Marlin/stepper.cpp @@ -135,9 +135,8 @@ uint8_t Stepper::steps_per_isr; #endif uint8_t Stepper::oversampling_factor; -int32_t Stepper::delta_error[XYZE] = { 0 }; - -uint32_t Stepper::advance_dividend[XYZE] = { 0 }, +int32_t Stepper::delta_error[NUM_AXIS] = { 0 }; +uint32_t Stepper::advance_dividend[NUM_AXIS] = { 0 }, Stepper::advance_divisor = 0, Stepper::step_events_completed = 0, // The number of step events executed in the current block Stepper::accelerate_until, // The point from where we need to stop acceleration @@ -180,14 +179,19 @@ uint32_t Stepper::nextMainISR = 0; #endif // LIN_ADVANCE int32_t Stepper::ticks_nominal = -1; + #if DISABLED(S_CURVE_ACCELERATION) uint32_t Stepper::acc_step_rate; // needed for deceleration start point #endif -volatile int32_t Stepper::endstops_trigsteps[XYZ]; - -volatile int32_t Stepper::count_position[NUM_AXIS] = { 0 }; -int8_t Stepper::count_direction[NUM_AXIS] = { 0, 0, 0, 0 }; +volatile int32_t Stepper::endstops_trigsteps[XYZ], + Stepper::count_position[NUM_AXIS] = { 0 }; +int8_t Stepper::count_direction[NUM_AXIS] = { + 1, 1, 1, 1 + #if ENABLED(HANGPRINTER) + , 1 + #endif +}; #if ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS) #define DUAL_ENDSTOP_APPLY_STEP(A,V) \ @@ -260,6 +264,28 @@ int8_t Stepper::count_direction[NUM_AXIS] = { 0, 0, 0, 0 }; #define Z_APPLY_STEP(v,Q) Z_STEP_WRITE(v) #endif +/** + * Hangprinter's mapping {A,B,C,D} <-> {X,Y,Z,E1} happens here. + * If you have two extruders: {A,B,C,D} <-> {X,Y,Z,E2} + * ... etc up to max 4 extruders. + * Place D connector on your first "free" extruder output. + */ +#if ENABLED(HANGPRINTER) + #define A_APPLY_DIR(v,Q) X_APPLY_DIR(v,Q) + #define A_APPLY_STEP(v,Q) X_APPLY_STEP(v,Q) + + #define B_APPLY_DIR(v,Q) Y_APPLY_DIR(v,Q) + #define B_APPLY_STEP(v,Q) Y_APPLY_STEP(v,Q) + + #define C_APPLY_DIR(v,Q) Z_APPLY_DIR(v,Q) + #define C_APPLY_STEP(v,Q) Z_APPLY_STEP(v,Q) + + #define __D_APPLY(I,T,v) E##I##_##T##_WRITE(v) + #define _D_APPLY(I,T,v) __D_APPLY(I,T,v) + #define D_APPLY_DIR(v,Q) _D_APPLY(EXTRUDERS, DIR, v) + #define D_APPLY_STEP(v,Q) _D_APPLY(EXTRUDERS, STEP, v) +#endif + #if DISABLED(MIXING_EXTRUDER) #define E_APPLY_STEP(v,Q) E_STEP_WRITE(active_extruder, v) #endif @@ -357,6 +383,9 @@ void Stepper::set_directions() { #if HAS_Z_DIR SET_STEP_DIR(Z); // C #endif + #if ENABLED(HANGPRINTER) + SET_STEP_DIR(D); + #endif #if DISABLED(LIN_ADVANCE) #if ENABLED(MIXING_EXTRUDER) @@ -1251,6 +1280,12 @@ void Stepper::isr() { * call to this method that might cause variation in the timing. The aim * is to keep pulse timing as regular as possible. */ +#if ENABLED(UNREGISTERED_MOVE_SUPPORT) + #define COUNT_IT current_block->count_it +#else + #define COUNT_IT true +#endif + void Stepper::stepper_pulse_phase_isr() { // If we must abort the current block, do so! @@ -1289,7 +1324,7 @@ void Stepper::stepper_pulse_phase_isr() { delta_error[_AXIS(AXIS)] += advance_dividend[_AXIS(AXIS)]; \ if (delta_error[_AXIS(AXIS)] >= 0) { \ _APPLY_STEP(AXIS)(!_INVERT_STEP_PIN(AXIS), 0); \ - count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \ + if (COUNT_IT) count_position[_AXIS(AXIS)] += count_direction[_AXIS(AXIS)]; \ } \ }while(0) @@ -1302,22 +1337,37 @@ void Stepper::stepper_pulse_phase_isr() { }while(0) // Pulse start - #if HAS_X_STEP - PULSE_START(X); - #endif - #if HAS_Y_STEP - PULSE_START(Y); - #endif - #if HAS_Z_STEP - PULSE_START(Z); - #endif + #if ENABLED(HANGPRINTER) + #if HAS_A_STEP + PULSE_START(A); + #endif + #if HAS_B_STEP + PULSE_START(B); + #endif + #if HAS_C_STEP + PULSE_START(C); + #endif + #if HAS_D_STEP + PULSE_START(D); + #endif + #else + #if HAS_X_STEP + PULSE_START(X); + #endif + #if HAS_Y_STEP + PULSE_START(Y); + #endif + #if HAS_Z_STEP + PULSE_START(Z); + #endif + #endif // HANGPRINTER // Pulse E/Mixing extruders #if ENABLED(LIN_ADVANCE) // Tick the E axis, correct error term and update position delta_error[E_AXIS] += advance_dividend[E_AXIS]; if (delta_error[E_AXIS] >= 0) { - count_position[E_AXIS] += count_direction[E_AXIS]; + if (COUNT_IT) count_position[E_AXIS] += count_direction[E_AXIS]; delta_error[E_AXIS] -= advance_divisor; // Don't step E here - But remember the number of steps to perform @@ -1329,7 +1379,7 @@ void Stepper::stepper_pulse_phase_isr() { // Tick the E axis delta_error[E_AXIS] += advance_dividend[E_AXIS]; if (delta_error[E_AXIS] >= 0) { - count_position[E_AXIS] += count_direction[E_AXIS]; + if (COUNT_IT) count_position[E_AXIS] += count_direction[E_AXIS]; delta_error[E_AXIS] -= advance_divisor; } @@ -1354,15 +1404,29 @@ void Stepper::stepper_pulse_phase_isr() { // Add the delay needed to ensure the maximum driver rate is enforced if (signed(added_step_ticks) > 0) pulse_end += hal_timer_t(added_step_ticks); - // Pulse stop - #if HAS_X_STEP - PULSE_STOP(X); - #endif - #if HAS_Y_STEP - PULSE_STOP(Y); - #endif - #if HAS_Z_STEP - PULSE_STOP(Z); + #if ENABLED(HANGPRINTER) + #if HAS_A_STEP + PULSE_STOP(A); + #endif + #if HAS_B_STEP + PULSE_STOP(B); + #endif + #if HAS_C_STEP + PULSE_STOP(C); + #endif + #if HAS_D_STEP + PULSE_STOP(D); + #endif + #else + #if HAS_X_STEP + PULSE_STOP(X); + #endif + #if HAS_Y_STEP + PULSE_STOP(Y); + #endif + #if HAS_Z_STEP + PULSE_STOP(Z); + #endif #endif #if DISABLED(LIN_ADVANCE) @@ -1531,8 +1595,11 @@ uint32_t Stepper::stepper_block_phase_isr() { // Sync block? Sync the stepper counts and return while (TEST(current_block->flag, BLOCK_BIT_SYNC_POSITION)) { _set_position( - current_block->position[A_AXIS], current_block->position[B_AXIS], - current_block->position[C_AXIS], current_block->position[E_AXIS] + current_block->position[A_AXIS], current_block->position[B_AXIS], current_block->position[C_AXIS], + #if ENABLED(HANGPRINTER) + current_block->position[D_AXIS], + #endif + current_block->position[E_AXIS] ); planner.discard_current_block(); @@ -2015,7 +2082,12 @@ void Stepper::init() { * This allows get_axis_position_mm to correctly * derive the current XYZ position later on. */ -void Stepper::_set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) { +void Stepper::_set_position(const int32_t &a, const int32_t &b, const int32_t &c, + #if ENABLED(HANGPRINTER) + const int32_t &d, + #endif + const int32_t &e +) { #if CORE_IS_XY // corexy positioning // these equations follow the form of the dA and dB equations on http://www.corexy.com/theory.html @@ -2037,6 +2109,9 @@ void Stepper::_set_position(const int32_t &a, const int32_t &b, const int32_t &c count_position[X_AXIS] = a; count_position[Y_AXIS] = b; count_position[Z_AXIS] = c; + #if ENABLED(HANGPRINTER) + count_position[D_AXIS] = d; + #endif #endif count_position[E_AXIS] = e; } @@ -2103,31 +2178,38 @@ void Stepper::report_positions() { const int32_t xpos = count_position[X_AXIS], ypos = count_position[Y_AXIS], + #if ENABLED(HANGPRINTER) + dpos = count_position[D_AXIS], + #endif zpos = count_position[Z_AXIS]; if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT(); - #if CORE_IS_XY || CORE_IS_XZ || IS_DELTA || IS_SCARA + #if CORE_IS_XY || CORE_IS_XZ || IS_DELTA || IS_SCARA || ENABLED(HANGPRINTER) SERIAL_PROTOCOLPGM(MSG_COUNT_A); #else SERIAL_PROTOCOLPGM(MSG_COUNT_X); #endif SERIAL_PROTOCOL(xpos); - #if CORE_IS_XY || CORE_IS_YZ || IS_DELTA || IS_SCARA + #if CORE_IS_XY || CORE_IS_YZ || IS_DELTA || IS_SCARA || ENABLED(HANGPRINTER) SERIAL_PROTOCOLPGM(" B:"); #else SERIAL_PROTOCOLPGM(" Y:"); #endif SERIAL_PROTOCOL(ypos); - #if CORE_IS_XZ || CORE_IS_YZ || IS_DELTA + #if CORE_IS_XZ || CORE_IS_YZ || IS_DELTA || ENABLED(HANGPRINTER) SERIAL_PROTOCOLPGM(" C:"); #else SERIAL_PROTOCOLPGM(" Z:"); #endif SERIAL_PROTOCOL(zpos); + #if ENABLED(HANGPRINTER) + SERIAL_PROTOCOLPAIR(" D:", dpos); + #endif + SERIAL_EOL(); } diff --git a/Marlin/stepper.h b/Marlin/stepper.h index 2ac9c7756..709981e5a 100644 --- a/Marlin/stepper.h +++ b/Marlin/stepper.h @@ -270,8 +270,8 @@ class Stepper { #endif // Delta error variables for the Bresenham line tracer - static int32_t delta_error[XYZE]; - static uint32_t advance_dividend[XYZE], + static int32_t delta_error[NUM_AXIS]; + static uint32_t advance_dividend[NUM_AXIS], advance_divisor, step_events_completed, // The number of step events executed in the current block accelerate_until, // The point from where we need to stop acceleration @@ -425,11 +425,21 @@ class Stepper { #endif // Set the current position in steps - inline static void set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) { + inline static void set_position(const int32_t &a, const int32_t &b, const int32_t &c + #if ENABLED(HANGPRINTER) + , const int32_t &d + #endif + , const int32_t &e + ) { planner.synchronize(); const bool was_enabled = STEPPER_ISR_ENABLED(); if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT(); - _set_position(a, b, c, e); + _set_position(a, b, c + #if ENABLED(HANGPRINTER) + , d + #endif + , e + ); if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT(); } @@ -447,7 +457,12 @@ class Stepper { private: // Set the current position in steps - static void _set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e); + static void _set_position(const int32_t &a, const int32_t &b, const int32_t &c + #if ENABLED(HANGPRINTER) + , const int32_t &d + #endif + , const int32_t &e + ); // Set direction bits for all steppers static void set_directions(); diff --git a/Marlin/twibus.cpp b/Marlin/twibus.cpp index 777d151e4..5156c8979 100644 --- a/Marlin/twibus.cpp +++ b/Marlin/twibus.cpp @@ -55,7 +55,7 @@ void TWIBus::address(const uint8_t adr) { #endif } -void TWIBus::addbyte(const char c) { +void TWIBus::addbyte(const byte c) { if (this->buffer_s >= COUNT(this->buffer)) return; this->buffer[this->buffer_s++] = c; #if ENABLED(DEBUG_TWIBUS) @@ -63,7 +63,7 @@ void TWIBus::addbyte(const char c) { #endif } -void TWIBus::addbytes(char src[], uint8_t bytes) { +void TWIBus::addbytes(byte src[], uint8_t bytes) { #if ENABLED(DEBUG_TWIBUS) debug(PSTR("addbytes"), bytes); #endif @@ -138,7 +138,7 @@ void TWIBus::relay(const uint8_t bytes) { echodata(bytes, PSTR("i2c-reply"), this->addr); } -uint8_t TWIBus::capture(char *dst, const uint8_t bytes) { +uint8_t TWIBus::capture(byte *dst, const uint8_t bytes) { this->reset(); uint8_t count = 0; while (count < bytes && Wire.available()) diff --git a/Marlin/twibus.h b/Marlin/twibus.h index 03763972a..8759c40db 100644 --- a/Marlin/twibus.h +++ b/Marlin/twibus.h @@ -33,6 +33,13 @@ typedef void (*twiReceiveFunc_t)(int bytes); typedef void (*twiRequestFunc_t)(); +#if ENABLED(MECHADUINO_I2C_COMMANDS) + typedef union { + float fval; + byte bval[sizeof(float)]; + } i2cFloat; +#endif + #define TWIBUS_BUFFER_SIZE 32 /** @@ -99,7 +106,7 @@ class TWIBus { * * @param c a data byte */ - void addbyte(const char c); + void addbyte(const byte c); /** * @brief Add some bytes to the buffer @@ -109,7 +116,7 @@ class TWIBus { * @param src source data address * @param bytes the number of bytes to add */ - void addbytes(char src[], uint8_t bytes); + void addbytes(byte src[], uint8_t bytes); /** * @brief Add a null-terminated string to the buffer @@ -172,7 +179,7 @@ class TWIBus { * @param bytes the number of bytes to request * @return the number of bytes captured to the buffer */ - uint8_t capture(char *dst, const uint8_t bytes); + uint8_t capture(byte *dst, const uint8_t bytes); /** * @brief Flush the i2c bus. diff --git a/Marlin/ubl.cpp b/Marlin/ubl.cpp index df9c212bb..26485c5d0 100644 --- a/Marlin/ubl.cpp +++ b/Marlin/ubl.cpp @@ -76,7 +76,7 @@ // ignore the status of the g26_debug_flag if (*title != '!' && !g26_debug_flag) return; - const float de = destination[E_AXIS] - current_position[E_AXIS]; + const float de = destination[E_CART] - current_position[E_CART]; if (de == 0.0) return; // Printing moves only @@ -97,7 +97,7 @@ SERIAL_ECHOPGM(", "); SERIAL_ECHO_F(current_position[Z_AXIS], 6); SERIAL_ECHOPGM(", "); - SERIAL_ECHO_F(current_position[E_AXIS], 6); + SERIAL_ECHO_F(current_position[E_CART], 6); SERIAL_ECHOPGM(" ) destination=( "); debug_echo_axis(X_AXIS); SERIAL_ECHOPGM(", "); diff --git a/Marlin/ubl_motion.cpp b/Marlin/ubl_motion.cpp index 5272e2079..0751c9572 100644 --- a/Marlin/ubl_motion.cpp +++ b/Marlin/ubl_motion.cpp @@ -46,8 +46,8 @@ */ #if ENABLED(SKEW_CORRECTION) // For skew correction just adjust the destination point and we're done - float start[XYZE] = { current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS] }, - end[XYZE] = { destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS] }; + float start[XYZE] = { current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_CART] }, + end[XYZE] = { destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_CART] }; planner.skew(start[X_AXIS], start[Y_AXIS], start[Z_AXIS]); planner.skew(end[X_AXIS], end[Y_AXIS], end[Z_AXIS]); #else @@ -64,7 +64,7 @@ SERIAL_ECHOPAIR(" ubl.line_to_destination_cartesian(xe=", destination[X_AXIS]); SERIAL_ECHOPAIR(", ye=", destination[Y_AXIS]); SERIAL_ECHOPAIR(", ze=", destination[Z_AXIS]); - SERIAL_ECHOPAIR(", ee=", destination[E_AXIS]); + SERIAL_ECHOPAIR(", ee=", destination[E_CART]); SERIAL_CHAR(')'); SERIAL_EOL(); debug_current_and_destination(PSTR("Start of ubl.line_to_destination_cartesian()")); @@ -85,7 +85,7 @@ + UBL_Z_RAISE_WHEN_OFF_MESH #endif ; - planner.buffer_segment(end[X_AXIS], end[Y_AXIS], end[Z_AXIS] + z_raise, end[E_AXIS], feed_rate, extruder); + planner.buffer_segment(end[X_AXIS], end[Y_AXIS], end[Z_AXIS] + z_raise, end[E_CART], feed_rate, extruder); set_current_from_destination(); if (g26_debug_flag) @@ -112,7 +112,7 @@ // Undefined parts of the Mesh in z_values[][] are NAN. // Replace NAN corrections with 0.0 to prevent NAN propagation. - planner.buffer_segment(end[X_AXIS], end[Y_AXIS], end[Z_AXIS] + (isnan(z0) ? 0.0 : z0), end[E_AXIS], feed_rate, extruder); + planner.buffer_segment(end[X_AXIS], end[Y_AXIS], end[Z_AXIS] + (isnan(z0) ? 0.0 : z0), end[E_CART], feed_rate, extruder); if (g26_debug_flag) debug_current_and_destination(PSTR("FINAL_MOVE in ubl.line_to_destination_cartesian()")); @@ -149,7 +149,7 @@ const bool use_x_dist = adx > ady; float on_axis_distance = use_x_dist ? dx : dy, - e_position = end[E_AXIS] - start[E_AXIS], + e_position = end[E_CART] - start[E_CART], z_position = end[Z_AXIS] - start[Z_AXIS]; const float e_normalized_dist = e_position / on_axis_distance, @@ -198,11 +198,11 @@ if (ry != start[Y_AXIS]) { if (!inf_normalized_flag) { on_axis_distance = use_x_dist ? rx - start[X_AXIS] : ry - start[Y_AXIS]; - e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist; + e_position = start[E_CART] + on_axis_distance * e_normalized_dist; z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist; } else { - e_position = end[E_AXIS]; + e_position = end[E_CART]; z_position = end[Z_AXIS]; } @@ -249,11 +249,11 @@ if (rx != start[X_AXIS]) { if (!inf_normalized_flag) { on_axis_distance = use_x_dist ? rx - start[X_AXIS] : ry - start[Y_AXIS]; - e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a horizontal move + e_position = start[E_CART] + on_axis_distance * e_normalized_dist; // is based on X or Y because this is a horizontal move z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist; } else { - e_position = end[E_AXIS]; + e_position = end[E_CART]; z_position = end[Z_AXIS]; } @@ -308,11 +308,11 @@ if (!inf_normalized_flag) { on_axis_distance = use_x_dist ? rx - start[X_AXIS] : next_mesh_line_y - start[Y_AXIS]; - e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist; + e_position = start[E_CART] + on_axis_distance * e_normalized_dist; z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist; } else { - e_position = end[E_AXIS]; + e_position = end[E_CART]; z_position = end[Z_AXIS]; } if (!planner.buffer_segment(rx, next_mesh_line_y, z_position + z0, e_position, feed_rate, extruder)) @@ -331,11 +331,11 @@ if (!inf_normalized_flag) { on_axis_distance = use_x_dist ? next_mesh_line_x - start[X_AXIS] : ry - start[Y_AXIS]; - e_position = start[E_AXIS] + on_axis_distance * e_normalized_dist; + e_position = start[E_CART] + on_axis_distance * e_normalized_dist; z_position = start[Z_AXIS] + on_axis_distance * z_normalized_dist; } else { - e_position = end[E_AXIS]; + e_position = end[E_CART]; z_position = end[Z_AXIS]; } @@ -378,7 +378,12 @@ #if ENABLED(DELTA) // apply delta inverse_kinematics DELTA_IK(raw); - planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], in_raw[E_AXIS], fr, active_extruder); + planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], in_raw[E_CART], fr, active_extruder); + + #elif ENABLED(HANGPRINTER) // apply hangprinter inverse_kinematics + + HANGPRINTER_IK(raw); + planner.buffer_segment(line_lengths[A_AXIS], line_lengths[B_AXIS], line_lengths[C_AXIS], line_lengths[D_AXIS], in_raw[E_CART], fr, active_extruder); #elif IS_SCARA // apply scara inverse_kinematics (should be changed to save raw->logical->raw) @@ -391,11 +396,11 @@ scara_oldB = delta[B_AXIS]; float s_feedrate = MAX(adiff, bdiff) * scara_feed_factor; - planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], in_raw[E_AXIS], s_feedrate, active_extruder); + planner.buffer_segment(delta[A_AXIS], delta[B_AXIS], delta[C_AXIS], in_raw[E_CART], s_feedrate, active_extruder); #else // CARTESIAN - planner.buffer_segment(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], in_raw[E_AXIS], fr, active_extruder); + planner.buffer_segment(raw[X_AXIS], raw[Y_AXIS], raw[Z_AXIS], in_raw[E_CART], fr, active_extruder); #endif } @@ -427,7 +432,7 @@ rtarget[X_AXIS] - current_position[X_AXIS], rtarget[Y_AXIS] - current_position[Y_AXIS], rtarget[Z_AXIS] - current_position[Z_AXIS], - rtarget[E_AXIS] - current_position[E_AXIS] + rtarget[E_CART] - current_position[E_CART] }; const float cartesian_xy_mm = HYPOT(total[X_AXIS], total[Y_AXIS]); // total horizontal xy distance @@ -454,7 +459,7 @@ total[X_AXIS] * inv_segments, total[Y_AXIS] * inv_segments, total[Z_AXIS] * inv_segments, - total[E_AXIS] * inv_segments + total[E_CART] * inv_segments }; // Note that E segment distance could vary slightly as z mesh height @@ -464,7 +469,7 @@ current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS] + current_position[E_CART] }; // Only compute leveling per segment if ubl active and target below z_fade_height. diff --git a/Marlin/ultralcd.cpp b/Marlin/ultralcd.cpp index 753df63fc..7ba2b94b7 100644 --- a/Marlin/ultralcd.cpp +++ b/Marlin/ultralcd.cpp @@ -3077,7 +3077,7 @@ void lcd_quick_feedback(const bool clear_buttons) { #if IS_KINEMATIC manual_move_offset += diff; #else - current_position[E_AXIS] += diff; + current_position[E_CART] += diff; #endif manual_move_to_current(E_AXIS #if E_MANUAL > 1 @@ -3107,7 +3107,7 @@ void lcd_quick_feedback(const bool clear_buttons) { #endif // E_MANUAL > 2 } #endif // E_MANUAL > 1 - lcd_implementation_drawedit(pos_label, ftostr41sign(current_position[E_AXIS] + lcd_implementation_drawedit(pos_label, ftostr41sign(current_position[E_CART] #if IS_KINEMATIC + manual_move_offset #endif