Marlin-LCD增加机器调试

增加 LCD 机器调试 的选项

## menu.h
`Marlin\src\lcd\menu\menu.h`
```C++
////////////////////////////////////////////
//////// Menu Item Helper Functions ////////
////////////////////////////////////////////
# 参考位置
# void _lcd_draw_homing();  # 参考位置
void manual_move(const_float_t scale);  // 增加-手动移动
# #define HAS_LINE_TO_Z ANY(DELTA, PROBE_MANUALLY, MESH_BED_LEVELING, LCD_BED_TRAMMING)  # 参考位置
```

## menu.cpp
`Marlin\src\lcd\menu\menu.cpp`
```C++
# // TERN_(HAS_MARLINUI_MENU, encoder_direction_normal());  // 源命令1
TERN_(HAS_MARLINUI_MENU, (encoderDirection = -(planner.invert_dir[5U] ? -1 : 1)));  // 修改后命令1

# // ui.encoder_direction_menus();  // 源命令2
ui.encoderDirection = (planner.invert_dir[5U] ? -1 : 1);  // 修改后命令2

# // encoder_direction_select();  // 源命令3
encoderDirection = (planner.invert_dir[5U] ? -1 : 1);  // 修改后命令3
```

## menu_media.cpp
`Marlin\src\lcd\menu\menu_media.cpp`
```C++
# #include "menu_item.h"  # 参考位置
# #include "../../sd/cardreader.h"  # 参考位置
#include "../../module/planner.h"  // 增加

# // ui.encoder_direction_menus();  // 源命令
ui.encoderDirection = (planner.invert_dir[5U] ? -1 : 1);  // 修改后命令
```

