#include <avr/pgmspace.h>
#include <util/delay.h>

//////////////////////////////////
//!!!!!!! Раскомментируйте следующую строку для вывода отладочной информации в "Монитор порта" !!!!!!!!
#define DEBUG_PRINT_THREAD_and_CONE

// ***** ПАРАМЕТРЫ ЖЕЛЕЗА ***** //

//int ENC_LINE_PER_REV;  // Кол-во линий энкодера на 1 оборот шпинделя

//int SCREW_Z;               // Шаг продольного винта Z в сотках, 2мм
//int MOTOR_Z_STEP_PER_REV;  // Кол-во шагов на оборот винта Z, продольная
//int McSTEP_Z;              // Микрошаг, ось Z, продольная
//int REBOUND_Z;             // Отскок резца в микрошагах, для авторезанья, должен быть больше люфта продольной

// int SCREW_X;               // Шаг поперечного винта X в сотках, 1.0мм
// int MOTOR_X_STEP_PER_REV;  // Кол-во шагов на оборот винта X, поперечная
// int McSTEP_X;              // Микрошаг, ось X, поперечная
// int REBOUND_X = 200;       // Отскок резца в микрошагах, для авторезанья, должен быть больше люфта поперечки

// int THRD_ACCEL;  // К.деления с которого будем ускоряться на Резьбах, Accel+Ks должен быть < 255
// int FEED_ACCEL;  // Жесткость разгона на подачах, бОльше значение - короче разгон.
// //
// int MIN_FEED;   // Желаемая минимальная подача  в сотках/оборот, 0.02мм/об
// int MAX_FEED;   // Желаемая максимальная подача в сотках/оборот, 0.25мм/об
// int MIN_aFEED;  // Желаемая минимальная подача  в mm/минуту, 20мм/мин
// int MAX_aFEED;  // Желаемая максимальная подача в mm/минуту, 400мм/мин

// // Ускоренные перемещения
// int MAX_RAPID_MOTION_Z;  // Меньше - бОльшая конечная скорость           //16000000/32/((25+1)*2)/800*60=721rpm
// int MAX_RAPID_MOTION_X;  // Меньше - бОльшая конечная скорость           //16000000/32/((75+1)*2)/800*60=~246rpm
// int MIN_RAPID_MOTION;
// int MIN_RAPID_MOTION1;
// //#define MIN_RAPID_MOTION (MAX_RAPID_MOTION_Z + 100)  // Больше - мЕньшая начальная скорость, max 255 //16000000/32/((150+25+1)*2)/800*60=107rpm
// int REPEAt;
// int REPEAt1;
// //#define REPEAt (McSTEP_Z * 2)                        // Кол-во повторов для постоянной скорости в пределах полного шага \
//                                                      // Длительность разгона = 150/2*REPEAT(4)/Microstep(4) = 75 полных шагов цикл ускорения
// // Ручной энкодер (100 линий)
// int HC_SCALE_1;         // 1-e положение, масштаб = 1сотка/тик = 1мм/оборот
// int HC_SCALE_10;        // 2-e положение, масштаб = 10соток/тик = 10мм/оборот
// int HC_START_SPEED_1;   // старт РГИ, 250000/(250+1)/800*60/2 = 37rpm
// int HC_MAX_SPEED_1;     // максимум скорости РГИ, 250000/(150+1)/800*60/2 = 62rpm
// int HC_START_SPEED_10;  // старт РГИ, 250000/(150+1)/800*60/2 = 62rpm
// int HC_MAX_SPEED_10;    // максимум скорости РГИ, 250000/(23+1)/800*60/2 = 391rpm
// int HC_X_DIR;           // 1-поперечка по часовой, 0-против

// int PP_X;         // 1-на диаметр , 0-на радиус (поперечная подача на радиус или на диаметр)
// int PASS_FINISH;  // Количество чистовых проходов, по умолчанию, после автоцикла в режиме "Резьба"
// int Th;           // Коэф. для подсройки тахометра 13300

#define INIT_ADDR 4094  // номер резервной ячейки EEPROM
#define INIT_KEY 50     // ключ первого запуска. 0-254, на выбор

struct Data_Setup_Param1 {
  int ENC_LINE_PER_REV = 0;
  int SCREW_Z = 0;
  int MOTOR_Z_STEP_PER_REV = 0;
  int McSTEP_Z = 0;
  int REBOUND_Z = 0;
  int SCREW_X = 0;
  int MOTOR_X_STEP_PER_REV = 0;
  int McSTEP_X = 0;
  int REBOUND_X = 0;
  int THRD_ACCEL = 0;
  int FEED_ACCEL = 0;
  int MIN_FEED = 0;
  int MAX_FEED = 0;
  int MIN_aFEED = 0;
  int MAX_aFEED = 0;
  int MAX_RAPID_MOTION_Z = 0;
  int MAX_RAPID_MOTION_X = 0;
  int MIN_RAPID_MOTION1 = 0;
  int REPEAt1 = 0;
  int HC_SCALE_1 = 0;
  int HC_SCALE_10 = 0;
  int HC_START_SPEED_1 = 0;
  int HC_START_SPEED_10 = 0;
  int HC_MAX_SPEED_1 = 0;
  int HC_MAX_SPEED_10 = 0;
  int HC_X_DIR = 0;
  int PP_X = 0;
  int PASS_FINISH = 0;
  int Th = 0;
};

Data_Setup_Param1 Data_Setup_Param;
#include <EEPROM.h>

//*************** загрузка из EEPROM параметров железа  ******************************

#define Data_Setup_Param2 EEPROM.get(0, Data_Setup_Param)
int ENC_LINE_PER_REV = Data_Setup_Param2.ENC_LINE_PER_REV;
int SCREW_Z = Data_Setup_Param2.SCREW_Z;
int MOTOR_Z_STEP_PER_REV = Data_Setup_Param2.MOTOR_Z_STEP_PER_REV;
int McSTEP_Z = Data_Setup_Param2.McSTEP_Z;
int REBOUND_Z = Data_Setup_Param2.REBOUND_Z;
int SCREW_X = Data_Setup_Param2.SCREW_X;
int MOTOR_X_STEP_PER_REV = Data_Setup_Param2.MOTOR_X_STEP_PER_REV;
int McSTEP_X = Data_Setup_Param2.McSTEP_X;
int REBOUND_X = Data_Setup_Param2.REBOUND_X;
int THRD_ACCEL = Data_Setup_Param2.THRD_ACCEL;
int FEED_ACCEL = Data_Setup_Param2.FEED_ACCEL;
int MIN_FEED = Data_Setup_Param2.MIN_FEED;
int MAX_FEED = Data_Setup_Param2.MAX_FEED;
int MIN_aFEED = Data_Setup_Param2.MIN_aFEED;
int MAX_aFEED = Data_Setup_Param2.MAX_aFEED;
int MAX_RAPID_MOTION_Z = Data_Setup_Param2.MAX_RAPID_MOTION_Z;
int MAX_RAPID_MOTION_X = Data_Setup_Param2.MAX_RAPID_MOTION_X;
int MIN_RAPID_MOTION1 = Data_Setup_Param2.MIN_RAPID_MOTION1;
int MIN_RAPID_MOTION = (MAX_RAPID_MOTION_Z + MIN_RAPID_MOTION1);
int REPEAt1 = Data_Setup_Param2.REPEAt1;
int REPEAt = (McSTEP_Z * REPEAt1);
int HC_SCALE_1 = Data_Setup_Param2.HC_SCALE_1;
int HC_SCALE_10 = Data_Setup_Param2.HC_SCALE_10;
int HC_START_SPEED_1 = Data_Setup_Param2.HC_START_SPEED_1;
int HC_START_SPEED_10 = Data_Setup_Param2.HC_START_SPEED_10;
int HC_MAX_SPEED_1 = Data_Setup_Param2.HC_MAX_SPEED_1;
int HC_MAX_SPEED_10 = Data_Setup_Param2.HC_MAX_SPEED_10;
int HC_X_DIR = Data_Setup_Param2.HC_X_DIR;
int PP_X = Data_Setup_Param2.PP_X;
int PASS_FINISH = Data_Setup_Param2.PASS_FINISH;
int Th = Data_Setup_Param2.Th;


// *******************   Запись начальных параметров в EEPROM  **************************

int ResetSetupParam() {

  if (EEPROM.read(INIT_ADDR) != INIT_KEY) {  // первый запуск
    EEPROM.write(INIT_ADDR, INIT_KEY);       // записали ключ
    Data_Setup_Param.ENC_LINE_PER_REV = 1800;
    Data_Setup_Param.SCREW_Z = 200;
    Data_Setup_Param.MOTOR_Z_STEP_PER_REV = 300;
    Data_Setup_Param.McSTEP_Z = 8;
    Data_Setup_Param.REBOUND_Z = 300;
    Data_Setup_Param.SCREW_X = 100;
    Data_Setup_Param.MOTOR_X_STEP_PER_REV = 200;
    Data_Setup_Param.McSTEP_X = 2;
    Data_Setup_Param.REBOUND_X = 300;
    Data_Setup_Param.THRD_ACCEL = 15;
    Data_Setup_Param.FEED_ACCEL = 3;
    Data_Setup_Param.MIN_FEED = 1;
    Data_Setup_Param.MAX_FEED = 50;
    Data_Setup_Param.MIN_aFEED = 10;
    Data_Setup_Param.MAX_aFEED = 200;
    Data_Setup_Param.MAX_RAPID_MOTION_Z = 60;
    Data_Setup_Param.MAX_RAPID_MOTION_X = 60;
    Data_Setup_Param.MIN_RAPID_MOTION1 = 100;
    Data_Setup_Param.REPEAt1 = 2;
    Data_Setup_Param.HC_SCALE_1 = 1;
    Data_Setup_Param.HC_SCALE_10 = 10;
    Data_Setup_Param.HC_START_SPEED_1 = 250;
    Data_Setup_Param.HC_START_SPEED_10 = 150;
    Data_Setup_Param.HC_MAX_SPEED_1 = 150;
    Data_Setup_Param.HC_MAX_SPEED_10 = 35;
    Data_Setup_Param.HC_X_DIR = 1;
    Data_Setup_Param.PP_X = 0;
    Data_Setup_Param.PASS_FINISH = 3;
    Data_Setup_Param.Th = 1480;
    EEPROM.put(0, Data_Setup_Param);  // поместить в EEPROM по адресу 0
  }
}
//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////

//#include "Formula.h"

volatile long Rev_Count;
volatile long Rev_Count_F;


// ***** MY CONSTANT *****
#define CW 0
#define CCW 1
#define ON 1
#define OFF 0


// ***** LCD *****

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);



char LCD_Row_1[21];
char LCD_Row_2[21];
char LCD_Row_3[21];
char LCD_Row_4[21];


byte strelka_vlevo[8] = {
  0b00000,
  0b00000,
  0b00100,
  0b01000,
  0b11111,
  0b01000,
  0b00100,
  0b00000,
};
byte strelka_vpravo[8] = {
  0b00100,
  0b00010,
  0b11111,
  0b00010,
  0b00100,
  0b00000,
  0b00000,
  0b00000,
};
byte strelka_vverh[8] = {
  0b00100,
  0b01110,
  0b10101,
  0b00100,
  0b00100,
  0b00000,
  0b00000,
  0b00000,
};
byte strelka_vniz[8] = {
  0b00000,
  0b00000,
  0b00100,
  0b00100,
  0b10101,
  0b01110,
  0b00100,
  0b00000,
};
byte znak_diametr[8] = {
  0b00001,
  0b01110,
  0b10011,
  0b10101,
  0b11001,
  0b01110,
  0b10000,
  0b00000
};
byte znak_gradus[8] = {
  0b01100,
  0b10010,
  0b10010,
  0b01100,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};

#define Beeper_Init() \
  DDRH = B01100010; \
  PORTH = B10011101                     // LCD-H5,H6 Buzzer-PH1_Pin16
#define Beeper_On() PORTH &= ~(1 << 1)  // Pin16 0
#define Beeper_Off() PORTH |= (1 << 1)  // Pin16 1



// ***** Stepper Motor *****
#define Motor_Init() \
  DDRL = B11111011; \
  PORTL = B0000100

#define Motor_Z_SetPulse() PORTL &= ~(1 << 0)    // Pin49 0
#define Motor_Z_RemovePulse() PORTL |= (1 << 0)  // Pin49 1
#define Motor_Z_InvertPulse() PORTL ^= (1 << 0)  // Pin49
#define Read_Z_State (PINL & (1 << 0))

#define Motor_X_SetPulse() PORTL &= ~(1 << 1)    // Pin48 0
#define Motor_X_RemovePulse() PORTL |= (1 << 1)  // Pin48 1
#define Motor_X_InvertPulse() PORTL ^= (1 << 1)  // Pin48
#define Read_X_State (PINL & (1 << 1))

#define Motor_Z_CW() PORTL &= ~(1 << 6)  // Pin43 0
#define Motor_Z_CCW() PORTL |= (1 << 6)  // Pin43 1

#define Motor_X_CW() PORTL &= ~(1 << 5)  // Pin44 0
#define Motor_X_CCW() PORTL |= (1 << 5)  // Pin44 1

#define Motor_Z_Enable() \
  do { \
    PORTL |= (1 << 4); \
    _delay_ms(250); \
  } while (0)  // Pin45 1   попробуйте задержку увеличить: _delay_ms(120); до 500, может тупо драйвер Ena не успевает отрабатывать
#define Motor_Z_Disable() \
  { \
    PORTL &= ~(1 << 4); \
    _delay_ms(100); \
  }  // Pin45 0

#define Read_Z_Ena_State (PINL & (1 << 4))

#define Motor_X_Enable() \
  do { \
    PORTL |= (1 << 3); \
    _delay_ms(120); \
  } while (0)  // Pin46 1  попробуйте задержку увеличить: _delay_ms(120); до 500, может тупо драйвер Ena не успевает отрабатывать
#define Motor_X_Disable() \
  { \
    PORTL &= ~(1 << 3); \
    _delay_ms(100); \
  }  // Pin46 0
#define Read_X_Ena_State (PINL & (1 << 3))


// ***** Tacho *****
#define TachoSetPulse() PORTL |= (1 << 7)      // Pin42 1
#define TachoRemovePulse() PORTL &= ~(1 << 7)  // Pin42 0


// ***** Encoder *****
int ENC_TICK(ENC_LINE_PER_REV * 2 + 1);  // Рабочее кол-во импульсов +1 корректирует

#define Encoder_Init() \
  DDRD = B00000000; \
  PORTD = B11111111  // подтяжка PIN_21, 20, 19, 18
#define Enc_Read (PIND & (1 << 1))
#define Enc_Ch_A (PIND & (1 << 0))
#define Enc_Ch_B (PIND & (1 << 1))



// ***** Hand_Coder *****            // Z/X: Input-E4,E5, подтяжка-E4,E5, X1/X10: Input-J0,J1, подтяжка-J0,J1.
#define Hand_Init() \
  DDRE = B00000000; \
  PORTE = B11111111; \
  DDRJ = B00000000; \
  PORTJ = B11111111

#define Hand_Ch_A (PIND & (1 << 2))
#define Hand_Ch_B (PIND & (1 << 3))

#define Hand_Axis_Read (PINE & B00110000)  // E4,E5
byte Hand_Axis_Old = 0;

#define Hand_Scale_Read (PINJ & B00000011)  // J0,J1
byte Hand_Scale_Old = 0;


//***** Limit Buttons & LEDs *****
#define Limit_Init() \
  DDRA = B10101010; \
  PORTA = B01010101  // IN-A0,A2,A4,A6, OUT-A1,A3,A5,A7, подтяжка

#define Limit_Buttons_Read (PINA & B01010101)  // PA0 Pin22, PA2 Pin24, PA4 Pin26, PA6 Pin28.
byte Limit_Button_Old = 0;

#define Limit_Rear_LED_On() PORTA &= ~(1 << 1)   // PA1, Pin23 0
#define Limit_Rear_LED_Off() PORTA |= (1 << 1)   // PA1, Pin23 1
#define Limit_Front_LED_On() PORTA &= ~(1 << 3)  // PA3, Pin25 0
#define Limit_Front_LED_Off() PORTA |= (1 << 3)  // PA3, Pin25 1
#define Limit_Right_LED_On() PORTA &= ~(1 << 5)  // PA5, Pin27 0
#define Limit_Right_LED_Off() PORTA |= (1 << 5)  // PA5, Pin27 1
#define Limit_Left_LED_On() PORTA &= ~(1 << 7)   // PA7, Pin29 0
#define Limit_Left_LED_Off() PORTA |= (1 << 7)   // PA7, Pin29 1

#define Limit_Pos_Max 2147480000
#define Limit_Pos_Min 1


//////////////////
#define Menu_Buttons_Init() \
  DDRF = B00000000; \
  PORTF = B11111111;

#define Buttons_Read (PINF & B00001111)  // Pin_A0 PF0, Pin_A1 PF1, Pin_A2 PF2, Pin_A3 PF3, Pin_A4 PF4.
byte Button_Old = 0;

#define Button_Sel_Read (PINF & B00010000)  // Pin_A4 PF4
byte Button_Sel_Old = 0;
bool key_sel_flag = false;

//////////////////
#define Joy_Init() \
  DDRK = B00000000; \
  PORTK = B11111111;  // подтяжка PIN_A8, A9, A10, A11, A12 // Submode Sw: A13, A14, A15

#define Joy_Read (PINK & B00001111)      // PK0 PK1 PK2 PK3
#define Button_Rapid (PINK & B00010000)  // PK4
byte Joy_Old = 0;

////////////////////
#define Submode_Read (PINK & B11100000)  // PK5 PK6 PK7
byte Submode_Old = 0;


// ***** Mode *****
#define Mode_Switch_Init() \
  DDRC = B00000000; \
  PORTC = B11111111;  // подтяжка PORT_A, ОБЯЗАТЕЛЬНА! внешняя подтяжка к +5 через 1К резисторы
#define Mode_Read (PINC & B11111111)
byte Mode_Old = 0;


enum Mode {
  Mode_Thread = 1,
  Mode_Feed,
  Mode_aFeed,
  Mode_Cone_L_R,
  Mode_Cone_R,
  Mode_Reserve,
  Mode_Sphere,
  Mode_Divider
};

enum Sub_Mode_Thread {
  Sub_Mode_Thread_Ext = 1,
  Sub_Mode_Thread_Man,
  Sub_Mode_Thread_Int,
};

enum Sub_Mode_Feed {
  Sub_Mode_Feed_Ext = 1,
  Sub_Mode_Feed_Man,
  Sub_Mode_Feed_Int,
};

enum Sub_Mode_aFeed {
  Sub_Mode_aFeed_Ext = 1,
  Sub_Mode_aFeed_Man,
  Sub_Mode_aFeed_Int,
};

enum Sub_Mode_Cone {
  Sub_Mode_Cone_Ext = 1,
  Sub_Mode_Cone_Man,
  Sub_Mode_Cone_Int,
};

enum Sub_Mode_Sphere {
  Sub_Mode_Sphere_Ext = 1,
  Sub_Mode_Sphere_Man,
  Sub_Mode_Sphere_Int,
};

int Mode2_Cone = 1;

//***** Ускоренное перемещение *****
#define Timer2_Init() \
  TCCR2A = (1 << WGM21); \
  TCCR2B = (1 << CS20) | (1 << CS21);  // 16MHz/32 = 500kHz

//***** РГИ перемещение *****
#define Timer3_Init() \
  TCCR3A = 0; \
  TCCR3B = (1 << WGM32) | (1 << CS30) | (1 << CS31);  // 16MHz/32 = 250kHz

// ***** aFeed *****
#define Timer4_Init() \
  TCCR4A = 0; \
  TCCR4B = (1 << WGM42) | (1 << CS40) | (1 << CS41);  // 16MHz/32 = 250kHz

// ***** Feed *****
#define Timer5_Init() \
  TCCR5A = 0; \
  TCCR5B = (1 << WGM52) | (1 << CS52) | (1 << CS51) | (1 << CS50)




// ***** Cone *****

//Формулы для расчета Конусов
#define CONE_AB(x, y) (((SCREW_X * 0.01) / (MOTOR_X_STEP_PER_REV * McSTEP_X) * ((float)y) * 2.0) / ((SCREW_Z * 0.01) / (MOTOR_Z_STEP_PER_REV * McSTEP_Z) * (((float)x) * 0.5)))
#define CONE_DEG(x) (((SCREW_X * 0.01) / (MOTOR_X_STEP_PER_REV * McSTEP_X) * 2.0) / ((SCREW_Z * 0.01) / (MOTOR_Z_STEP_PER_REV * McSTEP_Z) * (tan(((M_PI / 180.0) * x)))))
#define Cs_Div_AB(x, y) (int)(CONE_AB(x, y))
#define Cm_Div_AB(x, y) (int)(10000.0 * (CONE_AB(x, y) - (int)CONE_AB(x, y)))
#define Cs_Div_DEG(x) (int)(CONE_DEG(x))
#define Cm_Div_DEG(x) (int)(10000.0 * (CONE_DEG(x) - (int)CONE_DEG(x)))


struct cone_info_type {
  byte Cs_Div;
  int Cm_Div;
  char Cone_Print[6];
};

const cone_info_type Cone_Info[] = {
  { Cs_Div_DEG(45.0), Cm_Div_DEG(45.0), " 45\5" },
  { Cs_Div_DEG(30.0), Cm_Div_DEG(30.0), " 30\5" },
  { Cs_Div_DEG(15.0), Cm_Div_DEG(15.0), " 15\5" },
  { Cs_Div_DEG(10.0), Cm_Div_DEG(10.0), " 10\5" },
  { Cs_Div_DEG(8.0), Cm_Div_DEG(8.0), "  8\5" },
  { Cs_Div_AB(1.0, 19.212), Cm_Div_AB(1.0, 19.212), " KM0" },
  { Cs_Div_AB(1.0, 20.047), Cm_Div_AB(1.0, 20.047), " KM1" },
  { Cs_Div_AB(1.0, 20.020), Cm_Div_AB(1.0, 20.020), " KM2" },
  { Cs_Div_AB(1.0, 19.922), Cm_Div_AB(1.0, 19.922), " KM3" },
  { Cs_Div_AB(1.0, 19.254), Cm_Div_AB(1.0, 19.254), " KM4" },
  { Cs_Div_AB(1.0, 19.002), Cm_Div_AB(1.0, 19.002), " KM5" },
  { Cs_Div_AB(1.0, 19.180), Cm_Div_AB(1.0, 19.180), " KM6" },
  { Cs_Div_AB(1.0, 4.0), Cm_Div_AB(1.0, 4.0), " 1:4" },
  { Cs_Div_AB(1.0, 5.0), Cm_Div_AB(1.0, 5.0), " 1:5" },
  { Cs_Div_AB(1.0, 7.0), Cm_Div_AB(1.0, 7.0), " 1:7" },
  { Cs_Div_AB(1.0, 10.0), Cm_Div_AB(1.0, 10.0), "1:10" },
  { Cs_Div_AB(1.0, 16.0), Cm_Div_AB(1.0, 16.0), "1:16" },
  { Cs_Div_AB(1.0, 20.0), Cm_Div_AB(1.0, 20.0), "1:20" },
  { Cs_Div_AB(1.0, 24.0), Cm_Div_AB(1.0, 24.0), "1:24" },
  { Cs_Div_AB(1.0, 30.0), Cm_Div_AB(1.0, 30.0), "1:30" },
  { Cs_Div_AB(1.0, 50.0), Cm_Div_AB(1.0, 50.0), "1:50" },
  { Cs_Div_AB(7.0, 24.0), Cm_Div_AB(7.0, 24.0), "7:24" },
  { Cs_Div_AB(7.0, 64.0), Cm_Div_AB(7.0, 64.0), "7:64" },
  { Cs_Div_DEG(60.0), Cm_Div_DEG(60.0), " 60\5" },
  { Cs_Div_DEG(59.0), Cm_Div_DEG(59.0), " 59\5" },
  { Cs_Div_DEG(58.0), Cm_Div_DEG(58.0), " 58\5" },
  { Cs_Div_DEG(57.0), Cm_Div_DEG(57.0), " 57\5" },
  { Cs_Div_DEG(56.0), Cm_Div_DEG(56.0), " 56\5" },
  { Cs_Div_DEG(55.0), Cm_Div_DEG(55.0), " 55\5" },
  { Cs_Div_DEG(54.0), Cm_Div_DEG(54.0), " 54\5" },
  { Cs_Div_DEG(53.0), Cm_Div_DEG(53.0), " 53\5" },
  { Cs_Div_DEG(52.0), Cm_Div_DEG(52.0), " 52\5" },
  { Cs_Div_DEG(51.0), Cm_Div_DEG(51.0), " 51\5" },
  { Cs_Div_DEG(50.0), Cm_Div_DEG(50.0), " 50\5" },
  { Cs_Div_DEG(49.0), Cm_Div_DEG(49.0), " 49\5" },
  { Cs_Div_DEG(48.0), Cm_Div_DEG(48.0), " 48\5" },
  { Cs_Div_DEG(47.0), Cm_Div_DEG(47.0), " 47\5" },
  { Cs_Div_DEG(46.0), Cm_Div_DEG(46.0), " 46\5" },
  { Cs_Div_DEG(45.0), Cm_Div_DEG(45.0), " 45\5" },
  { Cs_Div_DEG(44.0), Cm_Div_DEG(44.0), " 44\5" },
  { Cs_Div_DEG(43.0), Cm_Div_DEG(43.0), " 43\5" },
  { Cs_Div_DEG(42.0), Cm_Div_DEG(42.0), " 42\5" },
  { Cs_Div_DEG(41.0), Cm_Div_DEG(41.0), " 41\5" },
  { Cs_Div_DEG(40.0), Cm_Div_DEG(40.0), " 40\5" },
  { Cs_Div_DEG(39.0), Cm_Div_DEG(39.0), " 39\5" },
  { Cs_Div_DEG(38.0), Cm_Div_DEG(38.0), " 38\5" },
  { Cs_Div_DEG(37.0), Cm_Div_DEG(37.0), " 37\5" },
  { Cs_Div_DEG(36.0), Cm_Div_DEG(36.0), " 36\5" },
  { Cs_Div_DEG(35.0), Cm_Div_DEG(35.0), " 35\5" },
  { Cs_Div_DEG(34.0), Cm_Div_DEG(34.0), " 34\5" },
  { Cs_Div_DEG(33.0), Cm_Div_DEG(33.0), " 33\5" },
  { Cs_Div_DEG(32.0), Cm_Div_DEG(32.0), " 32\5" },
  { Cs_Div_DEG(31.0), Cm_Div_DEG(31.0), " 31\5" },
  { Cs_Div_DEG(30.0), Cm_Div_DEG(30.0), " 30\5" },
  { Cs_Div_DEG(29.0), Cm_Div_DEG(29.0), " 29\5" },
  { Cs_Div_DEG(28.0), Cm_Div_DEG(28.0), " 28\5" },
  { Cs_Div_DEG(27.0), Cm_Div_DEG(27.0), " 27\5" },
  { Cs_Div_DEG(26.0), Cm_Div_DEG(26.0), " 26\5" },
  { Cs_Div_DEG(25.0), Cm_Div_DEG(26.0), " 25\5" },
  { Cs_Div_DEG(24.0), Cm_Div_DEG(24.0), " 24\5" },
  { Cs_Div_DEG(23.0), Cm_Div_DEG(23.0), " 23\5" },
  { Cs_Div_DEG(22.0), Cm_Div_DEG(22.0), " 22\5" },
  { Cs_Div_DEG(21.0), Cm_Div_DEG(21.0), " 21\5" },
  { Cs_Div_DEG(20.0), Cm_Div_DEG(20.0), " 20\5" },
  { Cs_Div_DEG(19.0), Cm_Div_DEG(19.0), " 19\5" },
  { Cs_Div_DEG(18.0), Cm_Div_DEG(18.0), " 18\5" },
  { Cs_Div_DEG(17.0), Cm_Div_DEG(17.0), " 17\5" },
  { Cs_Div_DEG(16.0), Cm_Div_DEG(16.0), " 16\5" },
  { Cs_Div_DEG(15.0), Cm_Div_DEG(15.0), " 15\5" },
  { Cs_Div_DEG(14.0), Cm_Div_DEG(14.0), " 14\5" },
  { Cs_Div_DEG(13.0), Cm_Div_DEG(13.0), " 13\5" },
  { Cs_Div_DEG(12.0), Cm_Div_DEG(12.0), " 12\5" },
  { Cs_Div_DEG(11.0), Cm_Div_DEG(11.0), " 11\5" },
  { Cs_Div_DEG(10.0), Cm_Div_DEG(10.0), " 10\5" },
  { Cs_Div_DEG(9.0), Cm_Div_DEG(9.0), "  9\5" },
  { Cs_Div_DEG(8.0), Cm_Div_DEG(8.0), "  8\5" },
  { Cs_Div_DEG(7.0), Cm_Div_DEG(7.0), "  7\5" },
  { Cs_Div_DEG(6.0), Cm_Div_DEG(6.0), "  6\5" },
  { Cs_Div_DEG(5.0), Cm_Div_DEG(5.0), "  5\5" },
  { Cs_Div_DEG(4.0), Cm_Div_DEG(4.0), "  4\5" },
  { Cs_Div_DEG(3.0), Cm_Div_DEG(3.0), "  3\5" },
  { Cs_Div_DEG(2.0), Cm_Div_DEG(2.0), "  2\5" },
  { Cs_Div_DEG(1.0), Cm_Div_DEG(1.0), "  1\5" },
};

#define TOTAL_CONE (sizeof(Cone_Info) / sizeof(Cone_Info[0]))


struct cone1_info_type {
  byte Cs_Div;
  int Cm_Div;
  char Cone_Print[6];
};

