mirror/Grbl_Esp32
1
0
Fork 0
mirror of https://github.com/bdring/Grbl_Esp32.git synced 2025-09-01 18:32:37 +02:00
Code Issues Releases Wiki Activity

Run-time squaring setup (#540)

Browse Source 
* Improved coding of squaring mode

* 2 Definitions of ganged_mode

Co-authored-by: bdring <barton.dring@gmail.com>
This commit is contained in:
Mitch Bradley
2020-08-20 08:33:13 -10:00
committed by GitHub
parent 7bc59aa0f2
commit 5899526c90
13 changed files with 102 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Grbl_Esp32/src/Defaults.h
View File

@@ -114,6 +114,10 @@
# define DEFAULT_HOMING_PULLOFF 1.0 // $27 mm
#endif
#ifndef DEFAULT_HOMING_SQUARED_AXES
# define DEFAULT_HOMING_SQUARED_AXES 0
#endif
// ======== SPINDLE STUFF ====================
#ifndef SPINDLE_TYPE
# define SPINDLE_TYPE SPINDLE_TYPE_NONE

38
Grbl_Esp32/src/Limits.cpp
View File

@@ -402,41 +402,3 @@ void limitCheckTask(void* pvParameters) {
}
}
}
// return true if the axis is defined as a squared axis
// Squaring: is used on gantry type axes that have two motors
// Each motor with touch off its own switch to square the axis
bool axis_is_squared(uint8_t axis_mask) {
// Note: multi-axis homing returns false because it will not match any of the following
if (axis_mask == (1 << X_AXIS)) {
#ifdef X_AXIS_SQUARING
return true;
#endif
}
if (axis_mask == (1 << Y_AXIS)) {
#ifdef Y_AXIS_SQUARING
return true;
#endif
}
if (axis_mask == (1 << Z_AXIS)) {
#ifdef Z_AXIS_SQUARING
return true;
#endif
}
if (axis_mask == (1 << A_AXIS)) {
#ifdef A_AXIS_SQUARING
return true;
#endif
}
if (axis_mask == (1 << B_AXIS)) {
#ifdef B_AXIS_SQUARING
return true;
#endif
}
if (axis_mask == (1 << C_AXIS)) {
#ifdef C_AXIS_SQUARING
return true;
#endif
}
return false;
}

6
Grbl_Esp32/src/Limits.h
View File

@@ -29,10 +29,6 @@
extern uint8_t n_homing_locate_cycle;
#define SQUARING_MODE_DUAL 0 // both motors run
#define SQUARING_MODE_A 1 // A motor runs
#define SQUARING_MODE_B 2 // B motor runs
// Initialize the limits module
void limits_init();
@@ -50,7 +46,5 @@ void limits_soft_check(float* target);
void isr_limit_switches();
bool axis_is_squared(uint8_t axis_mask);
// A task that runs after a limit switch interrupt.
void limitCheckTask(void* pvParameters);

6
Grbl_Esp32/src/Machines/lowrider_v1p2.h
View File

@@ -24,20 +24,20 @@
#define MACHINE_NAME "LOWRIDER_V1P2"
#define DEFAULT_HOMING_SQUARED_AXES (bit(Y_AXIS) | bit(Z_AXIS))
#define X_STEP_PIN GPIO_NUM_27 // use Z labeled connector
#define X_DIRECTION_PIN GPIO_NUM_33 // use Z labeled connector
#define Y_STEP_PIN GPIO_NUM_14 // use Y labeled connector
#define Y_STEP_PIN GPIO_NUM_14 // use Y labeled connector
#define Y2_STEP_PIN GPIO_NUM_21 // ganged motor
#define Y_DIRECTION_PIN GPIO_NUM_25 // use Y labeled connector
#define Y2_DIRECTION_PIN Y_DIRECTION_PIN
#define Y_AXIS_SQUARING
#define Z_STEP_PIN GPIO_NUM_12 // use X labeled connector
#define Z2_STEP_PIN GPIO_NUM_22 // ganged motor
#define Z_DIRECTION_PIN GPIO_NUM_26 // use X labeled connector
#define Z2_DIRECTION_PIN Z_DIRECTION_PIN
#define Z_AXIS_SQUARING
// OK to comment out to use pin for other features
#define STEPPERS_DISABLE_PIN GPIO_NUM_13

11
Grbl_Esp32/src/Machines/mpcnc_v1p1.h
View File