## menu_setup.cpp
`Marlin\src\lcd\menu\menu_setup.cpp` 额外增加的调试菜单文件
```C++
#include "../../inc/MarlinConfigPre.h"

// 如果启用 Marlinui 菜单
#if HAS_MARLINUI_MENU
  #include "menu_item.h"
  #include "../../module/motion.h"
  #include "../../module/planner.h"
  #include "../../module/stepper.h"
  #include "../../MarlinCore.h"
  #include "../../gcode/queue.h"

#define VALUE_ITEM(MSG, VALUE, STYL) \
    do                                 \
    {                                  \
      char msg[];                      \
      strcpy_P(msg, PSTR(": "));       \
      strcpy(msg + 2, VALUE);          \
      STATIC_ITEM(MSG, STYL, msg);     \
    } while (0)
  bool delock = false;
  //电机方向更新
  void update_invert_dir() {
    stepper.set_directions();
    ui.encoderDirection = (planner.invert_dir[5U] ? -1 : 1);
    ui.store_settings();
  }
  // 更新编码器
  void update_encoder() {
    ui.store_settings();
  }
  // Led设置
  // void led_block_control(){
  //   if (planner.led_control){
  //     OUT_WRITE(W_LED_W_PIN,HIGH);
  //   }else{
  //     OUT_WRITE(W_LED_W_PIN, LOW);
  //   }
  //   return;
  // }
  // 手动返回
  void manual_back () {
    queue.inject_P("G28 Z");
    delock = false;
    return ui.goto_previous_screen_no_defer();
  }
  // 菜单反转目录
  void menu_invert_dir() {
    START_MENU();
    BACK_ITEM(MSG_SETUP);
    EDIT_ITEM(intbool, MSG_X_INVERT_DIR, &planner.invert_dir[X_AXIS], update_invert_dir); //X电机方向
    EDIT_ITEM(intbool, MSG_Y_INVERT_DIR, &planner.invert_dir[Y_AXIS], update_invert_dir); //Y电机方向
    EDIT_ITEM(intbool, MSG_Z_INVERT_DIR, &planner.invert_dir[Z_AXIS], update_invert_dir); //Z电机方向

EDIT_ITEM(intbool, MSG_E_INVERT_DIR, &planner.invert_dir[E_AXIS], update_invert_dir); //挤出机电机方向
    #if NUM_Z_STEPPER_DRIVERS > 1
    EDIT_ITEM(intbool2Z, MSG_Z2_INVERT_DIR, &planner.invert_dir[4U], update_invert_dir); //双Z反方向电机
    #endif
    EDIT_ITEM(intbool, MSG_ENCODER_DIR, &planner.invert_dir[5U], update_invert_dir);     //旋钮方向
    END_MENU();
  }
  //限位触发电位修改
  void endstops_elect() {
    START_MENU();
    BACK_ITEM(MSG_SETUP);
    #ifdef USE_XMIN_PLUG
    EDIT_ITEM(int8bool, MSG_X_MIN_STATUS, &planner.endstops_inver[0], update_encoder); //X-min
    #endif
    #ifdef USE_XMAX_PLUG
    EDIT_ITEM(int8bool, MSG_X_MAX_STATUS, &planner.endstops_inver[1], update_encoder); //X-max
    #endif
    #ifdef USE_YMIN_PLUG
    EDIT_ITEM(int8bool, MSG_Y_MIN_STATUS, &planner.endstops_inver[2], update_encoder); //Y-min
    #endif
    #ifdef USE_YMAX_PLUG
    EDIT_ITEM(int8bool, MSG_Y_MAX_STATUS, &planner.endstops_inver[3], update_encoder); //Y-max
    #endif
    #ifdef USE_ZMIN_PLUG
    EDIT_ITEM(int8bool, MSG_Z_MIN_STATUS, &planner.endstops_inver[4], update_encoder); //Z-min
    #endif
    #ifdef USE_ZMAX_PLUG
    EDIT_ITEM(int8bool, MSG_Z_MAX_STATUS, &planner.endstops_inver[5], update_encoder); //Z-max
    #endif
    #if !(ENABLED(TOUCH_MI_PROBE) || ENABLED(BLTOUCH))
    #ifndef Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN
    EDIT_ITEM(int8bool, MSG_Z_PROBE_STATUS, &planner.endstops_inver[7], update_encoder); //Z-probe
    #endif
    #endif
    #ifdef FILAMENT_RUNOUT_SENSOR
    EDIT_ITEM(int8bool, MSG_MATERIAL_STATUS, &planner.endstops_inver[6], update_encoder); //断料检测
    #endif
    END_MENU();
  }
  //限位状态
  void menu_endstop_status() {
    START_MENU();
    BACK_ITEM(MSG_SETUP);
  #ifdef USE_XMIN_PLUG
    EDIT_ITEM(bool3, MSG_X_MIN_STATUS, (READ(X_MIN_PIN) != planner.endstops_inver[0]));
  #endif
  #ifdef USE_XMAX_PLUG
    EDIT_ITEM(bool3, MSG_X_MAX_STATUS, (READ(X_MAX_PIN) != planner.endstops_inver[1]));
  #endif
  #ifdef USE_YMIN_PLUG
    EDIT_ITEM(bool3, MSG_Y_MIN_STATUS, (READ(Y_MIN_PIN) != planner.endstops_inver[2]));
  #endif
  #ifdef USE_YMAX_PLUG
    EDIT_ITEM(bool3, MSG_Y_MAX_STATUS, (READ(Y_MAX_PIN) != planner.endstops_inver[3]));
  #endif
  #ifdef USE_ZMIN_PLUG
    EDIT_ITEM(bool3, MSG_Z_MIN_STATUS, (READ(Z_MIN_PIN) != planner.endstops_inver[4]));
  #endif
  #ifdef USE_ZMAX_PLUG
    EDIT_ITEM(bool3, MSG_Z_MAX_STATUS, (READ(Z_MAX_PIN) != planner.endstops_inver[5]));
  #endif
  #ifdef FILAMENT_RUNOUT_SENSOR
    EDIT_ITEM(bool3, MSG_MATERIAL_STATUS, (READ(FIL_RUNOUT1_PIN) != planner.endstops_inver[6]));
  #endif
    END_MENU();
  }
  //手动热床调整
  void manual_bed (){
    if(!delock) {
      delock = true;
      planner.invert_dir[4U] = !planner.invert_dir[4U];
    }
    START_MENU();
    STATIC_ITEM(MSG_MANUAL_BED, SS_DEFAULT|SS_INVERT);
    EDIT_ITEM(intbool2Z, MSG_INFO_COMPLETED_PRINTS, &planner.invert_dir[4U], manual_back);
    SUBMENU(MSG_MOVE_10MM, []{ manual_move(10.0f);    });
    SUBMENU(MSG_MOVE_1MM,  []{ manual_move( 1.0f);    });
    SUBMENU(MSG_MOVE_01MM, []{ manual_move( 0.1f); });
    SUBMENU(MSG_MOVE_002_MM, []{ manual_move(0.02f); });
    END_MENU();
  }
  //调机菜单
  void menu_setup() {
    START_MENU();
    BACK_ITEM(MSG_MAIN);
    SUBMENU(MSG_INVERT_DIR, menu_invert_dir);  // 电机方向子菜单
    SUBMENU(MSG_ENDSTOP_STATUS, menu_endstop_status);  // 限位状态子菜单
    SUBMENU(MSG_ENDSTOPS_CHANGE, endstops_elect);  // 限位电位修改子菜单
    EDIT_ITEM(bool, MSG_LCD_SOFT_ENDSTOPS, &soft_endstop._enabled);  // 软限位开关
    #if ENABLED(PREVENT_COLD_EXTRUSION)  // 如果启用 防止冷挤压
      EDIT_ITEM(bool, MSG_ALLOW_COLD_EXTRUDE, &thermalManager.allow_cold_extrude);  // 冷挤出保护开关
    #endif
    // EDIT_ITEM(bool, MSG_LED_CONTROL, &planner.led_control, led_block_control);  // 灯箱灯开关
    // #if ENABLED(Z2_DRIVER_ZWZW)
    //   SUBMENU(MSG_MANUAL_BED, manual_bed);  //手动热床调平
    // #endif
    // 初始化eeprom选项
    CONFIRM_ITEM(MSG_INIT_EEPROM,
      MSG_BUTTON_INIT, MSG_BUTTON_CANCEL,
      ui.init_eeprom, nullptr,
      GET_TEXT_F(MSG_INIT_EEPROM), (const char *)nullptr, F("?")
    );
    END_MENU();
  }
#endif
```