const cone1_info_type Cone1_Info[] = {
  { Cs_Div_DEG(30.0), Cm_Div_DEG(30.0), " 60\5" },
  { Cs_Div_DEG(31.0), Cm_Div_DEG(31.0), " 59\5" },
  { Cs_Div_DEG(32.0), Cm_Div_DEG(32.0), " 58\5" },
  { Cs_Div_DEG(33.0), Cm_Div_DEG(33.0), " 57\5" },
  { Cs_Div_DEG(34.0), Cm_Div_DEG(34.0), " 56\5" },
  { Cs_Div_DEG(35.0), Cm_Div_DEG(35.0), " 55\5" },
  { Cs_Div_DEG(36.0), Cm_Div_DEG(36.0), " 54\5" },
  { Cs_Div_DEG(37.0), Cm_Div_DEG(37.0), " 53\5" },
  { Cs_Div_DEG(38.0), Cm_Div_DEG(38.0), " 52\5" },
  { Cs_Div_DEG(39.0), Cm_Div_DEG(39.0), " 51\5" },
  { Cs_Div_DEG(40.0), Cm_Div_DEG(40.0), " 50\5" },
  { Cs_Div_DEG(41.0), Cm_Div_DEG(41.0), " 49\5" },
  { Cs_Div_DEG(42.0), Cm_Div_DEG(42.0), " 48\5" },
  { Cs_Div_DEG(43.0), Cm_Div_DEG(43.0), " 47\5" },
  { Cs_Div_DEG(44.0), Cm_Div_DEG(44.0), " 46\5" },
  { Cs_Div_DEG(45.0), Cm_Div_DEG(45.0), " 45\5" },
  { Cs_Div_DEG(46.0), Cm_Div_DEG(46.0), " 44\5" },
  { Cs_Div_DEG(47.0), Cm_Div_DEG(47.0), " 43\5" },
  { Cs_Div_DEG(48.0), Cm_Div_DEG(48.0), " 42\5" },
  { Cs_Div_DEG(49.0), Cm_Div_DEG(49.0), " 41\5" },
  { Cs_Div_DEG(50.0), Cm_Div_DEG(50.0), " 40\5" },
  { Cs_Div_DEG(51.0), Cm_Div_DEG(51.0), " 39\5" },
  { Cs_Div_DEG(52.0), Cm_Div_DEG(52.0), " 38\5" },
  { Cs_Div_DEG(53.0), Cm_Div_DEG(53.0), " 37\5" },
  { Cs_Div_DEG(54.0), Cm_Div_DEG(54.0), " 36\5" },
  { Cs_Div_DEG(55.0), Cm_Div_DEG(55.0), " 35\5" },
  { Cs_Div_DEG(56.0), Cm_Div_DEG(56.0), " 34\5" },
  { Cs_Div_DEG(57.0), Cm_Div_DEG(57.0), " 33\5" },
  { Cs_Div_DEG(58.0), Cm_Div_DEG(58.0), " 32\5" },
  { Cs_Div_DEG(59.0), Cm_Div_DEG(59.0), " 31\5" },
  { Cs_Div_DEG(60.0), Cm_Div_DEG(60.0), " 30\5" },
  { Cs_Div_DEG(61.0), Cm_Div_DEG(61.0), " 29\5" },
  { Cs_Div_DEG(62.0), Cm_Div_DEG(62.0), " 28\5" },
  { Cs_Div_DEG(63.0), Cm_Div_DEG(63.0), " 27\5" },
  { Cs_Div_DEG(64.0), Cm_Div_DEG(64.0), " 26\5" },
  { Cs_Div_DEG(65.0), Cm_Div_DEG(65.0), " 25\5" },
  { Cs_Div_DEG(66.0), Cm_Div_DEG(66.0), " 24\5" },
  { Cs_Div_DEG(67.0), Cm_Div_DEG(67.0), " 23\5" },
  { Cs_Div_DEG(68.0), Cm_Div_DEG(68.0), " 22\5" },
  { Cs_Div_DEG(69.0), Cm_Div_DEG(69.0), " 21\5" },
  { Cs_Div_DEG(70.0), Cm_Div_DEG(70.0), " 20\5" },
  { Cs_Div_DEG(71.0), Cm_Div_DEG(71.0), " 19\5" },
  { Cs_Div_DEG(72.0), Cm_Div_DEG(72.0), " 18\5" },
  { Cs_Div_DEG(73.0), Cm_Div_DEG(73.0), " 17\5" },
  { Cs_Div_DEG(74.0), Cm_Div_DEG(74.0), " 16\5" },
  { Cs_Div_DEG(75.0), Cm_Div_DEG(75.0), " 15\5" },
  { Cs_Div_DEG(76.0), Cm_Div_DEG(76.0), " 14\5" },
  { Cs_Div_DEG(77.0), Cm_Div_DEG(77.0), " 13\5" },
  { Cs_Div_DEG(78.0), Cm_Div_DEG(78.0), " 12\5" },
  { Cs_Div_DEG(79.0), Cm_Div_DEG(79.0), " 11\5" },
  { Cs_Div_DEG(80.0), Cm_Div_DEG(80.0), " 10\5" },
  { Cs_Div_DEG(81.0), Cm_Div_DEG(81.0), "  9\5" },
  { Cs_Div_DEG(82.0), Cm_Div_DEG(82.0), "  8\5" },
  { Cs_Div_DEG(83.0), Cm_Div_DEG(83.0), "  7\5" },
  { Cs_Div_DEG(84.0), Cm_Div_DEG(84.0), "  6\5" },
  { Cs_Div_DEG(85.0), Cm_Div_DEG(85.0), "  5\5" },
  { Cs_Div_DEG(86.0), Cm_Div_DEG(86.0), "  4\5" },
  { Cs_Div_DEG(87.0), Cm_Div_DEG(87.0), "  3\5" },
  { Cs_Div_DEG(88.0), Cm_Div_DEG(88.0), "  2\5" },
  { Cs_Div_DEG(89.0), Cm_Div_DEG(89.0), "  1\5" },
};

#define TOTAL_CONE1 (sizeof(Cone1_Info) / sizeof(Cone1_Info[0]))



// ***** Threads *****



//Формулы для расчета Резьб

#define K_Z(x) (ENC_LINE_PER_REV * 200.0 * SCREW_Z / (10000.0 * MOTOR_Z_STEP_PER_REV * McSTEP_Z * (float)x))
#define K_X(x) (ENC_LINE_PER_REV * 200.0 * SCREW_X / (10000.0 * MOTOR_X_STEP_PER_REV * McSTEP_X * (float)x))
#define Ks_Div_Z(x) (int)(K_Z(x))
#define Km_Div_Z(x) (int)(10000.0 * (K_Z(x) - (int)K_Z(x)))
#define Ks_Div_X(x) (int)(K_X(x))
#define Km_Div_X(x) (int)(10000.0 * (K_X(x) - (int)K_X(x)))



struct thread_info_type {
  byte Ks_Div_Z;
  int Km_Div_Z;
  byte Ks_Div_X;
  int Km_Div_X;
  char Thread_Print[7];
  float Step;
  byte Pass;
  char Limit_Print[8];
};
const thread_info_type Thread_Info[] = {
  // метрическая
  { Ks_Div_Z(0.100), Km_Div_Z(0.100), Ks_Div_X(0.100), Km_Div_X(0.100), "0.10", 0.100, 3, "980" },
  { Ks_Div_Z(0.125), Km_Div_Z(0.125), Ks_Div_X(0.125), Km_Div_X(0.125), "0.12", 0.125, 3, "980" },
  { Ks_Div_Z(0.150), Km_Div_Z(0.150), Ks_Div_X(0.150), Km_Div_X(0.150), "0.15", 0.150, 4, "980" },
  { Ks_Div_Z(0.175), Km_Div_Z(0.175), Ks_Div_X(0.175), Km_Div_X(0.175), "0.17", 0.175, 4, "980" },
  { Ks_Div_Z(0.200), Km_Div_Z(0.200), Ks_Div_X(0.200), Km_Div_X(0.200), "0.20", 0.200, 4, "980" },
  { Ks_Div_Z(0.250), Km_Div_Z(0.250), Ks_Div_X(0.250), Km_Div_X(0.250), "0.25", 0.250, 4, "820" },
  { Ks_Div_Z(0.300), Km_Div_Z(0.300), Ks_Div_X(0.300), Km_Div_X(0.300), "0.30", 0.300, 4, "700" },
  { Ks_Div_Z(0.350), Km_Div_Z(0.350), Ks_Div_X(0.350), Km_Div_X(0.350), "0.35", 0.350, 5, "620" },
  { Ks_Div_Z(0.400), Km_Div_Z(0.400), Ks_Div_X(0.400), Km_Div_X(0.400), "0.40", 0.400, 5, "560" },
  { Ks_Div_Z(0.450), Km_Div_Z(0.450), Ks_Div_X(0.450), Km_Div_X(0.450), "0.45", 0.450, 6, "500" },
  { Ks_Div_Z(0.500), Km_Div_Z(0.500), Ks_Div_X(0.500), Km_Div_X(0.500), "0.50", 0.500, 6, "480" },
  { Ks_Div_Z(0.600), Km_Div_Z(0.600), Ks_Div_X(0.600), Km_Div_X(0.600), "0.60", 0.600, 7, "420" },
  { Ks_Div_Z(0.700), Km_Div_Z(0.700), Ks_Div_X(0.700), Km_Div_X(0.700), "0.70", 0.700, 8, "380" },
  { Ks_Div_Z(0.750), Km_Div_Z(0.750), Ks_Div_X(0.750), Km_Div_X(0.750), "0.75", 0.750, 8, "360" },
  { Ks_Div_Z(0.800), Km_Div_Z(0.800), Ks_Div_X(0.800), Km_Div_X(0.800), "0.80", 0.800, 8, "340" },
  { Ks_Div_Z(1.000), Km_Div_Z(1.000), Ks_Div_X(1.000), Km_Div_X(1.000), "1.00", 1.000, 10, "300" },
  { Ks_Div_Z(1.250), Km_Div_Z(1.250), Ks_Div_X(1.250), Km_Div_X(1.250), "1.25", 1.250, 12, "260" },
  { Ks_Div_Z(1.500), Km_Div_Z(1.500), Ks_Div_X(1.500), Km_Div_X(1.500), "1.50", 1.500, 14, "240" },
  { Ks_Div_Z(1.750), Km_Div_Z(1.750), Ks_Div_X(1.750), Km_Div_X(1.750), "1.75", 1.750, 16, "220" },
  { Ks_Div_Z(2.000), Km_Div_Z(2.000), Ks_Div_X(2.000), Km_Div_X(2.000), "2.00", 2.000, 18, "220" },
  { Ks_Div_Z(2.500), Km_Div_Z(2.500), Ks_Div_X(2.500), Km_Div_X(2.500), "2.50", 2.500, 22, "200" },
  { Ks_Div_Z(3.000), Km_Div_Z(3.000), Ks_Div_X(3.000), Km_Div_X(3.000), "3.00", 3.000, 26, "180" },
  { Ks_Div_Z(3.500), Km_Div_Z(3.500), Ks_Div_X(3.500), Km_Div_X(3.500), "3.50", 3.000, 30, "180" },
  { Ks_Div_Z(4.000), Km_Div_Z(4.000), Ks_Div_X(4.000), Km_Div_X(4.000), "4.00", 4.000, 34, "180" },
  { Ks_Div_Z(5.000), Km_Div_Z(5.000), Ks_Div_X(5.000), Km_Div_X(5.000), "5.00", 5.000, 42, "150" },
  // дюймовая
  { Ks_Div_Z(25.4 / 80.0), Km_Div_Z(25.4 / 80.0), Ks_Div_X(25.4 / 80.0), Km_Div_X(25.4 / 80.0), " 80", 0.318, 5, "660" },
  { Ks_Div_Z(25.4 / 72.0), Km_Div_Z(25.4 / 72.0), Ks_Div_X(25.4 / 72.0), Km_Div_X(25.4 / 72.0), " 72", 0.353, 5, "620" },
  { Ks_Div_Z(25.4 / 64.0), Km_Div_Z(25.4 / 64.0), Ks_Div_X(25.4 / 64.0), Km_Div_X(25.4 / 64.0), " 64", 0.397, 5, "560" },
  { Ks_Div_Z(25.4 / 60.0), Km_Div_Z(25.4 / 60.0), Ks_Div_X(25.4 / 60.0), Km_Div_X(25.4 / 60.0), " 60", 0.423, 5, "540" },
  { Ks_Div_Z(25.4 / 56.0), Km_Div_Z(25.4 / 56.0), Ks_Div_X(25.4 / 56.0), Km_Div_X(25.4 / 56.0), " 56", 0.454, 6, "500" },
  { Ks_Div_Z(25.4 / 48.0), Km_Div_Z(25.4 / 48.0), Ks_Div_X(25.4 / 48.0), Km_Div_X(25.4 / 48.0), " 48", 0.529, 6, "460" },
  { Ks_Div_Z(25.4 / 44.0), Km_Div_Z(25.4 / 44.0), Ks_Div_X(25.4 / 44.0), Km_Div_X(25.4 / 44.0), " 44", 0.577, 7, "420" },
  { Ks_Div_Z(25.4 / 40.0), Km_Div_Z(25.4 / 40.0), Ks_Div_X(25.4 / 40.0), Km_Div_X(25.4 / 40.0), " 40", 0.635, 7, "400" },
  { Ks_Div_Z(25.4 / 36.0), Km_Div_Z(25.4 / 36.0), Ks_Div_X(25.4 / 36.0), Km_Div_X(25.4 / 36.0), " 36", 0.706, 8, "380" },
  { Ks_Div_Z(25.4 / 32.0), Km_Div_Z(25.4 / 32.0), Ks_Div_X(25.4 / 32.0), Km_Div_X(25.4 / 32.0), " 32", 0.794, 8, "340" },
  { Ks_Div_Z(25.4 / 28.0), Km_Div_Z(25.4 / 28.0), Ks_Div_X(25.4 / 28.0), Km_Div_X(25.4 / 28.0), " 28", 0.907, 9, "320" },
  { Ks_Div_Z(25.4 / 27.0), Km_Div_Z(25.4 / 27.0), Ks_Div_X(25.4 / 27.0), Km_Div_X(25.4 / 27.0), " 27", 0.941, 10, "320" },
  { Ks_Div_Z(25.4 / 26.0), Km_Div_Z(25.4 / 26.0), Ks_Div_X(25.4 / 26.0), Km_Div_X(25.4 / 26.0), " 26", 0.977, 10, "300" },
  { Ks_Div_Z(25.4 / 24.0), Km_Div_Z(25.4 / 24.0), Ks_Div_X(25.4 / 24.0), Km_Div_X(25.4 / 24.0), " 24", 1.580, 10, "300" },
  { Ks_Div_Z(25.4 / 22.0), Km_Div_Z(25.4 / 22.0), Ks_Div_X(25.4 / 22.0), Km_Div_X(25.4 / 22.0), " 22", 1.155, 11, "280" },
  { Ks_Div_Z(25.4 / 20.0), Km_Div_Z(25.4 / 20.0), Ks_Div_X(25.4 / 20.0), Km_Div_X(25.4 / 20.0), " 20", 1.270, 12, "260" },
  { Ks_Div_Z(25.4 / 19.0), Km_Div_Z(25.4 / 19.0), Ks_Div_X(25.4 / 19.0), Km_Div_X(25.4 / 19.0), " 19", 1.337, 13, "260" },
  { Ks_Div_Z(25.4 / 18.0), Km_Div_Z(25.4 / 18.0), Ks_Div_X(25.4 / 18.0), Km_Div_X(25.4 / 18.0), " 18", 1.411, 13, "260" },
  { Ks_Div_Z(25.4 / 16.0), Km_Div_Z(25.4 / 16.0), Ks_Div_X(25.4 / 16.0), Km_Div_X(25.4 / 16.0), " 16", 1.588, 15, "240" },
  { Ks_Div_Z(25.4 / 14.0), Km_Div_Z(25.4 / 14.0), Ks_Div_X(25.4 / 14.0), Km_Div_X(25.4 / 14.0), " 14", 1.814, 17, "220" },
  { Ks_Div_Z(25.4 / 13.0), Km_Div_Z(25.4 / 13.0), Ks_Div_X(25.4 / 13.0), Km_Div_X(25.4 / 13.0), " 13", 1.954, 18, "220" },
  { Ks_Div_Z(25.4 / 12.0), Km_Div_Z(25.4 / 12.0), Ks_Div_X(25.4 / 12.0), Km_Div_X(25.4 / 12.0), " 12", 2.117, 19, "220" },
  { Ks_Div_Z(25.4 / 11.0), Km_Div_Z(25.4 / 11.0), Ks_Div_X(25.4 / 11.0), Km_Div_X(25.4 / 11.0), " 11", 2.309, 20, "200" },
  { Ks_Div_Z(25.4 / 10.0), Km_Div_Z(25.4 / 10.0), Ks_Div_X(25.4 / 10.0), Km_Div_X(25.4 / 10.0), " 10", 2.540, 22, "200" },
  { Ks_Div_Z(25.4 / 9.0), Km_Div_Z(25.4 / 9.0), Ks_Div_X(25.4 / 9.0), Km_Div_X(25.4 / 9.0), "  9", 2.822, 25, "200" },
  { Ks_Div_Z(25.4 / 8.0), Km_Div_Z(25.4 / 8.0), Ks_Div_X(25.4 / 8.0), Km_Div_X(25.4 / 8.0), "  8", 3.175, 27, "180" },
  { Ks_Div_Z(25.4 / 7.0), Km_Div_Z(25.4 / 7.0), Ks_Div_X(25.4 / 7.0), Km_Div_X(25.4 / 7.0), "  7", 3.629, 31, "180" },
  { Ks_Div_Z(25.4 / 6.0), Km_Div_Z(25.4 / 6.0), Ks_Div_X(25.4 / 6.0), Km_Div_X(25.4 / 6.0), "  6", 4.233, 36, "180" },
};
#define TOTAL_THREADS (sizeof(Thread_Info) / sizeof(Thread_Info[0]))
//#define PASS_FINISH   3 // THRD_PS_FN ???

#define Thrd_Accel_Err Thread_Info[0].Ks_Div_Z  // неверно задано ускорение
//static_assert(Thrd_Accel_Err + THRD_ACCEL <= 255, "Неверно задано значение THRD_ACCEL");


// ***** Interrupts *****
#define INT0_Init() EICRA |= (1 << ISC00)
#define INT2_Init() EICRA |= (1 << ISC20)
#define Enable_INT0() EIMSK |= (1 << INT0)
#define Disable_INT0() EIMSK &= ~(1 << INT0)

#define Ena_INT_Hcoder() \
  do { \
    EIFR = (1 << INTF2); \
    EIMSK |= (1 << INT2); \
  } while (0)
#define Disa_INT_Hcoder() EIMSK &= ~(1 << INT2)

#define Enable_INT_OCR2A() \
  do { \
    TCNT2 = 0; \
    TIFR2 = (1 << OCF2A); \
    TIMSK2 = (1 << OCIE2A); \
  } while (0)
#define Disable_INT_OCR2A() TIMSK2 &= ~(1 << OCIE2A)

#define Enable_INT_OCR2B() \
  do { \
    TCNT2 = 0; \
    TIFR2 = (1 << OCF2B); \
    TIMSK2 = (1 << OCIE2B); \
  } while (0)
#define Disable_INT_OCR2B() TIMSK2 &= ~(1 << OCIE2B)

#define Enable_INT_OCR3A() \
  do { \
    TCNT3 = 0; \
    TIFR3 = (1 << OCF3A); \
    TIMSK3 = (1 << OCIE3A); \
  } while (0)
#define Disable_INT_OCR3A() TIMSK3 &= ~(1 << OCIE3A)

#define Enable_INT_OCR3B() \
  do { \
    TCNT3 = 0; \
    TIFR3 = (1 << OCF3B); \
    TIMSK3 = (1 << OCIE3B); \
  } while (0)
#define Disable_INT_OCR3B() TIMSK3 &= ~(1 << OCIE3B)

#define Enable_INT_OCR4A() \
  do { \
    TCNT4 = 0; \
    TIFR4 = (1 << OCF4A); \
    TIMSK4 = (1 << OCIE4A); \
  } while (0)
#define Disable_INT_OCR4A() TIMSK4 &= ~(1 << OCIE4A)

#define Enable_INT_OCR4B() \
  do { \
    TCNT4 = 0; \
    TIFR4 = (1 << OCF4B); \
    TIMSK4 = (1 << OCIE4B); \
  } while (0)
#define Disable_INT_OCR4B() TIMSK4 &= ~(1 << OCIE4B)

#define Enable_INT_OCR5A() \
  do { \
    TCNT5 = 0; \
    TIFR5 = (1 << OCF5A); \
    TIMSK5 = (1 << OCIE5A); \
  } while (0)
#define Disable_INT_OCR5A() TIMSK5 &= ~(1 << OCIE5A)

#define Enable_INT_OCR5B() \
  do { \
    TCNT5 = 0; \
    TIFR5 = (1 << OCF5B); \
    TIMSK5 = (1 << OCIE5B); \
  } while (0)
#define Disable_INT_OCR5B() TIMSK5 &= ~(1 << OCIE5B)

////////////////////////////////////////////////////////////
#define Ena_INT_Thrd() \
  do { \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Enable_INT0(); \
  } while (0)

#define Ena_INT_Z_Feed() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5B(); \
    Enable_INT_OCR5A(); \
  } while (0)

#define Ena_INT_Z_aFeed() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Enable_INT_OCR4A(); \
  } while (0)

#define Ena_INT_X_Feed() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Enable_INT_OCR5B(); \
  } while (0)

#define Ena_INT_X_aFeed() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Enable_INT_OCR4B(); \
  } while (0)

#define Ena_INT_aFD() \
  do { \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Enable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Disable_INT0(); \
  } while (0)

#define Ena_INT_Z_Rapid() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2B(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Enable_INT_OCR2A(); \
  } while (0)

#define Ena_INT_X_Rapid() \
  do { \
    Disable_INT0(); \
    Disable_INT_OCR2A(); \
    Disable_INT_OCR4A(); \
    Disable_INT_OCR4B(); \
    Disable_INT_OCR5A(); \
    Disable_INT_OCR5B(); \
    Enable_INT_OCR2B(); \
  } while (0)


// ***** My Flags *****
typedef struct
{
  uint8_t bit0 : 1;
  uint8_t bit1 : 1;
  uint8_t bit2 : 1;
  uint8_t bit3 : 1;
  uint8_t bit4 : 1;
  uint8_t bit5 : 1;
  uint8_t bit6 : 1;
  uint8_t bit7 : 1;
} FLAG;
#define Spindle_Dir ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit0  // CW-0, CCW-1
#define Motor_Z_Dir ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit1  // CW-0, CCW-1
#define Joy_Z_flag ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit2   // On-1, Off-0
#define Step_Z_flag ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit3  // On-1, Off-0
#define Motor_X_Dir ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit4  // CW-0, CCW-1
#define Joy_X_flag ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit5   // On-1, Off-0
#define Step_X_flag ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit6  // On-1, Off-0
#define Cone_flag ((volatile FLAG*)_SFR_MEM_ADDR(GPIOR0))->bit7    // On-1, Off-0

bool spindle_flag = OFF;
bool feed_Z_flag = OFF;
bool feed_X_flag = OFF;

bool rapid_step_Z_flag = OFF;
bool rapid_step_X_flag = OFF;
bool rapid_Z_flag = OFF;
bool rapid_X_flag = OFF;

bool limit_Left_flag = OFF;
bool limit_Right_flag = OFF;
bool limit_Front_flag = OFF;
bool limit_Rear_flag = OFF;

bool limit_button_flag = OFF;
bool button_up_flag = OFF;
bool button_down_flag = OFF;
bool button_left_flag = OFF;
bool button_right_flag = OFF;

bool a_flag = false;
bool b_flag = false;
bool c_flag = false;
bool d_flag = false;
bool cycle_flag = false;

bool err_1_flag = false;
bool err_2_flag = false;
bool err_3_flag = false;
bool Complete_flag = false;

bool hand_X = OFF;
bool hand_Z = OFF;
bool flag_hand_X = OFF;
bool flag_hand_Z = OFF;
bool X_flag = OFF;          // временный
bool Z_flag = OFF;          // временный
bool flag_Scale_x1 = OFF;   // возможно только для отладки
bool flag_Scale_x10 = OFF;  // возможно только для отладки
bool control_flag = OFF;
bool flag_j = OFF;

// ***** MY VARIABLES *****
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;

int Tacho_Count = 0;
int Tacho_Count_Old = 0;
int Spindle_Count = 0;
long Motor_Z_Pos = 1073740000;
long Motor_X_Pos = 1073740000;

int pin = 20;
float duration = 0;
unsigned long Timeout = 72000;
unsigned long timer;
byte KeyCycle = 0;
int q = 0;
int w = 0;
int Pass_Fin = 0;
int Thr_Pass_Summ = 0;
int SelectMenu = 0;
uint8_t SelectMenu_aFeed = 1;
uint8_t SelectMenu_Reserve = 1;
uint8_t Menu_Reserve_String = 1;
uint8_t SetupError = 0;
unsigned long RPM = 0;
unsigned long Freq = 0;
float Infeed_ValueX = 0;
float Infeed_ValueZ = 0;
long Size_X = 0;
long Size_Z = 0;
long X_pos = 0;
long Z_pos = 0;

int Enc_Pos = 0;
volatile long Hand_Count = 0;
long Hand_Count_Old = 0;
long Hand_Count_New = 0;
long Hand_Z_Pos = 0;
long Hand_X_Pos = 0;

byte Scale = HC_SCALE_1;

byte Ks_Count = 0;
int Km_Count = 0;
byte Ks_Divisor = 0;
byte tmp_Ks_Divisor = THRD_ACCEL;
int Km_Divisor = 0;
uint16_t Feed_Divisor = 0;
uint16_t aFeed_Divisor = 0;

byte Cs_Count = 0;
int Cm_Count = 0;
byte Cs_Divisor = 0;
int Cm_Divisor = 0;

byte tmp_Accel = THRD_ACCEL;
byte Repeat_Count = 0;

int Brake_Compens = 0;

byte Mode = Mode_Feed;
byte Sub_Mode_Thread = Sub_Mode_Thread_Man;
byte Sub_Mode_Feed = Sub_Mode_Feed_Man;
byte Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
byte Sub_Mode_Cone = Sub_Mode_Cone_Man;
byte Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
byte Thread_Step = 11;
byte Cone_Step = 1;

long Limit_Pos_Left = Limit_Pos_Max;
long Limit_Pos_Right = Limit_Pos_Min;
long Limit_Pos_Front = Limit_Pos_Max;
long Limit_Pos_Rear = Limit_Pos_Min;
volatile long Limit_Pos = 0;
volatile long Limit_Pos_HC = 0;

uint16_t Feed_mm = 0;
uint16_t aFeed_mm = 0;

uint16_t Start_Speed = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL;
uint16_t max_OCR5A = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL;  // Начальная скорость подачи при разгоне/торможении
uint16_t max_OCR4A = (250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1) / FEED_ACCEL;

byte Total_Tooth = 1;
byte Current_Tooth = 1;

//byte Pass_Total = 1;
uint16_t Pass_Total = 1;
//byte Pass_Nr = 1; заменил на int Pass_Nr = 1; добавил ниже строку
//int Pass_Nr = 1;
uint16_t Pass_Nr = 1;
long Size_X_mm = 0;
long Size_Z_mm = 0;
long Null_X_Pos = 0;
long Null_Z_Pos = 0;
int Ap = 0;

int ADC_Feed = 0;
long Sum_ADC = 0;
int ADC_Array[16];
byte x = 0;

long Control_Count = 0;


// Sphere
const int Cutter_Width_array[] = { 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300 };
#define TOTAL_CUTTER_WIDTH (sizeof(Cutter_Width_array) / sizeof(Cutter_Width_array[0]))
byte Cutter_Step = 5;
int Cutter_Width = Cutter_Width_array[Cutter_Step];