@@ -27,16 +27,15 @@
// // Pin assignments for the Buildlog.net MPCNC controller
#define MACHINE_NAME "MPCNC_V1P1"
#define DEFAULT_HOMING_SQUARED_AXES (bit(X_AXIS) | bit(Y_AXIS))
#define X_STEP_PIN GPIO_NUM_12
#define X2_STEP_PIN GPIO_NUM_22 // ganged motor
#define X_AXIS_SQUARING
#define X2_STEP_PIN GPIO_NUM_22 // ganged motor
#define Y_STEP_PIN GPIO_NUM_14
#define Y2_STEP_PIN GPIO_NUM_21 // ganged motor
#define Y_AXIS_SQUARING
#define Z_STEP_PIN GPIO_NUM_27
@@ -57,9 +56,9 @@
#define SPINDLE_OUTPUT_PIN GPIO_NUM_17
#else
#define SPINDLE_TYPE SPINDLE_TYPE_PWM
#define SPINDLE_OUTPUT_PIN GPIO_NUM_16
#define SPINDLE_OUTPUT_PIN GPIO_NUM_16
#define SPINDLE_ENABLE_PIN GPIO_NUM_32
#define SPINDLE_ENABLE_PIN GPIO_NUM_32
#endif
// Note: Only uncomment this if USE_SPINDLE_RELAY is commented out.

20
Grbl_Esp32/src/Machines/mpcnc_v1p2.h
View File

@@ -27,24 +27,22 @@
// // Pin assignments for the Buildlog.net MPCNC controller
#define MACHINE_NAME "MPCNC_V1P2"
#define DEFAULT_HOMING_SQUARED_AXES (bit(X_AXIS) | bit(Y_AXIS))
#define X_STEP_PIN GPIO_NUM_12
#define X2_STEP_PIN GPIO_NUM_22 // ganged motor
#define X_AXIS_SQUARING
#define X2_STEP_PIN GPIO_NUM_22 // ganged motor
#define Y_STEP_PIN GPIO_NUM_14
#define Y2_STEP_PIN GPIO_NUM_21 // ganged motor
#define Y_AXIS_SQUARING
#define Z_STEP_PIN GPIO_NUM_27
#define X_DIRECTION_PIN GPIO_NUM_26
#define X2_DIRECTION_PIN X_DIRECTION_PIN
#define X2_DIRECTION_PIN X_DIRECTION_PIN
#define Y_DIRECTION_PIN GPIO_NUM_25
#define Y2_DIRECTION_PIN Y_DIRECTION_PIN
#define Y2_DIRECTION_PIN Y_DIRECTION_PIN
#define Z_DIRECTION_PIN GPIO_NUM_33
// OK to comment out to use pin for other features
@@ -58,9 +56,9 @@
#define SPINDLE_OUTPUT_PIN GPIO_NUM_2
#else
#define SPINDLE_TYPE SPINDLE_TYPE_PWM
#define SPINDLE_OUTPUT_PIN GPIO_NUM_16
#define SPINDLE_OUTPUT_PIN GPIO_NUM_16
#define SPINDLE_ENABLE_PIN GPIO_NUM_32
#define SPINDLE_ENABLE_PIN GPIO_NUM_32
#endif
// Note: Only uncomment this if USE_SPINDLE_RELAY is commented out.
@@ -77,7 +75,6 @@
#define ENABLE_SOFTWARE_DEBOUNCE
#endif
#define PROBE_PIN GPIO_NUM_35
// The default value in config.h is wrong for this controller
@@ -87,7 +84,6 @@
#define INVERT_CONTROL_PIN_MASK B1110
#define CONTROL_RESET_PIN GPIO_NUM_34 // needs external pullup
#define CONTROL_FEED_HOLD_PIN GPIO_NUM_36 // needs external pullup
#define CONTROL_CYCLE_START_PIN GPIO_NUM_39 // needs external pullup
@@ -101,7 +97,7 @@
#define DEFAULT_INVERT_LIMIT_PINS 1 // boolean
#define DEFAULT_INVERT_PROBE_PIN 0 // boolean
#define DEFAULT_STATUS_REPORT_MASK 1
#define DEFAULT_STATUS_REPORT_MASK 1
#define DEFAULT_JUNCTION_DEVIATION 0.01 // mm
#define DEFAULT_ARC_TOLERANCE 0.002 // mm

4
Grbl_Esp32/src/Machines/spi_daisy_4axis_xyyz.h
View File

@@ -42,6 +42,8 @@
// The hardware enable pin is tied to ground
#define USE_TRINAMIC_ENABLE
#define DEFAULT_HOMING_SQUARED_AXES bit(Y_AXIS)
// Y motor connects to the 1st driver
#define X_TRINAMIC_DRIVER 2130 // Which Driver Type?
#define X_RSENSE TMC2130_RSENSE_DEFAULT
@@ -63,8 +65,6 @@
#define Y2_DIRECTION_PIN GPIO_NUM_2 // Z on schem
#define Y2_CS_PIN X_CS_PIN // Daisy Chain, all share same CS pin
#define Y_AXIS_SQUARING // optional
// Z Axis motor connects to the 4th driver
#define Z_TRINAMIC_DRIVER 2130 // Which Driver Type?
#define Z_RSENSE TMC2130_RSENSE_DEFAULT

62
Grbl_Esp32/src/MotionControl.cpp
View File

@@ -31,7 +31,7 @@
# define M_PI 3.14159265358979323846
#endif
uint8_t ganged_mode = SQUARING_MODE_DUAL;
SquaringMode ganged_mode = SquaringMode::Dual;
// this allows kinematics to be used.
void mc_line_kins(float* target, plan_line_data_t* pl_data, float* position) {
@@ -224,6 +224,32 @@ void mc_dwell(float seconds) {
delay_sec(seconds, DELAY_MODE_DWELL);
}
// return true if the mask has exactly one bit set,
// so it refers to exactly one axis
static bool mask_is_single_axis(uint8_t axis_mask) {
// This code depends on the fact that, for binary numberes
// with only one bit set - and only for such numbers -
// the bits in one less than the number are disjoint
// with that bit. For a number like B100, if you
// subtract one, the low order 00 bits will have to
// borrow from the high 1 bit and thus clear it.
// If any lower bits are 1, then there will be no
// borrow to clear the highest 1 bit.
return axis_mask && ((axis_mask & (axis_mask - 1)) == 0);
}
// return true if the axis is defined as a squared axis
// Squaring: is used on gantry type axes that have two motors
// Each motor with touch off its own switch to square the axis
static bool mask_has_squared_axis(uint8_t axis_mask) {
return axis_mask & homing_squared_axes->get();
}
// return true if axis_mask refers to a single squared axis
static bool axis_is_squared(uint8_t axis_mask) {
return mask_is_single_axis(axis_mask) && mask_has_squared_axis(axis_mask);
}
// Perform homing cycle to locate and set machine zero. Only '$H' executes this command.
// NOTE: There should be no motions in the buffer and Grbl must be in an idle state before
// executing the homing cycle. This prevents incorrect buffered plans after homing.
@@ -261,15 +287,15 @@ void mc_homing_cycle(uint8_t cycle_mask) {
if (!axis_is_squared(cycle_mask))
limits_go_home(cycle_mask); // Homing cycle 0
else {
ganged_mode = SQUARING_MODE_DUAL;
ganged_mode = SquaringMode::Dual;
n_homing_locate_cycle = 0; // don't do a second touch cycle
limits_go_home(cycle_mask);
ganged_mode = SQUARING_MODE_A;
ganged_mode = SquaringMode::A;
n_homing_locate_cycle = N_HOMING_LOCATE_CYCLE; // restore to default value
limits_go_home(cycle_mask);
ganged_mode = SQUARING_MODE_B;
ganged_mode = SquaringMode::B;
limits_go_home(cycle_mask);
ganged_mode = SQUARING_MODE_DUAL; // always return to dual
ganged_mode = SquaringMode::Dual; // always return to dual
}
} // Perform homing cycle based on mask.
else
@@ -279,44 +305,44 @@ void mc_homing_cycle(uint8_t cycle_mask) {
if (!axis_is_squared(HOMING_CYCLE_0))
limits_go_home(HOMING_CYCLE_0); // Homing cycle 0
else {
ganged_mode = SQUARING_MODE_DUAL;
ganged_mode = SquaringMode::Dual;
n_homing_locate_cycle = 0; // don't do a second touch cycle
limits_go_home(HOMING_CYCLE_0);
ganged_mode = SQUARING_MODE_A;
ganged_mode = SquaringMode::A;
n_homing_locate_cycle = N_HOMING_LOCATE_CYCLE; // restore to default value
limits_go_home(HOMING_CYCLE_0);
ganged_mode = SQUARING_MODE_B;
ganged_mode = SquaringMode::B;
limits_go_home(HOMING_CYCLE_0);
ganged_mode = SQUARING_MODE_DUAL; // always return to dual
ganged_mode = SquaringMode::Dual; // always return to dual
}
#ifdef HOMING_CYCLE_1
if (!axis_is_squared(HOMING_CYCLE_1))
limits_go_home(HOMING_CYCLE_1);
else {
ganged_mode = SQUARING_MODE_DUAL;
ganged_mode = SquaringMode::Dual;
n_homing_locate_cycle = 0; // don't do a second touch cycle
limits_go_home(HOMING_CYCLE_1);
ganged_mode = SQUARING_MODE_A;
ganged_mode = SquaringMode::A;
n_homing_locate_cycle = N_HOMING_LOCATE_CYCLE; // restore to default value
limits_go_home(HOMING_CYCLE_1);
ganged_mode = SQUARING_MODE_B;
ganged_mode = SquaringMode::B;
limits_go_home(HOMING_CYCLE_1);
ganged_mode = SQUARING_MODE_DUAL; // always return to dual
ganged_mode = SquaringMode::Dual; // always return to dual
}
#endif
#ifdef HOMING_CYCLE_2
if (!axis_is_squared(HOMING_CYCLE_2))
limits_go_home(HOMING_CYCLE_2);
else {
ganged_mode = SQUARING_MODE_DUAL;
ganged_mode = SquaringMode::Dual;
n_homing_locate_cycle = 0; // don't do a second touch cycle
limits_go_home(HOMING_CYCLE_2);
ganged_mode = SQUARING_MODE_A;
ganged_mode = SquaringMode::A;
n_homing_locate_cycle = N_HOMING_LOCATE_CYCLE; // restore to default value
limits_go_home(HOMING_CYCLE_2);
ganged_mode = SQUARING_MODE_B;
ganged_mode = SquaringMode::B;
limits_go_home(HOMING_CYCLE_2);
ganged_mode = SQUARING_MODE_DUAL; // always return to dual
ganged_mode = SquaringMode::Dual; // always return to dual
}
#endif
#ifdef HOMING_CYCLE_3
@@ -477,7 +503,7 @@ void mc_reset() {
system_set_exec_alarm(EXEC_ALARM_ABORT_CYCLE);
st_go_idle(); // Force kill steppers. Position has likely been lost.
}
ganged_mode = SQUARING_MODE_DUAL; // in case an error occurred during squaring
ganged_mode = SquaringMode::Dual; // in case an error occurred during squaring
#ifdef USE_I2S_STEPS
if (current_stepper == ST_I2S_STREAM) {

8
Grbl_Esp32/src/MotionControl.h
View File

@@ -75,3 +75,11 @@ void mc_parking_motion(float* parking_target, plan_line_data_t* pl_data);
// Performs system reset. If in motion state, kills all motion and sets system alarm.
void mc_reset();
enum class SquaringMode : uint8_t {
Dual, // both motors run
A, // A motor runs
B, // B motor runs
};
extern SquaringMode ganged_mode;

2
Grbl_Esp32/src/SettingsDefinitions.cpp
View File

@@ -13,6 +13,7 @@ AxisMaskSetting* step_invert_mask;
AxisMaskSetting* dir_invert_mask;
// TODO Settings - need to call st_generate_step_invert_masks;
AxisMaskSetting* homing_dir_mask;
AxisMaskSetting* homing_squared_axes;
AxisMaskSetting* stallguard_debug_mask;
FlagSetting* step_enable_invert;
@@ -296,6 +297,7 @@ void make_settings() {
homing_debounce = new FloatSetting(GRBL, WG, "26", "Homing/Debounce", DEFAULT_HOMING_DEBOUNCE_DELAY, 0, 10000);
homing_seek_rate = new FloatSetting(GRBL, WG, "25", "Homing/Seek", DEFAULT_HOMING_SEEK_RATE, 0, 10000);
homing_feed_rate = new FloatSetting(GRBL, WG, "24", "Homing/Feed", DEFAULT_HOMING_FEED_RATE, 0, 10000);
homing_squared_axes = new AxisMaskSetting(EXTENDED, WG, NULL, "Homing/Squared", DEFAULT_HOMING_SQUARED_AXES);
// TODO Settings - need to call st_generate_step_invert_masks()
homing_dir_mask = new AxisMaskSetting(GRBL, WG, "23", "Homing/DirInvert", DEFAULT_HOMING_DIR_MASK);

1
Grbl_Esp32/src/SettingsDefinitions.h
View File

@@ -20,6 +20,7 @@ extern IntSetting* stepper_idle_lock_time;
extern AxisMaskSetting* step_invert_mask;
extern AxisMaskSetting* dir_invert_mask;
extern AxisMaskSetting* homing_dir_mask;
extern AxisMaskSetting* homing_squared_axes;
extern FlagSetting* step_enable_invert;
extern FlagSetting* limit_invert;

48
Grbl_Esp32/src/Stepper.cpp
View File

@@ -521,9 +521,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef X2_STEP_PIN // if not a ganged axis
digitalWrite(X_STEP_PIN, (onMask & bit(X_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(X_STEP_PIN, (onMask & bit(X_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(X2_STEP_PIN, (onMask & bit(X_AXIS)));
# endif
#endif
@@ -531,9 +531,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef Y2_STEP_PIN // if not a ganged axis
digitalWrite(Y_STEP_PIN, (onMask & bit(Y_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(Y_STEP_PIN, (onMask & bit(Y_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(Y2_STEP_PIN, (onMask & bit(Y_AXIS)));
# endif
#endif
@@ -542,9 +542,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef Z2_STEP_PIN // if not a ganged axis
digitalWrite(Z_STEP_PIN, (onMask & bit(Z_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(Z_STEP_PIN, (onMask & bit(Z_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(Z2_STEP_PIN, (onMask & bit(Z_AXIS)));
# endif
#endif
@@ -553,9 +553,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef A2_STEP_PIN // if not a ganged axis
digitalWrite(A_STEP_PIN, (onMask & bit(A_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(A_STEP_PIN, (onMask & bit(A_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(A2_STEP_PIN, (onMask & bit(A_AXIS)));
# endif
#endif
@@ -564,9 +564,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef B2_STEP_PIN // if not a ganged axis
digitalWrite(B_STEP_PIN, (onMask & bit(B_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(B_STEP_PIN, (onMask & bit(B_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(B2_STEP_PIN, (onMask & bit(B_AXIS)));
# endif
#endif
@@ -575,9 +575,9 @@ void set_stepper_pins_on(uint8_t onMask) {
# ifndef C2_STEP_PIN // if not a ganged axis
digitalWrite(C_STEP_PIN, (onMask & bit(C_AXIS)));
# else // is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A))
digitalWrite(C_STEP_PIN, (onMask & bit(C_AXIS)));
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B))
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B))
digitalWrite(C2_STEP_PIN, (onMask & bit(C_AXIS)));
# endif
#endif
@@ -592,11 +592,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[X_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[X_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[X_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[X_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[X_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[X_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}
@@ -609,11 +609,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[Y_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Y_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[Y_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Y_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[Y_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Y_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}
@@ -627,11 +627,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[Z_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Z_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[Z_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Z_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[Z_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[Z_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}
@@ -645,11 +645,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[A_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[A_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[A_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[A_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[A_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[A_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}
@@ -663,11 +663,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[B_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[B_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[B_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[B_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[B_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[B_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}
@@ -681,11 +681,11 @@ inline IRAM_ATTR static void stepperRMT_Outputs() {
RMT.conf_ch[rmt_chan_num[C_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[C_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
# else // it is a ganged axis
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_A)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::A)) {
RMT.conf_ch[rmt_chan_num[C_AXIS][PRIMARY_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[C_AXIS][PRIMARY_MOTOR]].conf1.tx_start = 1;
}
if ((ganged_mode == SQUARING_MODE_DUAL) || (ganged_mode == SQUARING_MODE_B)) {
if ((ganged_mode == SquaringMode::Dual) || (ganged_mode == SquaringMode::B)) {
RMT.conf_ch[rmt_chan_num[C_AXIS][GANGED_MOTOR]].conf1.mem_rd_rst = 1;
RMT.conf_ch[rmt_chan_num[C_AXIS][GANGED_MOTOR]].conf1.tx_start = 1;
}

2
Grbl_Esp32/src/Stepper.h
View File

@@ -73,7 +73,7 @@ error "AMASS must have 1 or more levels to operate correctly."
extern uint64_t stepper_idle_counter;
extern bool stepper_idle;
extern uint8_t ganged_mode;
//extern uint8_t ganged_mode;
enum stepper_id_t {
ST_TIMED = 0,