## menu_item.h
`Marlin\src\lcd\menu\menu_item.h`
```C++
# #include "../../inc/MarlinConfigPre.h"  # 参考位置
// extern void led_block_control();  // LED 块控制  // 未解决禁用

# class MenuItem_bool : public MenuEditItemBase{...}  # 参考位置
// 以集成方案的电机方向修改菜单
class MenuItem_intbool : public MenuEditItemBase {
  public:
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, const bool onoff) {
      MenuEditItemBase::draw(sel, row, fstr, onoff ? GET_TEXT(MSG_LCD_Forward) : GET_TEXT(MSG_LCD_Backward), true);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, bool * const data, ...) {
      draw(sel, row, fstr, *data);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const, bool (*pget)(), ...) {
      draw(sel, row, fstr, pget());
    }
    static void action(FSTR_P const fstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) {
      *ptr ^= true; ui.refresh();
      if (callbackFunc) (*callbackFunc)();
    }
};
// 菜单2Z
class MenuItem_intbool2Z : public MenuEditItemBase {
  public:
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, const bool onoff) {
      MenuEditItemBase::draw(sel, row, fstr, onoff ? GET_TEXT(MSG_LCD_reverse) : GET_TEXT(MSG_LCD_syntropy), true);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, bool * const data, ...) {
      draw(sel, row, fstr, *data);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const, bool (*pget)(), ...) {
      draw(sel, row, fstr, pget());
    }
    static void action(FSTR_P const fstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) {
      *ptr ^= true;
      ui.refresh();
      if (callbackFunc) (*callbackFunc)();
    }
};
// 仅反馈bool菜单
class MenuItem_bool3 : public MenuEditItemBase {
  public:
    FORCE_INLINE static void draw(bool sel, const uint8_t row, FSTR_P const fstr, const bool onoff) {
      MenuEditItemBase::draw(sel, row, fstr, onoff ? GET_TEXT(MSG_LCD_CLOSE) : GET_TEXT(MSG_LCD_ON), true);
    }
    FORCE_INLINE static void draw(bool sel, const uint8_t row, FSTR_P const fstr, bool * const data, ...) {
      draw(sel, row, fstr, *data);
    }
    FORCE_INLINE static void draw(bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const, bool (*pget)(), ...) {
      draw(sel, row, fstr, pget());
    }
    static void action(FSTR_P const fstr, bool ptr, const screenFunc_t callbackFunc=nullptr) {
      if (callbackFunc) (*callbackFunc)();
    }
};
// 以集成方案的限位修改菜单
class MenuItem_int8bool : public MenuEditItemBase {
  public:
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, const bool onoff) {
      MenuEditItemBase::draw(sel, row, fstr, onoff ? GET_TEXT(MSG_ELECT_HIGH) : GET_TEXT(MSG_ELECT_LOW), true);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, bool * const data, ...) {
      draw(sel, row, fstr, *data);
    }
    FORCE_INLINE static void draw(const bool sel, const uint8_t row, FSTR_P const fstr, FSTR_P const, bool (*pget)(), ...) {
      draw(sel, row, fstr, pget());
    }
    static void action(FSTR_P const fstr, bool * const ptr, const screenFunc_t callbackFunc=nullptr) {
      *ptr ^= true;
      ui.refresh();
      if (callbackFunc) (*callbackFunc)();
    }
};
# 参考位置
////////////////////////////////////////////
//////////// Menu System Macros ////////////
////////////////////////////////////////////
```