const int Cutting_Width_array[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
#define TOTAL_CUTTING_STEP (sizeof(Cutting_Width_array) / sizeof(Cutting_Width_array[0]))
byte Cutting_Step = 4;
int Cutting_Width = Cutting_Width_array[Cutting_Step];

long Sph_R_mm = 1000;
long Sph_R = 0;
long R_Quad = Sph_R_mm * Sph_R_mm;
long Bar_R_mm = 0;
long Bar_R = 0;

#define KEYB_TIMER_FLAG (TIFR1 & (1 << OCF1A))
#define CLEAR_KEYB_TIMER \
  do { \
    TCNT1 = 0; \
    (TIFR1 |= (1 << OCF1A)); \
  } while (0)

uint16_t max_OCR3A = HC_START_SPEED_1;
uint16_t min_OCR3A = HC_MAX_SPEED_1;



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  ResetSetupParam();

  //-------- ОТЛАДОЧНАЯ ИНФОРМАЦИЯ ДЛЯ ВЫВОДА В "МОНИТОР ПОРТА" КОЭФФИЦИЕНТОВ РАССЧИТАННЫХ ПО ФОРМУЛЕ ИЗ ФАЙЛА Formula.h    ------------
#ifdef DEBUG_PRINT_THREAD_and_CONE
  //Активируем COM-порт
  Serial.begin(9600);
  //Печатаем исходные переменные на основе которых быдет выполняться расчёт
  Serial.print("ENC_LINE_PER_REV=");
  Serial.print(ENC_LINE_PER_REV);
  Serial.print("\n");  // Кол-во линий энкодера на 1 оборот шпинделя
  Serial.print("MOTOR_Z_STEP_PER_REV=");
  Serial.print(MOTOR_Z_STEP_PER_REV);
  Serial.print("\n");  // Кол-во шагов на оборот винта Z, продольная
  Serial.print("SCREW_Z=");
  Serial.print(SCREW_Z);
  Serial.print("\n");  // Шаг продольного винта Z в сотках, 1.5мм
  Serial.print("McSTEP_Z=");
  Serial.print(McSTEP_Z);
  Serial.print("\n");  // Микрошаг, ось Z, продольная
  Serial.print("MOTOR_X_STEP_PER_REV=");
  Serial.print(MOTOR_X_STEP_PER_REV);
  Serial.print("\n");  // Кол-во шагов на оборот винта X, поперечная
  Serial.print("SCREW_X=");
  Serial.print(SCREW_X);
  Serial.print("\n");  // Шаг поперечного винта X в сотках, 1.0мм
  Serial.print("McSTEP_X=");
  Serial.print(McSTEP_X);
  Serial.print("\n");  // Микрошаг, ось X, поперечная
  Serial.print("MIN_FEED=");
  Serial.print(MIN_FEED);
  Serial.print("\n");
  Serial.print("MAX_FEED=");
  Serial.print(MAX_FEED);
  Serial.print("\n");
  Serial.print("MIN_aFEED=");
  Serial.print(MIN_aFEED);
  Serial.print("\n");
  Serial.print("MAX_aFEED=");
  Serial.print(MAX_aFEED);
  Serial.print("\n");

  //Печатаем резьбы
  Serial.print("\nTHREAD Thread_Info:\n");
  for (int i = 0; i < TOTAL_THREADS; i++) {
    String Str = String(Thread_Info[i].Step) + " Kz = " + Thread_Info[i].Ks_Div_Z + "," + Thread_Info[i].Km_Div_Z
                 + " Kx = " + Thread_Info[i].Ks_Div_X + "," + Thread_Info[i].Km_Div_X + "  " + Thread_Info[i].Thread_Print
                 + "  " + Thread_Info[i].Pass + "  " + Thread_Info[i].Limit_Print + "\n";
    //String Str = String(Thread_Info[i].Step) +

    Serial.print(Str);
  }

  //Печатаем Конуса
   Serial.print("\n\nCONE Cone_Info[]:\n");
  for (int j = 0; j < TOTAL_CONE; j++) {
    Serial.print(j);
    Serial.print(" Cs_Div= ");
    Serial.print(Cone_Info[j].Cs_Div);
    Serial.print(" , Cm_Div= ");
    Serial.print(Cone_Info[j].Cm_Div);
    Serial.print("  ");
    Serial.print(Cone_Info[j].Cone_Print);
    Serial.print("\n");
  }

  Serial.print("\n\nCONE Cone1_Info[]:\n");
  for (int j = 0; j < TOTAL_CONE1; j++) {
    Serial.print(j);
    Serial.print(" Cs_Div= ");
    Serial.print(Cone1_Info[j].Cs_Div);
    Serial.print(" , Cm_Div= ");
    Serial.print(Cone1_Info[j].Cm_Div);
    Serial.print("  ");
    Serial.print(Cone1_Info[j].Cone_Print);
    Serial.print("\n");
  }

#endif


  lcd.begin(20, 4);
  lcd.setCursor(1, 1);
  lcd.print("                    ");
  lcd.setCursor(1, 3);
  lcd.print("          v. 7e2    ");  //версия 7e2
  _delay_ms(500);
  DDRG = B11111111;

  lcd.createChar(1, strelka_vlevo);
  lcd.createChar(2, strelka_vpravo);
  lcd.createChar(3, strelka_vverh);
  lcd.createChar(4, strelka_vniz);
  lcd.createChar(5, znak_gradus);
  lcd.createChar(6, znak_diametr);


  TIMSK0 = 0;
  // ***** Timer0 ***** // ***** Тахометр *****
  //  TCCR0A = (1<<COM0B0)|(1<<WGM01); // Toggle OC0B on Compare Match // CTC Mode2
  //  TCCR0B = (1<<CS00);     // No Prescaler
  //  OCR0A = 89; // 1800/10(выходных пульсов)/2-1 = 89
  //  TIMSK0 = (1<<OCIE0B);

  Encoder_Init();
  Hand_Init();
  Motor_Init();

  INT0_Init();
  INT2_Init();

  Timer2_Init();
  OCR2A = MIN_RAPID_MOTION;

  Timer3_Init();
  OCR3A = max_OCR3A;

  Timer4_Init();
  OCR4A = max_OCR4A;

  Timer5_Init();
  OCR5A = max_OCR5A;

  Ena_INT_Z_Feed();

  Limit_Init();
  Limit_Left_LED_Off();
  Limit_Right_LED_Off();
  Limit_Front_LED_Off();
  Limit_Rear_LED_Off();
  Menu_Buttons_Init();
  Joy_Init();
  Mode_Switch_Init();

  Beeper_Init();
  Beeper_Off();

  Spindle_Dir = CW;
  Motor_Z_Dir = CW;
  Joy_Z_flag = OFF;
  Step_Z_flag = OFF;
  Motor_X_Dir = CW;
  Joy_X_flag = OFF;
  Step_X_flag = OFF;

  TCCR1A = 0;
  TCCR1B = 0
           | (0 << ICNC1) | (0 << ICES1)
           | (0 << WGM13) | (1 << WGM12)
           | (1 << CS12) | (0 << CS11) | (1 << CS10);
  OCR1A = 625;

  Motor_Z_RemovePulse();
  Motor_X_RemovePulse();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  Spindle();

  if ((Mode == Mode_Reserve && SelectMenu_Reserve == 2) || (Mode == Mode_aFeed && SelectMenu_aFeed == 2)) {
    Size_X_mm = Motor_X_Pos / ((float)MOTOR_X_STEP_PER_REV / SCREW_X * McSTEP_X);
    Size_Z_mm = Motor_Z_Pos / ((float)MOTOR_Z_STEP_PER_REV / SCREW_Z * McSTEP_Z);
  }



  if (Mode == Mode_Reserve && SelectMenu_Reserve == 1) {
    Freq = ENC_LINE_PER_REV / (float)duration * Th;

    {
      duration = pulseIn(pin, HIGH, Timeout);
      if (timer >= 10) {
        timer = 0;
        RPM = Freq * 60 / 10000;
      }
    }
  }

  {
    Read_ADC_Feed();
    if (KEYB_TIMER_FLAG != 0) Menu();

    if (Mode == Mode_Divider) Print();  // пока для теста !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  }                                     //  Print();                         // тоько для теста !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}



void CheckingParameters() {

  // SetupError = 0;
  //uint32_t aa;

  a = (uint32_t)(ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / 2 + 0.5);
  b = (uint32_t)(ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MAX_FEED / SCREW_Z) / 2 + 0.5);
  c = 250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
  d = 250000 / ((uint32_t)MAX_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
  e = (uint32_t)(ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / 2 + 0.5);
  f = (uint32_t)(ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MAX_FEED / SCREW_X) / 2 + 0.5);
  g = 250000 / ((uint32_t)MIN_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;
  h = 250000 / ((uint32_t)MAX_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;

  //aa=(uint32_t)(ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / 2 + 0.5);
  //static_assert(aa <= 255, "Неверно задано значение MIN_FEED");
  SetupError = 2;

  //if (a <= 255) SetupError = 1;  //"Неверно задано значение MIN_FEED"
  //static_assert(a <= 255, "Неверно задано значение MIN_FEED");
  //int b;
  //else
  // if (b > 1) SetupError = 2;  //"Неверно задано значение MAX_FEED"
  //   //static_assert(b > 1, "Неверно задано значение MAX_FEED");
  //   //int c;
  // else if (c <= 65535) SetupError = 3;  //"Неверно задано значение MIN_aFEED"
  //   //static_assert(c <= 65535, "Неверно задано значение MIN_aFEED");
  //   //int d;
  // else if (d > 1) SetupError = 4;  //"Неверно задано значение MAX_aFEED"
  //   //static_assert(d > 1, "Неверно задано значение MAX_aFEED");

  // //int e;
  // else if (e <= 255) SetupError = 1;  //"Неверно задано значение MIN_FEED"
  // //static_assert(e <= 255, "Неверно задано значение MIN_FEED");
  // //int f;
  // else if (f > 1) SetupError = 2;  //"Неверно задано значение MAX_FEED"
  // //static_assert(f > 1, "Неверно задано значение MAX_FEED");
  // //int g;
  // else if (g <= 65535) SetupError = 3;  //"Неверно задано значение MIN_aFEED"
  // //static_assert(g <= 65535, "Неверно задано значение MIN_aFEED");
  // //int h;
  // else if (h > 1) SetupError = 4;  //"Неверно задано значение MAX_aFEED"
  //static_assert(h > 1, "Неверно задано значение MAX_aFEED");

  //Print();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// *****  Thread ***** ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(INT0_vect) {
  TachoRemovePulse();

  if (!Enc_Ch_A) {
    if (!Enc_Ch_B) {
      Spindle_Dir = CW;
      if (++Enc_Pos == ENC_TICK) {
        Enc_Pos = 0;
        TachoSetPulse();
        Rev_Count++;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    } else {
      Spindle_Dir = CCW;
      if (--Enc_Pos < 0) {
        Enc_Pos = ENC_TICK - 1;
        TachoSetPulse();
        Rev_Count--;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    }
  }

  else {
    if (!Enc_Ch_B) {
      Spindle_Dir = CCW;
      if (--Enc_Pos < 0) {
        Enc_Pos = ENC_TICK - 1;
        TachoSetPulse();
        Rev_Count--;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    } else {
      Spindle_Dir = CW;
      if (++Enc_Pos == ENC_TICK) {
        Enc_Pos = 0;
        TachoSetPulse();
        Rev_Count++;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    }
  }

  if (Step_Z_flag == ON) {
    Motor_Z_RemovePulse();
    if ((Motor_Z_Dir == CW && Motor_Z_Pos > Limit_Pos) || (Motor_Z_Dir == CCW && Motor_Z_Pos < Limit_Pos) || (!Joy_Z_flag)) {
      if (tmp_Ks_Divisor < tmp_Accel) {
        Ks_Count++;
        if (Ks_Count > tmp_Ks_Divisor) {
          Motor_Z_SetPulse();
          if (Motor_Z_Dir == CW) {
            Motor_Z_Pos++;
          } else {
            Motor_Z_Pos--;
          }
          Ks_Count = 0;
          if (++Repeat_Count == REPEAt) {
            Repeat_Count = 0;
            tmp_Ks_Divisor++;
          }
        }
      } else {
        Step_Z_flag = OFF;
      }
    }

    else {
      Ks_Count++;
      if (Ks_Count > tmp_Ks_Divisor) {
        Motor_Z_SetPulse();
        if (Motor_Z_Dir == CW) {
          Motor_Z_Pos++;
        } else {
          Motor_Z_Pos--;
        }

        if (tmp_Ks_Divisor > Ks_Divisor) {
          Ks_Count = 0;
          if (++Repeat_Count == REPEAt) {
            Repeat_Count = 0;
            tmp_Ks_Divisor--;
          }
        } else {
          Km_Count = Km_Count + Km_Divisor;
          if (Km_Count > Km_Divisor) {
            Km_Count = Km_Count - 10000;
            Ks_Count = 0;
          } else {
            Ks_Count = 1;
          }
        }
      }
    }
  }

  if (Step_X_flag == ON) {
    Motor_X_RemovePulse();
    if ((Motor_X_Dir == CW && Motor_X_Pos > Limit_Pos) || (Motor_X_Dir == CCW && Motor_X_Pos < Limit_Pos) || (!Joy_X_flag)) {
      if (tmp_Ks_Divisor < tmp_Accel) {
        Ks_Count++;
        if (Ks_Count > tmp_Ks_Divisor) {
          Motor_X_SetPulse();
          if (Motor_X_Dir == CW) {
            Motor_X_Pos++;
          } else {
            Motor_X_Pos--;
          }
          Ks_Count = 0;
          if (++Repeat_Count == REPEAt) {
            Repeat_Count = 0;
            tmp_Ks_Divisor++;
          }
        }
      } else {
        Step_X_flag = OFF;
      }
    }

    else {
      Ks_Count++;
      if (Ks_Count > tmp_Ks_Divisor) {
        Motor_X_SetPulse();
        if (Motor_X_Dir == CW) {
          Motor_X_Pos++;
        } else {
          Motor_X_Pos--;
        }

        if (tmp_Ks_Divisor > Ks_Divisor) {
          Ks_Count = 0;
          if (++Repeat_Count == REPEAt) {
            Repeat_Count = 0;
            tmp_Ks_Divisor--;
          }
        } else {
          Km_Count = Km_Count + Km_Divisor;
          if (Km_Count > Km_Divisor) {
            Km_Count = Km_Count - 10000;
            Ks_Count = 0;
          } else {
            Ks_Count = 1;
          }
        }
      }
    }
  }
}


ISR(INT1_vect) {
  //
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// *****  Tacho ***** ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER0_COMPB_vect)  // Тахометр
{
  //
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// *****  Feed & Cone ***** //////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER5_COMPA_vect) {
  if (!Enc_Ch_A) {
    if (!Enc_Ch_B) {
      Spindle_Dir = CW;
      if (++Enc_Pos == ENC_TICK) {
        Enc_Pos = 0;
        TachoSetPulse();
        Rev_Count_F++;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    } else {
      Spindle_Dir = CCW;
      if (--Enc_Pos < 0) {
        Enc_Pos = ENC_TICK - 1;
        TachoSetPulse();
        Rev_Count_F--;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    }
  }

  else {
    if (!Enc_Ch_B) {
      Spindle_Dir = CCW;
      if (--Enc_Pos < 0) {
        Enc_Pos = ENC_TICK - 1;
        TachoSetPulse();

        Rev_Count_F--;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    } else {
      Spindle_Dir = CW;
      if (++Enc_Pos == ENC_TICK) {
        Enc_Pos = 0;
        Rev_Count_F++;
        if (Joy_Z_flag == ON) {
          Step_Z_flag = ON;
        } else if (Joy_X_flag == ON) {
          Step_X_flag = ON;
        }
      }
    }
  }
  if (Joy_Z_flag == ON) { Motor_X_RemovePulse(); }
  TachoRemovePulse();
  Tacho_Count = Tacho_Count + (OCR5A + 1);
  if (Tacho_Count > ENC_LINE_PER_REV) {
    TachoSetPulse();
    if (Spindle_Dir == CW) {
      Rev_Count_F++;
    } else if (Spindle_Dir == CCW) {
      Rev_Count_F--;
    }
    Tacho_Count = Tacho_Count - ENC_LINE_PER_REV;
  }

  if ((Motor_Z_Dir == CW && Motor_Z_Pos > Limit_Pos) || (Motor_Z_Dir == CCW && Motor_Z_Pos < Limit_Pos) || (!feed_Z_flag)) {
    if (OCR5A < max_OCR5A) {
      Motor_Z_InvertPulse();
      if (!Read_Z_State) {
        OCR5A++;
        if (Motor_Z_Dir == CW) {
          Motor_Z_Pos++;
        } else {
          Motor_Z_Pos--;
        }
      }
    } else {
      Step_Z_flag = OFF;
      Step_X_flag = OFF;
    }
  }

  else {
    Step_Z_flag = ON;
    Motor_Z_InvertPulse();
    if (!Read_Z_State) {
      if (Motor_Z_Dir == CW) {
        Motor_Z_Pos++;
      } else {
        Motor_Z_Pos--;
      }

      if (OCR5A > Feed_Divisor) {
        OCR5A--;
      } else if (OCR5A < Feed_Divisor) {
        OCR5A++;
      }
    }
  }

  if (Step_X_flag == ON) {
    if (++Cs_Count > Cs_Divisor) {
      Motor_X_SetPulse();

      if (Motor_X_Dir == CW) {
        Motor_X_Pos++;
      } else {
        Motor_X_Pos--;
      }

      Cm_Count = Cm_Count + Cm_Divisor;
      if (Cm_Count > Cm_Divisor) {
        Cm_Count = Cm_Count - 10000;
        Cs_Count = 0;
      } else {
        Cs_Count = 1;
      }
    }
  }
}

////////////////////////////////////////////////////////////
ISR(TIMER5_COMPB_vect) {
  TachoRemovePulse();
  Tacho_Count = Tacho_Count + (OCR5A + 1);
  if (Tacho_Count > ENC_LINE_PER_REV) {
    TachoSetPulse();
    if (Spindle_Dir == CW) {
      Rev_Count_F++;
    } else if (Spindle_Dir == CCW) {
      Rev_Count_F--;
    }
    Tacho_Count = Tacho_Count - ENC_LINE_PER_REV;
  }

  if ((Motor_X_Dir == CW && Motor_X_Pos > Limit_Pos) || (Motor_X_Dir == CCW && Motor_X_Pos < Limit_Pos) || (!feed_X_flag)) {
    if (OCR5A < max_OCR5A) {
      Motor_X_InvertPulse();
      if (!Read_X_State) {
        OCR5A++;
        if (Motor_X_Dir == CW) {
          Motor_X_Pos++;
        } else {
          Motor_X_Pos--;
        }
      }
    } else {
      Step_X_flag = OFF;
    }
  }

  else {
    Step_X_flag = ON;
    Motor_X_InvertPulse();
    {
      if (!Read_X_State) {
        if (Motor_X_Dir == CW) {
          Motor_X_Pos++;
        } else {
          Motor_X_Pos--;
        }

        if (OCR5A > Feed_Divisor) {
          OCR5A--;
        } else if (OCR5A < Feed_Divisor) {
          OCR5A++;
        }
      }
    }
  }

  /////////////////////////////////////////////////////////
  if (Mode == Mode_Sphere)  // Режим Сфера
  {
  }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ***** Rapid Feed & Rapid Cone ***** ///////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER2_COMPA_vect) {
  Motor_X_RemovePulse();
  if ((Motor_Z_Dir == CW && Motor_Z_Pos > Limit_Pos) || (Motor_Z_Dir == CCW && Motor_Z_Pos < Limit_Pos) || (!rapid_Z_flag)) {
    if (OCR2A < MIN_RAPID_MOTION) {
      Motor_Z_InvertPulse();
      if (!Read_Z_State) {
        if (Motor_Z_Dir == CW) {
          Motor_Z_Pos++;
        } else {
          Motor_Z_Pos--;
        }

        if (++Repeat_Count == REPEAt) {
          Repeat_Count = 0;
          OCR2A++;
        }
      }
    } else {
      rapid_step_Z_flag = OFF;
      Step_X_flag = OFF;
    }
  }

  else {
    rapid_step_Z_flag = ON;
    Motor_Z_InvertPulse();
    if (!Read_Z_State) {
      if (Motor_Z_Dir == CW) {
        Motor_Z_Pos++;
      } else {
        Motor_Z_Pos--;
      }

      if (OCR2A > MAX_RAPID_MOTION_Z) {
        if (++Repeat_Count == REPEAt) {
          Repeat_Count = 0;
          OCR2A--;
        }
      }
    }
  }

  ///////////////////////////////////////////////////////
  if (Step_X_flag == ON) {
    if (++Cs_Count > Cs_Divisor) {
      Motor_X_SetPulse();
      if (Motor_X_Dir == CW) {
        Motor_X_Pos++;
      } else {
        Motor_X_Pos--;
      }

      Cm_Count = Cm_Count + Cm_Divisor;
      if (Cm_Count > Cm_Divisor) {
        Cm_Count = Cm_Count - 10000;
        Cs_Count = 0;
      } else {
        Cs_Count = 1;
      }
    }
  }
}

//////////////////////////////////////////////////////////
ISR(TIMER2_COMPB_vect) {
  if ((Motor_X_Dir == CW && Motor_X_Pos > Limit_Pos) || (Motor_X_Dir == CCW && Motor_X_Pos < Limit_Pos) || (!rapid_X_flag)) {
    if (OCR2A < MIN_RAPID_MOTION) {
      Motor_X_InvertPulse();
      if (!Read_X_State) {
        if (Motor_X_Dir == CW) {
          Motor_X_Pos++;
        } else {
          Motor_X_Pos--;
        }

        if (++Repeat_Count == REPEAt) {
          Repeat_Count = 0;
          OCR2A++;
        }
      }
    } else {
      rapid_step_X_flag = OFF;
    }
  }

  else {
    rapid_step_X_flag = ON;
    Motor_X_InvertPulse();
    if (!Read_X_State) {
      if (Motor_X_Dir == CW) {
        Motor_X_Pos++;
      } else {
        Motor_X_Pos--;
      }

      if (OCR2A > MAX_RAPID_MOTION_X) {
        if (++Repeat_Count == REPEAt) {
          Repeat_Count = 0;
          OCR2A--;
        }
      }
    }
  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ***** Asynchron Feed ***** ////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER4_COMPA_vect) {

  /* if (Joy_Z_flag == ON) {Motor_X_RemovePulse();}
   TachoRemovePulse();
   Tacho_Count = Tacho_Count + (OCR5A+1);
   if (Tacho_Count > ENC_LINE_PER_REV)
   {
      Tacho_Count = Tacho_Count - ENC_LINE_PER_REV;
   }*/

  if ((Motor_Z_Dir == CW && Motor_Z_Pos > Limit_Pos) || (Motor_Z_Dir == CCW && Motor_Z_Pos < Limit_Pos) || (!feed_Z_flag)) {
    if (OCR4A < max_OCR4A) {
      Motor_Z_InvertPulse();
      if (!Read_Z_State) {
        OCR4A++;
        if (Motor_Z_Dir == CW) {
          Motor_Z_Pos++;
        } else {
          Motor_Z_Pos--;
        }
      }
    } else {
      Step_Z_flag = OFF;
      Step_X_flag = OFF;
    }
  }

  else {
    Step_Z_flag = ON;
    Motor_Z_InvertPulse();
    if (!Read_Z_State) {
      if (Motor_Z_Dir == CW) {
        Motor_Z_Pos++;
      } else {
        Motor_Z_Pos--;
      }

      if (OCR4A > aFeed_Divisor) {
        OCR4A--;
      } else if (OCR4A < aFeed_Divisor) {
        OCR4A++;
      }
    }
  }
}

//////////////////////////////////////////////////////////
ISR(TIMER4_COMPB_vect) {
  if ((Motor_X_Dir == CW && Motor_X_Pos > Limit_Pos) || (Motor_X_Dir == CCW && Motor_X_Pos < Limit_Pos) || (!feed_X_flag)) {
    if (OCR4A < max_OCR4A) {
      Motor_X_InvertPulse();
      if (!Read_X_State) {
        OCR4A++;
        if (Motor_X_Dir == CW) {
          Motor_X_Pos++;
        } else {
          Motor_X_Pos--;
        }
      }
    } else {
      Step_Z_flag = OFF;
      Step_X_flag = OFF;
    }
  }

  else {
    Step_X_flag = ON;
    Motor_X_InvertPulse();
    if (!Read_X_State) {
      if (Motor_X_Dir == CW) {
        Motor_X_Pos++;
      } else {
        Motor_X_Pos--;
      }

      if (OCR4A > aFeed_Divisor) {
        OCR4A--;
      } else if (OCR4A < aFeed_Divisor) {
        OCR4A++;
      }
    }
  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ***** HandCoder ***** /////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(INT2_vect) {
  if (!Hand_Ch_A) {
    if (!Hand_Ch_B) { Hand_Count--; }
  }

  else {
    if (!Hand_Ch_B) { Hand_Count++; }
  }
}

/////////////////////////////////////////////
ISR(TIMER3_COMPA_vect) {
  if (Motor_Z_Dir == CW) {
    if (Motor_Z_Pos < Null_Z_Pos + Hand_Z_Pos) {
      Motor_Z_InvertPulse();
      if (!Read_Z_State) {
        Motor_Z_Pos++;

        if ((Motor_Z_Pos > Limit_Pos_HC) || (hand_Z == OFF)) {
          if (OCR3A < max_OCR3A) OCR3A++;
        } else if (Motor_Z_Pos < Limit_Pos_HC) {
          if (OCR3A > min_OCR3A) OCR3A--;
        }
      }
    } else if (Motor_Z_Pos == Hand_Z_Pos) {
      //
    }
  }

  else if (Motor_Z_Dir == CCW) {
    if (Motor_Z_Pos > Null_Z_Pos + Hand_Z_Pos) {
      Motor_Z_InvertPulse();
      if (!Read_Z_State) {
        Motor_Z_Pos--;

        if (Motor_Z_Pos < Limit_Pos_HC || hand_Z == OFF) {
          if (OCR3A < max_OCR3A) OCR3A++;
        } else if (Motor_Z_Pos > Limit_Pos_HC) {
          if (OCR3A > min_OCR3A) OCR3A--;
        }
      }
    } else if (Motor_Z_Pos == Hand_Z_Pos) {
      //
    }
  }
}

//////////////////////////////////////////////////////////
ISR(TIMER3_COMPB_vect) {
  if (Motor_X_Dir == CW) {
    if (Motor_X_Pos < Null_X_Pos + Hand_X_Pos) {
      Motor_X_InvertPulse();
      if (!Read_X_State) {
        Motor_X_Pos++;

        if ((Motor_X_Pos > Limit_Pos_HC) || (hand_X == OFF)) {
          if (OCR3A < max_OCR3A) OCR3A++;
        } else if (Motor_X_Pos < Limit_Pos_HC) {
          if (OCR3A > min_OCR3A) OCR3A--;
        }
      }
    } else if (Motor_X_Pos == Hand_X_Pos) {
      //
    }
  }

  else if (Motor_X_Dir == CCW) {
    if (Motor_X_Pos > Null_X_Pos + Hand_X_Pos) {
      Motor_X_InvertPulse();
      if (!Read_X_State) {
        Motor_X_Pos--;

        if ((Motor_X_Pos < Limit_Pos_HC) || (hand_X == OFF)) {
          if (OCR3A < max_OCR3A) OCR3A++;
        } else if (Motor_X_Pos > Limit_Pos_HC) {
          if (OCR3A > min_OCR3A) OCR3A--;
        }
      }
    } else if (Motor_X_Pos == Hand_X_Pos) {
      //
    }
  }
}




// ***** End ***** ///////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////// **************** ADC ************************** ////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





void Read_ADC_Feed()
{
   /////////// Переменник Подачи ///////////
   if (Mode == Mode_Feed || Mode == Mode_Cone_L_R || Mode == Mode_Cone_R || Mode == Mode_aFeed || Mode == Mode_Sphere)
   {
      int New_ADC_Feed = analogRead(A7);
      if (New_ADC_Feed > ADC_Feed +4 || New_ADC_Feed < ADC_Feed -4)
      {
         if (++x > 15) {x = 0;}
         Sum_ADC = Sum_ADC - ADC_Array[x];
         ADC_Array[x] = New_ADC_Feed;
         Sum_ADC = Sum_ADC + New_ADC_Feed;
         ADC_Feed = Sum_ADC /16;
      }
   }

   if (Mode == Mode_Feed || Mode == Mode_Cone_L_R || Mode == Mode_Cone_R || Mode == Mode_Sphere)
   {
      uint16_t Feed_mm_New = MAX_FEED - long(MAX_FEED - MIN_FEED + 1) * ADC_Feed / 1024;
      if (Feed_mm_New != Feed_mm)
      {
         Feed_mm = Feed_mm_New;
         Print();
         Beep();

         switch (Mode)
         {
            case Mode_Feed:    ////////////////////////////////
            if (Joy_Z_flag == ON && Button_Rapid != 0 && Step_Z_flag == ON)
            {
               b_flag = false;
               if (Motor_Z_Dir == CW) {Feed_Left(a_flag, b_flag);}
               else                   {Feed_Right(a_flag, b_flag);}
            }
            else if (Joy_X_flag == ON && Button_Rapid != 0 && Step_X_flag == ON)
            {
               b_flag = false;
               if (Motor_X_Dir == CW) {Feed_Front(a_flag, b_flag);}
               else                   {Feed_Rear(a_flag, b_flag);} 
            }
            break;

            case Mode_Cone_L_R:    ////////////////////////////////
            if (Joy_Z_flag == ON && Button_Rapid != 0  && Step_Z_flag == ON)
            {
               b_flag = false;
               if (Motor_Z_Dir == CW) {Cone_Left(a_flag, b_flag);}
               else                   {Cone_Right(a_flag, b_flag);}
            }
            else if (Joy_X_flag == ON && Button_Rapid != 0 && Step_X_flag == ON)
            {
               b_flag = false;
               if (Motor_X_Dir == CW) {Feed_Front(a_flag, b_flag);}
               else                   {Feed_Rear(a_flag, b_flag);}
            }
            break;

            case Mode_Cone_R:    ////////////////////////////////
            break;
         }
      }
   }

   else if (Mode == Mode_aFeed)
   {
      uint16_t aFeed_mm_New = MAX_aFEED/10 - long(MAX_aFEED/10 - MIN_aFEED/10 + 1) * ADC_Feed / 1024;
      aFeed_mm_New = (aFeed_mm_New * 10);
      if (aFeed_mm_New != aFeed_mm)
      {
         aFeed_mm = aFeed_mm_New;
         Print();
         Beep();

         switch (Mode)
         {
            case Mode_aFeed:     //////////////////////////////////
            if (Joy_Z_flag == ON && Button_Rapid != 0  && Step_Z_flag == ON)
            {
               b_flag = false;
               if (Motor_Z_Dir == CW) {aFeed_Left(a_flag, b_flag);}
               else                   {aFeed_Right(a_flag, b_flag);}
            }
            else if (Joy_X_flag == ON && Button_Rapid != 0  && Step_X_flag == ON)
            {
               b_flag = false;
               if (Motor_X_Dir == CW) {aFeed_Front(a_flag, b_flag);}
               else                   {aFeed_Rear(a_flag, b_flag);}
            }
            break;
         }
      } 
   } 
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Beeper ********** //////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Beep()
{
   Beeper_On();
   _delay_ms(25);
   Beeper_Off();
}

void BeepBeep()
{
   Beeper_On();
   _delay_ms(25);
   Beeper_Off();   
   _delay_ms(200);
   Beeper_On();
   _delay_ms(25);
   Beeper_Off();
}

void BeepComplete()  // три длинных сигнала
{
   Complete_flag = true;
   Print();
   Beeper_On();
   _delay_ms(500);
   Beeper_Off();   
   _delay_ms(100);
   Beeper_On();
   _delay_ms(500);
   Beeper_Off();
   _delay_ms(100);
   Beeper_On();
   _delay_ms(500);
   Beeper_Off();
}

void Beep_Error()
{
   Beeper_On();
   _delay_ms(250);
   Beeper_Off();
}

void Beep_Error1()  // три длинных сигнала
{
   Beeper_On();
   _delay_ms(700);
   Beeper_Off();   
   _delay_ms(100);
   Beeper_On();
   _delay_ms(700);
   Beeper_Off();
   _delay_ms(100);
   Beeper_On();
   _delay_ms(700);
   Beeper_Off();
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////// Режим "Конус" ///////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//  Режим "Конус"  Движение по Х и Z одновременно ------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------

void Cone_Left(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Cs_Divisor = Cone_Info[Cone_Step].Cs_Div;
  Cm_Divisor = Cone_Info[Cone_Step].Cm_Div;

  Start_Speed = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  if (Mode == Mode_Cone_L_R && Mode2_Cone == 1) {
    Motor_X_Dir = CW;
    Motor_X_CW();
  } else if (Mode == Mode_Cone_L_R && Mode2_Cone == 2) {
    Motor_X_Dir = CCW;
    Motor_X_CCW();
  }
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_Z_flag = ON;
  Step_X_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
  //Ena_INT_Thrd();
}

void Cone_Right(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Cs_Divisor = Cone_Info[Cone_Step].Cs_Div;
  Cm_Divisor = Cone_Info[Cone_Step].Cm_Div;

  Start_Speed = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((uint32_t)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  if (Mode == Mode_Cone_L_R && Mode2_Cone == 1) {
    Motor_X_Dir = CCW;
    Motor_X_CCW();
  } else if (Mode == Mode_Cone_L_R && Mode2_Cone == 2) {
    Motor_X_Dir = CW;
    Motor_X_CW();
  }
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_Z_flag = ON;
  Step_X_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Cone_Front(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;
}

void Cone_Rear(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;
}


//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Режим "Конус" Быстрая Подача Движение по Х и Z одновременно -----------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
void Rapid_Cone_Left(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Cs_Count = 0;
  Cm_Count = 0;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  if (Mode == Mode_Cone_L_R && Mode2_Cone == 1) {
    Motor_X_Dir = CW;
    Motor_X_CW();
  } else if (Mode == Mode_Cone_L_R && Mode2_Cone == 2) {
    Motor_X_Dir = CCW;
    Motor_X_CCW();
  }
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Step_X_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Cone_Right(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Cs_Count = 0;
  Cm_Count = 0;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  if (Mode == Mode_Cone_L_R && Mode2_Cone == 1) {
    Motor_X_Dir = CCW;
    Motor_X_CCW();
  } else if (Mode == Mode_Cone_L_R && Mode2_Cone == 2) {
    Motor_X_Dir = CW;
    Motor_X_CW();
  }
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Step_X_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Cone_Rear(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

void Rapid_Cone_Front(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}



//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Режим "Конус" Подача Джейстик Движение по Х или Z ---------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------

void Cone_Left_J(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Cone_Right_J(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = (max_OCR5A - Feed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Cone_Front_J(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos < Limit_Pos_Front - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((((float)MOTOR_X_STEP_PER_REV * McSTEP_X * Feed_mm / SCREW_X) / 2 + 0.5));
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}

void Cone_Rear_J(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos > Limit_Pos_Rear + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / (((float)MOTOR_X_STEP_PER_REV * McSTEP_X * Feed_mm / SCREW_X) / 2 + 0.5);
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}


//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//  Режим "Конус" Быстрая Подача Джейстик  Движение по Х или Z -----------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------

void Rapid_Cone_Left_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Cone_Right_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Cone_Front_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

void Rapid_Cone_Rear_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}


//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Режим "Конус" Цикл многопроходный конус -------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------

void Cone_Ext_Left() {
  if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF) {
    q = 0;
    q = 7;
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;
      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      // if (Infeed_Value == 0) {
      //   if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
      //   else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
      // } else {
      //   if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
      //   else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + Infeed_Value);
      // }
      Limit_Pos_Front = Motor_X_Pos + Infeed_Value;
      Limit_Front_LED_On();
      Limit_Pos_Rear = Motor_X_Pos - REBOUND_X;
      Limit_Rear_LED_On();
      BeepBeep();
      Cone_Front_J(a_flag, b_flag);
    }
  } else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF && q == 1) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;
      Cone_Left(a_flag, b_flag);
      q = 2;
    }
  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 2) {  //&& Motor_X_Pos == Limit_Pos_Front
    cycle_flag = false;
    a_flag = false;
    b_flag = false;
    Rapid_Cone_Rear_J(a_flag, b_flag);
    q = 3;

  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 3 && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {  //
    a_flag = false;
    b_flag = false;
    Rapid_Cone_Right_J(a_flag, b_flag);
    q = 4;
    Pass_Nr++;

  } else if (Motor_Z_Pos == Limit_Pos_Right && q == 4 && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
    if (Pass_Total - Pass_Nr + 1 > 0) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;
      q = 1;
      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      // Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X) + Infeed_Value;
      Limit_Pos_Front = Motor_X_Pos + Infeed_Value;
      Limit_Front_LED_On();
      Limit_Pos_Rear = Motor_X_Pos - REBOUND_X;
      Limit_Rear_LED_On();
      Cone_Front_J(a_flag, b_flag);
      BeepBeep();
      Print();
    } else {
      q = 6;
      // a_flag = false;
      // b_flag = false;
      // Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Pass_Total = 1;
      Pass_Nr = 1;
      // Feed_Front(a_flag, b_flag);
      BeepComplete();
      Print();
    }
    if (q == 6) {
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////
void Cone_Ext_Right() {
  if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF) {
    q = 0;
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + Infeed_Value);
      }
      Limit_Front_LED_On();
      BeepBeep();
      Feed_Front(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF && q != 6) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Cone_Right(a_flag, b_flag);
      q = 1;
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && q == 1) {
    Motor_Z_Pos = Limit_Pos_Right;
    Motor_X_Pos = Limit_Pos_Front;
    q = 2;

  } else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && q == 2) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
    Limit_Rear_LED_On();
    Feed_Rear(a_flag, b_flag);
    q = 3;

  } else if (Motor_Z_Pos == Limit_Pos_Right && q == 3 && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;
    Rapid_Cone_Left(a_flag, b_flag);
    q = 4;
    Pass_Nr++;

  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 4 && Step_Z_flag == OFF) {
    Motor_Z_Pos = Limit_Pos_Left;
    Motor_X_Pos = Limit_Pos_Rear;
    q = 5;

  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 5 && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
    if (Pass_Total - Pass_Nr + 1 > 0) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;
      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X) + Infeed_Value;
      Limit_Front_LED_On();
      BeepBeep();
      Feed_Front(a_flag, b_flag);
      Print();

    } else {
      q = 6;
      a_flag = false;
      b_flag = false;
      Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Pass_Total = 1;
      Pass_Nr = 1;
      Feed_Front(a_flag, b_flag);
      BeepComplete();
      Print();
    }
    if (q == 6) {
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////
void Cone_Int_Left() {
  if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF) {
    q = 0;
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos + 1);
        else Limit_Pos_Rear = (Limit_Pos_Rear + REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - Infeed_Value);
      }
      Limit_Rear_LED_On();
      BeepBeep();
      Feed_Rear(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF && q != 6) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Cone_Left(a_flag, b_flag);
      q = 1;
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && q == 1) {
    Motor_Z_Pos = Limit_Pos_Left;
    Motor_X_Pos = Limit_Pos_Rear;
    q = 2;
  } else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && q == 2) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
    Limit_Front_LED_On();
    Feed_Front(a_flag, b_flag);
    q = 3;
  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 3 && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;
    Rapid_Cone_Right(a_flag, b_flag);
    q = 4;
    Pass_Nr++;
  } else if (Motor_Z_Pos == Limit_Pos_Right && q == 4 && Step_Z_flag == OFF) {
    Motor_Z_Pos = Limit_Pos_Right;
    Motor_X_Pos = Limit_Pos_Front;
    q = 5;
  } else if (Motor_Z_Pos == Limit_Pos_Right && q == 5 && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
    if (Pass_Total - Pass_Nr + 1 > 0) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;
      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X) - Infeed_Value;
      Limit_Rear_LED_On();
      Feed_Rear(a_flag, b_flag);
      BeepBeep();
      Print();
    } else {
      q = 6;
      a_flag = false;
      b_flag = false;
      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Pass_Total = 1;
      Pass_Nr = 1;
      Feed_Rear(a_flag, b_flag);
      BeepComplete();
      Print();
    }
    if (q == 6) {
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
    }
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void Cone_Int_Right() {
  if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF) {
    q = 0;
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos + 1);
        else Limit_Pos_Rear = (Limit_Pos_Rear + REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - Infeed_Value);
      }
      Limit_Rear_LED_On();
      BeepBeep();
      Feed_Rear(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF && q != 6) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Cone_Right(a_flag, b_flag);
      q = 1;
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && q == 1) {
    Motor_Z_Pos = Limit_Pos_Right;
    Motor_X_Pos = Limit_Pos_Rear;
    q = 2;
  } else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && q == 2) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
    Limit_Front_LED_On();
    Feed_Front(a_flag, b_flag);
    q = 3;
  } else if (Motor_Z_Pos == Limit_Pos_Right && q == 3 && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;
    Rapid_Cone_Left(a_flag, b_flag);
    q = 4;
    Pass_Nr++;
  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 4 && Step_Z_flag == OFF) {
    Motor_Z_Pos = Limit_Pos_Left;
    Motor_X_Pos = Limit_Pos_Front;
    q = 5;
  } else if (Motor_Z_Pos == Limit_Pos_Left && q == 5 && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
    if (Pass_Total - Pass_Nr + 1 > 0) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;
      unsigned long Infeed_Value = (int)((float)MOTOR_X_STEP_PER_REV * (Ap / 2) / SCREW_X) * McSTEP_X;
      Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X) - Infeed_Value;
      Limit_Rear_LED_On();
      Feed_Rear(a_flag, b_flag);
      BeepBeep();
      Print();
    } else {
      q = 6;
      a_flag = false;
      b_flag = false;
      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Pass_Total = 1;
      Pass_Nr = 1;
      Feed_Rear(a_flag, b_flag);
      BeepComplete();
      Print();
    }
    if (q == 6) {
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
    }
  }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Подача" ********** //////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Left(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Feed_Right(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * Feed_mm / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = (max_OCR5A - Feed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Feed_Front(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos < Limit_Pos_Front - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((((float)MOTOR_X_STEP_PER_REV * McSTEP_X * Feed_mm / SCREW_X) / 2 + 0.5)) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}

void Feed_Rear(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos > Limit_Pos_Rear + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / (((float)MOTOR_X_STEP_PER_REV * McSTEP_X * Feed_mm / SCREW_X) / 2 + 0.5) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Быстрая Подача" ********** //////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Rapid_Feed_Left(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * (MAX_FEED * 2) / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Rapid_Feed_Right(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * MIN_FEED / SCREW_Z) / FEED_ACCEL / 2 + 0.5;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((float)MOTOR_Z_STEP_PER_REV * McSTEP_Z * (MAX_FEED * 2) / SCREW_Z) / 2 + 0.5;
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = (max_OCR5A - Feed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_Feed();
}

void Rapid_Feed_Front(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos < Limit_Pos_Front - Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / ((((float)MOTOR_X_STEP_PER_REV * McSTEP_X * (MAX_FEED * 2) / SCREW_X) / 2 + 0.5)) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}

void Rapid_Feed_Rear(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = ENC_LINE_PER_REV / ((float)MOTOR_X_STEP_PER_REV * McSTEP_X * MIN_FEED / SCREW_X) / FEED_ACCEL / 2 + 0.5;
  if (Motor_X_Pos > Limit_Pos_Rear + Start_Speed * 2) {
    Feed_Divisor = ENC_LINE_PER_REV / (((float)MOTOR_X_STEP_PER_REV * McSTEP_X * (MAX_FEED * 2) / SCREW_X) / 2 + 0.5) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
    if (Feed_Divisor < Start_Speed) {
      max_OCR5A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR5A = Start_Speed;
      }
    } else {
      max_OCR5A = Feed_Divisor;
      OCR5A = Feed_Divisor;
    }
  } else {
    Feed_Divisor = Start_Speed;
    max_OCR5A = Start_Speed;
    OCR5A = Start_Speed;
  }

  Brake_Compens = max_OCR5A - Feed_Divisor + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_Feed();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Быстрая Подача Джейстик" ********** //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Rapid_Feed_Left_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Feed_Right_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Feed_Front_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

void Rapid_Feed_Rear_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Цикл Подача" ********** /////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Ext_Left() {
  if ((Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X + 0.5) * McSTEP_X) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + Infeed_Value);
      }
      Limit_Front_LED_On();
      BeepBeep();
      Feed_Front(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
      Feed_Front(a_flag, b_flag);

      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Left(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
    Limit_Rear_LED_On();
    Feed_Rear(a_flag, b_flag);
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Right(a_flag, b_flag);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Ext_Right() {
  if ((Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X + 0.5) * McSTEP_X) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
        else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + Infeed_Value);
      }
      Limit_Front_LED_On();
      BeepBeep();
      Feed_Front(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
      Feed_Front(a_flag, b_flag);

      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Right(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
    Limit_Rear_LED_On();
    Feed_Rear(a_flag, b_flag);
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Left(a_flag, b_flag);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Int_Left() {
  if ((Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = ((int)((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X + 0.5) * McSTEP_X) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - 1);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - Infeed_Value);
      }
      Limit_Rear_LED_On();
      BeepBeep();
      Feed_Rear(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
      Feed_Rear(a_flag, b_flag);

      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Left(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
    Limit_Front_LED_On();
    Feed_Front(a_flag, b_flag);
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Right(a_flag, b_flag);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Int_Right() {
  if ((Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X + 0.5) * McSTEP_X) / (PP_X + 1);  // взял в скобки и добавил / (PP_X +1)
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - 1);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
        else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - Infeed_Value);
      }
      Limit_Rear_LED_On();
      BeepBeep();
      Feed_Rear(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
      Feed_Rear(a_flag, b_flag);

      Limit_Front_LED_Off();
      Limit_Rear_LED_Off();
      Limit_Pos_Front = Limit_Pos_Max;
      Limit_Pos_Rear = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Right(a_flag, b_flag);
    }
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
    Limit_Front_LED_On();
    Feed_Front(a_flag, b_flag);
  }

  else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Left(a_flag, b_flag);
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Ext_Front() {
  if ((Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) || (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Null_Z_Pos && Step_X_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = (int)((float)MOTOR_Z_STEP_PER_REV * Ap / SCREW_Z + 0.5) * McSTEP_Z;
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + 1);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + Infeed_Value);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z + Infeed_Value);
      }
      Limit_Left_LED_On();
      BeepBeep();
      Feed_Left(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Left = Limit_Pos_Right + REBOUND_Z;
      Feed_Left(a_flag, b_flag);

      Limit_Left_LED_Off();
      Limit_Right_LED_Off();
      Limit_Pos_Left = Limit_Pos_Max;
      Limit_Pos_Right = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Front(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Right = (Limit_Pos_Left - REBOUND_Z);
    Limit_Right_LED_On();
    Feed_Right(a_flag, b_flag);
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Rear(a_flag, b_flag);
  }
}

//////////////////////////////////////////////////////////////////////////////
void Feed_Ext_Rear() {
  if ((Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) || (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Null_Z_Pos && Step_X_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value = (int)((float)MOTOR_Z_STEP_PER_REV * Ap / SCREW_Z + 0.5) * McSTEP_Z;
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + 1);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + Infeed_Value);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z + Infeed_Value);
      }
      Limit_Left_LED_On();
      BeepBeep();
      Feed_Left(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Left = Limit_Pos_Right + REBOUND_Z;
      Feed_Left(a_flag, b_flag);

      Limit_Left_LED_Off();
      Limit_Right_LED_Off();
      Limit_Pos_Left = Limit_Pos_Max;
      Limit_Pos_Right = Limit_Pos_Min;
      Pass_Total = 1;
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      Feed_Rear(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Right = (Limit_Pos_Left - REBOUND_Z);
    Limit_Right_LED_On();
    Feed_Right(a_flag, b_flag);
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_Feed_Front(a_flag, b_flag);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Int_Front() {
  //
}

////////////////////////////////////////////////////////////////////////////////////////////////
void Feed_Int_Rear() {
  //
}


void H_Coder() {
  ///////////////
  // Масштаб
  ///////////////
  if (Motor_Z_Pos == Null_Z_Pos + Hand_Z_Pos && Motor_X_Pos == Null_X_Pos + Hand_X_Pos) {
    if (Scale == HC_SCALE_10 && flag_Scale_x1 == ON) {
      Hand_Count = 0;
      Hand_Count_New = 0;
      Hand_Count_Old = 0;
      Hand_Z_Pos = 0;
      Hand_X_Pos = 0;

      Null_Z_Pos = Motor_Z_Pos;
      Null_X_Pos = Motor_X_Pos;

      max_OCR3A = HC_START_SPEED_1;
      min_OCR3A = HC_MAX_SPEED_1;

      Scale = HC_SCALE_1;
    } else if (Scale == HC_SCALE_1 && flag_Scale_x10 == ON) {
      Hand_Count = 0;
      Hand_Count_New = 0;
      Hand_Count_Old = 0;
      Hand_Z_Pos = 0;
      Hand_X_Pos = 0;

      Null_Z_Pos = Motor_Z_Pos;
      Null_X_Pos = Motor_X_Pos;

      max_OCR3A = HC_START_SPEED_10;
      min_OCR3A = HC_MAX_SPEED_10;

      Scale = HC_SCALE_10;
    }
  }

  /////////////////
  // Активная ось
  /////////////////
  /////////////////
  if (hand_Z == ON) {
    Disa_INT_Hcoder();
    Hand_Count_New = Hand_Count;
    Ena_INT_Hcoder();

    if (Hand_Count_New != Hand_Count_Old) {
      Hand_Count_Old = Hand_Count_New;

      Hand_Z_Pos = (Hand_Count_New * Scale * MOTOR_Z_STEP_PER_REV * McSTEP_Z / SCREW_Z + McSTEP_Z / 2) & ~(McSTEP_Z - 1);
      Brake_Compens = max_OCR3A - min_OCR3A + 1;
      Disable_INT_OCR3B();
      Enable_INT_OCR3A();
    }


    if (Motor_Z_Pos < Null_Z_Pos + Hand_Z_Pos) {
      Motor_Z_Dir = CW;
      Motor_Z_CW();
      Limit_Pos_HC = Null_Z_Pos + Hand_Z_Pos - Brake_Compens;
      Limit_Pos = Limit_Pos_Left - Brake_Compens;
    } else if (Motor_Z_Pos > Null_Z_Pos + Hand_Z_Pos) {
      Motor_Z_Dir = CCW;
      Motor_Z_CCW();
      Limit_Pos_HC = Null_Z_Pos + Hand_Z_Pos + Brake_Compens;
      Limit_Pos = Limit_Pos_Right + Brake_Compens;
    }
  }

  //////////////////////////
  else if (hand_X == ON) {
    Disa_INT_Hcoder();
    if (HC_X_DIR == 0) {
      Hand_Count_New = Hand_Count;
    } else {
      Hand_Count_New = Hand_Count - Hand_Count * 2;
    }
    Ena_INT_Hcoder();

    if (Hand_Count_New != Hand_Count_Old) {
      Hand_Count_Old = Hand_Count_New;

      //Hand_X_Pos = ((Hand_Count_New * Scale * MOTOR_X_STEP_PER_REV * McSTEP_X / SCREW_X +McSTEP_X /2)  & ~(McSTEP_X - 1)) / (PP_X +1); // взял в скобки и добавил / (PP_X +1)
      //Hand_X_Pos = (Hand_Count_New / (PP_X +1) * Scale * MOTOR_X_STEP_PER_REV * McSTEP_X / SCREW_X +McSTEP_X /2)  & ~(McSTEP_X - 1); // добавил / (PP_X +1)
      Hand_X_Pos = (Hand_Count_New * Scale * MOTOR_X_STEP_PER_REV * McSTEP_X / SCREW_X + McSTEP_X / 2) & ~(McSTEP_X - 1);
      Brake_Compens = max_OCR3A - min_OCR3A + 1;
      Disable_INT_OCR3A();
      Enable_INT_OCR3B();
    }


    if (Motor_X_Pos < Null_X_Pos + Hand_X_Pos) {
      Motor_X_Dir = CW;
      Motor_X_CW();
      Limit_Pos_HC = Null_X_Pos + Hand_X_Pos - Brake_Compens;
    } else if (Motor_X_Pos > Null_X_Pos + Hand_X_Pos) {
      Motor_X_Dir = CCW;
      Motor_X_CCW();
      Limit_Pos_HC = Null_X_Pos + Hand_X_Pos + Brake_Compens;
    }
  }

  /////////////////////////////////////////////////
  else if (hand_Z == OFF && hand_X == OFF) {
    //
  }
}

#define DELAY_ENTER_KEYCYCLE 5  //Задержка для входа в режим автонажатия. Значения от 1 до разумного максимума. По умолчанию 10.
#define DELAY_INTO_KEYCYCLE 1   //Интервал срабатывания автонажатия. Значения от 1 до DELAY_ENTER_KEYCYCLE. По умолчанию 5.


void Menu() {
  /////// Джойстик ///////////////////////////////////////////////

  byte Joy_New = Joy_Read;
  {
    if (Joy_New == B00001110) {
      if (Joy_Old == B00001101) { Joy_NoPressed(); }
      Joy_Old = Joy_New;
      Joy_LeftPressed();
    } else if (Joy_New == B00001101) {
      if (Joy_Old == B00001110) { Joy_NoPressed(); }
      Joy_Old = Joy_New;
      Joy_RightPressed();
    } else if (Joy_New == B00001011) {
      if (Joy_Old == B00000111) { Joy_NoPressed(); }
      Joy_Old = Joy_New;
      Joy_UpPressed();
    } else if (Joy_New == B00000111) {
      if (Joy_Old == B00001011) { Joy_NoPressed(); }
      Joy_Old = Joy_New;
      Joy_DownPressed();
    } else if (Joy_New == B00001111) {
      Joy_Old = Joy_New;
      Joy_NoPressed();
    }
  }

  /////// Переключатель Режима ////////////////////////////////
  if (!Joy_Z_flag && !Joy_X_flag) {
    byte Mode_New = Mode_Read;
    if (Mode_New != Mode_Old) {
      if (Mode_New == B01111111) {
        Switch_Thread();
        Beep();
      } else if (Mode_New == B10111111) {
        Switch_Feed();
        Beep();
      } else if (Mode_New == B11011111) {
        Switch_aFeed();
        Beep();
      } else if (Mode_New == B11101111) {
        Switch_Cone_R();
        Beep();
      } else if (Mode_New == B11110111) {
        Switch_Cone_L();
        Beep();
      } else if (Mode_New == B11111011) {
        Switch_Sphere();
        Beep();
      }  // Switch_Reserve
      else if (Mode_New == B11111101) {
        Switch_Divider();
        Beep();
      }  //Switch_Sphere
      else if (Mode_New == B11111110) {
        Switch_Reserve();
        Beep();
      }  //Switch_Divider
      Mode_Old = Mode_New;
    }
  }


  /////// Переключатель Подрежима //////////////////////////////
  if (!Joy_Z_flag && !Joy_X_flag) {
    byte Submode_New = Submode_Read;
    if (Submode_New != Submode_Old) {
      if (Submode_New == B11000000) {
        Switch_Ext();
        Beep();
      }  //Switch_Int
      else if (Submode_New == B10100000) {
        Switch_Man();
        Beep();
      } else if (Submode_New == B01100000) {
        Switch_Int();
        Beep();
      }  //Switch_Ext
      Submode_Old = Submode_New;
    }
  }

  /////////// Кнопки Меню (с разрешённым автозажатием клавиш стрелок) //////////////////////////////////////
  byte Button_Sel_New = Button_Sel_Read;
  if (Button_Sel_New == Button_Sel_Old) {
    if (!Button_Sel_Read) {
      Key_Select_Pressed();
    } else {
      key_sel_flag = false;
      Print();
    }
  }
  Button_Sel_Old = Button_Sel_New;

  byte Button_New = Buttons_Read;
  if (Button_New != Button_Old)  //Меняем == на !=
  {
    //Кнопочку Нажали или Отпустили, состояние переменной изменилось
    if (Button_New == B00000111) Key_Down_Pressed();
    else if (Button_New == B00001011) Key_Up_Pressed();
    else if (Button_New == B00001101) Key_Right_Pressed();
    else if (Button_New == B00001110) Key_Left_Pressed();
    else {
      button_up_flag = false;
      button_down_flag = false;
      button_left_flag = false;
      button_right_flag = false;
    }
    KeyCycle = 0;  //Обнуляем переменную цикла
  } else {
    //Кнопочки(-ку) удерживают нажатой или наоборот сохраняет отпущенное состояние
    KeyCycle++;                           //Запускаем счётчик циклов
    if (KeyCycle > DELAY_ENTER_KEYCYCLE)  //это длительность удерживания клавиши для входа в цикл
    {
      if (Button_New == B00000111) {
        button_down_flag = false;  //Гасим флаг, чтобы повторно можно было вызвать обработчик этой кнопки
        Key_Down_Pressed();
      } else if (Button_New == B00001011) {
        button_up_flag = false;  //Гасим флаг, чтобы повторно можно было вызвать обработчик этой кнопки
        Key_Up_Pressed();
      } else if (Button_New == B00001101) {
        button_right_flag = false;  //Гасим флаг, чтобы повторно можно было вызвать обработчик этой кнопки
        Key_Right_Pressed();
      } else if (Button_New == B00001110) {
        button_left_flag = false;  //Гасим флаг, чтобы повторно можно было вызвать обработчик этой кнопки
        Key_Left_Pressed();
      }
      KeyCycle = (DELAY_ENTER_KEYCYCLE - DELAY_INTO_KEYCYCLE);  //Обнуляем переменную цикла или не до конца обнуляем, чтобы в нажатом состоянии цикл срабатывания был короче
    }
  }
  Button_Old = Button_New;
  //----------------------------------------------------------------------------------------------------------------------------------------

  /////// Кнопки Лимитов ///////////////////////////////////////
  byte Limit_Button_New = Limit_Buttons_Read;
  if (Limit_Button_New == Limit_Button_Old) {
    if (Limit_Button_New == B00010101) Limit_Left_Pressed();
    else if (Limit_Button_New == B01000101) Limit_Right_Pressed();
    else if (Limit_Button_New == B01010001) Limit_Front_Pressed();
    else if (Limit_Button_New == B01010100) Limit_Rear_Pressed();
    else limit_button_flag = false;
  }
  Limit_Button_Old = Limit_Button_New;


  /////// Переключатель Оси для ГРИ ////////////////////////////
  byte Hand_Axis_New = Hand_Axis_Read;
  if (Hand_Axis_New != Hand_Axis_Old) {
    if (Hand_Axis_New == B00100000) {
      Switch_Hand_Axis_Z();
    } else if (Hand_Axis_New == B00010000) {
      Switch_Hand_Axis_X();
    } else if (Hand_Axis_New == B00110000) {
      Switch_Hand_Axis_No();
    }
    Hand_Axis_Old = Hand_Axis_New;
  }


  /////// Переключатель Масштаба для ГРИ //////////////////////
  byte Hand_Scale_New = Hand_Scale_Read;
  if (Hand_Scale_New != Hand_Scale_Old) {
    if (Hand_Scale_New == B00000001) {
      Switch_Scale_x1();
    } else if (Hand_Scale_New == B00000010) {
      Switch_Scale_x10();
    }
    Hand_Scale_Old = Hand_Scale_New;
  }
  CLEAR_KEYB_TIMER;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка Джойстика ********** /////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// ********** Обработчик Джойстик Влево **********
void Joy_LeftPressed() {
  flag_j = ON;
  Disa_INT_Hcoder();
  Disable_INT_OCR3A();
  Disable_INT_OCR3B();
  hand_Z = OFF;
  hand_X = OFF;
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;

  ///////////////////////
  if (Mode == Mode_Thread) {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Man && err_1_flag == false && err_2_flag == false) {
      if (Spindle_Dir == CW) {
        Thread_Left(c_flag, d_flag);
      } else {
        if (!Button_Rapid) {
          Limit_Pos = Limit_Pos_Min;
        } else {
          Limit_Pos = Limit_Pos_Right + Brake_Compens;
        }
        Thread_Right(c_flag, d_flag);
      }
    } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext) {
      if (Spindle_Dir == CW) {
        Thread_Ext_Left();
      } else {
        Thread_Ext_Right();
      }
    } else if (Sub_Mode_Thread == Sub_Mode_Thread_Int) {
      if (Spindle_Dir == CW) {
        Thread_Int_Left();
      } else {
        Thread_Int_Right();
      }
    }
  }
  //////////////////////////
  else if (Mode == Mode_Feed) {
    if (Sub_Mode_Feed == Sub_Mode_Feed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos < (Limit_Pos_Left - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Feed_Left_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            if (Read_Z_Ena_State == false) Motor_Z_Enable();
            feed_Z_flag = ON;
            Feed_Left(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
      Feed_Ext_Left();
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
      Feed_Int_Left();
    }
  }
  ///////////////////////////
  else if (Mode == Mode_aFeed) {
    if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos < (Limit_Pos_Left - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_aFeed_Left_J(a_flag, b_flag); }
        }
      } else {
        if (OCR4A == max_OCR4A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            if (Read_Z_Ena_State == false) Motor_Z_Enable();
            feed_Z_flag = ON;
            aFeed_Left(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
      aFeed_Ext_Left();
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
      aFeed_Int_Left();
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_L_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos < (Limit_Pos_Left - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Cone_Left_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            Cone_Left_J(a_flag, b_flag);
          }
        }
      }


    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 1) {
      Cone_Int_Left();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 2) {
      Cone_Ext_Left();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos < (Limit_Pos_Left - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Cone_Left_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            Cone_Left_J(a_flag, b_flag);
          }
        }
      }
    }
  }
  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Sphere && err_1_flag == false && err_2_flag == false) {
    Sphere_Ext(a_flag, b_flag);
  }
}


// ********** Обработчик Джойстик Вправо **********
void Joy_RightPressed() {
  flag_j = ON;
  Disa_INT_Hcoder();
  Disable_INT_OCR3A();
  Disable_INT_OCR3B();
  hand_Z = OFF;
  hand_X = OFF;
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;

  ////////////////////////
  if (Mode == Mode_Thread) {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Man && err_1_flag == false && err_2_flag == false) {
      if (Spindle_Dir == CW) {
        if (!Button_Rapid) {
          Limit_Pos = Limit_Pos_Min;
        } else {
          Limit_Pos = Limit_Pos_Right + Brake_Compens;
        }
        Thread_Right(c_flag, d_flag);
      } else {
        Thread_Left(c_flag, d_flag);
      }
    } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext) {
      if (Spindle_Dir == CW) {
        Thread_Ext_Right();
      } else {
        Thread_Ext_Left();
      }
    } else if (Sub_Mode_Thread == Sub_Mode_Thread_Int) {
      if (Spindle_Dir == CW) {
        Thread_Int_Right();
      } else {
        Thread_Int_Left();
      }
    }
  }
  ///////////////////////////
  else if (Mode == Mode_Feed) {
    if (Sub_Mode_Feed == Sub_Mode_Feed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Feed_Right_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            if (Read_Z_Ena_State == false) Motor_Z_Enable();
            feed_Z_flag = ON;
            Feed_Right(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
      Feed_Ext_Right();
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
      Feed_Int_Right();
    }
  }
  ////////////////////////////
  else if (Mode == Mode_aFeed) {
    if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_aFeed_Right_J(a_flag, b_flag); }
        }
      } else {
        if (OCR4A == max_OCR4A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            if (Read_Z_Ena_State == false) Motor_Z_Enable();
            feed_Z_flag = ON;
            aFeed_Right(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
      aFeed_Ext_Right();
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
      aFeed_Int_Right();
    }
  }
  ////////////////////////////////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_L_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Cone_Right_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            Cone_Right_J(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 1) {
      Cone_Ext_Right();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
          feed_Z_flag = OFF;
          if (!Step_Z_flag) { Rapid_Cone_Right_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_Z_flag = OFF;
          if (!rapid_step_Z_flag) {
            Cone_Right_J(a_flag, b_flag);
          }
        }
      }
    }
  }
  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Sphere && err_1_flag == false && err_2_flag == false) {
    //   if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man && err_1_flag == false && err_2_flag == false) {
    //     if (!Button_Rapid) {
    //       if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
    //         feed_Z_flag = OFF;
    //         if (!Step_Z_flag) { Rapid_Sphere_Right_J(a_flag, b_flag); }
    //       }
    //     } else {
    //       if (OCR5A == max_OCR5A) {
    //         rapid_Z_flag = OFF;
    //         if (!rapid_step_Z_flag) {
    //           if (Read_Z_Ena_State == false) Motor_Z_Enable();
    //           feed_Z_flag = ON;
    //           Feed_Right(a_flag, b_flag);
    //         }
    //       }
    //     }
    //   } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext) {
    //     Sphere_Ext_Right();
    //   } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Int) {
    //     //
    //   }
  }
}

// ********** Обработчик Джойстик Вверх **********
void Joy_UpPressed() {
  flag_j = ON;
  Disa_INT_Hcoder();
  Disable_INT_OCR3A();
  Disable_INT_OCR3B();
  hand_X = OFF;
  hand_Z = OFF;
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;

  ///////////////////////
  if (Mode == Mode_Thread) {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Man && err_1_flag == false && err_2_flag == false) {
      if (Spindle_Dir == CW) {
        Thread_Front(c_flag, d_flag);
      } else {
        Thread_Rear(c_flag, d_flag);
      }
    }
  }

  //////////////////////////
  else if (Mode == Mode_Feed) {
    if (Sub_Mode_Feed == Sub_Mode_Feed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_X_Pos < (Limit_Pos_Front - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Feed_Front_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Feed_Front(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
      Feed_Ext_Front();
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
      Feed_Int_Front();
    }
  }

  //////////////////////////
  else if (Mode == Mode_aFeed) {
    if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_X_Pos < (Limit_Pos_Front - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_aFeed_Front_J(a_flag, b_flag); }
        }
      } else {
        if (OCR4A == max_OCR4A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            aFeed_Front(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
      aFeed_Ext_Front();
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
      aFeed_Int_Front();
    }
  }

  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_L_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_X_Pos < (Limit_Pos_Front - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Cone_Front_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Cone_Front_J(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    }
  }

  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_X_Pos < (Limit_Pos_Front - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Cone_Front_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Cone_Front_J(a_flag, b_flag);
          }
        }
      }
    }
  }
  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Sphere && err_1_flag == false && err_2_flag == false) {
  }
}


// ********** Обработчик Джойстик Вниз **********
void Joy_DownPressed() {
  flag_j = ON;
  Disa_INT_Hcoder();
  Disable_INT_OCR3A();
  Disable_INT_OCR3B();
  hand_X = OFF;
  hand_Z = OFF;
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;

  ///////////////////////
  if (Mode == Mode_Thread) {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Man && err_1_flag == false && err_2_flag == false) {
      if (Spindle_Dir == CW) {
        Thread_Rear(c_flag, d_flag);
      } else {
        Thread_Front(c_flag, d_flag);
      }
    }
  }

  ///////////////////////////
  else if (Mode == Mode_Feed) {
    if (Sub_Mode_Feed == Sub_Mode_Feed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_X_Pos > (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Feed_Rear_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Feed_Rear(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
      Feed_Ext_Rear();
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
      Feed_Int_Rear();
    }
  }


  ///////////////////////////
  else if (Mode == Mode_aFeed) {
    if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man && err_1_flag == false && err_2_flag == false) {
      if (!Button_Rapid) {
        if (Motor_X_Pos > (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_aFeed_Rear_J(a_flag, b_flag); }
        }
      } else {
        if (OCR4A == max_OCR4A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            aFeed_Rear(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
      //
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
      //
    }
  }

  ////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_L_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_X_Pos > (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Cone_Rear_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Cone_Rear_J(a_flag, b_flag);
          }
        }
      }
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 1) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int && Mode2_Cone == 2) {
      err_3_flag == true;
      Print();
    }

  }

  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Cone_R && err_1_flag == false && err_2_flag == false) {
    if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
      if (!Button_Rapid) {
        if (Motor_X_Pos > (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
          feed_X_flag = OFF;
          if (!Step_X_flag) { Rapid_Cone_Rear_J(a_flag, b_flag); }
        }
      } else {
        if (OCR5A == max_OCR5A) {
          rapid_X_flag = OFF;
          if (!rapid_step_X_flag) {
            if (Read_X_Ena_State == false) Motor_X_Enable();
            feed_X_flag = ON;
            Cone_Rear_J(a_flag, b_flag);
          }
        }
      }
    }
  }
  //////////////////////////////////////////////////////////////////////////
  else if (Mode == Mode_Sphere && err_1_flag == false && err_2_flag == false) {
  }
}


// ********** Обработчик Джойстик в нейтрали **********
void Joy_NoPressed() {
  Complete_flag = false;
  w = 0;
  q = 0;
  err_3_flag = false;

  if (Mode == Mode_aFeed) { Enable_INT0(); }
  if (flag_j == ON) {
    if (!Step_Z_flag && !rapid_step_Z_flag && !Step_X_flag && !rapid_step_X_flag) {
      flag_j = OFF;

      Motor_Z_Pos = ((Motor_Z_Pos + McSTEP_Z / 2) & ~(McSTEP_Z - 1));
      Motor_X_Pos = ((Motor_X_Pos + McSTEP_X / 2) & ~(McSTEP_X - 1));
      Null_Z_Pos = Motor_Z_Pos;
      Null_X_Pos = Motor_X_Pos;

      Motor_Z_RemovePulse();
      Motor_X_RemovePulse();
      Ks_Count = 0;
      Km_Count = 0;
      Cs_Count = 0;
      Cm_Count = 0;
      Repeat_Count = 0;
      a_flag = false;
      c_flag = false;
      d_flag = false;
      cycle_flag = false;
      Pass_Nr = 1;
      OCR5A = max_OCR5A;
      OCR4A = max_OCR4A;
      OCR2A = MIN_RAPID_MOTION;
      if (!flag_hand_Z) { Motor_Z_Disable(); }
      if (!flag_hand_X) { Motor_X_Disable(); }
    }
  }

  Joy_Z_flag = OFF;
  Joy_X_flag = OFF;
  feed_Z_flag = OFF;
  feed_X_flag = OFF;
  rapid_Z_flag = OFF;
  rapid_X_flag = OFF;
  b_flag = false;


  if (!Step_Z_flag && !rapid_step_Z_flag) {
    if (hand_Z == OFF) {
      if (flag_hand_Z == ON) {
        hand_Z = ON;
      }
    }
    H_Coder();
  }

  if (!Step_X_flag && !rapid_step_X_flag) {
    if (hand_X == OFF) {
      if (flag_hand_X == ON) {
        hand_X = ON;
      }
    }
    H_Coder();
  }


  if (Mode == Mode_Thread) {
    //
    if (Sub_Mode_Thread != Sub_Mode_Thread_Man) {
      //
    }
  }

  if (Mode == Mode_Feed || Mode == Mode_aFeed) {
    //
    if (Sub_Mode_Feed != Sub_Mode_Feed_Man) {
      //
    }
  }

  if (Mode == Mode_Cone_L_R) {
    if (!Step_Z_flag && !rapid_step_Z_flag) {
      rapid_step_X_flag = OFF;
      Step_X_flag = OFF;
    }
  }


  if (Mode == Mode_Cone_R) {
    if (!Step_Z_flag && !rapid_step_Z_flag) {
      rapid_step_X_flag = OFF;
      Step_X_flag = OFF;
    }
  }


  if ((Mode == Mode_Thread && Sub_Mode_Thread == Sub_Mode_Thread_Man) || (Mode == Mode_Feed && Sub_Mode_Feed == Sub_Mode_Feed_Man) || (Mode == Mode_aFeed && Sub_Mode_aFeed == Sub_Mode_aFeed_Man) || (Mode == Mode_Cone_L_R && Sub_Mode_Cone == Sub_Mode_Cone_Man) || (Mode == Mode_Cone_R && Sub_Mode_Cone == Sub_Mode_Cone_Man) || (Mode == Mode_Sphere && Sub_Mode_Sphere == Sub_Mode_Sphere_Man) || (Mode == Mode_Divider)) {
    //
  } else {
    Disa_INT_Hcoder();
  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка Переключателя Режима ********** //////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Switch_Thread() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_Thrd();
  Mode = Mode_Thread;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
  Thr_Pass_Summ = 0;
  Pass_Fin = 0;
  Print();
}

void Switch_Feed() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_Z_Feed();
  Mode = Mode_Feed;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
  Pass_Total = 1;
  Ap = 0;
  Print();
}

void Switch_aFeed() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_aFD();
  Mode = Mode_aFeed;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  // Ks_Count = 0;
  // Km_Count = 0;
  // Repeat_Count = 0;
  Pass_Total = 1;
  //Enc_Pos = 0;
  Ap = 0;
  Print();
}

void Switch_Cone_L() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_Z_Feed();
  Mode = Mode_Cone_L_R;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
  Pass_Total = 1;
  q = 0;
  Ap = 0;
  Print();
}

void Switch_Cone_R() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_Z_Feed();
  Mode = Mode_Cone_R;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
  Pass_Total = 1;
  q = 0;
  Ap = 0;
  Print();
}

void Switch_Reserve() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Mode = Mode_Reserve;

  //if (!Joy_Z_flag && !Joy_X_flag)


  Print();
}

void Switch_Sphere() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  //   Ena_INT_Z_Feed(); //
  Mode = Mode_Sphere;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
  Pass_Total = 1;
  Ap = 0;
  SelectMenu = 0;
  w = 0;
  Print();
}

void Switch_Divider() {
  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Ena_INT_Thrd();
  Mode = Mode_Divider;
  Step_Z_flag = OFF;
  Step_X_flag = OFF;
  rapid_step_Z_flag = OFF;
  rapid_step_X_flag = OFF;
  Ks_Count = 0;
  Km_Count = 0;
  Repeat_Count = 0;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка Переключателя Подрежима ********** ///////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Switch_Int() {
  switch (Mode) {
    case Mode_Thread:
    case Mode_Feed:
    case Mode_aFeed:
    case Mode_Cone_L_R:
    case Mode_Cone_R:
      if ((limit_Left_flag == ON && limit_Right_flag == ON) || (limit_Front_flag == ON && limit_Rear_flag == ON)) {
        Sub_Mode_Thread = Sub_Mode_Thread_Int;
        Sub_Mode_Feed = Sub_Mode_Feed_Int;
        Sub_Mode_aFeed = Sub_Mode_aFeed_Int;
        Sub_Mode_Cone = Sub_Mode_Cone_Int;
        err_1_flag = false;
        Step_Z_flag = OFF;
        Step_X_flag = OFF;
        rapid_step_Z_flag = OFF;
        rapid_step_X_flag = OFF;
        Ks_Count = 0;
        Km_Count = 0;
        Repeat_Count = 0;

        if (Motor_Z_Pos == Limit_Pos_Right || Motor_Z_Pos == Limit_Pos_Left || Motor_X_Pos == Limit_Pos_Rear || Motor_X_Pos == Limit_Pos_Front) {
          err_2_flag = false;
        } else {
          Sub_Mode_Thread = Sub_Mode_Thread_Man;
          Sub_Mode_Feed = Sub_Mode_Feed_Man;
          Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
          Sub_Mode_Cone = Sub_Mode_Cone_Man;
          err_2_flag = true;
          Beep_Error();
        }
      } else {
        Sub_Mode_Thread = Sub_Mode_Thread_Man;
        Sub_Mode_Feed = Sub_Mode_Feed_Man;
        Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
        Sub_Mode_Cone = Sub_Mode_Cone_Man;
        err_1_flag = true;
        Beep_Error();
      }

      Print();
      break;


    case Mode_Sphere:  /////////////////////////////////////////////////////////////////////////////////////
      if (limit_Right_flag == ON && limit_Rear_flag == ON) {
        Sub_Mode_Sphere = Sub_Mode_Sphere_Int;
        err_1_flag = false;
        Step_Z_flag = OFF;
        Step_X_flag = OFF;
        Ks_Count = 0;
        Km_Count = 0;
        Repeat_Count = 0;

        if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear) {
          err_2_flag = false;
        } else {
          Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
          err_2_flag = true;
          Beep_Error();
        }
      } else {
        Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
        err_1_flag = true;
        Beep_Error();
      }
      Print();
      break;
  }
}

void Switch_Man() {
  switch (Mode) {
    case Mode_Thread:
    case Mode_Feed:
    case Mode_aFeed:
    case Mode_Cone_L_R:
    case Mode_Cone_R:
    case Mode_Sphere:
      Sub_Mode_Thread = Sub_Mode_Thread_Man;
      Sub_Mode_Feed = Sub_Mode_Feed_Man;
      Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
      Sub_Mode_Cone = Sub_Mode_Cone_Man;
      Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
      err_1_flag = false;
      err_2_flag = false;
      Step_Z_flag = OFF;
      Step_X_flag = OFF;
      rapid_step_Z_flag = OFF;
      rapid_step_X_flag = OFF;
      Ks_Count = 0;
      Km_Count = 0;
      Repeat_Count = 0;
      Print();
      break;
  }
}

void Switch_Ext() {
  switch (Mode)  //////////////////////////////////////////////////////////////////////////////////////////////
  {
    case Mode_Thread:
    case Mode_Feed:
    case Mode_aFeed:
    case Mode_Cone_L_R:
    case Mode_Cone_R:

      if ((limit_Left_flag == ON && limit_Right_flag == ON) || (limit_Front_flag == ON && limit_Rear_flag == ON)) {
        Sub_Mode_Thread = Sub_Mode_Thread_Ext;
        Sub_Mode_Feed = Sub_Mode_Feed_Ext;
        Sub_Mode_aFeed = Sub_Mode_aFeed_Ext;
        Sub_Mode_Cone = Sub_Mode_Cone_Ext;
        err_1_flag = false;
        Step_Z_flag = OFF;
        Step_X_flag = OFF;
        rapid_step_Z_flag = OFF;
        rapid_step_X_flag = OFF;
        Ks_Count = 0;
        Km_Count = 0;
        Repeat_Count = 0;

        if (Motor_Z_Pos == Limit_Pos_Right || Motor_Z_Pos == Limit_Pos_Left || Motor_X_Pos == Limit_Pos_Rear || Motor_X_Pos == Limit_Pos_Front) {
          err_2_flag = false;
        } else {
          Sub_Mode_Thread = Sub_Mode_Thread_Man;
          Sub_Mode_Feed = Sub_Mode_Feed_Man;
          Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
          Sub_Mode_Cone = Sub_Mode_Cone_Man;
          err_2_flag = true;
          Beep_Error();
        }
      } else {
        Sub_Mode_Thread = Sub_Mode_Thread_Man;
        Sub_Mode_Feed = Sub_Mode_Feed_Man;
        Sub_Mode_aFeed = Sub_Mode_aFeed_Man;
        Sub_Mode_Cone = Sub_Mode_Cone_Man;
        err_1_flag = true;
        Beep_Error();
      }
      Print();
      break;


    case Mode_Sphere:  /////////////////////////////////////////////////////////////////////////////////////
      if (limit_Right_flag == ON && limit_Rear_flag == ON) {
        Sub_Mode_Sphere = Sub_Mode_Sphere_Ext;
        err_1_flag = false;
        Step_Z_flag = OFF;
        Step_X_flag = OFF;
        Ks_Count = 0;
        Km_Count = 0;
        Repeat_Count = 0;

        if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear) {
          err_2_flag = false;
        } else {
          Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
          err_2_flag = true;
          Beep_Error();
        }
      } else {
        Sub_Mode_Sphere = Sub_Mode_Sphere_Man;
        err_1_flag = true;
        Beep_Error();
      }
      Print();
      break;
  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка Кнопок Меню ********** ///////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработчик нажатия кнопки Select **********
void Key_Select_Pressed() {
  if (!key_sel_flag) {
    switch (Mode) {
      case Mode_Feed:
        if (!Joy_Z_flag && !Joy_X_flag) {
          Rev_Count_F = 0;
          Beep();
        }
        break;
      case Mode_aFeed:
        if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man)
          if (SelectMenu_aFeed == 1) {
            SelectMenu_aFeed = 2;
            Beep();
          } else if (SelectMenu_aFeed == 2) {
            SelectMenu_aFeed = 1;
            Beep();
          }
        if (!Joy_Z_flag && !Joy_X_flag) {
          //
        }
        break;

      case Mode_Cone_L_R:
        if (!Joy_Z_flag && !Joy_X_flag) {
          //
        }
        break;

      case Mode_Cone_R:
        if (!Joy_Z_flag && !Joy_X_flag) {
          //
        }
        break;

      case Mode_Thread:
        if (!Joy_Z_flag && !Joy_X_flag) {
          Rev_Count = 0;
          Beep();
        }
        break;

      case Mode_Sphere:
        if (!Joy_Z_flag && !Joy_X_flag) {
        }
        break;

      case Mode_Divider:
        if (!Joy_Z_flag && !Joy_X_flag) {
          Enc_Pos = 0;
          Beep();
        }

        break;
      case Mode_Reserve:
        if (Menu_Reserve_String == 99) {
          break;
        }
        if ((SelectMenu_Reserve == 3) && (SetupError == 1 || SetupError == 2 || SetupError == 3 || SetupError == 4)) {
          SetupError = 0;
          break;
        }
        if (SelectMenu_Reserve == 1) {
          SelectMenu_Reserve = 2;
        } else if (SelectMenu_Reserve == 2) {
          SelectMenu_Reserve = 3;
          Menu_Reserve_String = 1;
        } else if (SelectMenu_Reserve == 3) {
          SelectMenu_Reserve = 1;
           Serial.begin(9600);
  //Печатаем исходные переменные на основе которых быдет выполняться расчёт
  
  //Печатаем резьбы
  Serial.print("\nTHREAD Thread_Info:\n");
  for (int i = 0; i < TOTAL_THREADS; i++) {
    String Str = String(Thread_Info[i].Step) + " Kz = " + Thread_Info[i].Ks_Div_Z + "," + Thread_Info[i].Km_Div_Z
                 + " Kx = " + Thread_Info[i].Ks_Div_X + "," + Thread_Info[i].Km_Div_X + "  " + Thread_Info[i].Thread_Print
                 + "  " + Thread_Info[i].Pass + "  " + Thread_Info[i].Limit_Print + "\n";
    //String Str = String(Thread_Info[i].Step) +

    Serial.print(Str);
  }

  //Печатаем Конуса
   Serial.print("\n\nCONE Cone_Info[]:\n");
  for (int j = 0; j < TOTAL_CONE; j++) {
    Serial.print(j);
    Serial.print(" Cs_Div= ");
    Serial.print(Cone_Info[j].Cs_Div);
    Serial.print(" , Cm_Div= ");
    Serial.print(Cone_Info[j].Cm_Div);
    Serial.print("  ");
    Serial.print(Cone_Info[j].Cone_Print);
    Serial.print("\n");
  }

  Serial.print("\n\nCONE Cone1_Info[]:\n");
  for (int j = 0; j < TOTAL_CONE1; j++) {
    Serial.print(j);
    Serial.print(" Cs_Div= ");
    Serial.print(Cone1_Info[j].Cs_Div);
    Serial.print(" , Cm_Div= ");
    Serial.print(Cone1_Info[j].Cm_Div);
    Serial.print("  ");
    Serial.print(Cone1_Info[j].Cone_Print);
    Serial.print("\n");
  }
        }



        break;
    }
    key_sel_flag = true;
    Print();
  }
}

// ********** Обработчик нажатия кнопки Up **********
void Key_Up_Pressed() {
  if (!button_up_flag) {
    switch (Mode) {
      case Mode_Feed:
        if (Sub_Mode_Feed == Sub_Mode_Feed_Int || Sub_Mode_Feed == Sub_Mode_Feed_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap < 500) {
            Ap = Ap + 10;
            Beep();
          }
          /* else if (Ap < 200) {Ap = Ap + 20;  Beep();}
           else if (Ap < 500) {Ap = Ap + 50;  Beep();}
           else if (Ap < 900) {Ap = Ap + 100; Beep();}*/
        }
        Print();
        break;

      case Mode_aFeed:
        if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int || Sub_Mode_aFeed == Sub_Mode_aFeed_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap < 500) {
            Ap = Ap + 10;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Thread:
        if (Sub_Mode_Thread == Sub_Mode_Thread_Man && Thread_Step < TOTAL_THREADS - 1) {
          if (!Joy_Z_flag && !Joy_X_flag) {
            Thread_Step++;
            Ks_Count = 0;
            Km_Count = 0;
            Repeat_Count = 0;
            Step_Z_flag = OFF;
            Step_X_flag = OFF;
            rapid_step_Z_flag = OFF;
            rapid_step_X_flag = OFF;
            Thr_Pass_Summ = 0;  //
            Pass_Fin = 0;       //
            Beep();
          }
        } else if (Sub_Mode_Thread == Sub_Mode_Thread_Int && Thread_Info[Thread_Step].Pass + PASS_FINISH + Thr_Pass_Summ < 99 && !Joy_Z_flag && !Joy_X_flag) {
          Thr_Pass_Summ++;
          Beep();
        } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && Thread_Info[Thread_Step].Pass + PASS_FINISH + Thr_Pass_Summ < 99 && !Joy_Z_flag && !Joy_X_flag) {
          Thr_Pass_Summ++;
          Beep();
        }

        Print();
        break;

      case Mode_Sphere:
        if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Sph_R_mm < 2500) {
            Sph_R_mm = Sph_R_mm + 50;
            Beep();
          }
          /*else if (Sph_R_mm < 2500) {Sph_R_mm = Sph_R_mm + 50;  Beep();}
              else if (Sph_R_mm < 4750) {Sph_R_mm = Sph_R_mm + 250; Beep();}*/

          R_Quad = Sph_R_mm * Sph_R_mm;
          Sph_R = (MOTOR_X_STEP_PER_REV * McSTEP_X * Sph_R_mm / SCREW_X);
        }

        else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man && !Joy_Z_flag && !Joy_X_flag) {
          if (Cutter_Step < TOTAL_CUTTER_WIDTH - 1) {
            Cutter_Step++;
            Cutter_Width = Cutter_Width_array[Cutter_Step];
            Beep();
          }
        }
        Print();
        break;

      case Mode_Divider:
        if (Total_Tooth < 255) {
          Total_Tooth++;
          Current_Tooth = 1;
          Beep();
        }

      case Mode_Cone_L_R:

        if (Sub_Mode_Cone == Sub_Mode_Cone_Man && Cone_Step > 0 && !Joy_Z_flag && !Joy_X_flag) {
          Cone_Step--;
          Ks_Count = 0;
          Km_Count = 0;
          Repeat_Count = 0;
          Step_Z_flag = OFF;
          Step_X_flag = OFF;
          rapid_step_Z_flag = OFF;
          rapid_step_X_flag = OFF;
          Beep();
        } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int || Sub_Mode_Cone == Sub_Mode_Cone_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap < 500) {
            Ap = Ap + 10;
            Beep();
          }
          //else if (Ap < 900) {Ap = Ap + 50;  Beep();}
        }

        Print();
        break;



      case Mode_Cone_R:
        Print();
        break;





      case Mode_Reserve:

        if (SelectMenu_Reserve == 3) {
          if (Menu_Reserve_String == 2) {
            Menu_Reserve_String = 1;
            Beep();
          } else if (Menu_Reserve_String == 3) {
            Menu_Reserve_String = 2;
            Beep();
          } else if (Menu_Reserve_String == 4) {
            Menu_Reserve_String = 3;
            Beep();
          } else if (Menu_Reserve_String == 5) {
            Menu_Reserve_String = 4;
            Beep();
          } else if (Menu_Reserve_String == 6) {
            Menu_Reserve_String = 5;
            Beep();
          } else if (Menu_Reserve_String == 7) {
            Menu_Reserve_String = 6;
            Beep();
          } else if (Menu_Reserve_String == 8) {
            Menu_Reserve_String = 7;
            Beep();
          } else if (Menu_Reserve_String == 9) {
            Menu_Reserve_String = 8;
            Beep();
          } else if (Menu_Reserve_String == 10) {
            Menu_Reserve_String = 9;
            Beep();
          } else if (Menu_Reserve_String == 11) {
            Menu_Reserve_String = 10;
            Beep();
          } else if (Menu_Reserve_String == 12) {
            Menu_Reserve_String = 11;
            Beep();
          } else if (Menu_Reserve_String == 13) {
            Menu_Reserve_String = 12;
            Beep();
          } else if (Menu_Reserve_String == 14) {
            Menu_Reserve_String = 13;
            Beep();
          } else if (Menu_Reserve_String == 15) {
            Menu_Reserve_String = 14;
            Beep();
          } else if (Menu_Reserve_String == 16) {
            Menu_Reserve_String = 15;
            Beep();
          } else if (Menu_Reserve_String == 17) {
            Menu_Reserve_String = 16;
            Beep();
          } else if (Menu_Reserve_String == 18) {
            Menu_Reserve_String = 17;
            Beep();
          } else if (Menu_Reserve_String == 19) {
            Menu_Reserve_String = 18;
            Beep();
          } else if (Menu_Reserve_String == 20) {
            Menu_Reserve_String = 19;
            Beep();
          } else if (Menu_Reserve_String == 21) {
            Menu_Reserve_String = 20;
            Beep();
          } else if (Menu_Reserve_String == 22) {
            Menu_Reserve_String = 21;
            Beep();
          } else if (Menu_Reserve_String == 23) {
            Menu_Reserve_String = 22;
            Beep();
          } else if (Menu_Reserve_String == 24) {
            Menu_Reserve_String = 23;
            Beep();
          } else if (Menu_Reserve_String == 25) {
            Menu_Reserve_String = 24;
            Beep();
          } else if (Menu_Reserve_String == 26) {
            Menu_Reserve_String = 25;
            Beep();
          } else if (Menu_Reserve_String == 27) {
            Menu_Reserve_String = 26;
            Beep();
          } else if (Menu_Reserve_String == 28) {
            Menu_Reserve_String = 27;
            Beep();
          } else if (Menu_Reserve_String == 29) {
            Menu_Reserve_String = 28;
            Beep();
          } else if (Menu_Reserve_String == 30) {
            Menu_Reserve_String = 29;
            Beep();
          } else if (Menu_Reserve_String == 31) {
            Menu_Reserve_String = 30;
            Beep();
          } else if (Menu_Reserve_String == 32) {
            Menu_Reserve_String = 31;
            Beep();
          }

          Print();
          break;
        }
    }
    button_up_flag = true;
  }
}

// ********** Обработчик нажатия кнопки Down **********
void Key_Down_Pressed() {
  if (!button_down_flag) {
    switch (Mode) {
      case Mode_Feed:
        if (Sub_Mode_Feed == Sub_Mode_Feed_Int || Sub_Mode_Feed == Sub_Mode_Feed_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap > 0) {
            Ap = Ap - 1;
            Beep();
          }
          /* else if (Ap > 200) {Ap = Ap - 50;  Beep();}
            else if (Ap > 100) {Ap = Ap - 20;  Beep();}
            else if (Ap > 0)   {Ap = Ap - 10;  Beep();}*/
        }
        Print();
        break;

      case Mode_aFeed:
        if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int || Sub_Mode_aFeed == Sub_Mode_aFeed_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap > 0) {
            Ap = Ap - 1;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Thread:
        if (Sub_Mode_Thread == Sub_Mode_Thread_Man && Thread_Step > 0) {
          if (!Joy_Z_flag && !Joy_X_flag) {
            Thread_Step--;
            Ks_Count = 0;
            Km_Count = 0;
            Repeat_Count = 0;
            Step_Z_flag = OFF;
            Step_X_flag = OFF;
            rapid_step_Z_flag = OFF;
            rapid_step_X_flag = OFF;
            Thr_Pass_Summ = 0;
            Pass_Fin = 0;
            Beep();
          }
        } else if (Sub_Mode_Thread == Sub_Mode_Thread_Int && (Thread_Info[Thread_Step].Pass + Thr_Pass_Summ) > 4 && !Joy_Z_flag && !Joy_X_flag) {
          Thr_Pass_Summ--;
          Beep();
        } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && (Thread_Info[Thread_Step].Pass + Thr_Pass_Summ) > 4 && !Joy_Z_flag && !Joy_X_flag) {
          Thr_Pass_Summ--;
          Beep();
        }
        Print();
        break;

      case Mode_Sphere:
        if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Sph_R_mm > 100) {
            Sph_R_mm = Sph_R_mm - 25;
            Beep();
          }
          /*else if (Sph_R_mm > 1250) {Sph_R_mm = Sph_R_mm - 50;  Beep();}
               else if (Sph_R_mm > 50)   {Sph_R_mm = Sph_R_mm - 25;  Beep();}*/
          if (Sph_R_mm < Bar_R_mm) Bar_R_mm = Sph_R_mm;

          R_Quad = Sph_R_mm * Sph_R_mm;
          Sph_R = (MOTOR_X_STEP_PER_REV * McSTEP_X * Sph_R_mm / SCREW_X);  // радиус сферы в шагах
        }

        else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man && !Joy_Z_flag && !Joy_X_flag) {
          if (Cutter_Step > 0) {
            Cutter_Step--;
            Cutter_Width = Cutter_Width_array[Cutter_Step];
            Beep();
          }
        }
        Print();
        break;

      case Mode_Cone_L_R:
        if (Sub_Mode_Cone == Sub_Mode_Cone_Man && Cone_Step < TOTAL_CONE - 1 && !Joy_Z_flag && !Joy_X_flag) {
          Cone_Step++;
          Ks_Count = 0;
          Km_Count = 0;
          Repeat_Count = 0;
          Step_Z_flag = OFF;
          Step_X_flag = OFF;
          rapid_step_Z_flag = OFF;
          rapid_step_X_flag = OFF;
          Beep();
        } else if (Sub_Mode_Cone == Sub_Mode_Cone_Int || Sub_Mode_Cone == Sub_Mode_Cone_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Ap > 0) {
            Ap = Ap - 1;
            Beep();
          }
          //else if (Ap > 0)   {Ap = Ap - 10;  Beep();}
        }

        Print();
        break;



      case Mode_Cone_R:
        Print();
        break;

      case Mode_Divider:
        if (Total_Tooth > 1) {
          Total_Tooth--;
          Current_Tooth = 1;
          Beep();
        }
        Print();
        break;

      case Mode_Reserve:
        if (SelectMenu_Reserve == 3) {
          if (Menu_Reserve_String == 1) {
            Menu_Reserve_String = 2;
            Beep();
          } else if (Menu_Reserve_String == 2) {
            Menu_Reserve_String = 3;
            Beep();
          } else if (Menu_Reserve_String == 3) {
            Menu_Reserve_String = 4;
            Beep();
          } else if (Menu_Reserve_String == 4) {
            Menu_Reserve_String = 5;
            Beep();
          } else if (Menu_Reserve_String == 5) {
            Menu_Reserve_String = 6;
            Beep();
          } else if (Menu_Reserve_String == 6) {
            Menu_Reserve_String = 7;
            Beep();
          } else if (Menu_Reserve_String == 7) {
            Menu_Reserve_String = 8;
            Beep();
          } else if (Menu_Reserve_String == 8) {
            Menu_Reserve_String = 9;
            Beep();
          } else if (Menu_Reserve_String == 9) {
            Menu_Reserve_String = 10;
            Beep();
          } else if (Menu_Reserve_String == 10) {
            Menu_Reserve_String = 11;
            Beep();
          } else if (Menu_Reserve_String == 11) {
            Menu_Reserve_String = 12;
            Beep();
          } else if (Menu_Reserve_String == 12) {
            Menu_Reserve_String = 13;
            Beep();
          } else if (Menu_Reserve_String == 13) {
            Menu_Reserve_String = 14;
            Beep();
          } else if (Menu_Reserve_String == 14) {
            Menu_Reserve_String = 15;
            Beep();
          } else if (Menu_Reserve_String == 15) {
            Menu_Reserve_String = 16;
            Beep();
          } else if (Menu_Reserve_String == 16) {
            Menu_Reserve_String = 17;
            Beep();
          } else if (Menu_Reserve_String == 17) {
            Menu_Reserve_String = 18;
            Beep();
          } else if (Menu_Reserve_String == 18) {
            Menu_Reserve_String = 19;
            Beep();
          } else if (Menu_Reserve_String == 19) {
            Menu_Reserve_String = 20;
            Beep();
          } else if (Menu_Reserve_String == 20) {
            Menu_Reserve_String = 21;
            Beep();
          } else if (Menu_Reserve_String == 21) {
            Menu_Reserve_String = 22;
            Beep();
          } else if (Menu_Reserve_String == 22) {
            Menu_Reserve_String = 23;
            Beep();
          } else if (Menu_Reserve_String == 23) {
            Menu_Reserve_String = 24;
            Beep();
          } else if (Menu_Reserve_String == 24) {
            Menu_Reserve_String = 25;
            Beep();
          } else if (Menu_Reserve_String == 25) {
            Menu_Reserve_String = 26;
            Beep();
          } else if (Menu_Reserve_String == 26) {
            Menu_Reserve_String = 27;
            Beep();
          } else if (Menu_Reserve_String == 27) {
            Menu_Reserve_String = 28;
            Beep();
          } else if (Menu_Reserve_String == 28) {
            Menu_Reserve_String = 29;
            Beep();
          } else if (Menu_Reserve_String == 29) {
            Menu_Reserve_String = 30;
            Beep();
          } else if (Menu_Reserve_String == 30) {
            Menu_Reserve_String = 31;
            Beep();
          } else if (Menu_Reserve_String == 31) {
            Menu_Reserve_String = 32;
            Beep();
          }
          Print();
          break;
        }
    }
    button_down_flag = true;
  }
}

// ********** Обработчик нажатия кнопки Left **********
void Key_Left_Pressed() {
  if (!button_left_flag) {
    switch (Mode) {
      case Mode_Feed:
        if (!Joy_Z_flag && !Joy_X_flag && Pass_Total > 1) {
          if (Sub_Mode_Feed == Sub_Mode_Feed_Int || Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
            Pass_Total--;
            Beep();
          }
        }
        Print();
        break;

      case Mode_aFeed:
        if (!Joy_Z_flag && !Joy_X_flag && Pass_Total > 1) {
          if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int || Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
            Pass_Total--;
            Beep();
          }
        }
        Print();
        break;


      case Mode_Cone_L_R:
        if (Sub_Mode_Cone == Sub_Mode_Cone_Man && !Joy_Z_flag && !Joy_X_flag) {
          Mode2_Cone--;
          if (Mode2_Cone < 1) { Mode2_Cone = 2; }
          Beep();
        }

        else if (!Joy_Z_flag && !Joy_X_flag && Pass_Total > 1) {
          if (Sub_Mode_Cone == Sub_Mode_Cone_Int) {
            Pass_Total--;
            Beep();
          } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext) {
            Pass_Total--;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Cone_R:
        Print();
        break;

      case Mode_Sphere:
        if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Bar_R_mm > 0) {
            Bar_R_mm = Bar_R_mm - 25;
            Bar_R = (MOTOR_X_STEP_PER_REV * McSTEP_X * Bar_R_mm / SCREW_X);
            Beep();
          }
        } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man && !Joy_Z_flag && !Joy_X_flag) {
          if (Cutting_Step > 0) {
            Cutting_Step--;
            Cutting_Width = Cutting_Width_array[Cutting_Step];
            Beep();
          }
        }
        Print();
        break;

      case Mode_Divider:
        if (Current_Tooth > 1) {
          Current_Tooth--;
          Beep();
        } else if (Current_Tooth == 1) {
          Current_Tooth = Total_Tooth;
          Beep();
        }
        Print();
        break;

      case Mode_Thread:
        if (!Joy_Z_flag && !Joy_X_flag) {
          if (Sub_Mode_Thread == Sub_Mode_Thread_Int && Pass_Fin > 0) {
            Pass_Fin--;
            Beep();
          } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && Pass_Fin > 0) {
            Pass_Fin--;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Reserve:
        if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 1)) {
          byte Submode_New = Submode_Read;
          if (Submode_New == B11000000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV - 1;
          }  //Switch_Int
          else if (Submode_New == B10100000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV - 10;
          } else if (Submode_New == B01100000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV - 100;
          }  //Switch_Ext
          if (ENC_LINE_PER_REV < 300) PP_X = 300;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 2)) {
          SCREW_Z = SCREW_Z - 1;
          if (SCREW_Z < 50) SCREW_Z = 50;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 3)) {
          MOTOR_Z_STEP_PER_REV = MOTOR_Z_STEP_PER_REV - 1;
          if (MOTOR_Z_STEP_PER_REV < 100) MOTOR_Z_STEP_PER_REV = 100;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 4)) {
          McSTEP_Z = McSTEP_Z - 1;
          if (McSTEP_Z < 1) McSTEP_Z = 1;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 5)) {
          REBOUND_Z = REBOUND_Z - 1;
          if (REBOUND_Z < 1) REBOUND_Z = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 6)) {
          SCREW_X = SCREW_X - 1;
          if (SCREW_X < 50) SCREW_X = 50;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 7)) {
          MOTOR_X_STEP_PER_REV = MOTOR_X_STEP_PER_REV - 1;
          if (MOTOR_X_STEP_PER_REV < 100) MOTOR_X_STEP_PER_REV = 100;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 8)) {
          McSTEP_X = McSTEP_X - 1;
          if (McSTEP_X < 1) McSTEP_X = 1;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 9)) {
          REBOUND_X = REBOUND_X - 1;
          if (REBOUND_X < 1) REBOUND_X = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 10)) {
          THRD_ACCEL = THRD_ACCEL - 1;
          if (THRD_ACCEL < 1) THRD_ACCEL = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 11)) {
          FEED_ACCEL = FEED_ACCEL - 1;
          if (FEED_ACCEL < 1) FEED_ACCEL = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 12)) {
          MIN_FEED = MIN_FEED - 1;
          if (MIN_FEED < 1) MIN_FEED = 1;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 13)) {
          MAX_FEED = MAX_FEED - 1;
          if (MAX_FEED < 10) MAX_FEED = 10;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 14)) {
          MIN_aFEED = MIN_aFEED - 1;
          if (MIN_aFEED < 1) MIN_aFEED = 1;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 15)) {
          MAX_aFEED = MAX_aFEED - 1;
          if (MAX_aFEED < 10) MAX_aFEED = 10;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 16)) {
          MAX_RAPID_MOTION_Z = MAX_RAPID_MOTION_Z - 1;
          if (MAX_RAPID_MOTION_Z < 1) MAX_RAPID_MOTION_Z = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 17)) {
          MAX_RAPID_MOTION_X = MAX_RAPID_MOTION_X - 1;
          if (MAX_RAPID_MOTION_X < 1) MAX_RAPID_MOTION_X = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 18)) {
          MIN_RAPID_MOTION1 = MIN_RAPID_MOTION1 - 1;
          if (MIN_RAPID_MOTION1 < 1) MIN_RAPID_MOTION1 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 19)) {
          REPEAt1 = REPEAt1 - 1;
          if (REPEAt1 < 1) REPEAt1 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 20)) {
          HC_SCALE_1 = HC_SCALE_1 - 1;
          if (HC_SCALE_1 < 1) HC_SCALE_1 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 21)) {
          HC_SCALE_10 = HC_SCALE_10 - 1;
          if (HC_SCALE_10 < 1) HC_SCALE_10 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 22)) {
          HC_START_SPEED_1 = HC_START_SPEED_1 - 1;
          if (HC_START_SPEED_1 < 1) HC_START_SPEED_1 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 23)) {
          HC_MAX_SPEED_1 = HC_MAX_SPEED_1 - 1;
          if (HC_MAX_SPEED_1 < 1) HC_MAX_SPEED_1 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 24)) {
          HC_START_SPEED_10 = HC_START_SPEED_10 - 1;
          if (HC_START_SPEED_10 < 1) HC_START_SPEED_10 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 25)) {
          HC_MAX_SPEED_10 = HC_MAX_SPEED_10 - 1;
          if (HC_MAX_SPEED_10 < 1) HC_MAX_SPEED_10 = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 26)) {
          HC_X_DIR = HC_X_DIR - 1;
          if (HC_X_DIR < 0) HC_X_DIR = 0;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 27)) {
          PP_X = PP_X - 1;
          if (PP_X < 0) PP_X = 0;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 28)) {
          PASS_FINISH = PASS_FINISH - 1;
          if (PASS_FINISH < 1) PASS_FINISH = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 29)) {
          Th = Th - 1;
          if (Th < 1) Th = 1;

          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 30)) {
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 31)) {
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 32)) {

        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 90)) {
          Beep();
          Data_Setup_Param.ENC_LINE_PER_REV = ENC_LINE_PER_REV;
          Data_Setup_Param.SCREW_Z = SCREW_Z;
          Data_Setup_Param.MOTOR_Z_STEP_PER_REV = MOTOR_Z_STEP_PER_REV;
          Data_Setup_Param.McSTEP_Z = McSTEP_Z;
          Data_Setup_Param.REBOUND_Z = REBOUND_Z;

          Data_Setup_Param.SCREW_X = SCREW_X;
          Data_Setup_Param.MOTOR_X_STEP_PER_REV = MOTOR_X_STEP_PER_REV;
          Data_Setup_Param.McSTEP_X = McSTEP_X;
          Data_Setup_Param.REBOUND_X = REBOUND_X;

          Data_Setup_Param.THRD_ACCEL = THRD_ACCEL;
          Data_Setup_Param.FEED_ACCEL = FEED_ACCEL;

          Data_Setup_Param.MIN_FEED = MIN_FEED;
          Data_Setup_Param.MAX_FEED = MAX_FEED;
          Data_Setup_Param.MIN_aFEED = MIN_aFEED;
          Data_Setup_Param.MAX_aFEED = MAX_aFEED;

          Data_Setup_Param.MAX_RAPID_MOTION_Z = MAX_RAPID_MOTION_Z;
          Data_Setup_Param.MAX_RAPID_MOTION_X = MAX_RAPID_MOTION_X;
          Data_Setup_Param.MIN_RAPID_MOTION1 = MIN_RAPID_MOTION1;

          Data_Setup_Param.REPEAt1 = REPEAt1;

          Data_Setup_Param.HC_SCALE_1 = HC_SCALE_1;
          Data_Setup_Param.HC_SCALE_10 = HC_SCALE_10;

          Data_Setup_Param.HC_START_SPEED_1 = HC_START_SPEED_1;
          Data_Setup_Param.HC_START_SPEED_10 = HC_START_SPEED_10;

          Data_Setup_Param.HC_MAX_SPEED_1 = HC_MAX_SPEED_1;
          Data_Setup_Param.HC_MAX_SPEED_10 = HC_MAX_SPEED_10;
          Data_Setup_Param.HC_X_DIR = HC_X_DIR;

          Data_Setup_Param.PP_X = PP_X;
          Data_Setup_Param.PASS_FINISH = PASS_FINISH;
          Data_Setup_Param.Th = Th;
          EEPROM.put(0, Data_Setup_Param);
          SetupError = 5;
          Menu_Reserve_String = 99;
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 91)) {
          Beep();
          EEPROM.write(INIT_ADDR, 255);
          ResetSetupParam();
          SetupError = 5;
          Menu_Reserve_String = 99;
        }
        Print();
        break;
    }
    button_left_flag = true;
  }
}

// ********** Обработчик нажатия кнопки Right **********
void Key_Right_Pressed() {
  if (!button_right_flag) {
    switch (Mode) {
      case Mode_Feed:
        if (!Joy_Z_flag && !Joy_X_flag && Pass_Total < 99) {
          if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
            Pass_Total++;
            Beep();
          }
          if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
            Pass_Total++;
            Beep();
          }
        }

        Print();
        break;

      case Mode_aFeed:
        if (!Joy_Z_flag && !Joy_X_flag && Pass_Total < 99) {
          if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
            Pass_Total++;
            Beep();
          }
          if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
            Pass_Total++;
            Beep();
          }
        }

        Print();
        break;

      case Mode_Cone_L_R:
        if (Sub_Mode_Cone == Sub_Mode_Cone_Man && !Joy_Z_flag && !Joy_X_flag) {
          Mode2_Cone++;
          if (Mode2_Cone > 2) { Mode2_Cone = 1; }
          Beep();
        } else if (!Joy_Z_flag && !Joy_X_flag && Pass_Total < 99) {
          if (Sub_Mode_Cone == Sub_Mode_Cone_Int) {
            Pass_Total++;
            Beep();
          } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext) {
            Pass_Total++;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Cone_R:
        Print();
        break;

      case Mode_Sphere:
        if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext && !Joy_Z_flag && !Joy_X_flag) {
          if (Bar_R_mm < Sph_R_mm) {
            Bar_R_mm = Bar_R_mm + 50;
            Bar_R = (MOTOR_X_STEP_PER_REV * McSTEP_X * Bar_R_mm / SCREW_X);  // радиус недореза в шагах
            Beep();
          }
        } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man && !Joy_Z_flag && !Joy_X_flag) {
          if (Cutting_Step < TOTAL_CUTTING_STEP - 1) {
            Cutting_Step++;
            Cutting_Width = Cutting_Width_array[Cutting_Step];
            Beep();
          }
        }
        Print();
        break;

      case Mode_Divider:
        if (Current_Tooth < Total_Tooth) {
          Current_Tooth++;
          Beep();
        } else if (Current_Tooth == Total_Tooth) {
          Current_Tooth = 1;
          Beep();
        }
        Print();
        break;

      case Mode_Thread:
        if (!Joy_Z_flag && !Joy_X_flag) {
          if (Sub_Mode_Thread == Sub_Mode_Thread_Int && Pass_Fin < 9) {
            Pass_Fin++;
            Beep();
          } else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && Pass_Fin < 9) {
            Pass_Fin++;
            Beep();
          }
        }
        Print();
        break;

      case Mode_Reserve:
        if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 1)) {
          byte Submode_New = Submode_Read;
          if (Submode_New == B11000000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV + 1;
          }  //Switch_Int
          else if (Submode_New == B10100000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV + 10;
          } else if (Submode_New == B01100000) {
            ENC_LINE_PER_REV = ENC_LINE_PER_REV + 100;
          }  //Switch_Ext
          if (ENC_LINE_PER_REV < 300) ENC_LINE_PER_REV = 300;
          Beep();
          if (ENC_LINE_PER_REV > 2500) ENC_LINE_PER_REV = 2500;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 2)) {
          SCREW_Z = SCREW_Z + 1;
          if (SCREW_Z > 500) SCREW_Z = 500;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 3)) {
          MOTOR_Z_STEP_PER_REV = MOTOR_Z_STEP_PER_REV + 1;
          if (MOTOR_Z_STEP_PER_REV > 800) MOTOR_Z_STEP_PER_REV = 800;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 4)) {
          McSTEP_Z = McSTEP_Z + 1;
          if (McSTEP_Z > 8) McSTEP_Z = 8;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 5)) {
          REBOUND_Z = REBOUND_Z + 1;
          if (REBOUND_Z > 800) REBOUND_Z = 800;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 6)) {
          SCREW_X = SCREW_X + 1;
          if (SCREW_X > 500) SCREW_X = 500;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 7)) {
          MOTOR_X_STEP_PER_REV = MOTOR_X_STEP_PER_REV + 1;
          if (MOTOR_X_STEP_PER_REV > 800) MOTOR_X_STEP_PER_REV = 800;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 8)) {
          McSTEP_X = McSTEP_X + 1;
          if (McSTEP_X > 8) McSTEP_X = 8;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 9)) {
          REBOUND_X = REBOUND_X + 1;
          if (REBOUND_X > 800) REBOUND_X = 800;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 10)) {
          THRD_ACCEL = THRD_ACCEL + 1;
          if (THRD_ACCEL > 255) THRD_ACCEL = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 11)) {
          FEED_ACCEL = FEED_ACCEL + 1;
          if (FEED_ACCEL > 15) FEED_ACCEL = 15;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 12)) {
          MIN_FEED = MIN_FEED + 1;
          if (MIN_FEED > 10) MIN_FEED = 10;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 13)) {
          MAX_FEED = MAX_FEED + 1;
          if (MAX_FEED > 150) MAX_FEED = 150;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 14)) {
          MIN_aFEED = MIN_aFEED + 1;
          if (MIN_aFEED > 50) MIN_aFEED = 50;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 15)) {
          MAX_aFEED = MAX_aFEED + 1;
          if (MAX_aFEED > 600) MAX_aFEED = 600;
          Beep();
          //CheckingParameters();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 16)) {
          MAX_RAPID_MOTION_Z = MAX_RAPID_MOTION_Z + 1;
          if (MAX_RAPID_MOTION_Z > 255) MAX_RAPID_MOTION_Z = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 17)) {
          MAX_RAPID_MOTION_X = MAX_RAPID_MOTION_X + 1;
          if (MAX_RAPID_MOTION_X > 255) MAX_RAPID_MOTION_X = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 18)) {
          MIN_RAPID_MOTION1 = MIN_RAPID_MOTION1 + 1;
          if (MIN_RAPID_MOTION1 > 255) MIN_RAPID_MOTION1 = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 19)) {
          REPEAt1 = REPEAt1 + 1;
          if (REPEAt1 > 10) REPEAt1 = 10;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 20)) {
          HC_SCALE_1 = HC_SCALE_1 + 1;
          if (HC_SCALE_1 > 10) HC_SCALE_1 = 10;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 21)) {
          HC_SCALE_10 = HC_SCALE_10 + 1;
          if (HC_SCALE_10 > 100) HC_SCALE_10 = 100;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 22)) {
          HC_START_SPEED_1 = HC_START_SPEED_1 + 1;
          if (HC_START_SPEED_1 > 300) HC_START_SPEED_1 = 300;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 23)) {
          HC_MAX_SPEED_1 = HC_MAX_SPEED_1 + 1;
          if (HC_MAX_SPEED_1 > 255) HC_MAX_SPEED_1 = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 24)) {
          HC_START_SPEED_10 = HC_START_SPEED_10 + 1;
          if (HC_START_SPEED_10 > 255) HC_START_SPEED_10 = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 25)) {
          HC_MAX_SPEED_10 = HC_MAX_SPEED_10 + 1;
          if (HC_MAX_SPEED_10 > 255) HC_MAX_SPEED_10 = 255;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 26)) {
          HC_X_DIR = HC_X_DIR + 1;
          if (HC_X_DIR > 1) HC_X_DIR = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 27)) {
          PP_X = PP_X + 1;
          if (PP_X > 1) PP_X = 1;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 28)) {
          PASS_FINISH = PASS_FINISH + 1;
          if (PASS_FINISH > 15) PASS_FINISH = 15;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 29)) {
          Th = Th + 1;
          if (Th > 20000) Th = 40000;
          Beep();
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 30)) {
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 31)) {
          Beep();
          Menu_Reserve_String = 90;
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 32)) {
          Beep();
          Menu_Reserve_String = 91;
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 90)) {
          Beep();
          Menu_Reserve_String = 1;
        } else if ((SelectMenu_Reserve == 3) && (Menu_Reserve_String == 91)) {
          Beep();
          Menu_Reserve_String = 1;
        }
        Print();
        break;
    }
    button_right_flag = true;
  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка кнопок лимита ********** /////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработчик нажатия кнопки Limit_Left **********
void Limit_Left_Pressed() {
  if (!limit_button_flag) {
    limit_button_flag = true;
    switch (Mode) {
      case Mode_Thread:
      case Mode_Feed:
      case Mode_aFeed:
      case Mode_Cone_L_R:
      case Mode_Cone_R:
        if (!Joy_Z_flag && Submode_Read == B10100000) {
          if (limit_Left_flag == OFF) {
            if (Motor_Z_Pos > (Limit_Pos_Right + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
              limit_Left_flag = ON;
              Limit_Pos_Left = ((Motor_Z_Pos + McSTEP_Z / 2) & ~(McSTEP_Z - 1));
              Limit_Left_LED_On();
              Beep();
            }
          } else {
            limit_Left_flag = OFF;
            Limit_Pos_Left = Limit_Pos_Max;
            Limit_Left_LED_Off();
            Beep();
          }
        }
    }
  }
}

// ********** Обработчик нажатия кнопки Limit_Right **********
void Limit_Right_Pressed() {
  if (!limit_button_flag) {
    limit_button_flag = true;
    switch (Mode) {
      case Mode_Thread:
      case Mode_Feed:
      case Mode_aFeed:
      case Mode_Cone_L_R:
      case Mode_Cone_R:
      case Mode_Sphere:
        if (!Joy_Z_flag && Submode_Read == B10100000) {
          if (limit_Right_flag == OFF) {
            if (Motor_Z_Pos < (Limit_Pos_Left - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt) * 2)) {
              limit_Right_flag = ON;
              Limit_Pos_Right = ((Motor_Z_Pos + McSTEP_Z / 2) & ~(McSTEP_Z - 1));
              Limit_Right_LED_On();
              Beep();
            }
          } else {
            limit_Right_flag = OFF;
            Limit_Pos_Right = Limit_Pos_Min;
            Limit_Right_LED_Off();
            Beep();
          }
        }
    }
  }
}

// ********** Обработчик нажатия кнопки Limit_Front **********
void Limit_Front_Pressed() {
  if (!limit_button_flag) {
    limit_button_flag = true;
    switch (Mode) {
      case Mode_Thread:
      case Mode_Feed:
      case Mode_aFeed:
        if (!Joy_X_flag && Submode_Read == B10100000) {
          if (limit_Front_flag == OFF) {
            if (Motor_X_Pos > (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
              limit_Front_flag = ON;
              Limit_Pos_Front = ((Motor_X_Pos + McSTEP_X / 2) & ~(McSTEP_X - 1));
              Limit_Front_LED_On();
              Beep();
            }
          } else {
            limit_Front_flag = OFF;
            Limit_Pos_Front = Limit_Pos_Max;
            Limit_Front_LED_Off();
            Beep();
          }
        }
    }
  }
}

// ********** Обработчик нажатия кнопки Limit_Rear **********
void Limit_Rear_Pressed() {
  if (!limit_button_flag) {
    limit_button_flag = true;
    switch (Mode) {
      case Mode_Thread:
      case Mode_Feed:
      case Mode_aFeed:
      case Mode_Sphere:
        if (!Joy_X_flag && Submode_Read == B10100000) {
          if (limit_Rear_flag == OFF) {
            if (Motor_X_Pos < (Limit_Pos_Front - ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
              limit_Rear_flag = ON;
              Limit_Pos_Rear = ((Motor_X_Pos + McSTEP_X / 2) & ~(McSTEP_X - 1));
              Limit_Rear_LED_On();
              Beep();
            }
          } else {
            limit_Rear_flag = OFF;
            Limit_Pos_Rear = Limit_Pos_Min;
            Limit_Rear_LED_Off();
            Beep();
          }
        }
    }
  }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка переключателя оси РГИ ********** /////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Switch_Hand_Axis_Z() {
  Motor_X_Disable();
  Motor_Z_Enable();

  flag_hand_X = OFF;
  hand_X = OFF;
  flag_hand_Z = ON;

  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Null_Z_Pos = Motor_Z_Pos;

  Disable_INT_OCR3B();
  Enable_INT_OCR3A();
  Ena_INT_Hcoder();
}

void Switch_Hand_Axis_X() {
  Motor_Z_Disable();
  Motor_X_Enable();

  flag_hand_Z = OFF;
  hand_Z = OFF;
  flag_hand_X = ON;

  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_X_Pos = 0;
  Null_X_Pos = Motor_X_Pos;

  Disable_INT_OCR3A();
  Enable_INT_OCR3B();
  Ena_INT_Hcoder();
}

void Switch_Hand_Axis_No() {
  Motor_X_Disable();
  Motor_Z_Disable();

  flag_hand_Z = OFF;
  hand_Z = OFF;
  flag_hand_X = OFF;
  hand_X = OFF;

  Hand_Count = 0;
  Hand_Count_New = 0;
  Hand_Count_Old = 0;
  Hand_Z_Pos = 0;
  Hand_X_Pos = 0;

  Null_Z_Pos = Motor_Z_Pos;
  Null_X_Pos = Motor_X_Pos;

  Disa_INT_Hcoder();
  Disable_INT_OCR3A();
  Disable_INT_OCR3B();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Обработка Масштаба РГИ ********** /////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Switch_Scale_x1() {
  flag_Scale_x10 = OFF;
  flag_Scale_x1 = ON;
  hand_Z = OFF;
  hand_X = OFF;
}

void Switch_Scale_x10() {
  flag_Scale_x1 = OFF;
  flag_Scale_x10 = ON;
  hand_Z = OFF;
  hand_X = OFF;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ***** Print ***** /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Print() {
  if (Mode == Mode_Thread)  //////////////////////////////////////////////////////////
  {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Int) snprintf(LCD_Row_1, 21, "  THREAD    internal");       //РЕЗЬБА внутренняя
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Man) snprintf(LCD_Row_1, 21, "  THREAD            ");  //РЕЗЬБА
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext) snprintf(LCD_Row_1, 21, "  THREAD    external");  //РЕЗЬБА наружная

    int lenTP = strlen(Thread_Info[Thread_Step].Thread_Print);
    if (Sub_Mode_Thread == Sub_Mode_Thread_Int && lenTP == 4) snprintf(LCD_Row_2, 21, "step  %s mm         ", Thread_Info[Thread_Step].Thread_Print);        // шаг
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Int && lenTP == 3) snprintf(LCD_Row_2, 21, "step  %s tpi         ", Thread_Info[Thread_Step].Thread_Print);  // шаг
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Man && lenTP == 4) snprintf(LCD_Row_2, 21, "step  %s mm     \4\3", Thread_Info[Thread_Step].Thread_Print);   // шаг в мм
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Man && lenTP == 3) snprintf(LCD_Row_2, 21, "step  %s tpi     \4\3", Thread_Info[Thread_Step].Thread_Print);  // шаг в tpi
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && lenTP == 4) snprintf(LCD_Row_2, 21, "step  %s mm         ", Thread_Info[Thread_Step].Thread_Print);   // шаг
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext && lenTP == 3) snprintf(LCD_Row_2, 21, "step  %s tpi         ", Thread_Info[Thread_Step].Thread_Print);  // шаг


    if (Sub_Mode_Thread == Sub_Mode_Thread_Int) snprintf(LCD_Row_3, 21, "total passes   %2d \4\3", (Thread_Info[Thread_Step].Pass - Pass_Nr + 1 + PASS_FINISH + Pass_Fin) + Thr_Pass_Summ);       // всего проходов
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Man) snprintf(LCD_Row_3, 21, "max:   %s rpm         ", Thread_Info[Thread_Step].Limit_Print);                                                     // максимальные обороты
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext) snprintf(LCD_Row_3, 21, "total passes   %2d \4\3", (Thread_Info[Thread_Step].Pass - Pass_Nr + 1 + PASS_FINISH + Pass_Fin) + Thr_Pass_Summ);  // всего проходов


    if (Sub_Mode_Thread == Sub_Mode_Thread_Int) snprintf(LCD_Row_4, 21, "finishing      %2d \1\2", PASS_FINISH + Pass_Fin);       // из них чистовых
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Man) snprintf(LCD_Row_4, 21, "          %5ld turn", Rev_Count);                   //  0 витков
    else if (Sub_Mode_Thread == Sub_Mode_Thread_Ext) snprintf(LCD_Row_4, 21, "finishing      %2d \1\2", PASS_FINISH + Pass_Fin);  // из них чистовых
  }

  else if (Mode == Mode_Feed)  //////////////////////////////////////////////////////////
  {
    if (Sub_Mode_Feed == Sub_Mode_Feed_Int) {
      snprintf(LCD_Row_1, 21, "  FEED      internal");                                            // СИНХРОННАЯ внутри
      snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev  ", Feed_mm / 100, Feed_mm % 100);           //Подача мм/об
      snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);               //проходов
      if (PP_X == 0) snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);   // съём/R:
      if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);  // съём/Ф:
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Man) {
      snprintf(LCD_Row_1, 21, "  FEED              ");  // СИНХРОННАЯ
      snprintf(LCD_Row_2, 21, "                    ");
      snprintf(LCD_Row_3, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  //Подача мм/об
      snprintf(LCD_Row_4, 21, "          %5ld turn", Rev_Count_F);                        //  0 витков
    } else if (Sub_Mode_Feed == Sub_Mode_Feed_Ext) {
      snprintf(LCD_Row_1, 21, "  FEED      external");                                            // СИНХРОННАЯ снаружи
      snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev    ", Feed_mm / 100, Feed_mm % 100);         //Подача мм/об
      snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);               //проходов
      if (PP_X == 0) snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);   // съём/R:
      if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);  // съём/Ф:
    }
  }


  else if (Mode == Mode_aFeed)  //////////////////////////////////////////////////////////
  {
    if (Sub_Mode_aFeed == Sub_Mode_aFeed_Int) {
      snprintf(LCD_Row_1, 21, "  A FEED    internal");                               // АСИНХРОННАЯ внутри
      snprintf(LCD_Row_2, 21, "feed  %3d mm/min     ", aFeed_mm);                    //Подача мм/мин
      snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);  //проходов
      snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);     // съём/R:
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Man) {
      if (SelectMenu_aFeed == 1) {
        snprintf(LCD_Row_1, 21, "  A FEED            ");  //АСИНХРОННАЯ
        snprintf(LCD_Row_2, 21, "                    ");
        snprintf(LCD_Row_3, 21, "feed  %3d mm/min    ", aFeed_mm);  //Подача мм/мин
        snprintf(LCD_Row_4, 21, "                    ");
      }

      else if (SelectMenu_aFeed == 2) {
        snprintf(LCD_Row_1, 21, " A FEED STRAIGHTEDGE");
        snprintf(LCD_Row_2, 21, "feed  %3d mm/min    ", aFeed_mm);  //Подача мм/мин

        if (Size_X_mm % 100 >= 0) {
          snprintf(LCD_Row_3, 21, "axis X:    %3ld.%02d mm", Size_X_mm / 100, Size_X_mm % 100);
        } else snprintf(LCD_Row_3, 21, "axis X:   -%3ld.%02d mm", abs(Size_X_mm / 100), abs(Size_X_mm % 100));


        if (Size_Z_mm % 100 >= 0) {
          snprintf(LCD_Row_4, 21, "axis Z:    %3ld.%02d mm", Size_Z_mm / 100, Size_Z_mm % 100);
        } else snprintf(LCD_Row_4, 21, "axis Z:   -%3ld.%02d mm", abs(Size_Z_mm / 100), abs(Size_Z_mm % 100));
      }
    } else if (Sub_Mode_aFeed == Sub_Mode_aFeed_Ext) {
      snprintf(LCD_Row_1, 21, "  A FEED    external");                               // СИНХРОННАЯ снаружи
      snprintf(LCD_Row_2, 21, "feed  %3d mm/min     ", aFeed_mm);                    //Подача мм/мин
      snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);  //проходов
      snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);     // съём/R:
    }
  }


  else if (Mode == Mode_Cone_L_R)  //////////////////////////////////////////////////////////////
  {
    if (Mode2_Cone == 1) {
      if (Sub_Mode_Cone == Sub_Mode_Cone_Int) {
        snprintf(LCD_Row_1, 21, "CONE < %s internal", Cone_Info[Cone_Step].Cone_Print);     //конус < внутри
        snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  //подача мм/об
        snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);       //  проходов осталось
        snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);          // съём/R:
                                                                                            //if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);  // съём/Ф:
      } else if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
        snprintf(LCD_Row_1, 21, "\1\2CONE  <  %s   \4\3", Cone_Info[Cone_Step].Cone_Print);  //конус <
        snprintf(LCD_Row_2, 21, "                    ");
        snprintf(LCD_Row_3, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  // подача мм/об
        snprintf(LCD_Row_4, 21, "                    ");
      } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext) {
        snprintf(LCD_Row_1, 21, "CONE < %s external", Cone_Info[Cone_Step].Cone_Print);                       //конус < снаружи
        snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);                    //  подача мм/об
        snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);                         //  проходов осталось
        snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3    %1d.%02d\xBC\xBC  \4\3", Ap / 100, Ap % 100);  // съём/R:
        //if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);                           // съём/Ф:
      }
    } else if (Mode2_Cone == 2) {
      if (Sub_Mode_Cone == Sub_Mode_Cone_Int) {
        snprintf(LCD_Row_1, 21, "CONE > %s internal", Cone_Info[Cone_Step].Cone_Print);     //конус > внутри
        snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  //подача мм/об
        snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);       //  проходов осталось
        snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);          // съём/R:
        //if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);  // съём/Ф:
      } else if (Sub_Mode_Cone == Sub_Mode_Cone_Man) {
        snprintf(LCD_Row_1, 21, "\1\2CONE  >  %s   \4\3", Cone_Info[Cone_Step].Cone_Print);  //конус >
        snprintf(LCD_Row_2, 21, "                    ");
        snprintf(LCD_Row_3, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  // подача мм/об
        snprintf(LCD_Row_4, 21, "                    ");
      } else if (Sub_Mode_Cone == Sub_Mode_Cone_Ext) {
        snprintf(LCD_Row_1, 21, "CONE > %s external", Cone_Info[Cone_Step].Cone_Print);     //конус > снаружи
        snprintf(LCD_Row_2, 21, "feed  %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);  //  подача мм/об
        snprintf(LCD_Row_3, 21, "passage %2d        \1\2", Pass_Total - Pass_Nr + 1);       //  проходов осталось
        snprintf(LCD_Row_4, 21, "cut/R    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);          // съём/R:
        //if (PP_X == 1) snprintf(LCD_Row_4, 21, "cut/\6    %1d.%02dmm   \4\3", Ap / 100, Ap % 100);  // съём/Ф:
      }
    }

  }

  else if (Mode == Mode_Cone_R)  //////////////////////////////////////////////////////////////
  {
    snprintf(LCD_Row_1, 21, "                    ");
    snprintf(LCD_Row_2, 21, "                    ");
    snprintf(LCD_Row_3, 21, "                    ");
    snprintf(LCD_Row_4, 21, "                    ");
  }


  else if (Mode == Mode_Reserve)  //////////////////////////////////////////////////////////////
  {
    if (SelectMenu_Reserve == 1) {
      snprintf(LCD_Row_1, 21, "     TACHOMETER     ");
      snprintf(LCD_Row_2, 21, "                    ");
      snprintf(LCD_Row_3, 21, " %4ld  RPM          ", RPM, RPM);
      snprintf(LCD_Row_4, 21, "                    ");
      // snprintf(LCD_Row_4, 21, "%10ld          ", myTime1);

    }


    else if (SelectMenu_Reserve == 2) {
      snprintf(LCD_Row_1, 21, "    STRAIGHTEDGE    ");
      snprintf(LCD_Row_2, 21, "                    ");
      if (Size_X_mm % 100 >= 0) {
        snprintf(LCD_Row_3, 21, "axis X:    %3ld.%02d mm", Size_X_mm / 100, Size_X_mm % 100);
      } else snprintf(LCD_Row_3, 21, "axis X:   -%3ld.%02d mm", abs(Size_X_mm / 100), abs(Size_X_mm % 100));
      if (Size_Z_mm % 100 >= 0) {
        snprintf(LCD_Row_4, 21, "axis Z:    %3ld.%02d mm", Size_Z_mm / 100, Size_Z_mm % 100);
      } else snprintf(LCD_Row_4, 21, "axis Z:   -%3ld.%02d mm", abs(Size_Z_mm / 100), abs(Size_Z_mm % 100));
    }

    else if (SelectMenu_Reserve == 3) {
      snprintf(LCD_Row_1, 21, "   \3\4  SETUP  %2d(32)", Menu_Reserve_String);
      if (Menu_Reserve_String == 1) {
        snprintf(LCD_Row_2, 21, "\1\2ENC_LINE      %4ld", ENC_LINE_PER_REV);
        snprintf(LCD_Row_3, 21, "  SCREW_Z           ");
        snprintf(LCD_Row_4, 21, "  MOTOR_Z_STEP      ");
      } else if (Menu_Reserve_String == 2) {
        snprintf(LCD_Row_2, 21, "  ENC_LINE          ");
        snprintf(LCD_Row_3, 21, "\1\2SCREW_Z       %4ld", SCREW_Z);
        snprintf(LCD_Row_4, 21, "  MOTOR_Z_STEP      ");
      } else if (Menu_Reserve_String == 3) {
        snprintf(LCD_Row_2, 21, "  SCREW_Z           ");
        snprintf(LCD_Row_3, 21, "\1\2MOTOR_Z_STEP  %4ld", MOTOR_Z_STEP_PER_REV);
        snprintf(LCD_Row_4, 21, "  McSTEP_Z          ");
      } else if (Menu_Reserve_String == 4) {
        snprintf(LCD_Row_2, 21, "  MOTOR_Z_STEP      ");
        snprintf(LCD_Row_3, 21, "\1\2McSTEP_Z      %4ld", McSTEP_Z);
        snprintf(LCD_Row_4, 21, "  REBOUND_Z         ");
      } else if (Menu_Reserve_String == 5) {
        snprintf(LCD_Row_2, 21, "  McSTEP_Z          ");
        snprintf(LCD_Row_3, 21, "\1\2REBOUND_Z     %4ld", REBOUND_Z);
        snprintf(LCD_Row_4, 21, "  SCREW_X           ");
      } else if (Menu_Reserve_String == 6) {
        snprintf(LCD_Row_2, 21, "  REBOUND_Z         ");
        snprintf(LCD_Row_3, 21, "\1\2SCREW_X       %4ld", SCREW_X);
        snprintf(LCD_Row_4, 21, "  MOTOR_X_STEP      ");
      } else if (Menu_Reserve_String == 7) {
        snprintf(LCD_Row_2, 21, "  SCREW_X           ");
        snprintf(LCD_Row_3, 21, "\1\2MOTOR_X_STEP  %4ld", MOTOR_X_STEP_PER_REV);
        snprintf(LCD_Row_4, 21, "  McSTEP_X          ");
      } else if (Menu_Reserve_String == 8) {
        snprintf(LCD_Row_2, 21, "  MOTOR_X_STEP      ");
        snprintf(LCD_Row_3, 21, "\1\2McSTEP_X      %4ld", McSTEP_X);
        snprintf(LCD_Row_4, 21, "  REBOUND_X         ");
      } else if (Menu_Reserve_String == 9) {
        snprintf(LCD_Row_2, 21, "  McSTEP_X          ");
        snprintf(LCD_Row_3, 21, "\1\2REBOUND_X     %4ld", REBOUND_X);
        snprintf(LCD_Row_4, 21, "  THRD_ACCEL        ");
      } else if (Menu_Reserve_String == 10) {
        snprintf(LCD_Row_2, 21, "  REBOUND_X         ");
        snprintf(LCD_Row_3, 21, "\1\2THRD_ACCEL    %4ld", THRD_ACCEL);
        snprintf(LCD_Row_4, 21, "  FEED_ACCEL        ");
      } else if (Menu_Reserve_String == 11) {
        snprintf(LCD_Row_2, 21, "  THRD_ACCEL        ");
        snprintf(LCD_Row_3, 21, "\1\2FEED_ACCEL    %4ld", FEED_ACCEL);
        snprintf(LCD_Row_4, 21, "  MIN_FEED          ");
      } else if (Menu_Reserve_String == 12) {
        snprintf(LCD_Row_2, 21, "  FEED_ACCEL        ");
        snprintf(LCD_Row_3, 21, "\1\2MIN_FEED      %4ld", MIN_FEED);
        snprintf(LCD_Row_4, 21, "  MAX_FEED          ");
      } else if (Menu_Reserve_String == 13) {
        snprintf(LCD_Row_2, 21, "  MIN_FEED          ");
        snprintf(LCD_Row_3, 21, "\1\2MAX_FEED      %4ld", MAX_FEED);
        snprintf(LCD_Row_4, 21, "  MIN_aFEED         ");
      } else if (Menu_Reserve_String == 14) {
        snprintf(LCD_Row_2, 21, "  MAX_FEED          ");
        snprintf(LCD_Row_3, 21, "\1\2MIN_aFEED     %4ld", MIN_aFEED);
        snprintf(LCD_Row_4, 21, "  MAX_aFEED         ");
      } else if (Menu_Reserve_String == 15) {
        snprintf(LCD_Row_2, 21, "  MIN_aFEED         ");
        snprintf(LCD_Row_3, 21, "\1\2MAX_aFEED     %4ld", MAX_aFEED);
        snprintf(LCD_Row_4, 21, "  MAX_RAPID_Z       ");
      } else if (Menu_Reserve_String == 16) {
        snprintf(LCD_Row_2, 21, "  MAX_aFEED         ");
        snprintf(LCD_Row_3, 21, "\1\2MAX_RAPID_Z   %4ld", MAX_RAPID_MOTION_Z);
        snprintf(LCD_Row_4, 21, "  MAX_RAPID_X       ");
      } else if (Menu_Reserve_String == 17) {
        snprintf(LCD_Row_2, 21, "  MAX_RAPID_Z       ");
        snprintf(LCD_Row_3, 21, "\1\2MAX_RAPID_X   %4ld", MAX_RAPID_MOTION_X);
        snprintf(LCD_Row_4, 21, "  MIN_RAPID         ");
      } else if (Menu_Reserve_String == 18) {
        snprintf(LCD_Row_2, 21, "  MAX_RAPID_X       ");
        snprintf(LCD_Row_3, 21, "\1\2MIN_RAPID     %4ld", MIN_RAPID_MOTION1);
        snprintf(LCD_Row_4, 21, "  REPEAt            ");
      } else if (Menu_Reserve_String == 19) {
        snprintf(LCD_Row_2, 21, "  MIN_RAPID         ");
        snprintf(LCD_Row_3, 21, "\1\2REPEAt        %4ld", REPEAt1);
        snprintf(LCD_Row_4, 21, "  HC_SCALE_1        ");
      } else if (Menu_Reserve_String == 20) {
        snprintf(LCD_Row_2, 21, "  REPEAt            ");
        snprintf(LCD_Row_3, 21, "\1\2HC_SCALE_1    %4ld", HC_SCALE_1);
        snprintf(LCD_Row_4, 21, "  HC_SCALE_10       ");
      } else if (Menu_Reserve_String == 21) {
        snprintf(LCD_Row_2, 21, "  HC_SCALE_1        ");
        snprintf(LCD_Row_3, 21, "\1\2HC_SCALE_10   %4ld", HC_SCALE_10);
        snprintf(LCD_Row_4, 21, "  HC_START_SP_1     ");
      } else if (Menu_Reserve_String == 22) {
        snprintf(LCD_Row_2, 21, "  HC_SCALE_10       ");
        snprintf(LCD_Row_3, 21, "\1\2HC_START_SP_1 %4ld", HC_START_SPEED_1);
        snprintf(LCD_Row_4, 21, "  HC_MAX_SP_1       ");
      } else if (Menu_Reserve_String == 23) {
        snprintf(LCD_Row_2, 21, "  HC_START_SP_1     ");
        snprintf(LCD_Row_3, 21, "\1\2HC_MAX_SP_1     %4ld", HC_MAX_SPEED_1);
        snprintf(LCD_Row_4, 21, "  HC_START_SP_10    ");
      } else if (Menu_Reserve_String == 24) {
        snprintf(LCD_Row_2, 21, "  HC_MAX_SP_1       ");
        snprintf(LCD_Row_3, 21, "\1\2HC_START_SP_10 %4ld", HC_START_SPEED_10);
        snprintf(LCD_Row_4, 21, "  HC_MAX_SP_10      ");
      } else if (Menu_Reserve_String == 25) {
        snprintf(LCD_Row_2, 21, "  HC_START_SP_10    ");
        snprintf(LCD_Row_3, 21, "\1\2HC_MAX_SP_10  %4ld", HC_MAX_SPEED_10);
        snprintf(LCD_Row_4, 21, "  HC_X_DIR          ");
      } else if (Menu_Reserve_String == 26) {
        snprintf(LCD_Row_2, 21, "  HC_MAX_SP_10      ");
        snprintf(LCD_Row_3, 21, "\1\2HC_X_DIR      %4ld", HC_X_DIR);
        snprintf(LCD_Row_4, 21, "  PP_X              ");
      } else if (Menu_Reserve_String == 27) {
        snprintf(LCD_Row_2, 21, "  HC_X_DIR          ");
        snprintf(LCD_Row_3, 21, "\1\2PP_X          %4ld", PP_X);
        snprintf(LCD_Row_4, 21, "  PASS_FINISH       ");
      } else if (Menu_Reserve_String == 28) {
        snprintf(LCD_Row_2, 21, "  PP_X              ");
        snprintf(LCD_Row_3, 21, "\1\2PASS_FINISH   %4ld", PASS_FINISH);
        snprintf(LCD_Row_4, 21, "  Th                ");
      } else if (Menu_Reserve_String == 29) {
        snprintf(LCD_Row_2, 21, "  PASS_FINISH       ");
        snprintf(LCD_Row_3, 21, "\1\2Th           %5ld", Th);
        snprintf(LCD_Row_4, 21, "  ****************  ");
      } else if (Menu_Reserve_String == 30) {
        snprintf(LCD_Row_2, 21, " Th                 ");
        snprintf(LCD_Row_3, 21, "  ****************  ");
        snprintf(LCD_Row_4, 21, "                    ");
      } else if (Menu_Reserve_String == 31) {
        snprintf(LCD_Row_2, 21, "                    ");
        snprintf(LCD_Row_3, 21, "        Save       \2");
        snprintf(LCD_Row_4, 21, "                    ");
      } else if (Menu_Reserve_String == 32) {
        snprintf(LCD_Row_2, 21, " !!!!!!!!!!!!!!!!!! ");
        snprintf(LCD_Row_3, 21, "        RESSET     \2");
        snprintf(LCD_Row_4, 21, " !!!!!!!!!!!!!!!!!! ");
      } else if (Menu_Reserve_String == 90) {
        snprintf(LCD_Row_1, 21, "       CONFIRM      ");
        snprintf(LCD_Row_2, 21, "        Save        ");
        snprintf(LCD_Row_3, 21, " YES             NO ");
        snprintf(LCD_Row_4, 21, "  \1               \2 ");
      } else if (Menu_Reserve_String == 91) {
        snprintf(LCD_Row_1, 21, "       CONFIRM      ");
        snprintf(LCD_Row_2, 21, "        RESSET      ");
        snprintf(LCD_Row_3, 21, " YES             NO ");
        snprintf(LCD_Row_4, 21, "  \1               \2 ");
      }
    }
  }


  else if (Mode == Mode_Sphere)  //////////////////////////////////////////////////////////////
  {
    if (Sub_Mode_Sphere == Sub_Mode_Sphere_Int) {
      snprintf(LCD_Row_1, 21, "  SPHR      internal");
      snprintf(LCD_Row_2, 21, "      there is      ");  // Нет такого режима
      snprintf(LCD_Row_3, 21, "    no such mode    ");
      snprintf(LCD_Row_4, 21, "                    ");
    } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Man) {
      snprintf(LCD_Row_1, 21, "  SPHR              ");                                                  //Шар
      snprintf(LCD_Row_2, 21, "feed   %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);               //  подача мм/об
      snprintf(LCD_Row_3, 21, "cutter %1d.%02d mm    \4\3", Cutter_Width / 100, Cutter_Width % 100);    //резец
      snprintf(LCD_Row_4, 21, "Z step %1d.%02d mm    \1\2", Cutting_Width / 100, Cutting_Width % 100);  //Шаг по Z
    } else if (Sub_Mode_Sphere == Sub_Mode_Sphere_Ext) {
      snprintf(LCD_Row_1, 21, "  SPHR      external");  //Шар снаружи
      snprintf(LCD_Row_2, 21, "feed   %1d.%02d mm/rev   ", Feed_mm / 100, Feed_mm % 100);
      snprintf(LCD_Row_3, 21, "\6 sphr   %2ld.%01ld mm  \4\3", Sph_R_mm * 2 / 100, Sph_R_mm * 2 / 10 % 10);
      snprintf(LCD_Row_4, 21, "\6 leg    %2ld.%01ld mm  \1\2", Bar_R_mm * 2 / 100, Bar_R_mm * 2 / 10 % 10);  //Bar_R_mm*2/100, Bar_R_mm*2%100)
    }
  }




  else if (Mode == Mode_Divider)  /////////////////////////////////////////////////////////////
  {
    long Spindle_Angle = Enc_Pos * 360000 / ENC_TICK;
    long Required_Angle = 360000 * (Current_Tooth - 1) / Total_Tooth;

    snprintf(LCD_Row_1, 21, "spindle angle %3ld.%01ld\5", Spindle_Angle / 1000, Spindle_Angle % 1000 / 100);    //угол шпинделя
    snprintf(LCD_Row_2, 21, "total sectors \4\3%3d ", Total_Tooth);                                             //всего секторов
    snprintf(LCD_Row_3, 21, "select sector \1\3%3d ", Current_Tooth);                                           // выбор сектора
    snprintf(LCD_Row_4, 21, "angle sector  %3ld.%01ld\5", Required_Angle / 1000, Required_Angle % 1000 / 100);  //угол сектора
  }

  // Печать ошибки
  if (err_1_flag == true) {
    snprintf(LCD_Row_2, 21, "                    ");
    snprintf(LCD_Row_3, 21, "       STOPS        ");  //"       УПОРЫ        "
    snprintf(LCD_Row_4, 21, "   not installed    ");  //"   не установлены   "

  } else if (err_2_flag == true) {
    snprintf(LCD_Row_2, 21, "    The  SUPPORT    ");
    snprintf(LCD_Row_3, 21, "     must be on     ");  //"      СУППОРТ       "
    snprintf(LCD_Row_4, 21, "      the STOP      ");  //"должен быть на УПОРЕ"

  } else if (err_3_flag == true) {
    snprintf(LCD_Row_2, 21, "    Not supported   ");
    snprintf(LCD_Row_3, 21, "    in this mode    ");  //" В данном режиме    "
    snprintf(LCD_Row_4, 21, "                    ");  //"не поддерживается   "

  } else if (Complete_flag == true) {
    snprintf(LCD_Row_2, 21, "                    ");
    snprintf(LCD_Row_3, 21, "Operation completed ");  //" OПEPAЦИЯ 3ABEPШEHA "
    snprintf(LCD_Row_4, 21, "                    ");

  } else if (SetupError == 1) {
    snprintf(LCD_Row_1, 21, "                    ");
    snprintf(LCD_Row_2, 21, "        ERROR       ");
    snprintf(LCD_Row_3, 21, "       MIN_FEED     ");
    snprintf(LCD_Row_4, 21, "%8ld    %8ld", a, e);

  } else if (SetupError == 2) {
    snprintf(LCD_Row_1, 21, "                    ");
    snprintf(LCD_Row_2, 21, "        ERROR       ");
    snprintf(LCD_Row_3, 21, "       MAX_FEED     ");
    snprintf(LCD_Row_4, 21, "%8ld    %8ld", b, f);

  } else if (SetupError == 3) {
    snprintf(LCD_Row_1, 21, "                    ");
    snprintf(LCD_Row_2, 21, "        ERROR       ");
    snprintf(LCD_Row_3, 21, "       MIN_aFEED    ");
    snprintf(LCD_Row_4, 21, "%8ld    %8ld", c, g);

  } else if (SetupError == 4) {
    snprintf(LCD_Row_1, 21, "                    ");
    snprintf(LCD_Row_2, 21, "        ERROR       ");
    snprintf(LCD_Row_3, 21, "       MAX_aFEED    ");
    snprintf(LCD_Row_4, 21, "%8ld    %8ld", d, h);

  } else if (SetupError == 5) {
    snprintf(LCD_Row_1, 21, "      Changes       ");
    snprintf(LCD_Row_2, 21, "     require a      ");
    snprintf(LCD_Row_3, 21, "       REBOOT       ");
    snprintf(LCD_Row_4, 21, "                    ");
  }
  lcd.setCursor(0, 0);
  lcd.print(LCD_Row_1);
  //lcd.print("   ");

  lcd.setCursor(0, 1);
  lcd.print(LCD_Row_2);  //lcd.print(LCD_Row_2); lcd.print(Enc_Pos / 2);
  //lcd.print("   ");

  lcd.setCursor(0, 2);
  lcd.print(LCD_Row_3);
  //lcd.print("   ");

  lcd.setCursor(0, 3);
  lcd.print(LCD_Row_4);
  //lcd.print("   ");


  // if ((SetupError == 4) || (SetupError == 3) || (SetupError == 2) || (SetupError == 1)) {
  //   Beep_Error();
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //   delay(500);
  //  // delay(5000);
  //   SetupError = 0;
  // }
}


