diff --git a/Firmware/Configuration_adv.h b/Firmware/Configuration_adv.h index 1ce9032ad..08b4d543b 100644 --- a/Firmware/Configuration_adv.h +++ b/Firmware/Configuration_adv.h @@ -156,53 +156,6 @@ #error "You cannot have dual drivers for both Y and Z" #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. -//#define DUAL_X_CARRIAGE -#ifdef 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 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 EXTRUDER_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. - -// Pins for second x-carriage stepper driver (defined here to avoid further complicating pins.h) -#define X2_ENABLE_PIN 29 -#define X2_STEP_PIN 25 -#define X2_DIR_PIN 23 - -// There are a few selectable movement modes for dual x-carriages using M605 S -// Mode 0: 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: 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: 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 0 - -// As the x-carriages are independent we can now account for any relative Z offset -#define EXTRUDER1_Z_OFFSET 0.0 // z offset relative to extruder 0 - -// 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 - //homing hits the endstop, then retracts by this distance, before it tries to slowly bump again: #define X_HOME_RETRACT_MM 5 #define Y_HOME_RETRACT_MM 5 @@ -210,11 +163,7 @@ //#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. #define AXIS_RELATIVE_MODES {false, false, false, false} -#ifdef CONFIG_STEPPERS_TOSHIBA -#define MAX_STEP_FREQUENCY 10000 // Max step frequency for Toshiba Stepper Controllers -#else -#define MAX_STEP_FREQUENCY 40000 // Max step frequency for Ultimaker (5000 pps / half step) -#endif +#define MAX_STEP_FREQUENCY 40000 // Max step frequency for Ultimaker (5000 pps / half step). Toshiba steppers are 4x slower, but Prusa3D does not use those. //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 diff --git a/Firmware/Marlin.h b/Firmware/Marlin.h index b43a57fea..fc8af6dae 100644 --- a/Firmware/Marlin.h +++ b/Firmware/Marlin.h @@ -114,11 +114,7 @@ void process_commands(); void manage_inactivity(bool ignore_stepper_queue=false); -#if defined(DUAL_X_CARRIAGE) && defined(X_ENABLE_PIN) && X_ENABLE_PIN > -1 \ - && defined(X2_ENABLE_PIN) && X2_ENABLE_PIN > -1 - #define enable_x() do { WRITE(X_ENABLE_PIN, X_ENABLE_ON); WRITE(X2_ENABLE_PIN, X_ENABLE_ON); } while (0) - #define disable_x() do { WRITE(X_ENABLE_PIN,!X_ENABLE_ON); WRITE(X2_ENABLE_PIN,!X_ENABLE_ON); axis_known_position[X_AXIS] = false; } while (0) -#elif defined(X_ENABLE_PIN) && X_ENABLE_PIN > -1 +#if defined(X_ENABLE_PIN) && X_ENABLE_PIN > -1 #define enable_x() WRITE(X_ENABLE_PIN, X_ENABLE_ON) #define disable_x() { WRITE(X_ENABLE_PIN,!X_ENABLE_ON); axis_known_position[X_AXIS] = false; } #else diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 60d40107b..b1e3ae07e 100644 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -297,17 +297,14 @@ float zprobe_zoffset; // Extruder offset #if EXTRUDERS > 1 -#ifndef DUAL_X_CARRIAGE #define NUM_EXTRUDER_OFFSETS 2 // only in XY plane -#else - #define NUM_EXTRUDER_OFFSETS 3 // supports offsets in XYZ plane -#endif float extruder_offset[NUM_EXTRUDER_OFFSETS][EXTRUDERS] = { #if defined(EXTRUDER_OFFSET_X) && defined(EXTRUDER_OFFSET_Y) EXTRUDER_OFFSET_X, EXTRUDER_OFFSET_Y #endif }; #endif + uint8_t active_extruder = 0; int fanSpeed=0; @@ -1282,64 +1279,7 @@ XYZ_CONSTS_FROM_CONFIG(float, max_length, MAX_LENGTH); XYZ_CONSTS_FROM_CONFIG(float, home_retract_mm, HOME_RETRACT_MM); XYZ_CONSTS_FROM_CONFIG(signed char, home_dir, HOME_DIR); -#ifdef DUAL_X_CARRIAGE - #if EXTRUDERS == 1 || defined(COREXY) \ - || !defined(X2_ENABLE_PIN) || !defined(X2_STEP_PIN) || !defined(X2_DIR_PIN) \ - || !defined(X2_HOME_POS) || !defined(X2_MIN_POS) || !defined(X2_MAX_POS) \ - || !defined(X_MAX_PIN) || X_MAX_PIN < 0 - #error "Missing or invalid definitions for DUAL_X_CARRIAGE mode." - #endif - #if X_HOME_DIR != -1 || X2_HOME_DIR != 1 - #error "Please use canonical x-carriage assignment" // the x-carriages are defined by their homing directions - #endif - -#define DXC_FULL_CONTROL_MODE 0 -#define DXC_AUTO_PARK_MODE 1 -#define DXC_DUPLICATION_MODE 2 -static int dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE; - -static float x_home_pos(int extruder) { - if (extruder == 0) - return base_home_pos(X_AXIS) + add_homing[X_AXIS]; - else - // In dual carriage mode the extruder offset provides an override of the - // second X-carriage offset when homed - otherwise X2_HOME_POS is used. - // This allow soft recalibration of the second extruder offset position without firmware reflash - // (through the M218 command). - return (extruder_offset[X_AXIS][1] > 0) ? extruder_offset[X_AXIS][1] : X2_HOME_POS; -} - -static int x_home_dir(int extruder) { - return (extruder == 0) ? X_HOME_DIR : X2_HOME_DIR; -} - -static float inactive_extruder_x_pos = X2_MAX_POS; // used in mode 0 & 1 -static bool active_extruder_parked = false; // used in mode 1 & 2 -static float raised_parked_position[NUM_AXIS]; // used in mode 1 -static unsigned long delayed_move_time = 0; // used in mode 1 -static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2 -static float duplicate_extruder_temp_offset = 0; // used in mode 2 -bool extruder_duplication_enabled = false; // used in mode 2 -#endif //DUAL_X_CARRIAGE - static void axis_is_at_home(int axis) { -#ifdef DUAL_X_CARRIAGE - if (axis == X_AXIS) { - if (active_extruder != 0) { - current_position[X_AXIS] = x_home_pos(active_extruder); - min_pos[X_AXIS] = X2_MIN_POS; - max_pos[X_AXIS] = max(extruder_offset[X_AXIS][1], X2_MAX_POS); - return; - } - else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) { - current_position[X_AXIS] = base_home_pos(X_AXIS) + add_homing[X_AXIS]; - min_pos[X_AXIS] = base_min_pos(X_AXIS) + add_homing[X_AXIS]; - max_pos[X_AXIS] = min(base_max_pos(X_AXIS) + add_homing[X_AXIS], - max(extruder_offset[X_AXIS][1], X2_MAX_POS) - duplicate_extruder_x_offset); - return; - } - } -#endif current_position[axis] = base_home_pos(axis) + add_homing[axis]; min_pos[axis] = base_min_pos(axis) + add_homing[axis]; max_pos[axis] = base_max_pos(axis) + add_homing[axis]; @@ -1511,10 +1451,6 @@ void homeaxis(int axis) { axis==Z_AXIS ? HOMEAXIS_DO(Z) : 0) { int axis_home_dir = home_dir(axis); -#ifdef DUAL_X_CARRIAGE - if (axis == X_AXIS) - axis_home_dir = x_home_dir(active_extruder); -#endif current_position[axis] = 0; plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); @@ -1938,12 +1874,7 @@ void process_commands() { current_position[X_AXIS] = 0;current_position[Y_AXIS] = 0; - #ifndef DUAL_X_CARRIAGE int x_axis_home_dir = home_dir(X_AXIS); - #else - int x_axis_home_dir = x_home_dir(active_extruder); - extruder_duplication_enabled = false; - #endif plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); destination[X_AXIS] = 1.5 * max_length(X_AXIS) * x_axis_home_dir;destination[Y_AXIS] = 1.5 * max_length(Y_AXIS) * home_dir(Y_AXIS); @@ -1980,40 +1911,16 @@ void process_commands() } if((home_all_axis) || (code_seen(axis_codes[X_AXIS]))) - { - #ifdef DUAL_X_CARRIAGE - int tmp_extruder = active_extruder; - extruder_duplication_enabled = false; - active_extruder = !active_extruder; homeaxis(X_AXIS); - inactive_extruder_x_pos = current_position[X_AXIS]; - active_extruder = tmp_extruder; - homeaxis(X_AXIS); - // reset state used by the different modes - memcpy(raised_parked_position, current_position, sizeof(raised_parked_position)); - delayed_move_time = 0; - active_extruder_parked = true; - #else - homeaxis(X_AXIS); - #endif - } - if((home_all_axis) || (code_seen(axis_codes[Y_AXIS]))) { + if((home_all_axis) || (code_seen(axis_codes[Y_AXIS]))) homeaxis(Y_AXIS); - } - if(code_seen(axis_codes[X_AXIS])) - { - if(code_value_long() != 0) { - current_position[X_AXIS]=code_value()+add_homing[X_AXIS]; - } - } + if(code_seen(axis_codes[X_AXIS]) && code_value_long() != 0) + current_position[X_AXIS]=code_value()+add_homing[X_AXIS]; - if(code_seen(axis_codes[Y_AXIS])) { - if(code_value_long() != 0) { - current_position[Y_AXIS]=code_value()+add_homing[Y_AXIS]; - } - } + if(code_seen(axis_codes[Y_AXIS]) && code_value_long() != 0) + current_position[Y_AXIS]=code_value()+add_homing[Y_AXIS]; #if Z_HOME_DIR < 0 // If homing towards BED do Z last #ifndef Z_SAFE_HOMING @@ -3189,10 +3096,6 @@ Sigma_Exit: break; } if (code_seen('S')) setTargetHotend(code_value(), tmp_extruder); -#ifdef DUAL_X_CARRIAGE - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && tmp_extruder == 0) - setTargetHotend1(code_value() == 0.0 ? 0.0 : code_value() + duplicate_extruder_temp_offset); -#endif setWatch(); break; case 112: // M112 -Emergency Stop @@ -3278,17 +3181,9 @@ Sigma_Exit: #endif if (code_seen('S')) { setTargetHotend(code_value(), tmp_extruder); - #ifdef DUAL_X_CARRIAGE - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && tmp_extruder == 0) - setTargetHotend1(code_value() == 0.0 ? 0.0 : code_value() + duplicate_extruder_temp_offset); - #endif CooldownNoWait = true; } else if (code_seen('R')) { setTargetHotend(code_value(), tmp_extruder); - #ifdef DUAL_X_CARRIAGE - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && tmp_extruder == 0) - setTargetHotend1(code_value() == 0.0 ? 0.0 : code_value() + duplicate_extruder_temp_offset); - #endif CooldownNoWait = false; } #ifdef AUTOTEMP @@ -3820,12 +3715,6 @@ Sigma_Exit: { extruder_offset[Y_AXIS][tmp_extruder] = code_value(); } - #ifdef DUAL_X_CARRIAGE - if(code_seen('Z')) - { - extruder_offset[Z_AXIS][tmp_extruder] = code_value(); - } - #endif SERIAL_ECHO_START; SERIAL_ECHORPGM(MSG_HOTEND_OFFSET); for(tmp_extruder = 0; tmp_extruder < EXTRUDERS; tmp_extruder++) @@ -3834,10 +3723,6 @@ Sigma_Exit: SERIAL_ECHO(extruder_offset[X_AXIS][tmp_extruder]); SERIAL_ECHO(","); SERIAL_ECHO(extruder_offset[Y_AXIS][tmp_extruder]); - #ifdef DUAL_X_CARRIAGE - SERIAL_ECHO(","); - SERIAL_ECHO(extruder_offset[Z_AXIS][tmp_extruder]); - #endif } SERIAL_ECHOLN(""); }break; @@ -4453,52 +4338,6 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp } break; #endif //FILAMENTCHANGEENABLE - #ifdef DUAL_X_CARRIAGE - case 605: // Set dual x-carriage movement mode: - // M605 S0: Full control mode. The slicer has full control over x-carriage movement - // M605 S1: Auto-park mode. The inactive head will auto park/unpark without slicer involvement - // M605 S2 [Xnnn] [Rmmm]: Duplication mode. The second extruder will duplicate the first with nnn - // millimeters x-offset and an optional differential hotend temperature of - // mmm degrees. E.g., with "M605 S2 X100 R2" the second extruder will duplicate - // the first with a spacing of 100mm in the x direction and 2 degrees hotter. - // - // Note: the X axis should be homed after changing dual x-carriage mode. - { - st_synchronize(); - - if (code_seen('S')) - dual_x_carriage_mode = code_value(); - - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE) - { - if (code_seen('X')) - duplicate_extruder_x_offset = max(code_value(),X2_MIN_POS - x_home_pos(0)); - - if (code_seen('R')) - duplicate_extruder_temp_offset = code_value(); - - SERIAL_ECHO_START; - SERIAL_ECHORPGM(MSG_HOTEND_OFFSET); - SERIAL_ECHO(" "); - SERIAL_ECHO(extruder_offset[X_AXIS][0]); - SERIAL_ECHO(","); - SERIAL_ECHO(extruder_offset[Y_AXIS][0]); - SERIAL_ECHO(" "); - SERIAL_ECHO(duplicate_extruder_x_offset); - SERIAL_ECHO(","); - SERIAL_ECHOLN(extruder_offset[Y_AXIS][1]); - } - else if (dual_x_carriage_mode != DXC_FULL_CONTROL_MODE && dual_x_carriage_mode != DXC_AUTO_PARK_MODE) - { - dual_x_carriage_mode = DEFAULT_DUAL_X_CARRIAGE_MODE; - } - - active_extruder_parked = false; - extruder_duplication_enabled = false; - delayed_move_time = 0; - } - break; - #endif //DUAL_X_CARRIAGE case 907: // M907 Set digital trimpot motor current using axis codes. { @@ -4593,57 +4432,6 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp if(tmp_extruder != active_extruder) { // Save current position to return to after applying extruder offset memcpy(destination, current_position, sizeof(destination)); - #ifdef DUAL_X_CARRIAGE - if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE && Stopped == false && - (delayed_move_time != 0 || current_position[X_AXIS] != x_home_pos(active_extruder))) - { - // Park old head: 1) raise 2) move to park position 3) lower - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, - current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS] + TOOLCHANGE_PARK_ZLIFT, - current_position[E_AXIS], max_feedrate[X_AXIS], active_extruder); - plan_buffer_line(x_home_pos(active_extruder), current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - st_synchronize(); - } - - // apply Y & Z extruder offset (x offset is already used in determining home pos) - current_position[Y_AXIS] = current_position[Y_AXIS] - - extruder_offset[Y_AXIS][active_extruder] + - extruder_offset[Y_AXIS][tmp_extruder]; - current_position[Z_AXIS] = current_position[Z_AXIS] - - extruder_offset[Z_AXIS][active_extruder] + - extruder_offset[Z_AXIS][tmp_extruder]; - - active_extruder = tmp_extruder; - - // This function resets the max/min values - the current position may be overwritten below. - axis_is_at_home(X_AXIS); - - if (dual_x_carriage_mode == DXC_FULL_CONTROL_MODE) - { - current_position[X_AXIS] = inactive_extruder_x_pos; - inactive_extruder_x_pos = destination[X_AXIS]; - } - else if (dual_x_carriage_mode == DXC_DUPLICATION_MODE) - { - active_extruder_parked = (active_extruder == 0); // this triggers the second extruder to move into the duplication position - if (active_extruder == 0 || active_extruder_parked) - current_position[X_AXIS] = inactive_extruder_x_pos; - else - current_position[X_AXIS] = destination[X_AXIS] + duplicate_extruder_x_offset; - inactive_extruder_x_pos = destination[X_AXIS]; - extruder_duplication_enabled = false; - } - else - { - // record raised toolhead position for use by unpark - memcpy(raised_parked_position, current_position, sizeof(raised_parked_position)); - raised_parked_position[Z_AXIS] += TOOLCHANGE_UNPARK_ZLIFT; - active_extruder_parked = true; - delayed_move_time = 0; - } - #else // Offset extruder (only by XY) int i; for(i = 0; i < 2; i++) { @@ -4653,7 +4441,6 @@ case 404: //M404 Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or disp } // Set the new active extruder and position active_extruder = tmp_extruder; - #endif //else DUAL_X_CARRIAGE plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); // Move to the old position if 'F' was in the parameters if(make_move && Stopped == false) { @@ -4791,47 +4578,6 @@ void prepare_move() { clamp_to_software_endstops(destination); previous_millis_cmd = millis(); - -#ifdef DUAL_X_CARRIAGE - if (active_extruder_parked) - { - if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && active_extruder == 0) - { - // move duplicate extruder into correct duplication position. - plan_set_position(inactive_extruder_x_pos, current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); - plan_buffer_line(current_position[X_AXIS] + duplicate_extruder_x_offset, current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], max_feedrate[X_AXIS], 1); - plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]); - st_synchronize(); - extruder_duplication_enabled = true; - active_extruder_parked = false; - } - else if (dual_x_carriage_mode == DXC_AUTO_PARK_MODE) // handle unparking of head - { - if (current_position[E_AXIS] == destination[E_AXIS]) - { - // this is a travel move - skit it but keep track of current position (so that it can later - // be used as start of first non-travel move) - if (delayed_move_time != 0xFFFFFFFFUL) - { - memcpy(current_position, destination, sizeof(current_position)); - if (destination[Z_AXIS] > raised_parked_position[Z_AXIS]) - raised_parked_position[Z_AXIS] = destination[Z_AXIS]; - delayed_move_time = millis(); - return; - } - } - delayed_move_time = 0; - // unpark extruder: 1) raise, 2) move into starting XY position, 3) lower - plan_buffer_line(raised_parked_position[X_AXIS], raised_parked_position[Y_AXIS], raised_parked_position[Z_AXIS], current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], raised_parked_position[Z_AXIS], - current_position[E_AXIS], min(max_feedrate[X_AXIS],max_feedrate[Y_AXIS]), active_extruder); - plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], - current_position[E_AXIS], max_feedrate[Z_AXIS], active_extruder); - active_extruder_parked = false; - } - } -#endif //DUAL_X_CARRIAGE // Do not use feedmultiply for E or Z only moves if( (current_position[X_AXIS] == destination [X_AXIS]) && (current_position[Y_AXIS] == destination [Y_AXIS])) { @@ -5030,16 +4776,6 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) //default argument s WRITE(E0_ENABLE_PIN,oldstatus); } #endif - #if defined(DUAL_X_CARRIAGE) - // handle delayed move timeout - if (delayed_move_time != 0 && (millis() - delayed_move_time) > 1000 && Stopped == false) - { - // travel moves have been received so enact them - delayed_move_time = 0xFFFFFFFFUL; // force moves to be done - memcpy(destination,current_position,sizeof(destination)); - prepare_move(); - } - #endif #ifdef TEMP_STAT_LEDS handle_status_leds(); #endif diff --git a/Firmware/stepper.cpp b/Firmware/stepper.cpp index e7868e7bc..eef767e15 100644 --- a/Firmware/stepper.cpp +++ b/Firmware/stepper.cpp @@ -375,37 +375,11 @@ ISR(TIMER1_COMPA_vect) // Set the direction bits (X_AXIS=A_AXIS and Y_AXIS=B_AXIS for COREXY) if((out_bits & (1<active_extruder != 0) - WRITE(X2_DIR_PIN, INVERT_X_DIR); - else - WRITE(X_DIR_PIN, INVERT_X_DIR); - } - #else WRITE(X_DIR_PIN, INVERT_X_DIR); - #endif count_direction[X_AXIS]=-1; } else{ - #ifdef DUAL_X_CARRIAGE - if (extruder_duplication_enabled){ - WRITE(X_DIR_PIN, !INVERT_X_DIR); - WRITE(X2_DIR_PIN, !INVERT_X_DIR); - } - else{ - if (current_block->active_extruder != 0) - WRITE(X2_DIR_PIN, !INVERT_X_DIR); - else - WRITE(X_DIR_PIN, !INVERT_X_DIR); - } - #else WRITE(X_DIR_PIN, !INVERT_X_DIR); - #endif count_direction[X_AXIS]=1; } if((out_bits & (1<active_extruder == 0 && X_HOME_DIR == -1) - || (current_block->active_extruder != 0 && X2_HOME_DIR == -1)) - #endif { #if defined(X_MIN_PIN) && X_MIN_PIN > -1 bool x_min_endstop=(READ(X_MIN_PIN) != X_MIN_ENDSTOP_INVERTING); @@ -456,11 +425,6 @@ ISR(TIMER1_COMPA_vect) else { // +direction CHECK_ENDSTOPS { - #ifdef DUAL_X_CARRIAGE - // with 2 x-carriages, endstops are only checked in the homing direction for the active extruder - if ((current_block->active_extruder == 0 && X_HOME_DIR == 1) - || (current_block->active_extruder != 0 && X2_HOME_DIR == 1)) - #endif { #if defined(X_MAX_PIN) && X_MAX_PIN > -1 bool x_max_endstop=(READ(X_MAX_PIN) != X_MAX_ENDSTOP_INVERTING); @@ -598,89 +562,11 @@ ISR(TIMER1_COMPA_vect) #endif //ADVANCE counter_x += current_block->steps_x; - #ifdef CONFIG_STEPPERS_TOSHIBA - /* The toshiba stepper controller require much longer pulses - * tjerfore we 'stage' decompose the pulses between high, and - * low instead of doing each in turn. The extra tests add enough - * lag to allow it work with without needing NOPs */ - if (counter_x > 0) { - WRITE(X_STEP_PIN, HIGH); - } - - counter_y += current_block->steps_y; - if (counter_y > 0) { - WRITE(Y_STEP_PIN, HIGH); - } - - counter_z += current_block->steps_z; - if (counter_z > 0) { - WRITE(Z_STEP_PIN, HIGH); - } - - #ifndef ADVANCE - counter_e += current_block->steps_e; - if (counter_e > 0) { - WRITE_E_STEP(HIGH); - } - #endif //!ADVANCE - - if (counter_x > 0) { - counter_x -= current_block->step_event_count; - count_position[X_AXIS]+=count_direction[X_AXIS]; - WRITE(X_STEP_PIN, LOW); - } - - if (counter_y > 0) { - counter_y -= current_block->step_event_count; - count_position[Y_AXIS]+=count_direction[Y_AXIS]; - WRITE(Y_STEP_PIN, LOW); - } - - if (counter_z > 0) { - counter_z -= current_block->step_event_count; - count_position[Z_AXIS]+=count_direction[Z_AXIS]; - WRITE(Z_STEP_PIN, LOW); - } - - #ifndef ADVANCE - if (counter_e > 0) { - counter_e -= current_block->step_event_count; - count_position[E_AXIS]+=count_direction[E_AXIS]; - WRITE_E_STEP(LOW); - } - #endif //!ADVANCE -#else if (counter_x > 0) { - #ifdef DUAL_X_CARRIAGE - if (extruder_duplication_enabled){ - WRITE(X_STEP_PIN, !INVERT_X_STEP_PIN); - WRITE(X2_STEP_PIN, !INVERT_X_STEP_PIN); - } - else { - if (current_block->active_extruder != 0) - WRITE(X2_STEP_PIN, !INVERT_X_STEP_PIN); - else - WRITE(X_STEP_PIN, !INVERT_X_STEP_PIN); - } - #else WRITE(X_STEP_PIN, !INVERT_X_STEP_PIN); - #endif counter_x -= current_block->step_event_count; count_position[X_AXIS]+=count_direction[X_AXIS]; - #ifdef DUAL_X_CARRIAGE - if (extruder_duplication_enabled){ - WRITE(X_STEP_PIN, INVERT_X_STEP_PIN); - WRITE(X2_STEP_PIN, INVERT_X_STEP_PIN); - } - else { - if (current_block->active_extruder != 0) - WRITE(X2_STEP_PIN, INVERT_X_STEP_PIN); - else - WRITE(X_STEP_PIN, INVERT_X_STEP_PIN); - } - #else WRITE(X_STEP_PIN, INVERT_X_STEP_PIN); - #endif } counter_y += current_block->steps_y; @@ -726,7 +612,6 @@ ISR(TIMER1_COMPA_vect) WRITE_E_STEP(INVERT_E_STEP_PIN); } #endif //!ADVANCE - #endif step_events_completed += 1; if(step_events_completed >= current_block->step_event_count) break; } @@ -755,7 +640,7 @@ ISR(TIMER1_COMPA_vect) e_steps[current_block->active_extruder] += ((advance >>8) - old_advance); old_advance = advance >>8; - #endif + #endif // ADVANCE } else if (step_events_completed > (unsigned long int)current_block->decelerate_after) { MultiU24X24toH16(step_rate, deceleration_time, current_block->acceleration_rate); @@ -1140,29 +1025,16 @@ void babystep(const uint8_t axis,const bool direction) //setup new step WRITE(X_DIR_PIN,(INVERT_X_DIR)^direction); - #ifdef DUAL_X_CARRIAGE - WRITE(X2_DIR_PIN,(INVERT_X_DIR)^direction); - #endif //perform step WRITE(X_STEP_PIN, !INVERT_X_STEP_PIN); - #ifdef DUAL_X_CARRIAGE - WRITE(X2_STEP_PIN, !INVERT_X_STEP_PIN); - #endif { float x=1./float(axis+1)/float(axis+2); //wait a tiny bit } WRITE(X_STEP_PIN, INVERT_X_STEP_PIN); - #ifdef DUAL_X_CARRIAGE - WRITE(X2_STEP_PIN, INVERT_X_STEP_PIN); - #endif //get old pin state back. WRITE(X_DIR_PIN,old_x_dir_pin); - #ifdef DUAL_X_CARRIAGE - WRITE(X2_DIR_PIN,old_x_dir_pin); - #endif - } break; case Y_AXIS: @@ -1172,28 +1044,16 @@ void babystep(const uint8_t axis,const bool direction) //setup new step WRITE(Y_DIR_PIN,(INVERT_Y_DIR)^direction); - #ifdef DUAL_Y_CARRIAGE - WRITE(Y2_DIR_PIN,(INVERT_Y_DIR)^direction); - #endif //perform step WRITE(Y_STEP_PIN, !INVERT_Y_STEP_PIN); - #ifdef DUAL_Y_CARRIAGE - WRITE(Y2_STEP_PIN, !INVERT_Y_STEP_PIN); - #endif { float x=1./float(axis+1)/float(axis+2); //wait a tiny bit } WRITE(Y_STEP_PIN, INVERT_Y_STEP_PIN); - #ifdef DUAL_Y_CARRIAGE - WRITE(Y2_STEP_PIN, INVERT_Y_STEP_PIN); - #endif //get old pin state back. WRITE(Y_DIR_PIN,old_y_dir_pin); - #ifdef DUAL_Y_CARRIAGE - WRITE(Y2_DIR_PIN,old_y_dir_pin); - #endif } break; diff --git a/Firmware/stepper.h b/Firmware/stepper.h index 75caa4dd8..f39fa6012 100644 --- a/Firmware/stepper.h +++ b/Firmware/stepper.h @@ -28,16 +28,9 @@ #define NORM_E_DIR() { if(current_block->active_extruder == 2) { WRITE(E2_DIR_PIN, !INVERT_E2_DIR); } else { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, !INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, !INVERT_E0_DIR); }}} #define REV_E_DIR() { if(current_block->active_extruder == 2) { WRITE(E2_DIR_PIN, INVERT_E2_DIR); } else { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, INVERT_E0_DIR); }}} #elif EXTRUDERS > 1 - #ifndef DUAL_X_CARRIAGE - #define WRITE_E_STEP(v) { if(current_block->active_extruder == 1) { WRITE(E1_STEP_PIN, v); } else { WRITE(E0_STEP_PIN, v); }} - #define NORM_E_DIR() { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, !INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, !INVERT_E0_DIR); }} - #define REV_E_DIR() { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, INVERT_E0_DIR); }} - #else - extern bool extruder_duplication_enabled; - #define WRITE_E_STEP(v) { if(extruder_duplication_enabled) { WRITE(E0_STEP_PIN, v); WRITE(E1_STEP_PIN, v); } else if(current_block->active_extruder == 1) { WRITE(E1_STEP_PIN, v); } else { WRITE(E0_STEP_PIN, v); }} - #define NORM_E_DIR() { if(extruder_duplication_enabled) { WRITE(E0_DIR_PIN, !INVERT_E0_DIR); WRITE(E1_DIR_PIN, !INVERT_E1_DIR); } else if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, !INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, !INVERT_E0_DIR); }} - #define REV_E_DIR() { if(extruder_duplication_enabled) { WRITE(E0_DIR_PIN, INVERT_E0_DIR); WRITE(E1_DIR_PIN, INVERT_E1_DIR); } else if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, INVERT_E0_DIR); }} - #endif + #define WRITE_E_STEP(v) { if(current_block->active_extruder == 1) { WRITE(E1_STEP_PIN, v); } else { WRITE(E0_STEP_PIN, v); }} + #define NORM_E_DIR() { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, !INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, !INVERT_E0_DIR); }} + #define REV_E_DIR() { if(current_block->active_extruder == 1) { WRITE(E1_DIR_PIN, INVERT_E1_DIR); } else { WRITE(E0_DIR_PIN, INVERT_E0_DIR); }} #else #define WRITE_E_STEP(v) WRITE(E0_STEP_PIN, v) #define NORM_E_DIR() WRITE(E0_DIR_PIN, !INVERT_E0_DIR)