## marlinui.cpp
`Marlin\src\lcd\marlinui.cpp`
```C++
# // int8_t MarlinUI::encoderDirection = ENCODERBASE;  // 源命令1
int8_t MarlinUI::encoderDirection = (planner.invert_dir[5U] ? -1 : 1);  // 修改后命令1

# // if (encoderDirection == -(ENCODERBASE)) { // HAS_ADC_BUTTONS强制REVERSE_MENU_DIRECTION，因此这表示菜单导航  // 源命令2
if (encoderDirection == -(planner.invert_dir[5U] ? -1 : 1) {  // 修改后命令2

# void MarlinUI::status_screen() {  # 参考位置
#if ENABLED(SPI_SCREEN)  // 预留屏幕待机
  if (planner.oled_sleep_time < millis()) {
    planner.oled_sleep = true;
    init_lcd();
    u8g.drawPixel(sleep_draw_count,1);
  if (sleep_draw_count < 126) sleep_draw_count++;
  else sleep_draw_count = 1;
  return;
  }
  planner.oled_sleep = false;
#endif
# TERN_(HAS_MARLINUI_MENU, ENCODER_RATE_MULTIPLY(false));  # 参考位置
```

## marlinui_DOGM.cpp
`Marlin\src\lcd\dogm\marlinui_DOGM.cpp`
```C++
# #include "../../module/printcounter.h"  # 参考位置
# #include "../../MarlinCore.h"  # 参考位置
#include "../../module/planner.h"		// 增加-引用文件

# // ui.encoder_direction_normal();  // 源命令
ui.encoderDirection = (planner.invert_dir[5U] ? -1 : 1);  // 修改后命令
```

## planner.h
`Marlin\src\module\planner.h`
```C++
# #ifdef XY_FREQUENCY_LIMIT ... #endif  # 参考位置
/*X:0 Y:1 Z:2 Z2:4 E:3 Encoder:5 用于保存按钮方向与电机方向*/
bool invert_dir[6] = {INVERT_X_DIR,INVERT_Y_DIR,INVERT_Z_DIR,INVERT_E0_DIR,
#ifdef INVERT_Z2_VS_Z_DIR
true,
#else
false,
#endif
#ifdef REVERSE_ENCODER_DIRECTION
true,
#else
false,
#endif
};
/*Z-P 7 E 6   5 Z 4   3 Y 2   1 X 0   (MAX MIN) 用于保存限位电位*/
bool endstops_inver[8] = {X_MIN_ENDSTOP_INVERTING,
  X_MAX_ENDSTOP_INVERTING,
  Y_MIN_ENDSTOP_INVERTING,
  Y_MAX_ENDSTOP_INVERTING,
  Z_MIN_ENDSTOP_INVERTING,
  Z_MAX_ENDSTOP_INVERTING,
  #if FIL_RUNOUT_STATE == LOW
    true,
  #else
    false,
  #endif
  Z_MIN_PROBE_ENDSTOP_INVERTING};
bool led_control = false;
# private:  # 参考位置(在上方的public下)
```

## probe.h
`Marlin\src\module\probe.h`
```C++
# // #define PROBE_TRIGGERED() (READ(Z_MIN_PROBE_PIN) != Z_MIN_PROBE_ENDSTOP_INVERTING)  // 原命令1
#define PROBE_TRIGGERED() (READ(Z_MIN_PROBE_PIN) != (planner.endstops_inver[4])  // 修改后命令1

# // #define PROBE_TRIGGERED() (READ(Z_MIN_PIN) != Z_MIN_ENDSTOP_INVERTING)  // 原命令2
#define PROBE_TRIGGERED() (READ(Z_MIN_PIN) != planner.endstops_inver[4])  // 修改后命令2
```
## settings.cpp
`Marlin\src\module\settings.cpp` 注意，该表格为EEPROM配置，参数结构、写入、读取顺序之间要完全一致
```C++
# uint8_t e_factors;  // DISTINCT_AXES - NUM_AXES  # 参考位置(DISTINCT_E_FACTORS后)
//电机方向与限位电平 [debug-EEPROM存储]
//限位电平
bool endstops_inver_save_xmin,endstops_inver_save_xmax,
  endstops_inver_save_ymin,endstops_inver_save_ymax,
  endstops_inver_save_zmin,endstops_inver_save_zmax,
  endstops_inver_save_fil,endstops_inver_save_probe;
//电机方向
bool invert_dir_save_x,invert_dir_save_y,invert_dir_save_z,inver_dir_save_e,
  invert_dir_save_encoder,invert_dir_save_2z;
# planner_settings_t planner_settings;  # 参考位置(Planner settings前)

# // const uint8_t e_factors = DISTINCT_AXES - (NUM_AXES);  // 原命令
const uint8_t e_factors = COUNT(planner.settings.axis_steps_per_mm) - (NUM_AXES);  // 修改后命令

# _FIELD_TEST(e_factors);  # 参考位置
# EEPROM_WRITE(e_factors);  # 参考位置
// 电机方向与限位电平存储
// 限位电平
{
  _FIELD_TEST(endstops_inver_save);
  bool endstops_inver_save_xmin = planner.endstops_inver[0],
  endstops_inver_save_xmax = planner.endstops_inver[1],
  endstops_inver_save_ymin = planner.endstops_inver[2],
  endstops_inver_save_ymax = planner.endstops_inver[3],
  endstops_inver_save_zmin = planner.endstops_inver[4],
  endstops_inver_save_zmax = planner.endstops_inver[5],
  endstops_inver_save_fil = planner.endstops_inver[6],
  endstops_inver_save_probe = planner.endstops_inver[7];
  EEPROM_WRITE(endstops_inver_save_xmin);
  EEPROM_WRITE(endstops_inver_save_xmax);
  EEPROM_WRITE(endstops_inver_save_ymin);
  EEPROM_WRITE(endstops_inver_save_ymax);
  EEPROM_WRITE(endstops_inver_save_zmin);
  EEPROM_WRITE(endstops_inver_save_zmax);
  EEPROM_WRITE(endstops_inver_save_fil);
  EEPROM_WRITE(endstops_inver_save_probe);
}
// 电机方向
{
  _FIELD_TEST(endstops_inver_save);
  bool invert_dir_save_x = planner.invert_dir[0],
  invert_dir_save_y = planner.invert_dir[1],
  invert_dir_save_z = planner.invert_dir[2],
  invert_dir_save_e = planner.invert_dir[3],
  invert_dir_save_2z = planner.invert_dir[4],
  invert_dir_save_encoder = planner.invert_dir[5];
  EEPROM_WRITE(invert_dir_save_x);
  EEPROM_WRITE(invert_dir_save_y);
  EEPROM_WRITE(invert_dir_save_z);
  EEPROM_WRITE(invert_dir_save_e);
  EEPROM_WRITE(invert_dir_save_2z);
  EEPROM_WRITE(invert_dir_save_encoder);
}
# { EEPROM_WRITE(planner.settings);  # 参考位置(Planner Motion前)

# _FIELD_TEST(e_factors);  # 参考位置
# uint8_t e_factors;  # 参考位置
# EEPROM_READ_ALWAYS(e_factors);  # 参考位置
// 电机方向与限位电平存储
{  //限位电平
  bool endstops_inver_save_xmin,endstops_inver_save_xmax,
  endstops_inver_save_ymin,endstops_inver_save_ymax,
  endstops_inver_save_zmin,endstops_inver_save_zmax,
  endstops_inver_save_fil,endstops_inver_save_probe;
  EEPROM_READ(endstops_inver_save_xmin);
  EEPROM_READ(endstops_inver_save_xmax);
  EEPROM_READ(endstops_inver_save_ymin);
  EEPROM_READ(endstops_inver_save_ymax);
  EEPROM_READ(endstops_inver_save_zmin);
  EEPROM_READ(endstops_inver_save_zmax);
  EEPROM_READ(endstops_inver_save_fil);
  EEPROM_READ(endstops_inver_save_probe);
  planner.endstops_inver[0] = endstops_inver_save_xmin;
  planner.endstops_inver[1] = endstops_inver_save_xmax;
  planner.endstops_inver[2] = endstops_inver_save_ymin;
  planner.endstops_inver[3] = endstops_inver_save_ymax;
  planner.endstops_inver[4] = endstops_inver_save_zmin;
  planner.endstops_inver[5] = endstops_inver_save_zmax;
  planner.endstops_inver[6] = endstops_inver_save_fil;
  planner.endstops_inver[7] = endstops_inver_save_probe;
}
// 电机方向
{
  bool invert_dir_save_x,invert_dir_save_y,invert_dir_save_z,invert_dir_save_e,
  invert_dir_save_encoder,invert_dir_save_2z;
  EEPROM_READ(invert_dir_save_x);
  EEPROM_READ(invert_dir_save_y);
  EEPROM_READ(invert_dir_save_z);
  EEPROM_READ(invert_dir_save_e);
  EEPROM_READ(invert_dir_save_2z);
  EEPROM_READ(invert_dir_save_encoder);
  planner.invert_dir[0] = invert_dir_save_x;
  planner.invert_dir[1] = invert_dir_save_y;
  planner.invert_dir[2] = invert_dir_save_z;
  planner.invert_dir[3] = invert_dir_save_e;
  planner.invert_dir[4] = invert_dir_save_2z;
  planner.invert_dir[5] = invert_dir_save_encoder;
}
# {  uint32_t tmp1[NUM_AXES + e_factors];  # 参考位置(Planner Motion前)

# void MarlinSettings::reset() {  # 参考位置(MarlinSettings::reset{}下首项)
// 复位
planner.invert_dir[0] =INVERT_X_DIR;
planner.invert_dir[1] =INVERT_Y_DIR;
planner.invert_dir[2] =INVERT_Z_DIR;
planner.invert_dir[3] =INVERT_E0_DIR;
planner.invert_dir[4] =
#ifdef INVERT_Z2_VS_Z_DIR
  true;
  #else
  false;
  #endif
planner.invert_dir[5] =
#ifdef REVERSE_ENCODER_DIRECTION
  true;
  #else
  false;
  #endif
planner.endstops_inver[0] = X_MIN_ENDSTOP_INVERTING;
planner.endstops_inver[1] = X_MAX_ENDSTOP_INVERTING;
planner.endstops_inver[2] = Y_MIN_ENDSTOP_INVERTING;
planner.endstops_inver[3] = Y_MAX_ENDSTOP_INVERTING;
planner.endstops_inver[4] = Z_MIN_ENDSTOP_INVERTING;
planner.endstops_inver[5] = Z_MAX_ENDSTOP_INVERTING;
planner.endstops_inver[6] =
#if FIL_RUNOUT_STATE == LOW
  true;
  #else
  false;
  #endif
planner.endstops_inver[7] = Z_MIN_PROBE_ENDSTOP_INVERTING;
# LOOP_DISTINCT_AXES(i) { ... }  # 参考位置
```
## stepper.cpp
`Marlin\src\module\stepper.cpp`
```C++
# #elif NUM_Z_STEPPERS == 2  # 参考位置
// #define Z_APPLY_DIR(v,Q) do{ Z_DIR_WRITE(v); Z2_DIR_WRITE((v) ^ ENABLED(INVERT_Z2_VS_Z_DIR)); }while(0)  // 原代码
#define Z_APPLY_DIR(v,Q) do{ Z_DIR_WRITE(v); Z2_DIR_WRITE((v) ^ (planner.invert_dir[4])); }while(0)  // 修改后

# #elif HAS_EXTRUDERS if ... else ...  # 参考位置(if和else下都需要修改)
// NORM_E_DIR(stepper_extruder);  // 原代码
NORM_E_DIR(planner.invert_dir[E_AXIS]);  // 修改后(有两处都需要修改)
```
## endstops.cpp
`Marlin\src\module\endstops.cpp`
```C++
# #elif HAS_FILAMENT_SENSOR  # 参考位置
// print_es_state(READ(FIL_RUNOUT1_PIN) != FIL_RUNOUT1_STATE, F(STR_FILAMENT));  // 原代码
print_es_state(READ(FIL_RUNOUT1_PIN) != ((planner.endstops_inver[6])), F(STR_FILAMENT));  // 修改后
# #endif  # 参考位置
```
## Conditionals_LCD.h
`Marlin\src\inc\Conditionals_LCD.h`
```C++
# #ifdef SERIAL_PORT_2 ... #endif  # 参考位置(下面)
// 后备轴反转
#ifndef INVERT_X_DIR
  #define INVERT_X_DIR false
#endif
#ifndef INVERT_Y_DIR
  #define INVERT_Y_DIR false
#endif
#ifndef INVERT_Z_DIR
  #define INVERT_Z_DIR false
#endif
#ifndef INVERT_E0_DIR
  #define INVERT_E0_DIR true
#endif
#ifndef EXTRUDE_MINTEMP  # 参考位置(上方) EXTRUDE_MINTEMP(挤出最小温度)
```
## Configuration_adv.h
`Marlin\Configuration_adv.h`
```C++
# 参考位置，Z Steppers 下面，暂不需要禁用
// #ifdef Z2_DRIVER_ZWZW
//   #if ENABLED(TOUCH_MI_PROBE) || ENABLED(BLTOUCH)  // 要有Z探针
//     #define Z_STEPPER_AUTO_ALIGN
//   #endif
// #else
//   //#define Z_STEPPER_AUTO_ALIGN
// #endif
# #if ENABLED(Z_STEPPER_AUTO_ALIGN)  # 参考位置(上面)
```

## language_en.h
`Marlin\src\lcd\language\language_en.h`
```C++
// 增加英文菜单
  LSTR MSG_SETUP                           = _UxGT("Setup");
  LSTR MSG_INVERT_DIR                      = _UxGT("Machine Debugging");
  LSTR MSG_ENDSTOP_STATUS                  = _UxGT("EndStop Status");
  LSTR MSG_ALLOW_COLD_EXTRUDE              = _UxGT("Allow Cold Extrude");
  LSTR MSG_LCD_Forward                     = _UxGT("Forward");
  LSTR MSG_LCD_syntropy                    = _UxGT("Syntropy");
  LSTR MSG_LCD_Backward                    = _UxGT("Backward");
  LSTR MSG_LCD_reverse                     = _UxGT("Reverse");
  LSTR MSG_X_INVERT_DIR                    = _UxGT("X Direction");
  LSTR MSG_Y_INVERT_DIR                    = _UxGT("Y Direction");
  LSTR MSG_Z_INVERT_DIR                    = _UxGT("Z Direction");
  LSTR MSG_E_INVERT_DIR                    = _UxGT("Extrudere Direction");
  LSTR MSG_X_MIN_STATUS                    = _UxGT("X min Endstop");
  LSTR MSG_Y_MIN_STATUS                    = _UxGT("Y min Endstop");
  LSTR MSG_Z_MIN_STATUS                    = _UxGT("Z min Endstop");
  LSTR MSG_X_MAX_STATUS                    = _UxGT("X max Endstop");
  LSTR MSG_Y_MAX_STATUS                    = _UxGT("Y max Endstop");
  LSTR MSG_Z_MAX_STATUS                    = _UxGT("Z max Endstop");
  LSTR MSG_MATERIAL_STATUS                 = _UxGT("Materia Status");
  LSTR MSG_ENCODER_DIR                     = _UxGT("Encoder Backward");
  LSTR MSG_ELECT_HIGH                      = _UxGT("High");
  LSTR MSG_ELECT_LOW                       = _UxGT("Low");
  LSTR MSG_ENDSTOPS_CHANGE                 = _UxGT("Endstops Elect Change");
  LSTR MSG_LCD_CLOSE                       = _UxGT("Close");
  LSTR MSG_Z2_INVERT_DIR                   = _UxGT("Dual Z Reverse");
  LSTR MSG_Z_PROBE_STATUS                  = _UxGT("Z Probe");
  LSTR MSG_ERROR_ENDSTOP                   = _UxGT("Endstop place Error");
  LSTR MSG_TEST                            = _UxGT("Test_Mode");
  LSTR MSG_MANUAL_BED                      = _UxGT("Manual Bed leveling");
  LSTR MSG_MOVE_002_MM                     = _UxGT("Move 0.02mm");
```

## language_zh_CN.h
`Marlin\src\lcd\language\language_zh_CN.h`
```C++
// 增加中文菜单
  LSTR MSG_SETUP                           = _UxGT("机器调试");
  LSTR MSG_INVERT_DIR                      = _UxGT("电机方向");
  LSTR MSG_ENCODER_DIR                     = _UxGT("按钮方向");
  LSTR MSG_ENDSTOP_STATUS                  = _UxGT("限位状态");
  LSTR MSG_ALLOW_COLD_EXTRUDE              = _UxGT("冷挤出开关");
  LSTR MSG_LCD_Forward                     = _UxGT("正转");
  LSTR MSG_LCD_syntropy                    = _UxGT("++");
  LSTR MSG_LCD_Backward                    = _UxGT("反转");
  LSTR MSG_LCD_reverse                     = _UxGT("+-");
  LSTR MSG_X_INVERT_DIR                    = _UxGT("X");
  LSTR MSG_Y_INVERT_DIR                    = _UxGT("Y");
  LSTR MSG_Z_INVERT_DIR                    = _UxGT("Z");
  LSTR MSG_E_INVERT_DIR                    = _UxGT("挤出机");
  LSTR MSG_X_MIN_STATUS                    = _UxGT("Xmin");
  LSTR MSG_Y_MIN_STATUS                    = _UxGT("Ymin");
  LSTR MSG_Z_MIN_STATUS                    = _UxGT("Zmin");
  LSTR MSG_X_MAX_STATUS                    = _UxGT("Xmax");
  LSTR MSG_Y_MAX_STATUS                    = _UxGT("Ymax");
  LSTR MSG_Z_MAX_STATUS                    = _UxGT("Zmax");
  LSTR MSG_MATERIAL_STATUS                 = _UxGT("断料检测");
  LSTR MSG_ELECT_HIGH                      = _UxGT("高电平");
  LSTR MSG_ELECT_LOW                       = _UxGT("低电平");
  LSTR MSG_ENDSTOPS_CHANGE                 = _UxGT("限位电平");
  LSTR MSG_LCD_CLOSE                       = _UxGT("闭");
  LSTR MSG_Z2_INVERT_DIR                   = _UxGT("双Z反向");
  LSTR MSG_Z_PROBE_STATUS                  = _UxGT("Z探针");
  LSTR MSG_ERROR_ENDSTOP                   = _UxGT("位置错位");
  LSTR MSG_TEST                            = _UxGT("测试模式");
  LSTR MSG_MANUAL_BED                      = _UxGT("手动热床调平");
  LSTR MSG_MOVE_002_MM                     = _UxGT("移动 0.02 mm");
```