void Rapid_Sphere_Right(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;

  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Sphere_Rear(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Быстрая Подача Джейстик" ********** //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Rapid_Sphere_Left_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Sphere_Right_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_Sphere_Rear_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим " Цикл ШАР" ********** /////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void Rapid_Sphere_Front_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}




void Sphere_Ext(bool& a_flag, bool& b_flag) {
  int Pass_Total = Sph_R_mm * 2 / Cutting_Width;

  if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total + 1) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      long Infeed_Value;
      {
        if (Pass_Nr <= Pass_Total / 2) Infeed_Value = (long)((float)MOTOR_Z_STEP_PER_REV * (Cutting_Width * Pass_Nr) / SCREW_Z + 0.5) * McSTEP_Z;
        else Infeed_Value = (long)((float)MOTOR_Z_STEP_PER_REV * ((Cutting_Width * (Pass_Nr - 1) + Cutter_Width)) / SCREW_Z + 0.5) * McSTEP_Z;
      }

      Limit_Pos_Left = (Null_Z_Pos + Infeed_Value);
      Limit_Left_LED_On();
      BeepBeep();
      Feed_Left(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    if (Pass_Nr <= Pass_Total + 1) {
      a_flag = false;
      b_flag = false;

      long Infeed_Value;
      if (Pass_Nr > Pass_Total / 2) {
        long A = Cutting_Width * (Pass_Nr - (Pass_Total / 2 + 1));
        float B = sqrt(R_Quad - A * A);
        float E = (Sph_R_mm - B) * MOTOR_X_STEP_PER_REV / SCREW_X;
        Infeed_Value = ((long)E * McSTEP_X);
        if (Infeed_Value > Sph_R - Bar_R) {
          Infeed_Value = Sph_R - Bar_R;
        }
      }

      else {
        long A = Sph_R_mm - Cutting_Width * Pass_Nr;
        float B = sqrt(R_Quad - A * A);
        float E = (Sph_R_mm - B) * MOTOR_X_STEP_PER_REV / SCREW_X;
        Infeed_Value = ((long)E * McSTEP_X);
      }

      Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
      Limit_Pos_Right = Limit_Pos_Left;
      Limit_Front_LED_On();

      Feed_Front(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Rear = (Null_X_Pos - REBOUND_X);
    Pass_Nr++;
    /*Попробуйте для теста, в закладке Sphere подменить в 70-ой строке:
if (Motor_X_Pos >= (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION) * REPEAt) *2)) {Rapid_Sphere_Rear(a_flag, b_flag);}
на
if (Motor_X_Pos >= (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION) * REPEAt) *2)) {Feed_Rear(a_flag, b_flag);}
*/
    if (Motor_X_Pos >= (Limit_Pos_Rear + ((MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt) * 2)) {
      Feed_Rear(a_flag, b_flag);
    } else {
      Feed_Rear(a_flag, b_flag);
    }
  }

  if (Pass_Nr > Pass_Total + 1 && Complete_flag == false) {
    Limit_Pos_Left = Limit_Pos_Max;
    Limit_Left_LED_Off();
    Limit_Pos_Right = Limit_Pos_Min;
    Limit_Right_LED_Off();
    Limit_Pos_Front = Limit_Pos_Max;
    Limit_Front_LED_Off();
    Limit_Pos_Rear = Limit_Pos_Min;
    Limit_Rear_LED_Off();
    w = 0;
    BeepComplete();
  }
}

void Sphere_Ext_Right() {
  //
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Шпиндель запущен ********** ////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Spindle() {
  timer++;
  if (++Spindle_Count > 750)  // ~~1сек.
  {
    Spindle_Count = 0;
    if (Tacho_Count == Tacho_Count_Old) {
      spindle_flag = OFF;
    } else {
      spindle_flag = ON;
    }
    Tacho_Count_Old = Tacho_Count;
  }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Резьба" ********** //////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Thread_Left(bool& c_flag, bool& d_flag) {
  if (c_flag == true) return;
  d_flag = false;
  c_flag = true;

  Joy_X_flag = OFF;
  //OLD
  //if (Motor_Z_Pos < (Limit_Pos_Left - (THRD_ACCEL * REPEAt ) * 2))
  //Opti
  int THRD_ACCEL_REPEAt = THRD_ACCEL * REPEAt;
  if (Motor_Z_Pos < (Limit_Pos_Left - THRD_ACCEL_REPEAt * 2))
  //-
  {
    Ks_Divisor = Thread_Info[Thread_Step].Ks_Div_Z;
    if (tmp_Ks_Divisor != Ks_Divisor) {
      tmp_Ks_Divisor = tmp_Accel = THRD_ACCEL + Ks_Divisor;  //Opti: короче запись
    }
    Brake_Compens = THRD_ACCEL_REPEAt + 1;
    //-
  } else {
    tmp_Ks_Divisor = tmp_Accel = Ks_Divisor = THRD_ACCEL + Thread_Info[0].Ks_Div_Z;  //Opti: короче запись
    Brake_Compens = 1;                                                               //Opti: Оп. что за нелогичность? tmp_Accel - Ks_Divisor = 0!!! Brake_Compens всегда 1
  }

  Km_Divisor = Thread_Info[Thread_Step].Km_Div_Z;
  Ks_Count = 0;
  Km_Count = 0;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();
  Joy_Z_flag = ON;
}


void Thread_Right(bool& c_flag, bool& d_flag) {
  if (d_flag == true) return;
  c_flag = false;
  d_flag = true;

  Joy_X_flag = OFF;
  int THRD_ACCEL_REPEAt = THRD_ACCEL * REPEAt;
  if (Motor_Z_Pos > Limit_Pos_Right + THRD_ACCEL_REPEAt * 2 || Motor_Z_Pos <= Limit_Pos_Right)
  //-
  {
    Ks_Divisor = Thread_Info[Thread_Step].Ks_Div_Z;
    if (tmp_Ks_Divisor != Ks_Divisor) {
      tmp_Ks_Divisor = tmp_Accel = THRD_ACCEL + Ks_Divisor;  //Opti: короче запись
    }
    Brake_Compens = THRD_ACCEL_REPEAt + 1;  //Opti: короче запись
  } else {
    tmp_Ks_Divisor = tmp_Accel = Ks_Divisor = THRD_ACCEL + Thread_Info[0].Ks_Div_Z;  //Opti: короче запись
    Brake_Compens = 1;                                                               //Opti: Оп. что за нелогичность? tmp_Accel - Ks_Divisor = 0!!! Brake_Compens всегда 1
      //-
  }

  Km_Divisor = Thread_Info[Thread_Step].Km_Div_Z;
  Ks_Count = 0;
  Km_Count = 0;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();
  Joy_Z_flag = ON;
}


void Thread_Front(bool& c_flag, bool& d_flag) {
  if (c_flag == true) return;
  d_flag = false;
  c_flag = true;

  Joy_Z_flag = OFF;
  int THRD_ACCEL_REPEAt = THRD_ACCEL * REPEAt;
  if (Motor_X_Pos < (Limit_Pos_Front - THRD_ACCEL_REPEAt * 2))
  //-
  {

    if (Sub_Mode_Thread == Sub_Mode_Thread_Man) {
      Ks_Divisor = Thread_Info[Thread_Step].Ks_Div_X;
      Km_Divisor = Thread_Info[Thread_Step].Km_Div_X;
    } else {
      Ks_Divisor = (Thread_Info[Thread_Step].Ks_Div_Z + (float)(Thread_Info[Thread_Step].Km_Div_Z + 5000) / 10000) * ((float)McSTEP_Z / McSTEP_X);
      Km_Divisor = 0;
      //-
    }

    if (tmp_Ks_Divisor != Ks_Divisor) {
      tmp_Ks_Divisor = tmp_Accel = THRD_ACCEL + Ks_Divisor;  //Opti: короче запись
        //-
    }
    Brake_Compens = THRD_ACCEL_REPEAt + 1;
    //-
  } else {
    tmp_Ks_Divisor = tmp_Accel = Ks_Divisor = THRD_ACCEL + Thread_Info[0].Ks_Div_X;
    Km_Divisor = 0;
    Brake_Compens = 1;  //Opti: Оп. что за нелогичность? tmp_Accel - Ks_Divisor = 0!!! Brake_Compens всегда 1
    //-
  }

  Ks_Count = 0;
  Km_Count = 0;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();
  Joy_X_flag = ON;
}


void Thread_Rear(bool& c_flag, bool& d_flag) {
  if (d_flag == true) return;
  c_flag = false;
  d_flag = true;

  Joy_Z_flag = OFF;
  int THRD_ACCEL_REPEAt = THRD_ACCEL * REPEAt;
  if (Motor_X_Pos > (Limit_Pos_Rear + THRD_ACCEL_REPEAt * 2))
  //-
  {
    if (Sub_Mode_Thread == Sub_Mode_Thread_Man) {
      Ks_Divisor = Thread_Info[Thread_Step].Ks_Div_X;
      Km_Divisor = Thread_Info[Thread_Step].Km_Div_X;
    } else {
      Ks_Divisor = (Thread_Info[Thread_Step].Ks_Div_Z + (float)(Thread_Info[Thread_Step].Km_Div_Z + 5000) / 10000) * ((float)McSTEP_Z / McSTEP_X);
      Km_Divisor = 0;
      //-
    }
    if (tmp_Ks_Divisor != Ks_Divisor) {
      tmp_Ks_Divisor = tmp_Accel = THRD_ACCEL + Ks_Divisor;  //Opti: короче запись
      //-
    }
    Brake_Compens = THRD_ACCEL_REPEAt + 1;  //Opti: короче запись
      //-
  } else {
    Ks_Divisor = tmp_Ks_Divisor = tmp_Accel = THRD_ACCEL + Thread_Info[0].Ks_Div_X;  //Opti: короче запись
    Km_Divisor = 0;
    Brake_Compens = 1;  //Opti: Оп. что за нелогичность? tmp_Accel - Ks_Divisor = 0!!! Brake_Compens всегда 1
    //-
  }

  Ks_Count = 0;
  Km_Count = 0;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();
  Joy_X_flag = ON;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Цикл Резьба" ********** /////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Thread_Ext_Left() {
  if (Motor_Z_Pos == Limit_Pos_Right) {
    if (Motor_X_Pos == Limit_Pos_Rear || Motor_X_Pos == Null_X_Pos) {
      Pass_Total = Thread_Info[Thread_Step].Pass + Thr_Pass_Summ;
      if (cycle_flag == false) {
        if (Pass_Nr <= Pass_Total) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;


          float Pass_Depth;
          const float csf = (float)(1.0f - 1.0f / 6.0f - 1.0f / 8.0f);  // 1  -0.16(6)  - 0.125 = 0,708(3), близко к sin(45°) == cos(45°) = 0.707107 == M_SQRT1_2 //const float csf = cos(M_PI_4);
          float Step_0866 = 0.8660254f * csf * Thread_Info[Thread_Step].Step / sqrt(Pass_Total - 1);
          if (Pass_Nr == 1) {
            Pass_Depth = Step_0866 * sqrt(0.3);
          } else {
            Pass_Depth = Step_0866 * sqrt(Pass_Nr - 1);
          }
          //-
          long Infeed_Value = long(Pass_Depth / ((float)SCREW_X / 100 / MOTOR_X_STEP_PER_REV) + 0.5) * McSTEP_X + McSTEP_X;

          Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
          Limit_Front_LED_On();
          Pass_Nr++;
          BeepBeep();
          Thread_Front(c_flag, d_flag);
        } else if (Pass_Nr > Pass_Total && Pass_Nr <= Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;

          Pass_Nr++;
          BeepBeep();
          Thread_Front(c_flag, d_flag);
        } else if (Pass_Nr > Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          c_flag = false;
          d_flag = false;

          Limit_Pos_Front = Null_X_Pos;
          Thread_Front(c_flag, d_flag);

          Limit_Front_LED_Off();
          Limit_Rear_LED_Off();
          Limit_Pos_Front = Limit_Pos_Max;
          Limit_Pos_Rear = Limit_Pos_Min;
          BeepComplete();
        }
      }
    } else if (Motor_X_Pos == Limit_Pos_Front) {
      c_flag = false;
      d_flag = false;
      Thread_Left(c_flag, d_flag);
    }
  } else if (Motor_Z_Pos == Limit_Pos_Left) {
    if (Motor_X_Pos == Limit_Pos_Front) {
      cycle_flag = false;
      c_flag = false;
      d_flag = false;

      Limit_Pos_Rear = (Null_X_Pos - REBOUND_X);
      Limit_Rear_LED_On();

      Thread_Rear(c_flag, d_flag);
    } else if (Motor_X_Pos == Limit_Pos_Rear) {
      c_flag = false;
      d_flag = false;

      Thread_Right(c_flag, d_flag);
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Thread_Ext_Right() {
  if (Motor_Z_Pos == Limit_Pos_Left) {
    if (Motor_X_Pos == Limit_Pos_Rear || Motor_X_Pos == Null_X_Pos) {
      Pass_Total = Thread_Info[Thread_Step].Pass + Thr_Pass_Summ;
      if (cycle_flag == false) {
        if (Pass_Nr <= Pass_Total) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;


          float Pass_Depth = 0;
          const float csf = (float)(1.0f - 1.0f / 6.0f - 1.0f / 8.0f);  // 1  -0.16(6)  - 0.125 = 0,708(3), близко к sin(45°) == cos(45°) = 0.707107 == M_SQRT1_2 //const float csf = cos(M_PI_4);
          float Step_0866 = 0.8660254f * csf * Thread_Info[Thread_Step].Step / sqrt(Pass_Total - 1);
          if (Pass_Nr == 1) {
            Pass_Depth = Step_0866 * sqrt(0.3);
          } else {
            Pass_Depth = Step_0866 * sqrt(Pass_Nr - 1);
          }
          //-
          long Infeed_Value = long(Pass_Depth / ((float)SCREW_X / 100 / MOTOR_X_STEP_PER_REV) + 0.5) * McSTEP_X + McSTEP_X;
          Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
          Limit_Front_LED_On();
          Pass_Nr++;

          BeepBeep();
          Thread_Front(c_flag, d_flag);
        } else if ((cycle_flag == false) && (Pass_Nr > Pass_Total && Pass_Nr <= Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false)) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;

          Pass_Nr++;
          BeepBeep();
          Thread_Front(c_flag, d_flag);
        } else if (cycle_flag == false && Pass_Nr > Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          c_flag = false;
          d_flag = false;
          Limit_Pos_Front = Null_X_Pos;
          Thread_Front(c_flag, d_flag);

          Limit_Front_LED_Off();
          Limit_Rear_LED_Off();
          Limit_Pos_Front = Limit_Pos_Max;
          Limit_Pos_Rear = Limit_Pos_Min;
          BeepComplete();
        }
      }
    } else if (Motor_X_Pos == Limit_Pos_Front) {
      c_flag = false;
      d_flag = false;

      Thread_Right(c_flag, d_flag);
    }
  } else if (Motor_Z_Pos == Limit_Pos_Right) {
    if (Motor_X_Pos == Limit_Pos_Front) {
      cycle_flag = false;
      c_flag = false;
      d_flag = false;

      Limit_Pos_Rear = (Null_X_Pos - REBOUND_X);
      Limit_Rear_LED_On();

      Thread_Rear(c_flag, d_flag);
    } else if (Motor_X_Pos == Limit_Pos_Rear) {
      c_flag = false;
      d_flag = false;

      Thread_Left(c_flag, d_flag);
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Thread_Int_Left() {
  if (Motor_Z_Pos == Limit_Pos_Right) {
    if (Motor_X_Pos == Limit_Pos_Front || Motor_X_Pos == Null_X_Pos) {
      Pass_Total = Thread_Info[Thread_Step].Pass + Thr_Pass_Summ;
      if (cycle_flag == false) {
        if (Pass_Nr <= Pass_Total) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;

          float Pass_Depth = 0;
          const float csf = (float)(1.0f - 1.0f / 4.0f - 1.0f / 18.0f);
          float Step_0866 = 0.8660254f * csf * Thread_Info[Thread_Step].Step / sqrt(Pass_Total - 1);
          if (Pass_Nr == 1) {
            Pass_Depth = Step_0866 * sqrt(0.3);
          } else {
            Pass_Depth = Step_0866 * sqrt(Pass_Nr - 1);
          }
          //-

          long Infeed_Value = long(Pass_Depth / ((float)SCREW_X / 100 / MOTOR_X_STEP_PER_REV) + 0.5) * McSTEP_X + McSTEP_X;
          Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
          Limit_Rear_LED_On();
          Pass_Nr++;
          BeepBeep();
          Thread_Rear(c_flag, d_flag);
        } else if (Pass_Nr > Pass_Total && Pass_Nr <= Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;

          Pass_Nr++;
          BeepBeep();
          Thread_Rear(c_flag, d_flag);
        } else if (Pass_Nr > Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          c_flag = false;
          d_flag = false;

          Limit_Pos_Rear = Null_X_Pos;
          Thread_Rear(c_flag, d_flag);

          Limit_Front_LED_Off();
          Limit_Rear_LED_Off();
          Limit_Pos_Front = Limit_Pos_Max;
          Limit_Pos_Rear = Limit_Pos_Min;
          BeepComplete();
        }
      }
    } else if (Motor_X_Pos == Limit_Pos_Rear) {
      c_flag = false;
      d_flag = false;
      Thread_Left(c_flag, d_flag);
    }
  } else if (Motor_Z_Pos == Limit_Pos_Left) {
    if (Motor_X_Pos == Limit_Pos_Rear) {
      cycle_flag = false;
      c_flag = false;
      d_flag = false;

      Limit_Pos_Front = (Null_X_Pos + REBOUND_X);
      Limit_Front_LED_On();

      Thread_Front(c_flag, d_flag);
    } else if (Motor_X_Pos == Limit_Pos_Front) {
      c_flag = false;
      d_flag = false;

      Thread_Right(c_flag, d_flag);
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Thread_Int_Right() {
  if (Motor_Z_Pos == Limit_Pos_Left) {
    if (Motor_X_Pos == Limit_Pos_Front || Motor_X_Pos == Null_X_Pos) {
      Pass_Total = Thread_Info[Thread_Step].Pass + Thr_Pass_Summ;
      if (cycle_flag == false) {
        if (Pass_Nr <= Pass_Total) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;

          float Pass_Depth = 0;
          const float csf = (float)(1.0f - 1.0f / 4.0f - 1.0f / 18.0f);
          float Step_0866 = 0.8660254f * csf * Thread_Info[Thread_Step].Step / sqrt(Pass_Total - 1);
          if (Pass_Nr == 1) {
            Pass_Depth = Step_0866 * sqrt(0.3);
          } else {
            Pass_Depth = Step_0866 * sqrt(Pass_Nr - 1);
          }
          //-
          long Infeed_Value = long(Pass_Depth / ((float)SCREW_X / 100 / MOTOR_X_STEP_PER_REV) + 0.5) * McSTEP_X + McSTEP_X;
          Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
          Limit_Rear_LED_On();
          Pass_Nr++;

          BeepBeep();
          Thread_Rear(c_flag, d_flag);
        } else if ((cycle_flag == false) && (Pass_Nr > Pass_Total && Pass_Nr <= Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false)) {
          cycle_flag = true;
          c_flag = false;
          d_flag = false;
          Pass_Nr++;
          BeepBeep();

          Pass_Nr++;
          BeepBeep();
          Thread_Rear(c_flag, d_flag);
        } else if (cycle_flag == false && Pass_Nr > Pass_Total + PASS_FINISH + Pass_Fin && Complete_flag == false) {
          c_flag = false;
          d_flag = false;
          Limit_Pos_Rear = Null_X_Pos;
          Thread_Rear(c_flag, d_flag);

          Limit_Front_LED_Off();
          Limit_Rear_LED_Off();
          Limit_Pos_Front = Limit_Pos_Max;
          Limit_Pos_Rear = Limit_Pos_Min;
          BeepComplete();
        }
      }
    } else if (Motor_X_Pos == Limit_Pos_Rear) {
      c_flag = false;
      d_flag = false;

      Thread_Right(c_flag, d_flag);
    }
  } else if (Motor_Z_Pos == Limit_Pos_Right) {
    if (Motor_X_Pos == Limit_Pos_Rear) {
      cycle_flag = false;
      c_flag = false;
      d_flag = false;

      Limit_Pos_Front = (Null_X_Pos + REBOUND_X);
      Limit_Front_LED_On();

      Thread_Front(c_flag, d_flag);
    } else if (Motor_X_Pos == Limit_Pos_Front) {
      c_flag = false;
      d_flag = false;

      Thread_Left(c_flag, d_flag);
    }
  }
}




//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Асинхронная Подача" ********** //////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Left(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)aFeed_mm * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_aFeed();
}

/////////////////////////////////////////////
void aFeed_Right(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)aFeed_mm * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_aFeed();
}

void aFeed_Front(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_X_Pos < Limit_Pos_Front - Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)aFeed_mm * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_aFeed();
}

void aFeed_Rear(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_X_Pos > Limit_Pos_Rear + Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)aFeed_mm * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_aFeed();
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Быстрая Подача" ********** //////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Rapid_aFeed_Left(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_Z_Pos < Limit_Pos_Left - Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)(MAX_aFEED * 2) * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_aFeed();
}

/////////////////////////////////////////////
void Rapid_aFeed_Right(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_Z_Pos > Limit_Pos_Right + Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)(MAX_aFEED * 2) * MOTOR_Z_STEP_PER_REV * McSTEP_Z / ((uint32_t)60 * SCREW_Z / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_Z_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  feed_Z_flag = ON;
  Joy_Z_flag = ON;
  Ena_INT_Z_aFeed();
}

void Rapid_aFeed_Front(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_X_Pos < Limit_Pos_Front - Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)(MAX_aFEED * 2) * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_aFeed();
}

void Rapid_aFeed_Rear(bool& a_flag, bool& b_flag) {
  if (b_flag == true) return;
  a_flag = false;
  b_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  Start_Speed = (250000 / ((uint32_t)MIN_aFEED * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1) / FEED_ACCEL;
  if (Motor_X_Pos > Limit_Pos_Rear + Start_Speed * 2) {
    aFeed_Divisor = 250000 / ((uint32_t)(MAX_aFEED * 2) * MOTOR_X_STEP_PER_REV * McSTEP_X / ((uint32_t)60 * SCREW_X / 100) * 2) - 1;
    if (aFeed_Divisor < Start_Speed) {
      max_OCR4A = Start_Speed;
      if (Step_X_flag == OFF) {
        OCR4A = Start_Speed;
      }
    } else {
      max_OCR4A = aFeed_Divisor;
      OCR4A = aFeed_Divisor;
    }
  } else {
    aFeed_Divisor = Start_Speed;
    max_OCR4A = Start_Speed;
    OCR4A = Start_Speed;
  }

  Brake_Compens = (max_OCR4A - aFeed_Divisor) + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  feed_X_flag = ON;
  Joy_X_flag = ON;
  Ena_INT_X_aFeed();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ********** Режим "Быстрая Подача Джейстик" ********** //////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Rapid_aFeed_Left_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Left - Brake_Compens;

  Motor_Z_Dir = CW;
  Motor_Z_CW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_aFeed_Right_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_X_flag = OFF;
  feed_X_flag = OFF;
  rapid_X_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_Z) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Right + Brake_Compens;

  Motor_Z_Dir = CCW;
  Motor_Z_CCW();
  if (Read_Z_Ena_State == false) Motor_Z_Enable();

  Joy_Z_flag = ON;
  rapid_Z_flag = ON;
  Ena_INT_Z_Rapid();
}

void Rapid_aFeed_Front_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Front - Brake_Compens;

  Motor_X_Dir = CW;
  Motor_X_CW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}

void Rapid_aFeed_Rear_J(bool& a_flag, bool& b_flag) {
  if (a_flag == true) return;
  b_flag = false;
  a_flag = true;

  Joy_Z_flag = OFF;
  feed_Z_flag = OFF;
  rapid_Z_flag = OFF;
  Brake_Compens = (MIN_RAPID_MOTION - MAX_RAPID_MOTION_X) * REPEAt + 1;
  Limit_Pos = Limit_Pos_Rear + Brake_Compens;

  Motor_X_Dir = CCW;
  Motor_X_CCW();
  if (Read_X_Ena_State == false) Motor_X_Enable();

  Joy_X_flag = ON;
  rapid_X_flag = ON;
  Ena_INT_X_Rapid();
}



/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
////////////////************Режим многопроходная асинхронная подача*************/////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

void aFeed_Ext_Left() {
  if (Ap != 0) {
    if ((Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
        if (Infeed_Value == 0) {
          if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
          else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
        } else {
          if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
          else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + (Infeed_Value * (Pass_Total - (Pass_Total - Pass_Nr))));  //
        }
        Limit_Front_LED_On();
        BeepBeep();
        aFeed_Front(a_flag, b_flag);
        w = Infeed_Value;

      }

      else if (cycle_flag == false && Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
        aFeed_Front(a_flag, b_flag);

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        Limit_Pos_Front = Limit_Pos_Max;
        Limit_Pos_Rear = Limit_Pos_Min;
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
      if (Pass_Nr <= Pass_Total) {
        a_flag = false;
        b_flag = false;

        aFeed_Left(a_flag, b_flag);
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;

      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X - (w * (Pass_Total - (Pass_Total - Pass_Nr)));
      Limit_Rear_LED_On();
      aFeed_Rear(a_flag, b_flag);
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Right(a_flag, b_flag);
    }

    //////////////
  } else {
    if (Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;

        Limit_Front_LED_On();
        Limit_Rear_LED_On();
        a_flag = false;
        b_flag = false;

        aFeed_Left(a_flag, b_flag);
        BeepBeep();
      }

      else if (Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;
      cycle_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Right(a_flag, b_flag);
    }
    ////////
  }
}


/////////////////////////////////////////////////////////////////////////////////////////////////

void aFeed_Ext_Right() {
  if (Ap != 0) {
    if ((Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
        if (Infeed_Value == 0) {
          if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + 1);
          else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X);
        } else {
          if (Pass_Nr == 1) Limit_Pos_Front = (Null_X_Pos + Infeed_Value);
          else Limit_Pos_Front = (Limit_Pos_Rear + REBOUND_X + (Infeed_Value * (Pass_Total - (Pass_Total - Pass_Nr))));  //
        }
        Limit_Front_LED_On();
        BeepBeep();
        aFeed_Front(a_flag, b_flag);
        w = Infeed_Value;

      }

      else if (cycle_flag == false && Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X;
        aFeed_Front(a_flag, b_flag);

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        Limit_Pos_Front = Limit_Pos_Max;
        Limit_Pos_Rear = Limit_Pos_Min;
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
      if (Pass_Nr <= Pass_Total) {
        a_flag = false;
        b_flag = false;

        aFeed_Right(a_flag, b_flag);
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;

      Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X - (w * (Pass_Total - (Pass_Total - Pass_Nr)));
      Limit_Rear_LED_On();
      aFeed_Rear(a_flag, b_flag);
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Left(a_flag, b_flag);
    }

  } else {
    if (Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;

        Limit_Front_LED_On();
        Limit_Rear_LED_On();
        a_flag = false;
        b_flag = false;

        aFeed_Right(a_flag, b_flag);
        BeepBeep();
      }

      else if (Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;
      cycle_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Left(a_flag, b_flag);
    }
    ////////
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Int_Left() {
  if (Ap != 0) {
    if ((Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
        if (Infeed_Value == 0) {
          if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - 1);
          else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
        } else {
          if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
          else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - (Infeed_Value * (Pass_Total - (Pass_Total - Pass_Nr))));  //
        }
        Limit_Rear_LED_On();
        BeepBeep();
        aFeed_Rear(a_flag, b_flag);
        w = Infeed_Value;

      }

      else if (cycle_flag == false && Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
        aFeed_Rear(a_flag, b_flag);

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        Limit_Pos_Front = Limit_Pos_Max;
        Limit_Pos_Rear = Limit_Pos_Min;
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
      if (Pass_Nr <= Pass_Total) {
        a_flag = false;
        b_flag = false;

        aFeed_Left(a_flag, b_flag);
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;

      Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X + (w * (Pass_Total - (Pass_Total - Pass_Nr)));
      Limit_Front_LED_On();
      aFeed_Front(a_flag, b_flag);
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Right(a_flag, b_flag);
    }

  } else {
    if (Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;

        Limit_Front_LED_On();
        Limit_Rear_LED_On();
        a_flag = false;
        b_flag = false;

        aFeed_Left(a_flag, b_flag);
        BeepBeep();
      }

      else if (Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;
      cycle_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Right(a_flag, b_flag);
    }
  }
}



/////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Int_Right() {
  if (Ap != 0) {
    if ((Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Front && Step_Z_flag == OFF) || (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Null_X_Pos && Step_Z_flag == OFF)) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
        if (Infeed_Value == 0) {
          if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - 1);
          else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X);
        } else {
          if (Pass_Nr == 1) Limit_Pos_Rear = (Null_X_Pos - Infeed_Value);
          else Limit_Pos_Rear = (Limit_Pos_Front - REBOUND_X - (Infeed_Value * (Pass_Total - (Pass_Total - Pass_Nr))));  //
        }
        Limit_Rear_LED_On();
        BeepBeep();
        aFeed_Rear(a_flag, b_flag);
        w = Infeed_Value;

      }

      else if (cycle_flag == false && Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Pos_Rear = Limit_Pos_Front - REBOUND_X;
        aFeed_Rear(a_flag, b_flag);

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        Limit_Pos_Front = Limit_Pos_Max;
        Limit_Pos_Rear = Limit_Pos_Min;
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Left && Motor_X_Pos == Limit_Pos_Rear && Step_X_flag == OFF) {
      if (Pass_Nr <= Pass_Total) {
        a_flag = false;
        b_flag = false;

        aFeed_Right(a_flag, b_flag);
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Rear && Step_Z_flag == OFF) {
      cycle_flag = false;
      a_flag = false;
      b_flag = false;

      Limit_Pos_Front = Limit_Pos_Rear + REBOUND_X + (w * (Pass_Total - (Pass_Total - Pass_Nr)));
      Limit_Front_LED_On();
      aFeed_Front(a_flag, b_flag);
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Motor_X_Pos == Limit_Pos_Front && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Left(a_flag, b_flag);
    }

  } else {
    if (Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
      if (cycle_flag == false && Pass_Nr <= Pass_Total) {
        cycle_flag = true;

        Limit_Front_LED_On();
        Limit_Rear_LED_On();
        a_flag = false;
        b_flag = false;

        aFeed_Right(a_flag, b_flag);
        BeepBeep();
      }

      else if (Pass_Nr > Pass_Total) {
        cycle_flag = true;
        a_flag = false;
        b_flag = false;

        Limit_Front_LED_Off();
        Limit_Rear_LED_Off();
        if (SelectMenu != 1) {
          Pass_Total = 1;
        }
        Pass_Nr = 1;
        Print();
        BeepComplete();
      }
    }

    else if (Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) {
      a_flag = false;
      b_flag = false;
      cycle_flag = false;

      Pass_Nr++;
      Print();
      Rapid_aFeed_Left(a_flag, b_flag);
    }
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Ext_Front() {
  if ((Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) || (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Null_Z_Pos && Step_X_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + 1);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + Infeed_Value);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z + Infeed_Value);
      }
      Limit_Left_LED_On();
      BeepBeep();
      aFeed_Left(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Left = Limit_Pos_Right + REBOUND_Z;
      aFeed_Left(a_flag, b_flag);

      Limit_Left_LED_Off();
      Limit_Right_LED_Off();
      Limit_Pos_Left = Limit_Pos_Max;
      Limit_Pos_Right = Limit_Pos_Min;
      if (SelectMenu != 1) {
        Pass_Total = 1;
      }
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      aFeed_Front(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Right = (Limit_Pos_Left - REBOUND_Z);
    Limit_Right_LED_On();
    aFeed_Right(a_flag, b_flag);
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_aFeed_Rear(a_flag, b_flag);
  }
}

//////////////////////////////////////////////////////////////////////////////
void aFeed_Ext_Rear() {
  if ((Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Right && Step_X_flag == OFF) || (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Null_Z_Pos && Step_X_flag == OFF)) {
    if (cycle_flag == false && Pass_Nr <= Pass_Total) {
      cycle_flag = true;
      a_flag = false;
      b_flag = false;

      unsigned long Infeed_Value = (int)(((float)MOTOR_X_STEP_PER_REV * Ap / SCREW_X) * McSTEP_X);
      if (Infeed_Value == 0) {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + 1);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z);
      } else {
        if (Pass_Nr == 1) Limit_Pos_Left = (Null_Z_Pos + Infeed_Value);
        else Limit_Pos_Left = (Limit_Pos_Right + REBOUND_Z + Infeed_Value);
      }
      Limit_Left_LED_On();
      BeepBeep();
      aFeed_Left(a_flag, b_flag);
    }

    else if (cycle_flag == false && Pass_Nr > Pass_Total) {
      a_flag = false;
      b_flag = false;

      Limit_Pos_Left = Limit_Pos_Right + REBOUND_Z;
      aFeed_Left(a_flag, b_flag);

      Limit_Left_LED_Off();
      Limit_Right_LED_Off();
      Limit_Pos_Left = Limit_Pos_Max;
      Limit_Pos_Right = Limit_Pos_Min;
      if (SelectMenu != 1) {
        Pass_Total = 1;
      }
      Pass_Nr = 1;
      Print();
      BeepComplete();
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Front && Motor_Z_Pos == Limit_Pos_Left && Step_Z_flag == OFF) {
    if (Pass_Nr <= Pass_Total) {
      a_flag = false;
      b_flag = false;

      aFeed_Rear(a_flag, b_flag);
    }
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Left && Step_X_flag == OFF) {
    cycle_flag = false;
    a_flag = false;
    b_flag = false;

    Limit_Pos_Right = (Limit_Pos_Left - REBOUND_Z);
    Limit_Right_LED_On();
    aFeed_Right(a_flag, b_flag);
  }

  else if (Motor_X_Pos == Limit_Pos_Rear && Motor_Z_Pos == Limit_Pos_Right && Step_Z_flag == OFF) {
    a_flag = false;
    b_flag = false;

    Pass_Nr++;
    Print();
    Rapid_aFeed_Front(a_flag, b_flag);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Int_Front() {
  //
}

////////////////////////////////////////////////////////////////////////////////////////////////
void aFeed_Int_Rear() {
  //
}