jessikitty/Marlin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🧑‍💻 Reduction via TERF

Browse Source
This commit is contained in:
Scott Lahteine
2025-11-27 12:48:28 -06:00
parent 584abc5835
commit 0ac1435a8c
4 changed files with 82 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Marlin/src/feature/fancheck.cpp
+9 -33
View File
@@ -42,30 +42,18 @@ bool FanCheck::enabled;
void FanCheck::init() {
#define _TACHINIT(N) TERN(E##N##_FAN_TACHO_PULLUP, SET_INPUT_PULLUP, TERN(E##N##_FAN_TACHO_PULLDOWN, SET_INPUT_PULLDOWN, SET_INPUT))(E##N##_FAN_TACHO_PIN)
TERF(HAS_E0_FAN_TACHO, _TACHINIT)(0);
TERF(HAS_E1_FAN_TACHO, _TACHINIT)(1);
TERF(HAS_E2_FAN_TACHO, _TACHINIT)(2);
TERF(HAS_E3_FAN_TACHO, _TACHINIT)(3);
TERF(HAS_E4_FAN_TACHO, _TACHINIT)(4);
TERF(HAS_E5_FAN_TACHO, _TACHINIT)(5);
TERF(HAS_E6_FAN_TACHO, _TACHINIT)(6);
TERF(HAS_E7_FAN_TACHO, _TACHINIT)(7);
#define _EN_TACHINIT(N) TERF(HAS_E##N##_FAN_TACHO, _TACHINIT)(N);
REPEAT(8, _EN_TACHINIT);
}
void FanCheck::update_tachometers() {
bool status;
#define _TACHO_CASE(N) case N: status = READ(E##N##_FAN_TACHO_PIN); break;
#define __TACHO_GET_STATUS(N) case N: status = READ(E##N##_FAN_TACHO_PIN); break;
#define _TACHO_GET_STATUS(N) TERF(HAS_E##N##_FAN_TACHO, __TACHO_GET_STATUS)(N)
for (uint8_t f = 0; f < TACHO_COUNT; ++f) {
switch (f) {
TERF(HAS_E0_FAN_TACHO, _TACHO_CASE)(0)
TERF(HAS_E1_FAN_TACHO, _TACHO_CASE)(1)
TERF(HAS_E2_FAN_TACHO, _TACHO_CASE)(2)
TERF(HAS_E3_FAN_TACHO, _TACHO_CASE)(3)
TERF(HAS_E4_FAN_TACHO, _TACHO_CASE)(4)
TERF(HAS_E5_FAN_TACHO, _TACHO_CASE)(5)
TERF(HAS_E6_FAN_TACHO, _TACHO_CASE)(6)
TERF(HAS_E7_FAN_TACHO, _TACHO_CASE)(7)
REPEAT(8, _TACHO_GET_STATUS)
default: continue;
}
@@ -83,14 +71,8 @@ void FanCheck::compute_speed(uint16_t elapsedTime) {
uint8_t fan_error_msk = 0;
for (uint8_t f = 0; f < TACHO_COUNT; ++f) {
switch (f) {
TERN_(HAS_E0_FAN_TACHO, case 0:)
TERN_(HAS_E1_FAN_TACHO, case 1:)
TERN_(HAS_E2_FAN_TACHO, case 2:)
TERN_(HAS_E3_FAN_TACHO, case 3:)
TERN_(HAS_E4_FAN_TACHO, case 4:)
TERN_(HAS_E5_FAN_TACHO, case 5:)
TERN_(HAS_E6_FAN_TACHO, case 6:)
TERN_(HAS_E7_FAN_TACHO, case 7:)
#define _EN_COMPUTE_FAN_CASE(N) TERN_(HAS_E##N##_FAN_TACHO, case N:)
REPEAT(8, _EN_COMPUTE_FAN_CASE)
// Compute fan speed
rps[f] = edge_counter[f] * float(250) / elapsedTime;
edge_counter[f] = 0;
@@ -147,14 +129,8 @@ void FanCheck::print_fan_states() {
for (uint8_t s = 0; s < 2; ++s) {
for (uint8_t f = 0; f < TACHO_COUNT; ++f) {
switch (f) {
TERN_(HAS_E0_FAN_TACHO, case 0:)
TERN_(HAS_E1_FAN_TACHO, case 1:)
TERN_(HAS_E2_FAN_TACHO, case 2:)
TERN_(HAS_E3_FAN_TACHO, case 3:)
TERN_(HAS_E4_FAN_TACHO, case 4:)
TERN_(HAS_E5_FAN_TACHO, case 5:)
TERN_(HAS_E6_FAN_TACHO, case 6:)
TERN_(HAS_E7_FAN_TACHO, case 7:)
#define _EN_PRINT_FAN_CASE(N) TERN_(HAS_E##N##_FAN_TACHO, case N:)
REPEAT(8, _EN_PRINT_FAN_CASE)
SERIAL_ECHOPGM("E", f);
if (s == 0)
SERIAL_ECHOPGM(":", 60 * rps[f], " RPM ");
Marlin/src/module/endstops.cpp
+32 -141
View File
@@ -133,34 +133,9 @@ Endstops::endstop_mask_t Endstops::live_state = 0;
void Endstops::init() {
#define _INIT_ENDSTOP(T,A,N) TERN(ENDSTOPPULLUP_##A##T, SET_INPUT_PULLUP, TERN(ENDSTOPPULLDOWN_##A##T, SET_INPUT_PULLDOWN, SET_INPUT))(A##N##_##T##_PIN)
TERF(USE_X_MIN, _INIT_ENDSTOP)(MIN,X,);
TERF(USE_X_MAX, _INIT_ENDSTOP)(MAX,X,);
TERF(USE_X2_MIN, _INIT_ENDSTOP)(MIN,X,2);
TERF(USE_X2_MAX, _INIT_ENDSTOP)(MAX,X,2);
TERF(USE_Y_MIN, _INIT_ENDSTOP)(MIN,Y,);
TERF(USE_Y_MAX, _INIT_ENDSTOP)(MAX,Y,);
TERF(USE_Y2_MIN, _INIT_ENDSTOP)(MIN,Y,2);
TERF(USE_Y2_MAX, _INIT_ENDSTOP)(MAX,Y,2);
TERF(USE_Z_MIN, _INIT_ENDSTOP)(MIN,Z,);
TERF(USE_Z_MAX, _INIT_ENDSTOP)(MAX,Z,);
TERF(USE_Z2_MIN, _INIT_ENDSTOP)(MIN,Z,2);
TERF(USE_Z2_MAX, _INIT_ENDSTOP)(MAX,Z,2);
TERF(USE_Z3_MIN, _INIT_ENDSTOP)(MIN,Z,3);
TERF(USE_Z3_MAX, _INIT_ENDSTOP)(MAX,Z,3);
TERF(USE_Z4_MIN, _INIT_ENDSTOP)(MIN,Z,4);
TERF(USE_Z4_MAX, _INIT_ENDSTOP)(MAX,Z,4);
TERF(USE_I_MIN, _INIT_ENDSTOP)(MIN,I,);
TERF(USE_I_MAX, _INIT_ENDSTOP)(MAX,I,);
TERF(USE_J_MIN, _INIT_ENDSTOP)(MIN,J,);
TERF(USE_J_MAX, _INIT_ENDSTOP)(MAX,J,);
TERF(USE_K_MIN, _INIT_ENDSTOP)(MIN,K,);
TERF(USE_K_MAX, _INIT_ENDSTOP)(MAX,K,);
TERF(USE_U_MIN, _INIT_ENDSTOP)(MIN,U,);
TERF(USE_U_MAX, _INIT_ENDSTOP)(MAX,U,);
TERF(USE_V_MIN, _INIT_ENDSTOP)(MIN,V,);
TERF(USE_V_MAX, _INIT_ENDSTOP)(MAX,V,);
TERF(USE_W_MIN, _INIT_ENDSTOP)(MIN,W,);
TERF(USE_W_MAX, _INIT_ENDSTOP)(MAX,W,);
#define _INIT_ES_MINMAX(A,N) do{ TERF(USE_##A##N##_MIN, _INIT_ENDSTOP)(MIN,A,N); TERF(USE_##A##N##_MAX, _INIT_ENDSTOP)(MAX,A,N); }while(0);
#define INIT_AXIS_ENDSTOPS(S) do{ _INIT_ES_MINMAX(S, ); _INIT_ES_MINMAX(S,2); _INIT_ES_MINMAX(S,3); _INIT_ES_MINMAX(S,4); }while(0);
MAIN_AXIS_MAP(INIT_AXIS_ENDSTOPS);
#if USE_CALIBRATION
#if ENABLED(CALIBRATION_PIN_PULLUP)
@@ -399,37 +374,15 @@ void Endstops::event_handler() {
#endif
void __O2 Endstops::report_states() {
TERN_(BLTOUCH, bltouch._set_SW_mode());
SERIAL_ECHOLNPGM(STR_M119_REPORT);
#define ES_REPORT(S) print_es_state(READ_ENDSTOP(S##_PIN) == S##_ENDSTOP_HIT_STATE, F(STR_##S))
TERF(USE_X_MIN, ES_REPORT)(X_MIN);
TERF(USE_X2_MIN, ES_REPORT)(X2_MIN);
TERF(USE_X_MAX, ES_REPORT)(X_MAX);
TERF(USE_X2_MAX, ES_REPORT)(X2_MAX);
TERF(USE_Y_MIN, ES_REPORT)(Y_MIN);
TERF(USE_Y2_MIN, ES_REPORT)(Y2_MIN);
TERF(USE_Y_MAX, ES_REPORT)(Y_MAX);
TERF(USE_Y2_MAX, ES_REPORT)(Y2_MAX);
TERF(USE_Z_MIN, ES_REPORT)(Z_MIN);
TERF(USE_Z2_MIN, ES_REPORT)(Z2_MIN);
TERF(USE_Z3_MIN, ES_REPORT)(Z3_MIN);
TERF(USE_Z4_MIN, ES_REPORT)(Z4_MIN);
TERF(USE_Z_MAX, ES_REPORT)(Z_MAX);
TERF(USE_Z2_MAX, ES_REPORT)(Z2_MAX);
TERF(USE_Z3_MAX, ES_REPORT)(Z3_MAX);
TERF(USE_Z4_MAX, ES_REPORT)(Z4_MAX);
TERF(USE_I_MIN, ES_REPORT)(I_MIN);
TERF(USE_I_MAX, ES_REPORT)(I_MAX);
TERF(USE_J_MIN, ES_REPORT)(J_MIN);
TERF(USE_J_MAX, ES_REPORT)(J_MAX);
TERF(USE_K_MIN, ES_REPORT)(K_MIN);
TERF(USE_K_MAX, ES_REPORT)(K_MAX);
TERF(USE_U_MIN, ES_REPORT)(U_MIN);
TERF(USE_U_MAX, ES_REPORT)(U_MAX);
TERF(USE_V_MIN, ES_REPORT)(V_MIN);
TERF(USE_V_MAX, ES_REPORT)(V_MAX);
TERF(USE_W_MIN, ES_REPORT)(W_MIN);
TERF(USE_W_MAX, ES_REPORT)(W_MAX);
#define _ES_REPORT(S) print_es_state(READ_ENDSTOP(S##_PIN) == S##_ENDSTOP_HIT_STATE, F(STR_##S))
#define ES_REPORT(S) TERF(USE_##S, _ES_REPORT)(S);
MAP(ES_REPORT, X_MIN, X2_MIN, X_MAX, X2_MAX, Y_MIN, Y2_MIN, Y_MAX, Y2_MAX, Z_MIN, Z2_MIN, Z3_MIN, Z4_MIN, Z_MAX, Z2_MAX, Z3_MAX, Z4_MAX);
MAP(ES_REPORT, I_MIN, I_MAX, J_MIN, J_MAX, K_MIN, K_MAX, U_MIN, U_MAX, V_MIN, V_MAX, W_MIN, W_MAX)
TERF(PROBE_ACTIVATION_SWITCH, print_es_state)(probe_switch_activated(), F(STR_PROBE_EN));
@@ -605,18 +558,8 @@ void Endstops::update() {
COPY_LIVE_STATE(Z_MAX, Z4_MAX);
#endif
TERF(USE_I_MIN, UPDATE_LIVE_STATE)(I, MIN);
TERF(USE_I_MAX, UPDATE_LIVE_STATE)(I, MAX);
TERF(USE_J_MIN, UPDATE_LIVE_STATE)(J, MIN);
TERF(USE_J_MAX, UPDATE_LIVE_STATE)(J, MAX);
TERF(USE_K_MIN, UPDATE_LIVE_STATE)(K, MIN);
TERF(USE_K_MAX, UPDATE_LIVE_STATE)(K, MAX);
TERF(USE_U_MIN, UPDATE_LIVE_STATE)(U, MIN);
TERF(USE_U_MAX, UPDATE_LIVE_STATE)(U, MAX);
TERF(USE_V_MIN, UPDATE_LIVE_STATE)(V, MIN);
TERF(USE_V_MAX, UPDATE_LIVE_STATE)(V, MAX);
TERF(USE_W_MIN, UPDATE_LIVE_STATE)(W, MIN);
TERF(USE_W_MAX, UPDATE_LIVE_STATE)(W, MAX);
#define _LIVE_UPDATE(A) TERF(USE_##A##_MIN, UPDATE_LIVE_STATE)(A, MIN); TERF(USE_##A##_MAX, UPDATE_LIVE_STATE)(A, MAX);
SECONDARY_AXIS_MAP(_LIVE_UPDATE);
#if ENDSTOP_NOISE_THRESHOLD
@@ -1039,15 +982,19 @@ void Endstops::update() {
}
void Endstops::clear_endstop_state() {
TERN_(X_SPI_SENSORLESS, CBI(live_state, X_ENDSTOP));
#define _ES_CLEAR(S) CBI(live_state, S##_ENDSTOP);
#define ES_CLEAR(S) TERN_(S##_SPI_SENSORLESS, CBI(live_state, S##_ENDSTOP));
ES_CLEAR(X);
#if ALL(X_SPI_SENSORLESS, X_DUAL_ENDSTOPS)
CBI(live_state, X2_ENDSTOP);
#endif
TERN_(Y_SPI_SENSORLESS, CBI(live_state, Y_ENDSTOP));
ES_CLEAR(Y);
#if ALL(Y_SPI_SENSORLESS, Y_DUAL_ENDSTOPS)
CBI(live_state, Y2_ENDSTOP);
#endif
TERN_(Z_SPI_SENSORLESS, CBI(live_state, Z_ENDSTOP));
ES_CLEAR(Z);
#if ALL(Z_SPI_SENSORLESS, Z_MULTI_ENDSTOPS)
CBI(live_state, Z2_ENDSTOP);
#if NUM_Z_STEPPERS >= 3
@@ -1057,12 +1004,7 @@ void Endstops::update() {
#endif
#endif
#endif
TERN_(I_SPI_SENSORLESS, CBI(live_state, I_ENDSTOP));
TERN_(J_SPI_SENSORLESS, CBI(live_state, J_ENDSTOP));
TERN_(K_SPI_SENSORLESS, CBI(live_state, K_ENDSTOP));
TERN_(U_SPI_SENSORLESS, CBI(live_state, U_ENDSTOP));
TERN_(V_SPI_SENSORLESS, CBI(live_state, V_ENDSTOP));
TERN_(W_SPI_SENSORLESS, CBI(live_state, W_ENDSTOP));
SECONDARY_AXIS_MAP(ES_CLEAR);
}
#endif // SPI_ENDSTOPS
@@ -1086,73 +1028,22 @@ void Endstops::update() {
static uint8_t local_LED_status = 0;
uint16_t live_state_local = 0;
#define ES_GET_STATE(S) if (READ_ENDSTOP(S##_PIN)) SBI(live_state_local, S)
TERF(USE_X_MIN, ES_GET_STATE)(X_MIN);
TERF(USE_X_MAX, ES_GET_STATE)(X_MAX);
TERF(USE_Y_MIN, ES_GET_STATE)(Y_MIN);
TERF(USE_Y_MAX, ES_GET_STATE)(Y_MAX);
TERF(USE_Z_MIN, ES_GET_STATE)(Z_MIN);
TERF(USE_Z_MAX, ES_GET_STATE)(Z_MAX);
TERF(USE_Z_MIN_PROBE, ES_GET_STATE)(Z_MIN_PROBE);
TERF(USE_CALIBRATION, ES_GET_STATE)(CALIBRATION);
TERF(USE_X2_MIN, ES_GET_STATE)(X2_MIN);
TERF(USE_X2_MAX, ES_GET_STATE)(X2_MAX);
TERF(USE_Y2_MIN, ES_GET_STATE)(Y2_MIN);
TERF(USE_Y2_MAX, ES_GET_STATE)(Y2_MAX);
TERF(USE_Z2_MIN, ES_GET_STATE)(Z2_MIN);
TERF(USE_Z2_MAX, ES_GET_STATE)(Z2_MAX);
TERF(USE_Z3_MIN, ES_GET_STATE)(Z3_MIN);
TERF(USE_Z3_MAX, ES_GET_STATE)(Z3_MAX);
TERF(USE_Z4_MIN, ES_GET_STATE)(Z4_MIN);
TERF(USE_Z4_MAX, ES_GET_STATE)(Z4_MAX);
TERF(USE_I_MAX, ES_GET_STATE)(I_MAX);
TERF(USE_I_MIN, ES_GET_STATE)(I_MIN);
TERF(USE_J_MAX, ES_GET_STATE)(J_MAX);
TERF(USE_J_MIN, ES_GET_STATE)(J_MIN);
TERF(USE_K_MAX, ES_GET_STATE)(K_MAX);
TERF(USE_K_MIN, ES_GET_STATE)(K_MIN);
TERF(USE_U_MAX, ES_GET_STATE)(U_MAX);
TERF(USE_U_MIN, ES_GET_STATE)(U_MIN);
TERF(USE_V_MAX, ES_GET_STATE)(V_MAX);
TERF(USE_V_MIN, ES_GET_STATE)(V_MIN);
TERF(USE_W_MAX, ES_GET_STATE)(W_MAX);
TERF(USE_W_MIN, ES_GET_STATE)(W_MIN);
#define _ES_GET_STATE(S) if (READ_ENDSTOP(S##_PIN)) SBI(live_state_local, S);
#define ES_GET_STATE(S) TERF(USE_##S, _ES_GET_STATE)(S)
MAP(ES_GET_STATE, X_MIN, X_MAX, Y_MIN, Y_MAX, Z_MIN, Z_MAX);
MAP(ES_GET_STATE, Z_MIN_PROBE, CALIBRATION);
MAP(ES_GET_STATE, X2_MIN, X2_MAX, Y2_MIN, Y2_MAX, Z2_MIN, Z2_MAX, Z3_MIN, Z3_MAX, Z4_MIN, Z4_MAX)
MAP(ES_GET_STATE, I_MIN, I_MAX, J_MIN, J_MAX, K_MIN, K_MAX, U_MIN, U_MAX, V_MIN, V_MAX, W_MIN, W_MAX);
const uint16_t endstop_change = live_state_local ^ old_live_state_local;
#define ES_REPORT_CHANGE(S) if (TEST(endstop_change, S)) SERIAL_ECHOPGM(" " STRINGIFY(S) ":", TEST(live_state_local, S))
#define _ES_REPORT_CHANGE(S) SERIAL_ECHO(F(" " STRINGIFY(S) ":"), TEST(live_state_local, S));
#define ES_REPORT_CHANGE(S) TERF(USE_##S, _ES_REPORT_CHANGE)(S)
if (endstop_change) {
TERF(USE_X_MIN, ES_REPORT_CHANGE)(X_MIN);
TERF(USE_X_MAX, ES_REPORT_CHANGE)(X_MAX);
TERF(USE_Y_MIN, ES_REPORT_CHANGE)(Y_MIN);
TERF(USE_Y_MAX, ES_REPORT_CHANGE)(Y_MAX);
TERF(USE_Z_MIN, ES_REPORT_CHANGE)(Z_MIN);
TERF(USE_Z_MAX, ES_REPORT_CHANGE)(Z_MAX);
TERF(USE_Z_MIN_PROBE, ES_REPORT_CHANGE)(Z_MIN_PROBE);
TERF(USE_CALIBRATION, ES_REPORT_CHANGE)(CALIBRATION);
TERF(USE_X2_MIN, ES_REPORT_CHANGE)(X2_MIN);
TERF(USE_X2_MAX, ES_REPORT_CHANGE)(X2_MAX);
TERF(USE_Y2_MIN, ES_REPORT_CHANGE)(Y2_MIN);
TERF(USE_Y2_MAX, ES_REPORT_CHANGE)(Y2_MAX);
TERF(USE_Z2_MIN, ES_REPORT_CHANGE)(Z2_MIN);
TERF(USE_Z2_MAX, ES_REPORT_CHANGE)(Z2_MAX);
TERF(USE_Z3_MIN, ES_REPORT_CHANGE)(Z3_MIN);
TERF(USE_Z3_MAX, ES_REPORT_CHANGE)(Z3_MAX);
TERF(USE_Z4_MIN, ES_REPORT_CHANGE)(Z4_MIN);
TERF(USE_Z4_MAX, ES_REPORT_CHANGE)(Z4_MAX);
TERF(USE_I_MIN, ES_REPORT_CHANGE)(I_MIN);
TERF(USE_I_MAX, ES_REPORT_CHANGE)(I_MAX);
TERF(USE_J_MIN, ES_REPORT_CHANGE)(J_MIN);
TERF(USE_J_MAX, ES_REPORT_CHANGE)(J_MAX);
TERF(USE_K_MIN, ES_REPORT_CHANGE)(K_MIN);
TERF(USE_K_MAX, ES_REPORT_CHANGE)(K_MAX);
TERF(USE_U_MIN, ES_REPORT_CHANGE)(U_MIN);
TERF(USE_U_MAX, ES_REPORT_CHANGE)(U_MAX);
TERF(USE_V_MIN, ES_REPORT_CHANGE)(V_MIN);
TERF(USE_V_MAX, ES_REPORT_CHANGE)(V_MAX);
TERF(USE_W_MIN, ES_REPORT_CHANGE)(W_MIN);
TERF(USE_W_MAX, ES_REPORT_CHANGE)(W_MAX);
MAP(ES_REPORT_CHANGE, X_MIN, X_MAX, Y_MIN, Y_MAX, Z_MIN, Z_MAX,
, Z_MIN_PROBE, CALIBRATION,
, X2_MIN, X2_MAX, Y2_MIN, Y2_MAX, Z2_MIN, Z2_MAX, Z3_MIN, Z3_MAX, Z4_MIN, Z4_MAX,
, I_MIN, I_MAX, J_MIN, J_MAX, K_MIN, K_MAX, U_MIN, U_MAX, V_MIN, V_MAX, W_MIN, W_MAX);
SERIAL_ECHOLNPGM("\n");
hal.set_pwm_duty(pin_t(LED_PIN), local_LED_status);
local_LED_status ^= 255;
Marlin/src/module/stepper.cpp
+24 -86
View File
@@ -2041,15 +2041,8 @@ void Stepper::pulse_phase_isr() {
const uint32_t advance_divisor_cached = advance_divisor;
// Determine if pulses are needed
TERF(HAS_X_STEP, PULSE_PREP)(X);
TERF(HAS_Y_STEP, PULSE_PREP)(Y);
TERF(HAS_Z_STEP, PULSE_PREP)(Z);
TERF(HAS_I_STEP, PULSE_PREP)(I);
TERF(HAS_J_STEP, PULSE_PREP)(J);
TERF(HAS_K_STEP, PULSE_PREP)(K);
TERF(HAS_U_STEP, PULSE_PREP)(U);
TERF(HAS_V_STEP, PULSE_PREP)(V);
TERF(HAS_W_STEP, PULSE_PREP)(W);
#define _PULSE_PREP(A) TERF(HAS_##A##_STEP, PULSE_PREP)(A);
MAIN_AXIS_MAP(_PULSE_PREP);
#if ANY(HAS_E0_STEP, MIXING_EXTRUDER)
PULSE_PREP(E);
@@ -2099,15 +2092,8 @@ void Stepper::pulse_phase_isr() {
#endif
// Pulse start
TERF(HAS_X_STEP, PULSE_START)(X);
TERF(HAS_Y_STEP, PULSE_START)(Y);
TERF(HAS_Z_STEP, PULSE_START)(Z);
TERF(HAS_I_STEP, PULSE_START)(I);
TERF(HAS_J_STEP, PULSE_START)(J);
TERF(HAS_K_STEP, PULSE_START)(K);
TERF(HAS_U_STEP, PULSE_START)(U);
TERF(HAS_V_STEP, PULSE_START)(V);
TERF(HAS_W_STEP, PULSE_START)(W);
#define _PULSE_START(A) TERF(HAS_##A##_STEP, PULSE_START)(A);
MAIN_AXIS_MAP(_PULSE_START);
#if ENABLED(MIXING_EXTRUDER)
if (step_needed.e) {
@@ -2127,15 +2113,8 @@ void Stepper::pulse_phase_isr() {
#endif
// Pulse stop
TERF(HAS_X_STEP, PULSE_STOP)(X);
TERF(HAS_Y_STEP, PULSE_STOP)(Y);
TERF(HAS_Z_STEP, PULSE_STOP)(Z);
TERF(HAS_I_STEP, PULSE_STOP)(I);
TERF(HAS_J_STEP, PULSE_STOP)(J);
TERF(HAS_K_STEP, PULSE_STOP)(K);
TERF(HAS_U_STEP, PULSE_STOP)(U);
TERF(HAS_V_STEP, PULSE_STOP)(V);
TERF(HAS_W_STEP, PULSE_STOP)(W);
#define _PULSE_STOP(A) TERF(HAS_##A##_STEP, PULSE_STOP)(A);
MAIN_AXIS_MAP(_PULSE_STOP);
#if ENABLED(MIXING_EXTRUDER)
if (step_needed.e) E_STEP_WRITE(mixer.get_stepper(), !STEP_STATE_E);
@@ -3231,53 +3210,21 @@ void Stepper::init() {
TERN_(HAS_MICROSTEPS, microstep_init());
// Init Dir Pins
TERN_(HAS_X_DIR, X_DIR_INIT());
TERN_(HAS_X2_DIR, X2_DIR_INIT());
TERN_(HAS_Y_DIR, Y_DIR_INIT());
TERN_(HAS_Y2_DIR, Y2_DIR_INIT());
TERN_(HAS_Z_DIR, Z_DIR_INIT());
TERN_(HAS_Z2_DIR, Z2_DIR_INIT());
TERN_(HAS_Z3_DIR, Z3_DIR_INIT());
TERN_(HAS_Z4_DIR, Z4_DIR_INIT());
TERN_(HAS_I_DIR, I_DIR_INIT());
TERN_(HAS_J_DIR, J_DIR_INIT());
TERN_(HAS_K_DIR, K_DIR_INIT());
TERN_(HAS_U_DIR, U_DIR_INIT());
TERN_(HAS_V_DIR, V_DIR_INIT());
TERN_(HAS_W_DIR, W_DIR_INIT());
TERN_(HAS_E0_DIR, E0_DIR_INIT());
TERN_(HAS_E1_DIR, E1_DIR_INIT());
TERN_(HAS_E2_DIR, E2_DIR_INIT());
TERN_(HAS_E3_DIR, E3_DIR_INIT());
TERN_(HAS_E4_DIR, E4_DIR_INIT());
TERN_(HAS_E5_DIR, E5_DIR_INIT());
TERN_(HAS_E6_DIR, E6_DIR_INIT());
TERN_(HAS_E7_DIR, E7_DIR_INIT());
#define _INIT_DIR(A) TERN_(HAS_##A##_DIR, A##_DIR_INIT());
#define _EN_INIT_DIR(N) _INIT_DIR(E##N)
MAIN_AXIS_MAP(_INIT_DIR);
MAP(_INIT_DIR, X2, Y2, Z2, Z3, Z4);
REPEAT(8, _EN_INIT_DIR);
// Init Enable Pins - Steppers default to disabled.
#define _INIT_CONFIG_ENABLE(A) do{ A##_ENABLE_INIT(); if (A##_ENABLE_INIT_STATE) A##_ENABLE_WRITE(HIGH); }while(0)
TERN_(HAS_X_ENABLE, _INIT_CONFIG_ENABLE(X));
TERN_(HAS_X2_ENABLE, _INIT_CONFIG_ENABLE(X2));
TERN_(HAS_Y_ENABLE, _INIT_CONFIG_ENABLE(Y));
TERN_(HAS_Y2_ENABLE, _INIT_CONFIG_ENABLE(Y2));
TERN_(HAS_Z_ENABLE, _INIT_CONFIG_ENABLE(Z));
TERN_(HAS_Z2_ENABLE, _INIT_CONFIG_ENABLE(Z2));
TERN_(HAS_Z3_ENABLE, _INIT_CONFIG_ENABLE(Z3));
TERN_(HAS_Z4_ENABLE, _INIT_CONFIG_ENABLE(Z4));
TERN_(HAS_I_ENABLE, _INIT_CONFIG_ENABLE(I));
TERN_(HAS_J_ENABLE, _INIT_CONFIG_ENABLE(J));
TERN_(HAS_K_ENABLE, _INIT_CONFIG_ENABLE(K));
TERN_(HAS_U_ENABLE, _INIT_CONFIG_ENABLE(U));
TERN_(HAS_V_ENABLE, _INIT_CONFIG_ENABLE(V));
TERN_(HAS_W_ENABLE, _INIT_CONFIG_ENABLE(W));
TERN_(HAS_E0_ENABLE, _INIT_CONFIG_ENABLE(E0));
TERN_(HAS_E1_ENABLE, _INIT_CONFIG_ENABLE(E1));
TERN_(HAS_E2_ENABLE, _INIT_CONFIG_ENABLE(E2));
TERN_(HAS_E3_ENABLE, _INIT_CONFIG_ENABLE(E3));
TERN_(HAS_E4_ENABLE, _INIT_CONFIG_ENABLE(E4));
TERN_(HAS_E5_ENABLE, _INIT_CONFIG_ENABLE(E5));
TERN_(HAS_E6_ENABLE, _INIT_CONFIG_ENABLE(E6));
TERN_(HAS_E7_ENABLE, _INIT_CONFIG_ENABLE(E7));
#define __INIT_ENABLE(A) do{ A##_ENABLE_INIT(); if (A##_ENABLE_INIT_STATE) A##_ENABLE_WRITE(HIGH); }while(0)
#define _INIT_ENABLE(A) TERF(HAS_##A##_ENABLE, __INIT_ENABLE)(A);
MAIN_AXIS_MAP(_INIT_ENABLE);
MAP(_INIT_ENABLE, X2, Y2, Z2, Z3, Z4);
#define _EN_INIT_ENABLE(N) TERN_(HAS_E##N##_ENABLE, __INIT_ENABLE(E##N));
REPEAT(8, _EN_INIT_ENABLE);
#define _STEP_INIT(AXIS) AXIS ##_STEP_INIT()
#define _WRITE_STEP(AXIS, HIGHLOW) AXIS ##_STEP_WRITE(HIGHLOW)
@@ -3322,21 +3269,12 @@ void Stepper::init() {
#endif
AXIS_INIT(Z, Z);
#endif
TERN_(HAS_I_STEP, AXIS_INIT(I, I));
TERN_(HAS_J_STEP, AXIS_INIT(J, J));
TERN_(HAS_K_STEP, AXIS_INIT(K, K));
TERN_(HAS_U_STEP, AXIS_INIT(U, U));
TERN_(HAS_V_STEP, AXIS_INIT(V, V));
TERN_(HAS_W_STEP, AXIS_INIT(W, W));
TERN_(HAS_E0_STEP, E_AXIS_INIT(0));
TERN_(HAS_E1_STEP, E_AXIS_INIT(1));
TERN_(HAS_E2_STEP, E_AXIS_INIT(2));
TERN_(HAS_E3_STEP, E_AXIS_INIT(3));
TERN_(HAS_E4_STEP, E_AXIS_INIT(4));
TERN_(HAS_E5_STEP, E_AXIS_INIT(5));
TERN_(HAS_E6_STEP, E_AXIS_INIT(6));
TERN_(HAS_E7_STEP, E_AXIS_INIT(7));
#define _AXIS_INIT(A) TERF(HAS_##A##_STEP, AXIS_INIT)(A, A);
SECONDARY_AXIS_MAP(_AXIS_INIT);
#define _EN_AXIS_INIT(N) TERF(HAS_E##N##_STEP, E_AXIS_INIT)(N);
REPEAT(8, _EN_AXIS_INIT);
#if DISABLED(I2S_STEPPER_STREAM)
HAL_timer_start(MF_TIMER_STEP, 122); // Init Stepper ISR to 122 Hz for quick starting
Marlin/src/module/temperature.cpp
+17 -83
View File
@@ -3090,14 +3090,8 @@ void Temperature::init() {
OUT_WRITE(HEATER_0_PIN, ENABLED(HEATER_0_INVERTING));
#endif
#endif
TERF(HAS_HEATER_1, OUT_WRITE)(HEATER_1_PIN, ENABLED(HEATER_1_INVERTING));
TERF(HAS_HEATER_2, OUT_WRITE)(HEATER_2_PIN, ENABLED(HEATER_2_INVERTING));
TERF(HAS_HEATER_3, OUT_WRITE)(HEATER_3_PIN, ENABLED(HEATER_3_INVERTING));
TERF(HAS_HEATER_4, OUT_WRITE)(HEATER_4_PIN, ENABLED(HEATER_4_INVERTING));
TERF(HAS_HEATER_5, OUT_WRITE)(HEATER_5_PIN, ENABLED(HEATER_5_INVERTING));
TERF(HAS_HEATER_6, OUT_WRITE)(HEATER_6_PIN, ENABLED(HEATER_6_INVERTING));
TERF(HAS_HEATER_7, OUT_WRITE)(HEATER_7_PIN, ENABLED(HEATER_7_INVERTING));
#define _INIT_HEATER(N) TERF(HAS_HEATER_##N, OUT_WRITE)(HEATER_##N##_PIN, ENABLED(HEATER_##N##_INVERTING));
REPEAT_1(7, _INIT_HEATER);
#if HAS_HEATED_BED
#if ENABLED(PELTIER_BED)
@@ -3119,14 +3113,9 @@ void Temperature::init() {
OUT_WRITE(COOLER_PIN, ENABLED(COOLER_INVERTING));
#endif
TERF(HAS_FAN0, INIT_FAN_PIN)(FAN0_PIN);
TERF(HAS_FAN1, INIT_FAN_PIN)(FAN1_PIN);
TERF(HAS_FAN2, INIT_FAN_PIN)(FAN2_PIN);
TERF(HAS_FAN3, INIT_FAN_PIN)(FAN3_PIN);
TERF(HAS_FAN4, INIT_FAN_PIN)(FAN4_PIN);
TERF(HAS_FAN5, INIT_FAN_PIN)(FAN5_PIN);
TERF(HAS_FAN6, INIT_FAN_PIN)(FAN6_PIN);
TERF(HAS_FAN7, INIT_FAN_PIN)(FAN7_PIN);
#define _INIT_FAN(N) TERF(HAS_FAN##N, INIT_FAN_PIN)(FAN##N##_PIN);
REPEAT(FAN_COUNT, _INIT_FAN);
TERF(USE_CONTROLLER_FAN, INIT_FAN_PIN)(CONTROLLER_FAN_PIN);
TERN_(HAS_MAXTC_SW_SPI, max_tc_spi.init());
@@ -4043,6 +4032,10 @@ void Temperature::isr() {
#define WRITE_FAN(n, v) WRITE(FAN##n##_PIN, (v) ^ ENABLED(FAN_INVERTING))
#if ENABLED(FAN_SOFT_PWM)
#define _FAN_LOW(N) if (TERN0(HAS_FAN##N, soft_pwm_count_fan[N] <= pwm_count_tmp)) { TERF(HAS_FAN##N, WRITE_FAN)(N, LOW); };
#endif
#if DISABLED(SLOW_PWM_HEATERS)
#if ANY(HAS_HOTEND, HAS_HEATED_BED, HAS_HEATED_CHAMBER, HAS_COOLER, FAN_SOFT_PWM)
@@ -4079,20 +4072,13 @@ void Temperature::isr() {
WRITE(CONTROLLER_FAN_PIN, soft_pwm_controllerfan.add(pwm_mask, controllerFan.soft_pwm_speed));
#endif
#define _FAN_PWM(N) do{ \
#define __FAN_PWM(N) do{ \
uint8_t &spcf = soft_pwm_count_fan[N]; \
spcf = (spcf & pwm_mask) + (soft_pwm_amount_fan[N] >> 1); \
WRITE_FAN(N, spcf > pwm_mask ? HIGH : LOW); \
}while(0)
TERF(HAS_FAN0, _FAN_PWM)(0);
TERF(HAS_FAN1, _FAN_PWM)(1);
TERF(HAS_FAN2, _FAN_PWM)(2);
TERF(HAS_FAN3, _FAN_PWM)(3);
TERF(HAS_FAN4, _FAN_PWM)(4);
TERF(HAS_FAN5, _FAN_PWM)(5);
TERF(HAS_FAN6, _FAN_PWM)(6);
TERF(HAS_FAN7, _FAN_PWM)(7);
#define _FAN_PWM(N) TERF(HAS_FAN##N, __FAN_PWM)(N);
REPEAT(FAN_COUNT, _FAN_PWM);
#endif
}
else {
@@ -4107,30 +4093,7 @@ void Temperature::isr() {
TERF(HAS_COOLER, _PWM_LOW)(COOLER, soft_pwm_cooler);
#if ENABLED(FAN_SOFT_PWM)
#if HAS_FAN0
if (soft_pwm_count_fan[0] <= pwm_count_tmp) WRITE_FAN(0, LOW);
#endif
#if HAS_FAN1
if (soft_pwm_count_fan[1] <= pwm_count_tmp) WRITE_FAN(1, LOW);
#endif
#if HAS_FAN2
if (soft_pwm_count_fan[2] <= pwm_count_tmp) WRITE_FAN(2, LOW);
#endif
#if HAS_FAN3
if (soft_pwm_count_fan[3] <= pwm_count_tmp) WRITE_FAN(3, LOW);
#endif
#if HAS_FAN4
if (soft_pwm_count_fan[4] <= pwm_count_tmp) WRITE_FAN(4, LOW);
#endif
#if HAS_FAN5
if (soft_pwm_count_fan[5] <= pwm_count_tmp) WRITE_FAN(5, LOW);
#endif
#if HAS_FAN6
if (soft_pwm_count_fan[6] <= pwm_count_tmp) WRITE_FAN(6, LOW);
#endif
#if HAS_FAN7
if (soft_pwm_count_fan[7] <= pwm_count_tmp) WRITE_FAN(7, LOW);
#endif
REPEAT(FAN_COUNT, _FAN_LOW);
#if ENABLED(USE_CONTROLLER_FAN)
if (soft_pwm_controllerfan.count <= pwm_count_tmp) WRITE(CONTROLLER_FAN_PIN, LOW);
#endif
@@ -4185,43 +4148,14 @@ void Temperature::isr() {
#if ENABLED(FAN_SOFT_PWM)
if (pwm_count_tmp >= 127) {
pwm_count_tmp = 0;
#define _PWM_FAN(N) do{ \
#define __PWM_FAN(N) do{ \
soft_pwm_count_fan[N] = soft_pwm_amount_fan[N] >> 1; \
WRITE_FAN(N, soft_pwm_count_fan[N] > 0 ? HIGH : LOW); \
}while(0)
TERF(HAS_FAN0, _PWM_FAN)(0);
TERF(HAS_FAN1, _PWM_FAN)(1);
TERF(HAS_FAN2, _PWM_FAN)(2);
TERF(HAS_FAN3, _FAN_PWM)(3);
TERF(HAS_FAN4, _FAN_PWM)(4);
TERF(HAS_FAN5, _FAN_PWM)(5);
TERF(HAS_FAN6, _FAN_PWM)(6);
TERF(HAS_FAN7, _FAN_PWM)(7);
#define _PWM_FAN(N) TERF(HAS_FAN##N, __PWM_FAN)(N);
REPEAT(FAN_COUNT, _PWM_FAN);
}
#if HAS_FAN0
if (soft_pwm_count_fan[0] <= pwm_count_tmp) WRITE_FAN(0, LOW);
#endif
#if HAS_FAN1
if (soft_pwm_count_fan[1] <= pwm_count_tmp) WRITE_FAN(1, LOW);
#endif
#if HAS_FAN2
if (soft_pwm_count_fan[2] <= pwm_count_tmp) WRITE_FAN(2, LOW);
#endif
#if HAS_FAN3
if (soft_pwm_count_fan[3] <= pwm_count_tmp) WRITE_FAN(3, LOW);
#endif
#if HAS_FAN4
if (soft_pwm_count_fan[4] <= pwm_count_tmp) WRITE_FAN(4, LOW);
#endif
#if HAS_FAN5
if (soft_pwm_count_fan[5] <= pwm_count_tmp) WRITE_FAN(5, LOW);
#endif
#if HAS_FAN6
if (soft_pwm_count_fan[6] <= pwm_count_tmp) WRITE_FAN(6, LOW);
#endif
#if HAS_FAN7
if (soft_pwm_count_fan[7] <= pwm_count_tmp) WRITE_FAN(7, LOW);
#endif
REPEAT(FAN_COUNT, _FAN_LOW);
#endif // FAN_SOFT_PWM
// SOFT_PWM_SCALE to frequency: