Overridable Options - Part 8 (PR#2560)

Apply `ENABLED` / `DISABLED` macros to stepper-related files.

Marlin/stepper.cpp

 static unsigned char out_bits = 0;        // The next stepping-bits to be output
 static unsigned int cleaning_buffer_counter;
 
-#ifdef Z_DUAL_ENDSTOPS
+#if ENABLED(Z_DUAL_ENDSTOPS)
   static bool performing_homing = false, 
               locked_z_motor = false, 
               locked_z2_motor = false;
 static long counter_x, counter_y, counter_z, counter_e;
 volatile static unsigned long step_events_completed; // The number of step events executed in the current block
 
-#ifdef ADVANCE
+#if ENABLED(ADVANCE)
   static long advance_rate, advance, final_advance = 0;
   static long old_advance = 0;
   static long e_steps[4];
 volatile long endstops_stepsTotal, endstops_stepsDone;
 static volatile char endstop_hit_bits = 0; // use X_MIN, Y_MIN, Z_MIN and Z_PROBE as BIT value
 
-#ifndef Z_DUAL_ENDSTOPS
+#if DISABLED(Z_DUAL_ENDSTOPS)
   static byte
 #else
   static uint16_t
 #endif
   old_endstop_bits = 0; // use X_MIN, X_MAX... Z_MAX, Z_PROBE, Z2_MIN, Z2_MAX
 
-#ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
+#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
   bool abort_on_endstop_hit = false;
 #endif
 
-#ifdef MOTOR_CURRENT_PWM_XY_PIN
+#if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
   int motor_current_setting[3] = DEFAULT_PWM_MOTOR_CURRENT;
 #endif
 
 //================================ functions ================================
 //===========================================================================
 
-#ifdef DUAL_X_CARRIAGE
+#if ENABLED(DUAL_X_CARRIAGE)
   #define X_APPLY_DIR(v,ALWAYS) \
     if (extruder_duplication_enabled || ALWAYS) { \
       X_DIR_WRITE(v); \
   #define X_APPLY_STEP(v,Q) X_STEP_WRITE(v)
 #endif
 
-#ifdef Y_DUAL_STEPPER_DRIVERS
+#if ENABLED(Y_DUAL_STEPPER_DRIVERS)
   #define Y_APPLY_DIR(v,Q) { Y_DIR_WRITE(v); Y2_DIR_WRITE((v) != INVERT_Y2_VS_Y_DIR); }
   #define Y_APPLY_STEP(v,Q) { Y_STEP_WRITE(v); Y2_STEP_WRITE(v); }
 #else
   #define Y_APPLY_STEP(v,Q) Y_STEP_WRITE(v)
 #endif
 
-#ifdef Z_DUAL_STEPPER_DRIVERS
+#if ENABLED(Z_DUAL_STEPPER_DRIVERS)
   #define Z_APPLY_DIR(v,Q) { Z_DIR_WRITE(v); Z2_DIR_WRITE(v); }
-  #ifdef Z_DUAL_ENDSTOPS
+  #if ENABLED(Z_DUAL_ENDSTOPS)
     #define Z_APPLY_STEP(v,Q) \
     if (performing_homing) { \
       if (Z_HOME_DIR > 0) {\
       SERIAL_ECHOPAIR(" Z:", (float)endstops_trigsteps[Z_AXIS] / axis_steps_per_unit[Z_AXIS]);
       LCD_MESSAGEPGM(MSG_ENDSTOPS_HIT "Z");
     }
-    #ifdef Z_PROBE_ENDSTOP
-    if (endstop_hit_bits & BIT(Z_PROBE)) {
-      SERIAL_ECHOPAIR(" Z_PROBE:", (float)endstops_trigsteps[Z_AXIS] / axis_steps_per_unit[Z_AXIS]);
-      LCD_MESSAGEPGM(MSG_ENDSTOPS_HIT "ZP");
-    }
+    #if ENABLED(Z_PROBE_ENDSTOP)
+      if (endstop_hit_bits & BIT(Z_PROBE)) {
+        SERIAL_ECHOPAIR(" Z_PROBE:", (float)endstops_trigsteps[Z_AXIS] / axis_steps_per_unit[Z_AXIS]);
+        LCD_MESSAGEPGM(MSG_ENDSTOPS_HIT "ZP");
+      }
     #endif
     SERIAL_EOL;
 
     endstops_hit_on_purpose();
 
-    #if defined(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) && defined(SDSUPPORT)
+    #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED) && ENABLED(SDSUPPORT)
       if (abort_on_endstop_hit) {
         card.sdprinting = false;
         card.closefile();
     count_direction[Z_AXIS] = 1;
   }
   
-  #ifndef ADVANCE
+  #if DISABLED(ADVANCE)
     if (TEST(out_bits, E_AXIS)) {
       REV_E_DIR();
       count_direction[E_AXIS] = -1;
     set_stepper_direction();
   }
   
-  #ifdef ADVANCE
+  #if ENABLED(ADVANCE)
     advance = current_block->initial_advance;
     final_advance = current_block->final_advance;
     // Do E steps + advance steps
       counter_y = counter_z = counter_e = counter_x;
       step_events_completed = 0;
 
-      #ifdef Z_LATE_ENABLE
+      #if ENABLED(Z_LATE_ENABLE)
         if (current_block->steps[Z_AXIS] > 0) {
           enable_z();
           OCR1A = 2000; //1ms wait
         }
       #endif
 
-      // #ifdef ADVANCE
+      // #if ENABLED(ADVANCE)
       //   e_steps[current_block->active_extruder] = 0;
       // #endif
     }
         MSerial.checkRx(); // Check for serial chars.
       #endif
 
-      #ifdef ADVANCE
+      #if ENABLED(ADVANCE)
         counter_e += current_block->steps[E_AXIS];
         if (counter_e > 0) {
           counter_e -= current_block->step_event_count;
       STEP_ADD(x,X);
       STEP_ADD(y,Y);
       STEP_ADD(z,Z);
-      #ifndef ADVANCE
+      #if DISABLED(ADVANCE)
         STEP_ADD(e,E);
       #endif
 
       STEP_IF_COUNTER(x, X);
       STEP_IF_COUNTER(y, Y);
       STEP_IF_COUNTER(z, Z);
-      #ifndef ADVANCE
+      #if DISABLED(ADVANCE)
         STEP_IF_COUNTER(e, E);
       #endif
 
       timer = calc_timer(acc_step_rate);
       OCR1A = timer;
       acceleration_time += timer;
-      #ifdef ADVANCE
+      #if ENABLED(ADVANCE)
         for(int8_t i=0; i < step_loops; i++) {
           advance += advance_rate;
         }
       timer = calc_timer(step_rate);
       OCR1A = timer;
       deceleration_time += timer;
-      #ifdef ADVANCE
+      #if ENABLED(ADVANCE)
         for(int8_t i=0; i < step_loops; i++) {
           advance -= advance_rate;
         }
   }
 }
 
-#ifdef ADVANCE
+#if ENABLED(ADVANCE)
   unsigned char old_OCR0A;
   // Timer interrupt for E. e_steps is set in the main routine;
   // Timer 0 is shared with millies
   microstep_init(); //Initialize Microstepping Pins
 
   // initialise TMC Steppers
-  #ifdef HAVE_TMCDRIVER
+  #if ENABLED(HAVE_TMCDRIVER)
     tmc_init();
   #endif
     // initialise L6470 Steppers
-  #ifdef HAVE_L6470DRIVER
+  #if ENABLED(HAVE_L6470DRIVER)
     L6470_init();
   #endif
 
   #endif
   #if HAS_Y_DIR
     Y_DIR_INIT;
-    #if defined(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_DIR
+    #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_DIR
       Y2_DIR_INIT;
     #endif
   #endif
   #if HAS_Z_DIR
     Z_DIR_INIT;
-    #if defined(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_DIR
+    #if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_DIR
       Z2_DIR_INIT;
     #endif
   #endif
     Y_ENABLE_INIT;
     if (!Y_ENABLE_ON) Y_ENABLE_WRITE(HIGH);
 
-  #if defined(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_ENABLE
+  #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_ENABLE
     Y2_ENABLE_INIT;
     if (!Y_ENABLE_ON) Y2_ENABLE_WRITE(HIGH);
   #endif
     Z_ENABLE_INIT;
     if (!Z_ENABLE_ON) Z_ENABLE_WRITE(HIGH);
 
-    #if defined(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_ENABLE
+    #if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_ENABLE
       Z2_ENABLE_INIT;
       if (!Z_ENABLE_ON) Z2_ENABLE_WRITE(HIGH);
     #endif
 
   #if HAS_X_MIN
     SET_INPUT(X_MIN_PIN);
-    #ifdef ENDSTOPPULLUP_XMIN
+    #if ENABLED(ENDSTOPPULLUP_XMIN)
       WRITE(X_MIN_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_Y_MIN
     SET_INPUT(Y_MIN_PIN);
-    #ifdef ENDSTOPPULLUP_YMIN
+    #if ENABLED(ENDSTOPPULLUP_YMIN)
       WRITE(Y_MIN_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_Z_MIN
     SET_INPUT(Z_MIN_PIN);
-    #ifdef ENDSTOPPULLUP_ZMIN
+    #if ENABLED(ENDSTOPPULLUP_ZMIN)
       WRITE(Z_MIN_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_X_MAX
     SET_INPUT(X_MAX_PIN);
-    #ifdef ENDSTOPPULLUP_XMAX
+    #if ENABLED(ENDSTOPPULLUP_XMAX)
       WRITE(X_MAX_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_Y_MAX
     SET_INPUT(Y_MAX_PIN);
-    #ifdef ENDSTOPPULLUP_YMAX
+    #if ENABLED(ENDSTOPPULLUP_YMAX)
       WRITE(Y_MAX_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_Z_MAX
     SET_INPUT(Z_MAX_PIN);
-    #ifdef ENDSTOPPULLUP_ZMAX
+    #if ENABLED(ENDSTOPPULLUP_ZMAX)
       WRITE(Z_MAX_PIN,HIGH);
     #endif
   #endif
 
   #if HAS_Z2_MAX
     SET_INPUT(Z2_MAX_PIN);
-    #ifdef ENDSTOPPULLUP_ZMAX
+    #if ENABLED(ENDSTOPPULLUP_ZMAX)
       WRITE(Z2_MAX_PIN,HIGH);
     #endif
   #endif
 
-  #if (defined(Z_PROBE_PIN) && Z_PROBE_PIN >= 0) && defined(Z_PROBE_ENDSTOP) // Check for Z_PROBE_ENDSTOP so we don't pull a pin high unless it's to be used.
+  #if HAS_Z_PROBE && ENABLED(Z_PROBE_ENDSTOP) // Check for Z_PROBE_ENDSTOP so we don't pull a pin high unless it's to be used.
     SET_INPUT(Z_PROBE_PIN);
-    #ifdef ENDSTOPPULLUP_ZPROBE
+    #if ENABLED(ENDSTOPPULLUP_ZPROBE)
       WRITE(Z_PROBE_PIN,HIGH);
     #endif
   #endif
     AXIS_INIT(x, X2, X);
   #endif
   #if HAS_Y_STEP
-    #if defined(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_STEP
+    #if ENABLED(Y_DUAL_STEPPER_DRIVERS) && HAS_Y2_STEP
       Y2_STEP_INIT;
       Y2_STEP_WRITE(INVERT_Y_STEP_PIN);
     #endif
     AXIS_INIT(y, Y, Y);
   #endif
   #if HAS_Z_STEP
-    #if defined(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_STEP
+    #if ENABLED(Z_DUAL_STEPPER_DRIVERS) && HAS_Z2_STEP
       Z2_STEP_INIT;
       Z2_STEP_WRITE(INVERT_Z_STEP_PIN);
     #endif
   TCNT1 = 0;
   ENABLE_STEPPER_DRIVER_INTERRUPT();
 
-  #ifdef ADVANCE
+  #if ENABLED(ADVANCE)
     #if defined(TCCR0A) && defined(WGM01)
       TCCR0A &= ~BIT(WGM01);
       TCCR0A &= ~BIT(WGM00);
   ENABLE_STEPPER_DRIVER_INTERRUPT();
 }
 
-#ifdef BABYSTEPPING
+#if ENABLED(BABYSTEPPING)
 
   // MUST ONLY BE CALLED BY AN ISR,
   // No other ISR should ever interrupt this!
  
       case Z_AXIS: {
 
-        #ifndef DELTA
+        #if DISABLED(DELTA)
 
           BABYSTEP_AXIS(z, Z, BABYSTEP_INVERT_Z);
 
     case 1: digitalWrite(Y_MS2_PIN, ms2); break;
     case 2: digitalWrite(Z_MS2_PIN, ms2); break;
     case 3: digitalWrite(E0_MS2_PIN, ms2); break;
-    #if defined(E1_MS2_PIN) && E1_MS2_PIN >= 0
+    #if PIN_EXISTS(E1_MS2)
       case 4: digitalWrite(E1_MS2_PIN, ms2); break;
     #endif
   }
   #endif
 }
 
-#ifdef Z_DUAL_ENDSTOPS
+#if ENABLED(Z_DUAL_ENDSTOPS)
   void In_Homing_Process(bool state) { performing_homing = state; }
   void Lock_z_motor(bool state) { locked_z_motor = state; }
   void Lock_z2_motor(bool state) { locked_z2_motor = state; }

Marlin/stepper.h

   #define NORM_E_DIR() { if(current_block->active_extruder == 2) { E2_DIR_WRITE(!INVERT_E2_DIR); } else { if(current_block->active_extruder == 1) { E1_DIR_WRITE(!INVERT_E1_DIR); } else { E0_DIR_WRITE(!INVERT_E0_DIR); }}}
   #define REV_E_DIR() { if(current_block->active_extruder == 2) { E2_DIR_WRITE(INVERT_E2_DIR); } else { if(current_block->active_extruder == 1) { E1_DIR_WRITE(INVERT_E1_DIR); } else { E0_DIR_WRITE(INVERT_E0_DIR); }}}
 #elif EXTRUDERS > 1
-  #ifndef DUAL_X_CARRIAGE
+  #if DISABLED(DUAL_X_CARRIAGE)
     #define E_STEP_WRITE(v) { if(current_block->active_extruder == 1) { E1_STEP_WRITE(v); } else { E0_STEP_WRITE(v); }}
     #define NORM_E_DIR() { if(current_block->active_extruder == 1) { E1_DIR_WRITE(!INVERT_E1_DIR); } else { E0_DIR_WRITE(!INVERT_E0_DIR); }}
     #define REV_E_DIR() { if(current_block->active_extruder == 1) { E1_DIR_WRITE(INVERT_E1_DIR); } else { E0_DIR_WRITE(INVERT_E0_DIR); }}
   #define REV_E_DIR() E0_DIR_WRITE(INVERT_E0_DIR)
 #endif
 
-#ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
+#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
   extern bool abort_on_endstop_hit;
 #endif
 
 void microstep_init();
 void microstep_readings();
 
-#ifdef Z_DUAL_ENDSTOPS
+#if ENABLED(Z_DUAL_ENDSTOPS)
   void In_Homing_Process(bool state);
   void Lock_z_motor(bool state);
   void Lock_z2_motor(bool state);
 #endif
 
-#ifdef BABYSTEPPING
+#if ENABLED(BABYSTEPPING)
   void babystep(const uint8_t axis,const bool direction); // perform a short step with a single stepper motor, outside of any convention
 #endif
      

Marlin/stepper_indirection.cpp

 #include "stepper_indirection.h"
 #include "Configuration.h"
 
-#ifdef HAVE_TMCDRIVER
-#include <SPI.h>
-#include <TMC26XStepper.h>
+#if ENABLED(HAVE_TMCDRIVER)
+  #include <SPI.h>
+  #include <TMC26XStepper.h>
 #endif
 
 // Stepper objects of TMC steppers used
-#ifdef X_IS_TMC
+#if ENABLED(X_IS_TMC)
 	TMC26XStepper stepperX(200,X_ENABLE_PIN,X_STEP_PIN,X_DIR_PIN,X_MAX_CURRENT,X_SENSE_RESISTOR);
 #endif
-#ifdef X2_IS_TMC
+#if ENABLED(X2_IS_TMC)
 	TMC26XStepper stepperX2(200,X2_ENABLE_PIN,X2_STEP_PIN,X2_DIR_PIN,X2_MAX_CURRENT,X2_SENSE_RESISTOR);
 #endif
-#ifdef Y_IS_TMC
+#if ENABLED(Y_IS_TMC)
 	TMC26XStepper stepperY(200,Y_ENABLE_PIN,Y_STEP_PIN,Y_DIR_PIN,Y_MAX_CURRENT,Y_SENSE_RESISTOR);
 #endif
-#ifdef Y2_IS_TMC
+#if ENABLED(Y2_IS_TMC)
 	TMC26XStepper stepperY2(200,Y2_ENABLE_PIN,Y2_STEP_PIN,Y2_DIR_PIN,Y2_MAX_CURRENT,Y2_SENSE_RESISTOR);
 #endif
-#ifdef Z_IS_TMC
+#if ENABLED(Z_IS_TMC)
 	TMC26XStepper stepperZ(200,Z_ENABLE_PIN,Z_STEP_PIN,Z_DIR_PIN,Z_MAX_CURRENT,Z_SENSE_RESISTOR);
 #endif
-#ifdef Z2_IS_TMC
+#if ENABLED(Z2_IS_TMC)
 	TMC26XStepper stepperZ2(200,Z2_ENABLE_PIN,Z2_STEP_PIN,Z2_DIR_PIN,Z2_MAX_CURRENT,Z2_SENSE_RESISTOR);
 #endif
-#ifdef E0_IS_TMC
+#if ENABLED(E0_IS_TMC)
 	TMC26XStepper stepperE0(200,E0_ENABLE_PIN,E0_STEP_PIN,E0_DIR_PIN,E0_MAX_CURRENT,E0_SENSE_RESISTOR);
 #endif
-#ifdef E1_IS_TMC
+#if ENABLED(E1_IS_TMC)
 	TMC26XStepper stepperE1(200,E1_ENABLE_PIN,E1_STEP_PIN,E1_DIR_PIN,E1_MAX_CURRENT,E1_SENSE_RESISTOR);
 #endif
-#ifdef E2_IS_TMC
+#if ENABLED(E2_IS_TMC)
 	TMC26XStepper stepperE2(200,E2_ENABLE_PIN,E2_STEP_PIN,E2_DIR_PIN,E2_MAX_CURRENT,E2_SENSE_RESISTOR);
 #endif
-#ifdef E3_IS_TMC
+#if ENABLED(E3_IS_TMC)
 	TMC26XStepper stepperE3(200,E3_ENABLE_PIN,E3_STEP_PIN,E3_DIR_PIN,E3_MAX_CURRENT,E3_SENSE_RESISTOR);
 #endif	
 
-#ifdef HAVE_TMCDRIVER
+#if ENABLED(HAVE_TMCDRIVER)
 void tmc_init()
 {
-#ifdef X_IS_TMC
+  #if ENABLED(X_IS_TMC)
 	stepperX.setMicrosteps(X_MICROSTEPS);
 	stepperX.start();
-#endif
-#ifdef X2_IS_TMC
+  #endif
+  #if ENABLED(X2_IS_TMC)
 	stepperX2.setMicrosteps(X2_MICROSTEPS);
 	stepperX2.start();
-#endif
-#ifdef Y_IS_TMC
+  #endif
+  #if ENABLED(Y_IS_TMC)
 	stepperY.setMicrosteps(Y_MICROSTEPS);
 	stepperY.start();
-#endif
-#ifdef Y2_IS_TMC
+  #endif
+  #if ENABLED(Y2_IS_TMC)
 	stepperY2.setMicrosteps(Y2_MICROSTEPS);
 	stepperY2.start();
-#endif
-#ifdef Z_IS_TMC
+  #endif
+  #if ENABLED(Z_IS_TMC)
 	stepperZ.setMicrosteps(Z_MICROSTEPS);
 	stepperZ.start();
-#endif
-#ifdef Z2_IS_TMC
+  #endif
+  #if ENABLED(Z2_IS_TMC)
 	stepperZ2.setMicrosteps(Z2_MICROSTEPS);
 	stepperZ2.start();
-#endif
-#ifdef E0_IS_TMC
+  #endif
+  #if ENABLED(E0_IS_TMC)
 	stepperE0.setMicrosteps(E0_MICROSTEPS);
 	stepperE0.start();
-#endif
-#ifdef E1_IS_TMC
+  #endif
+  #if ENABLED(E1_IS_TMC)
 	stepperE1.setMicrosteps(E1_MICROSTEPS);
 	stepperE1.start();
-#endif
-#ifdef E2_IS_TMC
+  #endif
+  #if ENABLED(E2_IS_TMC)
 	stepperE2.setMicrosteps(E2_MICROSTEPS);
 	stepperE2.start();
-#endif
-#ifdef E3_IS_TMC
+  #endif
+  #if ENABLED(E3_IS_TMC)
 	stepperE3.setMicrosteps(E3_MICROSTEPS);
 	stepperE3.start();
-#endif
+  #endif
 }
 #endif
 
 // L6470 Driver objects and inits
 
-#ifdef HAVE_L6470DRIVER
+#if ENABLED(HAVE_L6470DRIVER)
 #include <SPI.h>
 #include <L6470.h>
 #endif
 
 // L6470 Stepper objects
-#ifdef X_IS_L6470
+  #if ENABLED(X_IS_L6470)
 	L6470 stepperX(X_ENABLE_PIN);
-#endif
-#ifdef X2_IS_L6470
+  #endif
+  #if ENABLED(X2_IS_L6470)
 	L6470 stepperX2(X2_ENABLE_PIN);
-#endif
-#ifdef Y_IS_L6470
+  #endif
+  #if ENABLED(Y_IS_L6470)
 	L6470 stepperY(Y_ENABLE_PIN);
-#endif
-#ifdef Y2_IS_L6470
+  #endif
+  #if ENABLED(Y2_IS_L6470)
 	L6470 stepperY2(Y2_ENABLE_PIN);
-#endif
-#ifdef Z_IS_L6470
+  #endif
+  #if ENABLED(Z_IS_L6470)
 	L6470 stepperZ(Z_ENABLE_PIN);
-#endif
-#ifdef Z2_IS_L6470
+  #endif
+  #if ENABLED(Z2_IS_L6470)
 	L6470 stepperZ2(Z2_ENABLE_PIN);
-#endif
-#ifdef E0_IS_L6470
+  #endif
+  #if ENABLED(E0_IS_L6470)
 	L6470 stepperE0(E0_ENABLE_PIN);
-#endif
-#ifdef E1_IS_L6470
+  #endif
+  #if ENABLED(E1_IS_L6470)
 	L6470 stepperE1(E1_ENABLE_PIN);
-#endif
-#ifdef E2_IS_L6470
+  #endif
+  #if ENABLED(E2_IS_L6470)
 	L6470 stepperE2(E2_ENABLE_PIN);
-#endif
-#ifdef E3_IS_L6470
+  #endif
+  #if ENABLED(E3_IS_L6470)
 	L6470 stepperE3(E3_ENABLE_PIN);
-#endif	
+  #endif	
 
 
 // init routine
-#ifdef HAVE_L6470DRIVER
+#if ENABLED(HAVE_L6470DRIVER)
 void L6470_init()
 {
-#ifdef X_IS_L6470
+  #if ENABLED(X_IS_L6470)
 	stepperX.init(X_K_VAL);
 	stepperX.softFree();
 	stepperX.setMicroSteps(X_MICROSTEPS);
     stepperX.setOverCurrent(X_OVERCURRENT); //set overcurrent protection
     stepperX.setStallCurrent(X_STALLCURRENT);
-#endif
-#ifdef X2_IS_L6470
+  #endif
+  #if ENABLED(X2_IS_L6470)
 	stepperX2.init(X2_K_VAL);
 	stepperX2.softFree();
 	stepperX2.setMicroSteps(X2_MICROSTEPS);
     stepperX2.setOverCurrent(X2_OVERCURRENT); //set overcurrent protection
     stepperX2.setStallCurrent(X2_STALLCURRENT);
-#endif
-#ifdef Y_IS_L6470
+  #endif
+  #if ENABLED(Y_IS_L6470)
 	stepperY.init(Y_K_VAL);
 	stepperY.softFree();
 	stepperY.setMicroSteps(Y_MICROSTEPS);
     stepperY.setOverCurrent(Y_OVERCURRENT); //set overcurrent protection
     stepperY.setStallCurrent(Y_STALLCURRENT);
-#endif
-#ifdef Y2_IS_L6470
+  #endif
+  #if ENABLED(Y2_IS_L6470)
 	stepperY2.init(Y2_K_VAL);
 	stepperY2.softFree();
 	stepperY2.setMicroSteps(Y2_MICROSTEPS);
     stepperY2.setOverCurrent(Y2_OVERCURRENT); //set overcurrent protection
     stepperY2.setStallCurrent(Y2_STALLCURRENT);
-#endif
-#ifdef Z_IS_L6470
+  #endif
+  #if ENABLED(Z_IS_L6470)
 	stepperZ.init(Z_K_VAL);
 	stepperZ.softFree();
 	stepperZ.setMicroSteps(Z_MICROSTEPS);
     stepperZ.setOverCurrent(Z_OVERCURRENT); //set overcurrent protection
     stepperZ.setStallCurrent(Z_STALLCURRENT);
-#endif
-#ifdef Z2_IS_L6470
+  #endif
+  #if ENABLED(Z2_IS_L6470)
 	stepperZ2.init(Z2_K_VAL);
 	stepperZ2.softFree();
 	stepperZ2.setMicroSteps(Z2_MICROSTEPS);
     stepperZ2.setOverCurrent(Z2_OVERCURRENT); //set overcurrent protection
     stepperZ2.setStallCurrent(Z2_STALLCURRENT);
-#endif
-#ifdef E0_IS_L6470
+  #endif
+  #if ENABLED(E0_IS_L6470)
 	stepperE0.init(E0_K_VAL);
 	stepperE0.softFree();
 	stepperE0.setMicroSteps(E0_MICROSTEPS);
     stepperE0.setOverCurrent(E0_OVERCURRENT); //set overcurrent protection
     stepperE0.setStallCurrent(E0_STALLCURRENT);
-#endif
-#ifdef E1_IS_L6470
+  #endif
+  #if ENABLED(E1_IS_L6470)
 	stepperE1.init(E1_K_VAL);
 	stepperE1.softFree();
 	stepperE1.setMicroSteps(E1_MICROSTEPS);
     stepperE1.setOverCurrent(E1_OVERCURRENT); //set overcurrent protection
     stepperE1.setStallCurrent(E1_STALLCURRENT);
-#endif
-#ifdef E2_IS_L6470
+  #endif
+  #if ENABLED(E2_IS_L6470)
 	stepperE2.init(E2_K_VAL);
 	stepperE2.softFree();
 	stepperE2.setMicroSteps(E2_MICROSTEPS);
     stepperE2.setOverCurrent(E2_OVERCURRENT); //set overcurrent protection
     stepperE2.setStallCurrent(E2_STALLCURRENT);
-#endif
-#ifdef E3_IS_L6470
+  #endif
+  #if ENABLED(E3_IS_L6470)
 	stepperE3.init(E3_K_VAL);
 	stepperE3.softFree();
 	stepperE3.setMicroSteps(E3_MICROSTEPS);
     stepperE3.setOverCurrent(E3_OVERCURRENT); //set overcurrent protection
     stepperE3.setStallCurrent(E3_STALLCURRENT);
-#endif	
+  #endif	
 }
 #endif
 

Marlin/stepper_indirection.h

 // Pin redefines for TMC drivers. 
 // TMC26X drivers have step and dir on normal pins, but everything else via SPI
 //////////////////////////////////
-#ifdef HAVE_TMCDRIVER
+#if ENABLED(HAVE_TMCDRIVER)
 #include <SPI.h>
 #include <TMC26XStepper.h>
 
   void tmc_init();
-#ifdef X_IS_TMC
+#if ENABLED(X_IS_TMC)
    extern TMC26XStepper stepperX;
    #undef X_ENABLE_INIT 
    #define X_ENABLE_INIT ((void)0)
    #define X_ENABLE_READ stepperX.isEnabled()
    
 #endif
-#ifdef X2_IS_TMC
+#if ENABLED(X2_IS_TMC)
    extern TMC26XStepper stepperX2;
    #undef X2_ENABLE_INIT
    #define X2_ENABLE_INIT ((void)0)
    #undef X2_ENABLE_READ
    #define X2_ENABLE_READ stepperX2.isEnabled()   
 #endif
-#ifdef Y_IS_TMC
+#if ENABLED(Y_IS_TMC)
    extern TMC26XStepper stepperY;
    #undef Y_ENABLE_INIT
    #define Y_ENABLE_INIT ((void)0)
    #undef Y_ENABLE_READ
    #define Y_ENABLE_READ stepperY.isEnabled()   
 #endif
-#ifdef Y2_IS_TMC
+#if ENABLED(Y2_IS_TMC)
    extern TMC26XStepper stepperY2;
    #undef Y2_ENABLE_INIT
    #define Y2_ENABLE_INIT ((void)0)
    #undef Y2_ENABLE_READ
    #define Y2_ENABLE_READ stepperY2.isEnabled()     
 #endif
-#ifdef Z_IS_TMC
+#if ENABLED(Z_IS_TMC)
    extern TMC26XStepper stepperZ;
    #undef Z_ENABLE_INIT
    #define Z_ENABLE_INIT ((void)0)
    #undef Z_ENABLE_READ
    #define Z_ENABLE_READ stepperZ.isEnabled()       
 #endif
-#ifdef Z2_IS_TMC
+#if ENABLED(Z2_IS_TMC)
    extern TMC26XStepper stepperZ2;
    #undef Z2_ENABLE_INIT
    #define Z2_ENABLE_INIT ((void)0)
    #undef Z2_ENABLE_READ
    #define Z2_ENABLE_READ stepperZ2.isEnabled()   
 #endif
-#ifdef E0_IS_TMC
+#if ENABLED(E0_IS_TMC)
    extern TMC26XStepper stepperE0;
    #undef E0_ENABLE_INIT
    #define E0_ENABLE_INIT ((void)0)
    #undef E0_ENABLE_READ
    #define E0_ENABLE_READ stepperE0.isEnabled()   
 #endif
-#ifdef E1_IS_TMC
+#if ENABLED(E1_IS_TMC)
    extern TMC26XStepper stepperE1;
    #undef E1_ENABLE_INIT
    #define E1_ENABLE_INIT ((void)0)
    #undef E1_ENABLE_READ
    #define E1_ENABLE_READ stepperE1.isEnabled()   
 #endif
-#ifdef E2_IS_TMC
+#if ENABLED(E2_IS_TMC)
    extern TMC26XStepper stepperE2;
    #undef E2_ENABLE_INIT
    #define E2_ENABLE_INIT ((void)0)
    #undef E2_ENABLE_READ
    #define E2_ENABLE_READ stepperE2.isEnabled()   
 #endif
-#ifdef E3_IS_TMC
+#if ENABLED(E3_IS_TMC)
    extern TMC26XStepper stepperE3;
    #undef E3_ENABLE_INIT
    #define E3_ENABLE_INIT ((void)0)
 // Pin redefines for L6470 drivers. 
 // L640 drivers have step on normal pins, but dir and everything else via SPI
 //////////////////////////////////
-#ifdef HAVE_L6470DRIVER
+#if ENABLED(HAVE_L6470DRIVER)
 
 #include <SPI.h>
 #include <L6470.h>
 
   void L6470_init();
-#ifdef X_IS_L6470
+#if ENABLED(X_IS_L6470)
    extern L6470 stepperX;
    #undef X_ENABLE_INIT 
    #define X_ENABLE_INIT ((void)0)
    #define X_DIR_READ (stepperX.getStatus() & STATUS_DIR)
    
 #endif
-#ifdef X2_IS_L6470
+#if ENABLED(X2_IS_L6470)
    extern L6470 stepperX2;
    #undef X2_ENABLE_INIT
    #define X2_ENABLE_INIT ((void)0)
    #undef X2_DIR_READ
    #define X2_DIR_READ (stepperX2.getStatus() & STATUS_DIR)
 #endif
-#ifdef Y_IS_L6470
+#if ENABLED(Y_IS_L6470)
    extern L6470 stepperY;
    #undef Y_ENABLE_INIT
    #define Y_ENABLE_INIT ((void)0)
    #undef Y_DIR_READ
    #define Y_DIR_READ (stepperY.getStatus() & STATUS_DIR)  
 #endif
-#ifdef Y2_IS_L6470
+#if ENABLED(Y2_IS_L6470)
    extern L6470 stepperY2;
    #undef Y2_ENABLE_INIT
    #define Y2_ENABLE_INIT ((void)0)
    #undef Y2_DIR_READ
    #define Y2_DIR_READ (stepperY2.getStatus() & STATUS_DIR)   
 #endif
-#ifdef Z_IS_L6470
+#if ENABLED(Z_IS_L6470)
    extern L6470 stepperZ;
    #undef Z_ENABLE_INIT
    #define Z_ENABLE_INIT ((void)0)
    #undef Y_DIR_READ
    #define Y_DIR_READ (stepperZ.getStatus() & STATUS_DIR)      
 #endif
-#ifdef Z2_IS_L6470
+#if ENABLED(Z2_IS_L6470)
    extern L6470 stepperZ2;
    #undef Z2_ENABLE_INIT
    #define Z2_ENABLE_INIT ((void)0)
    #undef Y2_DIR_READ
    #define Y2_DIR_READ (stepperZ2.getStatus() & STATUS_DIR)       
 #endif
-#ifdef E0_IS_L6470
+#if ENABLED(E0_IS_L6470)
    extern L6470 stepperE0;
    #undef E0_ENABLE_INIT
    #define E0_ENABLE_INIT ((void)0)
    #undef E0_DIR_READ
    #define E0_DIR_READ (stepperE0.getStatus() & STATUS_DIR)    
 #endif
-#ifdef E1_IS_L6470
+#if ENABLED(E1_IS_L6470)
    extern L6470 stepperE1;
    #undef E1_ENABLE_INIT
    #define E1_ENABLE_INIT ((void)0)
    #undef E1_DIR_READ
    #define E1_DIR_READ (stepperE1.getStatus() & STATUS_DIR)  
 #endif
-#ifdef E2_IS_L6470
+#if ENABLED(E2_IS_L6470)
    extern L6470 stepperE2;
    #undef E2_ENABLE_INIT
    #define E2_ENABLE_INIT ((void)0)
    #undef E2_DIR_READ
    #define E2_DIR_READ (stepperE2.getStatus() & STATUS_DIR)  
 #endif
-#ifdef E3_IS_L6470
+#if ENABLED(E3_IS_L6470)
    extern L6470 stepperE3;
    #undef E3_ENABLE_INIT
    #define E3_ENABLE_INIT ((void)0)