#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "GyverEncoder.h" 
#include <EEPROM.h>
#include "I2Cdev.h"//не забути про розгон!!!
#include "MPU6050_6Axis_MotionApps20.h"
#include <BleGamepad.h> // при загрузці нa реально Arduino даний фрагмент розкоментувати a пуcті класи закоментувати
#include <FastLED.h> //FastLED Daniel Garcia


// Additional elements
   
  // constants-variable-arrays  
    
    //  СПІЛЬНІ КОНСТАНТИ ПІД ХОД ДЛЯ БАГ ФУНК
      
      
      #define  X(x) (x) // Макрос повертає прийняти значення створено для кращого розуміння коду
      #define  Y(y) (y) 
      #define  W(w) (w) // ширина
      #define  H(h) (h) //висота
      
      
      #define tf_passive 0
      #define tf_active 1
      
      #define tf_reset 0
      #define tf_perform 1
      
      #define tf_reset_settings 0
      
      #define tf_function_not_completed 0
      #define tf_function_completed 1
      
      #define tf_disabled 0
      #define tf_enabled 1
      
      #define tf_on 0
      #define tf_yes 1      
      
      #define tf_data_ready 1
      #define tf_get_data 1
      #define tf_start 1
      
      #define g_no_action 2
      #define g_waiting_command 2
      #define g_non_bool 2
      
      #define stage_0 0 // етапи виконання
      #define stage_1 1
      #define stage_2 2
      #define stage_3 3
      #define stage_4 4
      #define stage_5 5
      
      #define path_0 0 // шлях
      #define path_1 1
      #define path_2 2
      #define path_3 3
      #define path_4 4
      #define path_5 5    
    //
    
    // Піни карта
      
      #define p_bolt_rifle_12 12   
      #define p_vibration_motor_18 18 
      #define p_h_b_14 14  //test
      #define p_triger_r_35 35 
      #define p_triger_l_34 34
      #define p_s_t_x_39 39//test
      #define p_s_t_y_36 36
      #define p_sw_25 25 //  кнопка енко // RotaryEncoder encoder(27, 14, RotaryEncoder::LatchMode::TWO03);
      #define p_dt_32 32
      #define p_clk_33 33
      #define p_on_off 26
      #define p_led_pin_13 13
      #define p_test_25 25 // test
       
    //     
    
    //Md_moveButtonsAnimation(); 
      
      #define print_batton 20
      #define reset_animation 21
    
    //    
    
    //af_displayPrintLain()
    
     #define L(x) (x) // line
     #define N(x) (x) // number
    
    //
    
    //Gf_combinedGyroRightJoystick()Gf_da()
      
      #define g_x 0
      #define g_y 1
      #define s_x 2
      #define s_y 3
      
       
      #define joystick_full_priority 1
      #define joystick_disable_gyro 2
      #define gyro_joystick_combination 3
      #define priority_by_magnitude 4
      #define gyro_full_priority 5
      #define only_gyro 6
      #define g_o_m 7
    
    //   
 
    //Gf_g()
      
      #define g_x 0
      #define g_y 1 //g_z = axis y horizon
      #define g_z 2 //g_z = axis z vertical
      #define g_g_d 20 //g_g_d = get gyro data 
      #define r_g_d 21 //g_g_d = get gyro data 
      #define g_e 22
      #define g_d 23
   
    //    
    
    //Gf_leftJoystick() Gf_rj() 
      
      #define x_l 0 // x_l = X left
      #define x_r 1 // x_r = X right
      #define y_u 2 // y_u = Y up 
      #define y_d 3 // y_d = Y down
      #define x_a 0 // x_a = X axis h
      #define y_a 1 // y_a = Y axis v
     
      #define r_a_d 20  
      #define g_a_d 21 // g_a_d = get analog data
      #define r_j_e 22
      #define r_j_d 23
      #define g_d_z 24 // g_d_z = get dead zones
      #define g_m_m 25 // gmm = get minimum maximum
      #define s_d_z 26 // s_d_z = set dead zones
      #define s_m_m 27 // s_m_m = set minimum maximum  
      #define c_c_j 28 //  = check calibrate joystick
     
      #define s_c_w 28 // s_c_w = stop check Work
      
    //    
    
    
    //Md_disableButton()
      
      #define check_for_pressed_buttons 20
      #define deactivated_buttons_get 21
      #define deactivation_buttons_start 22
      #define reset_deactivation_buttons 23

    //    
    
    
    
    //Md_saveSelectedProfile( ) 
      
      #define ssp_get_setting 20
      #define ssp_change_setting 21
      #define ssp_reset_settings 22
      #define ssp_get_eeprom 23
      #define ssp_set_eeprom 24
    //      
    
    //af_triggerLight() 
      
      #define color_light_setting 20
      #define color_switching 21
      #define clssc 22  //clssc = color light standard settings check
      #define color_light_reset 23
      #define color_one 24
      #define color_two 25
      #define get_color1 26
      #define get_color2 27
      #define get_light1 28
      #define get_light2 29
      #define set_color1 30
      #define set_color2 31
      #define set_light1 32
      #define set_light2 33
      #define color_light_default 34    
    
    //mdf_batteryCheck()
     
     #define g_b_s 20  //get battery status
     #define b_c_p 21   // battery charge plus
     #define g_c_m 22 // battery charge minus
     #define b_c_m 23  //// battery charge minus
     
    //
    
    //Md_gyroCalibrationExecution()
      
      #define calibration_start 20
    
    //    
    
    //af_saveToEEPROM()
      
      #define get_eeprom 101
      #define set_eeprom 102
      #define eeprom_initialization 103
      #define eeprom_seve 104
      #define get_eeprom_last_read 105
      #define address_indicator_reset 106
    
    //
    
    //Effects    
         
      //af_vibration();
        
        //#define p_vibration_motor_18 18
        #define vibration_start 21     
        #define vibration_stop 22
        #define vt_get_permission 23
        #define vt_pin_activate 24          
        #define vt_change 25         
      
      //
      
      // af_shotgunBolt()
         
        #define trigger_light_change 20
        #define trigger_get_light 21
        #define change_color 22
        #define trigger_color_red 23
        #define trigger_color_dreen 24
        #define trigger_color_start 25       
      
      //
      
      // af_shotgunBolt()
        
        //#define p_bolt_rifle_12 12
        #define bolt_start 21     
        #define bolt_stop 22
        #define bolt_get_permission 23
        #define bolt_pin_activate 24
        #define bolt_change 25
      //         
    
    //
    
    //bgpr()
    
     #define set_press_permit 20
     #define get_press_permit 21 
     #define set_reset_permit 22
     #define get_disconnected_number 23 
    
    //    
    
    // af_passwordEntry()
      #define typing_a_password 20
      #define password_reset 21
      #define password_not_entered 22
      #define password_entered 23
    //     
    
    //Gf_gamepadButtonsDuplicators()
      #define dbrs_change_mode 20
      #define dbrs_get_mode 21
      #define dbrs_reset 22
    //    
    
    // display() {
      
      #define d_u_d  23 //disable_updates_display
      #define e_u_d  24 //enablet_updates_display
      
    //
    
    // Md_mainDisplayENG();
      #define menu_off 21
      #define menu_start 22
    //
    
    // byte mdf_addres()
      
      #define back 20
      #define get_add 23
      #define check_emb 24 
      #define check_emb_ptp 25
      #define mode_click_input 26  
      #define mode_click_back 27      
      #define back_add 28      
      #define mode_function_returns 29
      #define set_add 30
      #define address_not_entered 0
      #define address_entered -1
      #define address_deleted -2
    
    //
    
    // int mdf_cursor() // mdf_p_cursor()
     
      #define get_pos 20
      #define set_pos 21
      #define cursor_read_encoder 24
      #define cursor_type_one 0 
      #define cursor_type_two 1
    
    //
    
    // mdf_confirm() // mdf_p_confirm() // mdf_p_outputNotNeed()
      //#define X(x) (x)
      //#define Y(y) (y) 
      //#define tf_reset 0
      //#define tf_get_data 1
      //#define tf_function_completed 1
      #define choice_no 20
      #define choice_yes 21
      #define accelerate_frame_blinking 22
      #define print_not_need 23
      #define offer_a_choice 24
      #define output_by_coordinates 25
      #define output_by_center_x 27
      #define change_selection 28
   
    
    //
    
    // Md_autoPowerOffa()
      
      // #define tf_reset 11
      #define apo_change_time 20
      #define apo_get_time 21
      #define apo_restart_time 22
   
    //
    
    // Md_movingButtons()
      
      #define choice_bat_waiting 20
      #define button_selection_complete 21
      #define return_default 22
      #define select_button 23
      #define select_button_completed 34 //34 тому що щоб не було співпадінь  з кнопками
    
    //
    
    //Md_displayTimeout()
      
      #define dt_get_tim_minutes 20
      #define dt_get_tim_seconds 21
      #define dt_change_time 22
      #define timeout_restart 23
      #define timeout_reset 24
    
    //
    
    // Md_duplicateButtons()
      
      #define d_b_d_m 0  // duplicate Buttons default mode
      #define select_button_r_s 20
      #define select_button_r_m 21
      #define duplicate_button_reset 22
      #define show_duplicate_buttons 23
      #define r_s_button_reset 24
      #define r_m_button_reset 25
      #define select_regime_r_s 26
    //    
    
    // Button gamepad class
    
      #define touch_dead_zone 50
      
      //getCalibrationData()
        #define d_z 0   // Dead zone
        #define m_v 1   // maximum value 
        
     
      // ButGamepad(byte gBT, byte gBN, byte pRT, byte n)
      #define button_gamepad 20
      #define trigger_gamepad 21
      #define tactile_read 22
      #define touch_read 23
      #define analog_read 24
      
      // byte (*gamepadPressPtr)();
      #define read_button_state 20
      #define gamepad_button_pressed 22
      #define gamepad_button_release 23
      #define button_get_name 24
      #define r_b_double_press 25
      #define read_analog_state 26
      #define get_analog_state 27
      #define i_p_p_g_b 28    //input pullup pin gamepad button
      
      //byte. bgc_buttonGamepadPressRelease();
      
      #define press_button 1
      #define release_button 2
      #define trigger_motion_detected 3
      
    
    //  
    
    // Profiles class 
      
      // Profiles class constructor
        
        #define t_sp 1// не міняти число!
        #define t_mp 2// не міняти число! 
        
      
      //
      
      //Md_changeNameProfile()
        
        #define cl 24
        #define dl 25 
        #define tb 26
        #define sb 27
        #define g_s_n_i_n_l_a_r_s 28 // (give standard name if no letters and remove spaces ) дати стандартну назву, якщо немає букв
        #define get_name 29
        #define get_name_a_f 30
        #define add_letter 31
        #define delete_letter 32
     
      //
      
      // mps()
        
        #define activate_sp 20
        #define activate_mp 21
        #define reset_gyro 22
        #define mps_reset_settings 23
        #define mps_get_eeprom 24
        #define mps_set_eeprom 25
      
      //
      
      //malb()
        
        #define enter_default_location 20
        #define check_location 21
        #define standard_location 22
        #define non_standard_location 23
      
      //      
      
      // virtualButtonsList[19] даний масив має в собі номер-назву віртуальної-програмної кнопки геймпада (останні дві використовуються для дублювання)
      
        #define button_0 0 // неіснуюча кнопка щоб виконувати деактивації //список програмних-віртуальних кнопок які натискаються різними фізичними методами
       
        #define button_1 1 // // початкова локація для збереження комірка № 1 (1=b_1)
        #define button_2 2 // 
        #define button_3 3
        #define button_4 4
        #define button_5 5
        #define button_6 6
        #define button_7 7
        #define button_8 8    
        
        #define button_select 9
        #define button_start 10
        #define button_home 11
        
        #define dpad_up 12
        #define dpad_down 13
        #define dpad_left 14
        #define dpad_right 15
        
        #define trigger_l 16
        #define trigger_r 17  // початкова локація для збереження комірка № 16 (16=t_r)
      
      //
    
    // physicalButtons  Profiles class  
      
      // physicalButtons[]  константи використовується як номер-назва екземпляра класу 
      // virtualButtonsList[] константи використовується як номер-назва комірки масиву
        
        #define b_1 0
        #define b_2 1
        #define b_3 2
        #define b_4 3
        #define b_5 4
        #define b_6 5
        #define b_7 6
        #define b_8 7

        #define b_se 8
        #define b_st 9
        #define b_h 10

        #define d_u 11
        #define d_d 12
        #define d_l 13
        #define d_r 14

        #define t_l 15
        #define t_r 16      
        
        #define r_s 17
        #define r_m 18
      
      //
      
    //
    
    // encoder module class 
      
      //turn()
      #define get_press_end_turn 20
      #define get_turn 21
      #define rotated_r 22
      #define rotated_l 23
      #define rotated_r_fast 24
      #define rotated_l_fast 25
      #define reset_rotation 27
      
      //bat()   
      #define click 28
      #define press_b_e 29
      #define hold_b_e 30
      #define press_end_turn 31
      #define get_button 32
      
      //
      #define send_report_execute 0
      #define send_report 1
      #define send_report_stop 2
      #define send_report_start 3
      #define waiting_command 4   
      
      
      //Gf_functionsGamepad( ){
        
        #define functions_gamepad_stop 20
        #define functions_gamepad_start 21
      
      //
      
    //
    
  // c-v-a  
  
  // Function prototypes 

    byte mps(byte acceptedCommand = 0, byte number = 0, byte acceptedData = 0);
    void fd_drawCenteredFilledRect(int centerX = 0, int centerY = 0, int width = 0, int height = 0, uint16_t color = WHITE);
    void fd_drawCenteredHollowRect(int centerX = 0, int centerY = 0, int width = 0, int height = 0, uint16_t color = WHITE);
    void af_controlsCheck(); 
    bool af_controlsCheckСalibration(bool reset = 0);
    void Gf_controlElementsStope(void);
    bool af_checkLeftTrigger(bool mode = 0);
    bool af_checkRightTrigger(bool mode = 0);    
    void printgetCalibrationData();
    int* Md_dzcdrj(bool getArr = false, bool arrClearFill = false);
    int* Md_dzcdlj(bool getArr = false, bool arrClearFill = false);
    byte Md_joysticksCalibrationDeadZones();

    int* Md_mvcdrj(bool getArr = false, bool arrClearFill = false);
    int* Md_mvcdlj(bool getArr = false, bool arrClearFill = false);
    void Md_joysticksCalibrationMaximumValues();    
    
    
    int16_t* Gf_g(int cmd = 0); 
    int* Gf_rj(int cmd = 0, int* newData = nullptr);
    int Gf_da(int cmd = 0, int data = 0);
    void Gf_combinedGyroRightJoystick(); 
    int* Gf_leftJoystick(int cmd = 0, int* newData = nullptr);
   
    template<typename T>
    bool mdf_magnifier(T &numeric, int minNam = 0, int maxNam = 0, int Speed1 = 0, int Speed2 = 0);
    int af_triggerLight(byte acceptedCommand = 0, int acceptedData = 0);
    void Gf_functionsGamepad(byte acceptedCommand = 0);
    void Gf_sendReport(byte acceptedCommand = 0);
    void Md_moveButtonsAnimation(byte cmd = 0, byte buttonOne = 0, byte buttonTwo = 0);
    void Md_gyroCalibrationExecution(byte acceptedCommand = 0);
    byte af_shotgunBolt(byte acceptedCommand = 0);
    byte af_vibration(byte acceptedCommand = 0);
    int af_saveToEEPROM(int acceptedCommand = 0, void* address = nullptr, size_t dataSize = 0); 
    byte Gf_gamepadButtonsDuplicators(byte acceptedCommand = 0);
    byte Md_displayTimeout(byte acceptedCommand = 0);
    uint32_t af_clamp(int value = 0, int minVal = 0, int maxVal = 0);
    void af_displayPrintLain(String text = "", byte x = 0, byte y = 0, byte scrollFlag = 0, byte cropText = 20);
    byte mdf_confirm(byte acceptedCommand = 0, byte x = 0, byte y = 0);
    byte mdf_p_confirm(byte acceptedCommand = 0, byte x = 0, byte y = 0);
    void Md_p_duplicateButtons(byte acceptedCommand = 0);
    int mdf_addres(byte acceptedCommand = 0, byte addNumb = 0);
    void mdf_displayOutput();
    void displayRefresh(byte acceptedCommand = 0);
    byte Md_autoPowerOff(byte acceptedCommand = 0);
    void bgc_buttonGamepadPressRelease(byte command = 0, byte buttonName = 0, int analogData = 32767);
    byte mdf_cursor(byte acceptedCommand = 0, byte data = 0, const byte* coordinate = nullptr);
    void af_triggerShootingEffects(byte startEffects = 0);
  // Fp
  
// Ae 

// Class instances from external libraries
  
  Adafruit_SSD1306 display(128, 64, &Wire, -1);
  BleGamepadConfiguration bleGamepadConfig;//потрібно для настройок геймпада
  BleGamepad bleGamepad("FS G36", "UA", 100);
  Encoder enc(p_clk_33, p_dt_32, p_sw_25); 
  MPU6050 mpu;
  CRGB leds[1];

//

// Byte saving data (bsd) використовується як унікальна зміна яка після досягнення потрібного нам значення повертає його і скидається на нуль
 
  class bsd {
    
    private:
    const byte maxValue; // Максимальне значення
    byte val = 0;      // Накопичене значення

    public:
    // Конструктор
    bsd(byte mV = 0, byte minV = 0) : maxValue(mV){
      val = minV;   
    }

    // Метод p() для додавання значення
    void p(byte addValue) {
        
      val += addValue;
      val = af_clamp(val, 0, maxValue);// Скидання на нуль, якщо перевищено
      
    }

    // Метод m() для перевірки досягнення максимального значення
    bool m() {
        
      if (val >= maxValue) {
        
        val = 0;
        return true; // Повертаємо true, якщо досягнуто максимального значення
      
      }
      
      return false; // Максимальне значення не досягнуто
    
    }

    // Метод g() для повернення накопиченого значення
    byte g() {
       
      return val; 
    
    }
    
    byte s(byte recordDatae) {
       
      return val = recordDatae; 
    
    }    
    
    byte r() {//перед скиданням одноразового відправляємо получене число
      
      byte temp = val; // Зберігаємо значення
      val = 0; // Скидання на нуль
      return temp; // Повертаємо збережене значення
      
    }  
    
    byte tnar() { //tnar = take number automatic reset  функція доплюсовує повертає і скидає самостійно
     
      byte temp = val; // Зберігаємо значення
      val = (val == maxValue) ? 0 : val + 1;
      return temp;
    
    }
    
    byte enar(byte addValue) {  //enar = enter number and return вписує нове значення і повертає його
      
      val = addValue; 
      return val;
    
    }
  
  
  };

// Bsd

// Timer class (конструкція працює приблизно 49 днів після чого потрібен перезапуск мікроконтролера) 
  
  class Timer {
  
    private:
      
      uint32_t tmr = 0;
      bool timerFlag = 0;
      uint32_t restartTimer = 0;//час перезапуску 
    
    public:
      
      
      //!!!!!таймер запускається коли викликається один з методів час не запускається одразу коли вказати його в конструкторі або  методі st()
      
      //конструктор вказуємо час і з чого починати правда брехня  
       
        Timer(uint32_t rT = 0, bool firstCall = 1) { //екземпляри таймерів можуть створюватися одразу з вказаним часом або вказувати його пізніше
        
          restartTimer = rT;//якщо не вказати час тоді буде постійно повертатись значення яке є в timerFlag
          timerFlag = firstCall;//якщо вказати час тоді стан буде мінятися Якщо ні тоді стан цієї змінної буде повертатись постійно допоки не вкажемо час через метод
            
        } 
      
      // 

      // таймер одноразово поверне правда з вказаною частотою 

        bool gp() { // gt = get pulsation з вказаною частотою повертає правда
          
          if (restartTimer) {
            
            if (tmr < millis()) {  
              
              tmr = millis() + restartTimer;
              
              if (timerFlag) {//одноразово повертаємо те що вказали в настройках
               return true; 
              }
              else{
               timerFlag = true;//повертаємося до стандартного значення яке буде повертатись 
              }
            
            }  
          
          }
          
          else{//якщо змінна restartTimer брехня тоді будемо постійно повертати те що вказали в другому параметрі
            return timerFlag;
          }
        
         return false; 
        
        }      
         
      //
      
      // таймер одноразовий сигнал (брехня один раз правда по завершенню таймера, брехня до перезапуску)
        
        bool ts() { // ts = timer single одноразова повернуть правда  і буде чекати перезапуску
          
          if (restartTimer) {
            
            if (tmr < millis()){
              
              if (!tmr){//це означає перший запуск або перший запуск після перезапуску
               
               tmr = millis() + restartTimer;//
               int temp = timerFlag;//одноразово повертаємо значення вказане в другому параметрі 
               timerFlag = true;//встановлюєm стандартне значення
               return temp;
               
              }
              
              else{//це означає що таймер спрацював  вдруге завершуємо роботу очікуємо перезапуск
               timerFlag = restartTimer = false;//забороняємо виконання основної умови
               return true;//одноразово повертаємо правда
              } 
            
            }  
           
          }
          
          else{//Дана умова виконується якщо ми не вказали перший параметр або функція завершила роботу
            return timerFlag;//(0, false || true)=буде постійно повертати другий параметр//якщо завершила роботу буде постійно повертати брехня
          }          
          
          return false; 
        
        }      
        
      //
      
      // таймер (секунда правда секунда брехня)
        
        bool ta() {//ta = timer auto  постійно повертає правда брехня використовується там де не потрібна точність
        
          if (restartTimer){ 
           
           if (tmr < millis()){
            
            tmr = millis() + restartTimer;
            timerFlag = !timerFlag; //
           
           }
           
           return !timerFlag;//потрібно виконати ще раз інверсію  щоб було правильнo підлаштовуємося під стандартний спосіб запуску-зупинки таймера
          
          }
          
          return timerFlag;
          
        }        
        
      //
      
      // повертає постійно по завершенню часу правда або брехня залежно від настройки
        
        bool tm() { // tm = timer manual
          
          if (restartTimer){
           
            if (tmr < millis()){
              
              if (!tmr){//спрацювання 1 запуск таймера або перший запуск після перезапуску
               
               tmr = millis() + restartTimer;
               
               int temp = timerFlag;//одноразово повертаємо значення вказане в другому параметрі 
               timerFlag = true;//встановлюєm стандартне значення
               return temp;
               
              }
              
              else{//друге спрацювання завершуємо роботу  
               
               timerFlag = true;//ставимо значення правда щоб вона постійно поверталася
               restartTimer = false;//забороняє виконання основної умови
               return true;
              
              } 
            
            }  
          
          }
          
          else{//якщо Друга умова неправда То будемо постійно повертати те значення яке знаходиться в зміній
            
            return timerFlag;
          
          }
         
         return false; 
        
        }         
             
      //     

      // відправляємо в новий час або зупиняємо таймер
        
        void st(uint32_t rT = 0, bool firstCall = 1){ // вказуємо новий час спрацювання для tmr І що перше повертати правда брехня
          
          tmr = false;
          timerFlag = firstCall;//
          restartTimer = rT;//вказуємо новий час або зупиняємо роботу таймера  якщо вказати false
        
        }
      
      //
      
      // берем стан таймера
        
        int gmt() {//get millis timer
           
          if (restartTimer && millis() < tmr) {
           
           return tmr - millis();
          
          }
          
          return 0;
        
        }
        
        int gst() {//get seconds timer
           
          if (restartTimer && millis() < tmr) {
           
           return (tmr - millis()) / 1000;
          
          }
          
          return 0;
        
        }
      
      //  
  
  };
     
// Tc

// Profiles class + supporting functions  
  
  class Profiles {
    
    public:
      
      Profiles(int deZoH, byte senHor, int deZoV, byte senVer, const char* nameProf, byte tpProf, byte nbProf)
       
       :dzxa(deZoH),
        sxa(senHor),
        dzya(deZoV),
        sya(senVer),
        nps(nameProf),
        tape(tpProf),
        number(nbProf)
        {    
        
        malb(enter_default_location); //(virtualButtonsList) даємо стандартні імена-номера кнопкам + дублікатори натискають кнопку нуль
          
      }
      
      Profiles() {}// конструктор без параметрів потрібен для сейф профайл
      
      
      // гіроскоп 
        
        bool gs(byte cmd){
        
        }
        
        void gyroReset(){
         
         sxa = sya = 150;//це означає що чутливість мінімальна а максимальна 50
         dzxa = dzya = 0;
        
        }
        
        bool gssc(){//gssc = gyroStandardSettingsCheck якщо в нас стандартні настройки повернуться правда щоб не виконувати дії в подальшому використовується
         
         return ((!dzxa && !dzya) && (sya == 150  && sxa == 150));
         
        }        
        
        void setDeZoHor(int newDeZoH) {// set
        
          if (dzxa != newDeZoH) {//якщо встановлюємо нову мертву зону чутливість потрібно скинути чутливість настроюється після мертвої зони
           sxa = 150;//ставим мінімальну чутливість в даному випадку це 150
          }
          
          dzxa = newDeZoH; 
         
        } 
        
        void setSenHor(byte senHor) {
        
         sxa = senHor;
        
        }
        
        void setDeZoVer(int newDeZoV) {
        
          if (dzya != newDeZoV) {
            sya = 150;
          }
          
          dzya = newDeZoV;
        
        }
        
        void setSenVer(byte senVer) {
        
         sya = senVer;
        
        }
      
      //
      
      // робота з іменами профілів String nps;
        
        String nameProfiles(byte acceptedCommand, char Letter = ' '){// функція працює з іменем профілю
          
          static Timer tmr(1000);
          
          switch (acceptedCommand) {
          
            case get_name://повертаємо ім'я
              
              return nps;
            
             break;
            
            case add_letter://додаємо букву якщо є місце
              
              if (nps.length() < 20) {nps += Letter;}
            
             break;                    
            
            case delete_letter://якщо є букви То видаляємо
              
              if (nps.length()) {nps.remove(nps.length()-1, 1);}//nps.remove(кількість букв які потрібно оставити-1, кількість звуків які потрібно Видалити В кінці);
              
             break;             
            
            case g_s_n_i_n_l_a_r_s://give standard name if no letters and remove spaces 
            
              checkForLetters();//стандартне ім'я якщо пустота
              trimTrailingSpaces();//видаляємо пробіли в кінці
            
             break;                 
          
          }
          
          return "";
          
        }
          
        void checkForLetters() {//check for letters перевірити наявність букв якщо немає букв То дати стандартне ім'я
          
          bool allSpaces = true; // Припускаємо, що всі символи — пробіли
          
          // Перевіряємо кожен символ у рядку
          for (int i = 0; i < nps.length(); i++) {
            if (nps[i] != ' ') {  // Якщо хоча б один символ не пробіл
              allSpaces = false;
              break;  // Можна припинити перевірку, якщо знайдено символ, відмінний від пробілу
            }
          }

          // Якщо рядок порожній або складається лише з пробілів
          if (nps.length() == 0 || allSpaces) {
            resetName();
          }
        
        }
        
        void trimTrailingSpaces() { // trim Trailing Spaces видаляю пробіли в кінці речення
           
          int i = nps.length() - 1;
          
          while (i >= 0 && nps.charAt(i) == ' ') {
              i--; // Знаходимо позицію останнього непустого символу
          }
          
          nps.remove(i + 1); // Видаляємо всі символи після останнього значущого
        
        }        
        
        byte lettersTakeNumber(){//повертає кількість букв в реченні
          
          return nps.length();
        
        }
        
        void resetName(){
          
          nps = "    My profile " + String(number) + String("    ");  // Присвоюємо стандартне ім'я
          
        }
      
      //  

      byte malb(byte acceptedCommand) {//malb = management array list buttons //функція працює з порядковими номерами кнопок геймпада
        
        if (acceptedCommand == enter_default_location) { // Скеровування до активного профілю
          
          for (byte i = 0; i <= 16; i++) {//стандартний порядок кнопок два останніх елемента використовуються для дублювання
          
           virtualButtonsList[i] = i + 1; //вказуємо кнопкам номер-ім'я (i + 1 не чіпати Все правильно)
          
          }   
          
          virtualButtonsList[17] = virtualButtonsList[18] = 0;//iціалізуємо дублікатори нулями тому що там сміттєві значення  там потрібні нулі тому що кнопка нічого не дублює
        
        }
          
        else if (acceptedCommand == check_location) {
        
          for (byte i = 0; i <= 16; i++) {//якщо розташування кнопок помінялось місцями функція видасть брехня(стандарт від 1-15)
          
            if (virtualButtonsList[i] != i+1) {
             return non_standard_location;
            }
          
          }     
          return standard_location;
        
        }
        
        return 0;
      
      }
      
      void profileResetAll(){//функція скидає всі настройки профілю
       
       gyroReset();
       resetName();
       malb(enter_default_location);//даємо стандартні імена-номера кнопкам
      
      }
      
      String nps;// Динамічний масив для імені профілю//nps = name profile string 
      byte virtualButtonsList[19];//зберігаю номер програмної кнопки
      int ap[4];// aiming parameters
      int dzxa; // 
      byte sxa;
      int dzya;
      byte sya;
      byte tape;
      byte number;
      //byte lblm;//list button located monitoring
      byte rrsps = 1; //rrsps = regime rifle stock profile save 
  
    private:

  };
  
  // Profile 
    
    Profiles profileNotSelected (0, 150, 0, 150, "PROFILE NOT SELECTED", false, false);// використовується якщо профіль не вибрано
    
    Profiles profilSp[] = {// test 
      
      Profiles (2000, 100, 2556, 92, "CodMW", t_sp, 1),
      Profiles (166, 120, 1965, 112, "Batl3", t_sp, 2),
      Profiles (2000, 100, 2556, 92, "SP 33", t_sp, 3),
      Profiles (166, 120, 1965, 112, "SP 44", t_sp, 4),
      Profiles (2000, 100, 2556, 92, "SP 55", t_sp, 5),
      Profiles (166, 120, 1965, 112, "SP 66", t_sp, 6),
      Profiles (2000, 100, 2556, 92, "SP 77", t_sp, 7)
      
    };    
    
    Profiles profilMp[] = {// test 
      
      Profiles (2000, 100, 2556, 92, "05461545454546441264", t_mp, 1),
      Profiles (166, 120, 1965, 112, "Xmen   74           ", t_mp, 2),
      Profiles (2000, 100, 2556, 92, "Mp 3                ", t_mp, 3),
      Profiles (166, 120, 1965, 112, "Mp 4                ", t_mp, 4),
      Profiles (2000, 100, 2556, 92, "Mp 5                ", t_mp, 5),
      Profiles (166, 120, 1965, 112, "Mp 6                ", t_mp, 6),
      Profiles (2000, 100, 2556, 92, "Mp 7                ", t_mp, 7)
    
    };
  
  // Pd
  
  //  Profiles supporting functions
     
    Profiles *ap = &profileNotSelected; // = active Profile ->вказівник на активний профіль інтимізується в Void setup
    
    byte mps(byte acceptedCommand, byte number, byte acceptedData) {// mps= management profile setting 
     
      if (acceptedCommand == activate_sp) {// вибраний sp профіль активується
        
        ap = &profilSp[number]; 
      
      }
      
      else if (acceptedCommand == activate_mp) {// вибраний mp профіль активується
        
        ap = &profilMp[number]; 
      
      }    
      
      //скидання настроек гіроскопа
      
        else if (acceptedCommand == reset_gyro) {
        
          if (ap->gssc()) {//gssc = gyroStandardSettingsCheck якщо є стандартні настройки і хочемо скинути то відображаємо повідомлення що не потрібно
          
            if (mdf_confirm(print_not_need) == tf_function_completed) {
             return tf_function_completed;
            }
          
          }       
          
          else if (mdf_confirm(offer_a_choice) == tf_data_ready) {//якщо настройки нестандартні перевіряємо чи є готові дані-вибір
          
            if (mdf_confirm(tf_get_data) == choice_yes) {ap->gyroReset();}//якщо настройки нестандартні перевіряємо чи є готові дані вибір
            return tf_function_completed;//в любому випадку так або ні повертається команда tf_function_completed
          
          }            
      
        }   
      
      //
       
      else if (acceptedCommand == mps_get_eeprom) {
       /*
        
        if (!Md_saveSelectedProfile(ssp_get_setting)) {ap = &profileNotSelected;}  // має йти вище по списку Md_saveSelectedProfile !!!!
        else{
        byte tempTypeNumber[2];
        af_saveToEEPROM(get_eeprom, &tempTypeNumber, sizeof(tempTypeNumber));
        if (tempTypeNumber[0]) {ap = &profilSp[tempTypeNumber[1]];}
        else if (tempTypeNumber[0]) {ap = &profilMp[tempTypeNumber[1]];}
        }      
      
      */
      }
      
      else if (acceptedCommand == mps_set_eeprom) {
       /*
       
        byte tempTypeNumber[2]{ap->tape, ap->number};
        af_saveToEEPROM(set_eeprom, &tempTypeNumber, sizeof(tempTypeNumber));
      
       */
      }      
      
      return 0; 
    
    }
  
  //  

// Pc

// Button debounce class

  class DebButton {

    private:
        const byte pin;
        Timer tmr; // Оголошення без ініціалізації
        byte debounceTime;
        bool buttonState = false; // Змінено на bool

    public:
        // Конструктор класу, ініціалізація піна, номера кнопки геймпада та часу захисту від випадкових спрацьовувань
        DebButton(int p, int dT = 10) : pin(p), tmr(false, true) { // Ініціалізація tmr у списку ініціалізації
            
            debounceTime = dT;
            pinMode(pin, INPUT_PULLUP);
            
        }

        // Метод для обробки натискання кнопки
        bool press() {

            if (!digitalRead(pin) && !buttonState && tmr.ts()) {
                
                tmr.st(debounceTime, false); 
                buttonState = true;
                
            } 

            else if (buttonState && digitalRead(pin) && tmr.ts()) {
                
                tmr.st(debounceTime, false); 
                buttonState = false;
                
            }

            return buttonState;

        }

  };

// Bdc
 
// Button gamepad class + supporting functions

  class ButGamepad {
    
    private:
      
      byte gamepadButtonName;
      byte pinReadType; 
      byte numbPin;
      
      int flagPress = 0; //можемо зчитати через метод Get стан кнопки
      Timer tmr;
      int cd[2] = {2048+300, 4095-100};//calibration data //потрібно зробити получення даних з енергонезалежної пам'яті
      int ars; //analog read seve
      int ar;  //analog read 
      
      //вказівник вказує на одну з вибраних функцій які ми вибираємо конструкторi
      typedef byte (ButGamepad::*GamepadPressMethod)(byte);
      GamepadPressMethod gamepadPressPtr;     
      

    
    public:
      
      // функції використовуються всередині класу обробка натиску кнопки

        int tactilePinButtonRead(byte acceptedCommand = 0) {//кожна функція має мати параметр тому що має бути схожість
          
          if (acceptedCommand == read_button_state) {//після натиску відбувається одноразове повернення правда або брехня
            
            bool dr = !digitalRead(numbPin); //підстроїмся під попередній код получаємо правда при натиску
            
            if (dr != flagPress && tmr.ts()) {//  виконує інверсію зчитаного сигналу тому що прапорець flagPress стартує з Нолика не міняє старий код
              
              tmr.st(50, false);
              flagPress = dr;
              if (flagPress) {return press_button;}   
              else {return release_button;}   
            
            }
            
          }
 
          else if (acceptedCommand == i_p_p_g_b && pinReadType == tactile_read){ //i_p_p_g_b=input pullup pin gamepad button) 
           pinMode(numbPin, INPUT_PULLUP);
          } 
          
          return 0;// постійно  повертаємо стан кнопки
          
        }          
         
        int touchPinButtonRead(byte acceptedCommand = 0) {
          
          bool tr = touch_dead_zone < touchRead(numbPin);
          
          if (tr && !flagPress && (tmr < millis())) {// після натську кнопки буде повернення true
            tmr = millis() + 50;
            
            flagPress = true;
            return press_button;
          } 
          
          else if (!tr && flagPress && (tmr < millis())) {// пісня відпущення кнопки буде повернення брехня
            tmr = millis() + 50;
            
            flagPress = false;
            return release_button;
          }
          
          return 0;// постійно  повертаємо стан кнопки          
           
        }
        
        int analogPinButtonRead(byte acceptedCommand = 0) {
            
          if(acceptedCommand == read_button_state){
            
            ar = analogRead(numbPin);
              
            bool dze = cd[d_z] < ar;// Dead zone Exit
            
            if (gamepadButtonName == trigger_r || gamepadButtonName == trigger_l) { 
              
              switch (flagPress) {  
                
                case false://
                
                  if (dze) {
                    
                    flagPress = true;// міняємо шлях виконання
                    return trigger_motion_detected; //повертаємо дану команду щоб виконати return press_button; 
                  
                  }
                
                 break;              
                
                case true:
                  
                  if (dze) { 
                    
                    if (ar != ars) {// якщо є вихід з мертвої зони і є зміни даних повертаємо повідомлення щоб відправити ці дані
                     ars = ar;
                     return trigger_motion_detected;
                    }                
                  
                  } 
                  
                  else if (!dze) {// пісня відпущення курка буде повернення брехня одноразово значить курок в мертвій зоні
                    
                    ars = flagPress = false;//скидаємо щоб очікувати вихід з мертвої зони
                    return release_button;
                
                  }                    
                
                break;               
                
              }
              
            }
          
            else{
              
              if (dze != flagPress) { 
              
                flagPress = dze;
              
                if (flagPress) {return press_button;} 
                else {return release_button;}  
              
              }          
            
            }
          
          }
          
          else if (acceptedCommand == get_analog_state){
             
            return map(constrain(ar, cd[d_z], cd[m_v]), cd[d_z], cd[m_v], 0, 32767);  // test потрібно буде підібрати плюс або мінус        
            
          }        
        
          return 0;
        
        }
 
      //      
      
      // Конструктор проводимо настройку при першому запуску
        
        ButGamepad(byte gBN, byte pRT, byte nP)  { 
          
          gamepadButtonName = gBN;
          pinReadType = pRT;     
          numbPin = nP;
          
          // вибір яким способом-методом буде натиснути кнопки геймпада 1-16. варіанти tactile touch analog
          
            if (pinReadType == tactile_read) {
              
              tmr.st(50, false);//вказуємо час дебаунс щоб працювала коректно
              gamepadPressPtr = &ButGamepad::tactilePress;
            
            }
          
            else if (pinReadType == touch_read) {
            
             gamepadPressPtr = &ButGamepad::touchPress;
          
            }
          
            else if (pinReadType == analog_read) {
             
             tmr.st(false, false);//перенастроюємо таймер для того щоб коректно  працювала провірка analogDeadZonTest
             gamepadPressPtr = &ButGamepad::analogDeadZonTest; //одразу вказуємо на функцію яка буде робити перевірку мертвої зони
             
            }        
          
          //
        
        }
      
      //
      
      // Bluetooth button (методи які фізично зчитують стан піна і натискають програм кноп)
        
        byte tactilePress(byte acceptedCommand) {
        
          if (acceptedCommand == read_button_state) {
           
            switch (tactilePinButtonRead(read_button_state)) {  
              case press_button:  
                bgc_buttonGamepadPressRelease(press_button, gamepadButtonName);    
               return press_button;
               
              case release_button: //після того як кнопка відпущена повертається правда 
                bgc_buttonGamepadPressRelease(release_button, gamepadButtonName);   
               return release_button;     
            }            
            
          }
          
          else if (acceptedCommand == r_b_double_press) {//використовується для кнопки приціл коли не можна змінити режим включення прицілу
            
            switch (tactilePinButtonRead(r_b_double_press)) {  ///test
              case true:  
                bgc_buttonGamepadPressRelease(press_button, gamepadButtonName);    
               break;  
              
              case false:  
                bgc_buttonGamepadPressRelease(release_button, gamepadButtonName);   
               break;     
            }        
            
          }
          
          return 0;
        
        }
        
        byte touchPress(byte acceptedCommand) {
        
          if (acceptedCommand == read_button_state) {
            
            switch (touchPinButtonRead()) {  
              case press_button: 
                bgc_buttonGamepadPressRelease(press_button, gamepadButtonName);    
               return press_button;
              
              case release_button:  
                bgc_buttonGamepadPressRelease(release_button, gamepadButtonName);   
               return release_button;   
            }
          
          }
            
          return 0;        
        
        }
        
        byte analogReadPress(byte acceptedCommand) {
        
          if (acceptedCommand == read_button_state) {
              
            switch (analogPinButtonRead(read_button_state)) {  
              
              case false:
               break;
              
              case press_button:  // якщо віртуальну кнопку натискаємо за допомогою аналогового піна
                
                bgc_buttonGamepadPressRelease(press_button, gamepadButtonName);    
                
               return press_button;
              
              case release_button:  // виконуємо відпущення кнопки якщо попали в dz використовується в двох випадках  press_button trigger_motion_detected
                
                bgc_buttonGamepadPressRelease(release_button, gamepadButtonName);   
              
               return release_button;     
              
              case trigger_motion_detected: // якщо в віртуальну кнопку курок натискаємо за допомогою аналога виконується даний кейс
                  
                  bgc_buttonGamepadPressRelease(press_button, gamepadButtonName, analogPinButtonRead(get_analog_state));
                
                return press_button; // тепер коли курок міняє положення постоянно буде повертатись Дана команда щоб виконати сет Report
                  
            }
          
          } 
          
          return 0;             
        
        }          
      
      //     
      
      // Різне
        
        byte analogDeadZonTest(byte acceptedCommand) {
       
         if (cd[0] < art) {//якщо не в мертвій зоні постійно перезапускаємо таймер
          tmr.st(2000, false);
         }
         
         else if(tmr.ts()){gamepadPressPtr = &ButGamepad::analogReadPress;} //(tmr.st(false, false); виконали конструкторі для коректної роботи)  якщо будемо мертвій зоні дві секунди тоді таймер завершить роботу переключимося на звичайний режим
         
         return false;
       
        }
        
        bool calibrationTrigger() {
            
          int art = analogRead(numbPin); //  art analog Read temp
          
          if (art < 2048-300 || 2048+300 < art) {// критичне відхилення або несправність 1he спрацювання виводимо повідомлення 2ge спрацювання виконуємо відключення deactivateButton()
            
            return true;//повертаємо правда виконуємо дії залежності від етапу перезапуск або відключення
          
          }             
           
          if (!cd[0]) {//це означає перший запуск записуємо початковий центр
            cd[0] = art;
          }
          
          if (cd[0] < art) {//записуємо максимальну величину потрібно підібрати полярність//
            cd[0] = art;
          }
          
          return false;
        
        }        
       
        void deactivateButton() {// використовується на станції при провірці кнопок
          
          gamepadPressPtr = &ButGamepad::returnFalse;
        
        }        
        
        byte returnFalse(byte) {
          
          return false;
        
        }        
        
        int getAnalogData() {
            
          return analogRead(numbPin);
          
        }                
        byte getVirtualButtonName(){
        
         return gamepadButtonName;
        
        }
        
        void virtualButtonReinstall(byte newButton){// 
          
          gamepadButtonName = newButton; //  
          
        }
        
        byte gamepadBatton(byte acceptedCommand) { //функція повертає вказівник який вказує на функцію яка була вибрана через конструктор
            
          return (this->*gamepadPressPtr)(acceptedCommand);
            
        }   
        
        int* getCalibrationData(){//калібровочні дані для курків
            
          return cd;
            
        }        
        
        void setCalibrationData(int newData[]){//калібровочні дані для курків
          
          memcpy(cd, newData, sizeof(cd));
            
        }        
        
        bool getButtonState(){
          
          return flagPress;
           
        }        
        
        void releaseButton(){
          
          flagPress = false;//скидуємо стан флажка щоб можна було повторно получити press_button;
          bgc_buttonGamepadPressRelease(release_button, gamepadButtonName); //виконуємо команду відпустити кнопки щоб не було натиску коли викличуться  сет репорт
        
        }
       
        bool triggerRightGetStatus(){// получимо стан флажка-кнопки
          
          static bool stateSeve;
          
          if (stateSeve != flagPress) {
           
           stateSeve = flagPress;
           return flagPress;//одноразово повертаємо стан//при розриві функції може не відреагувати на зміну стану Але дальше буде самоналаштовуватися
          
          }
        
        }
  
      //
  
  };//  Button gamepad
  
  // Cтворюємо екземпляри класу настроюємо вказівник на необхідну функцію
  // ButGamepad(1(reinstall!), 2, 3) 1-вибираємо курок чи кнопка 2-вибираємо чим будемо натискати сенсорна-звичайна кнопка або аналог 3-номер піна
  
  ButGamepad physicalButtons[] = {// test конструктор класів вказуємо номера пінів і способи зчитування які відповідають за кнопки
     
    ButGamepad(ap->virtualButtonsList[b_1], tactile_read, 5), // стандартно virtualButtonsList[b_1 = 0] = gamepad button 1
    ButGamepad(ap->virtualButtonsList[b_2], tactile_read, 23),
    ButGamepad(ap->virtualButtonsList[b_3], tactile_read, 16), 
    ButGamepad(ap->virtualButtonsList[b_4], tactile_read, 16),
    ButGamepad(ap->virtualButtonsList[b_5], tactile_read, 16),
    ButGamepad(ap->virtualButtonsList[b_6], tactile_read, 16),
    ButGamepad(ap->virtualButtonsList[b_7], tactile_read, 16),
    ButGamepad(ap->virtualButtonsList[b_8], tactile_read, 16),
    
    ButGamepad(ap->virtualButtonsList[b_se], tactile_read, 16), // virtualButtonsList[b_se] = button_select = 9 
    ButGamepad(ap->virtualButtonsList[b_st], tactile_read, 16), // virtualButtonsList[b_st] = button_start = 10 
    ButGamepad(ap->virtualButtonsList[b_h], tactile_read, 16), // virtualButtonsList[b_h] = button_home = 11
    
    ButGamepad(ap->virtualButtonsList[d_u], tactile_read, 16), // virtualButtonsList[d_u] = dpad_up = 12
    ButGamepad(ap->virtualButtonsList[d_d], tactile_read, 17), // virtualButtonsList[d_d] = dpad_down = 13
    ButGamepad(ap->virtualButtonsList[d_l], tactile_read, 16), // virtualButtonsList[d_l] = dpad_left = 14
    ButGamepad(ap->virtualButtonsList[d_r], tactile_read, 17), // virtualButtonsList[d_r] = dpad_right = 15
    
    ButGamepad(ap->virtualButtonsList[t_l], analog_read, p_triger_l_34),  // virtualButtonsList[t_l] = trigger_l = 16
    ButGamepad(ap->virtualButtonsList[t_r], analog_read, p_triger_r_35),  // virtualButtonsList[t_r] = trigger_r = 17
    
    ButGamepad(ap->virtualButtonsList[r_s], tactile_read, 16), // два останніх для дублювання кнопок
    ButGamepad(ap->virtualButtonsList[r_m], tactile_read, 16) 
 
  };
      
  // Supporting functions bgc
    
    void bgc_buttonGamepadPressRelease(byte command, byte buttonName, int analogData) {//функція натискає кнопки 1-8 Select Start і d-пад викликається в кожному екземплярі класу через метод gamepadBatton  analogData = 32767
      
      static byte x = 1;
      static byte y = 1; 
      
      const byte dPad[3][3] = {
        
        {HAT_UP_LEFT, HAT_UP, HAT_UP_RIGHT},
        {HAT_LEFT, HAT_CENTERED, HAT_RIGHT},
        {HAT_DOWN_LEFT, HAT_DOWN, HAT_DOWN_RIGHT}
      
      };
      
      if (command == press_button) {
        
        switch (buttonName) {
          
          case button_0://використовується щоб відключати кнопки кнопки нуль не існує
          case button_1:
          case button_2:
          case button_3:
          case button_4:
          case button_5:
          case button_6:
          case button_7:
          case button_8:
            bleGamepad.press(buttonName);
            break;

          case button_select:// 9
            bleGamepad.pressSelect();
            break;

          case button_start:// 10
            bleGamepad.pressStart();
            break;

          case button_home://11
            bleGamepad.pressHome();
            break;         
          
          case dpad_up:// 12-13
          case dpad_down:
            x = map(buttonName, dpad_up, dpad_down, 0, 2);
            bleGamepad.setHat1(dPad[x][y]);
            break;//не прибирати брейк

          case dpad_left:// 14-15
          case dpad_right:
            y = map(buttonName, dpad_left, dpad_right, 0, 2);
            bleGamepad.setHat1(dPad[x][y]);
            break;

          case trigger_l://16
            bleGamepad.setLeftTrigger(analogData);//якщо звичайна кнопка то встановиться максимум 32767 якщо аналог  дані будуть іншими в залежності від сили натиску
            break;

          case trigger_r://17
            bleGamepad.setRightTrigger(analogData);
            break;
          
        }    
      
      }
      
      else if (command == release_button) {

        switch (buttonName) {
          
          case button_0:
          case button_1:
          case button_2:
          case button_3:
          case button_4:
          case button_5:
          case button_6:
          case button_7:
          case button_8:
            bleGamepad.release(buttonName);
            break;

          case button_select://9
            bleGamepad.releaseSelect();
            break;

          case button_start://10
            bleGamepad.releaseStart();
            break;
          
          case button_home://11
            bleGamepad.releaseHome();
            break;
          
          case dpad_up://12-13
          case dpad_down:
            x = 1;
            bleGamepad.setHat1(dPad[x][y]);
            break;

          case dpad_left://14-15
          case dpad_right:
            y = 1;
            bleGamepad.setHat1(dPad[x][y]);
            break;

          case trigger_l://16
            bleGamepad.setLeftTrigger(0);
            break;

          case trigger_r://17
            bleGamepad.setRightTrigger(0);
            break;
          
        }          
        
      }
    
    }    
    
    void bgc_buttonGamepadResetlAll() {//скидання назва фізичної і віртуальної папки буде співпадати
              
      for (int i = 0; i <= 16; i++) {
      
        physicalButtons[i].virtualButtonReinstall(i+1); //аналог перезапуску всіх(17ти) конструкторів екземплярів класу
      
      }
      
    }    
    
    void bgc_buttonConnectionResistor(){
      
      for (int i = 0; i <= 14; i++) {//test невідомо якого типу будуть фізичні кнопки приклад і магазин
        physicalButtons[i].tactilePinButtonRead(i_p_p_g_b); 
      }  
      
      delay(10);
    
    }
    
    void bgc_releaseButtonsAll(){ // відпускаємо всі кнопки окрім куртів

        for (byte i = 0; i <= 14; i++) {
          
          physicalButtons[i].releaseButton();
          
        }
      
      physicalButtons[r_s].releaseButton();
      physicalButtons[r_m].releaseButton();
      
      
      bleGamepad.sendReport();   
      
    }
        
    bool bgc_checkingAllButtons() {
      
      static byte mode;
    
      if (mode == stage_0) {
        
        for (byte i = b_1; i <= t_r; i++) {//Перевіряємо чи натиснуті кнопки
          
          if (physicalButtons[i].gamepadBatton(read_button_state) == press_button){//
          
           mode = stage_1;
          
          } 
        
        }
        
        if (physicalButtons[r_s].gamepadBatton(read_button_state) == press_button || physicalButtons[r_m].gamepadBatton(read_button_state) == press_button) {
          
          mode = stage_1;
          
        }    
        
        bgc_releaseButtonsAll();//скидаємо всі кнопки щоб можна було повторно получити press_button
        
        if (mode == stage_1) {return true;}//якщо є зміна етапу то відправляємо правда щоб виконати дії
      
      }
      
      else if (mode == stage_1 || mode == stage_2) {//після того як вивели попередження і якщо фіксуємо натиснуту кнопку то вона відключиться аж до наступного запуску контролера
      
        for (byte i = b_1; i <= t_r; i++) {
          
          if (physicalButtons[i].gamepadBatton(read_button_state) == press_button){// 
           mode = stage_2;
           physicalButtons[i].deactivateButton(); //відключаємо повністю зчитування піна Щоб зекономити ресурси помилки немає
          } 
        
        }
        
        if (physicalButtons[r_s].gamepadBatton(read_button_state) == press_button) {
          mode = stage_2;
          physicalButtons[r_s].deactivateButton();
        }
        
        if (physicalButtons[r_m].gamepadBatton(read_button_state) == press_button) {
          mode = stage_2;
          physicalButtons[r_m].deactivateButton();
        } 
        
        bgc_releaseButtonsAll();// тепер виконуємо скидання щоб натиснута кнопка не відображалась натиснутою
      
        if (mode == stage_2) {return true;}//якщо при другому виклику відбулось відключення будемо повертати правда щоб вивести повідомлення
      
      }
      
      return false;//
    
    }  
  
  //

// Bgc

// Additional functions Function svmbols
 
  //Additional functions
 
    //void tick(){}
    
    void af_menuLinesCenterY(byte totalItems, byte spacing, byte centerY, byte yOut[]) {
        
        const byte lineHeight = 8;  // Висота одного рядка
        int top;

        if (totalItems % 2 == 1) {
            // Непарна кількість рядків: центральний рядок точно на centerY
            byte middleIndex = totalItems / 2;
            top = centerY - middleIndex * (lineHeight + spacing) - lineHeight / 2;
        } else {
            // Парна кількість рядків: центр між двома середніми рядками
            byte middleIndex = totalItems / 2 - 1;
            top = centerY - (middleIndex * (lineHeight + spacing) + lineHeight + spacing / 2);
        }

        for (byte i = 0; i < totalItems; i++) {
            yOut[i] = top + i * (lineHeight + spacing);
        }
    }
            
    int clampMinMax(int value, int minVal, int maxVal) {
      if (value < minVal) return minVal;
      if (value > maxVal) return maxVal;
      return value;
    }     
    
    //Encoder module  
    
      bool af_checkClick() {
        if (enc.isClick()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }
      
      bool af_checkTurn() {
        if (enc.isTurn()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }      
      
      bool af_checkRightHolded() {
        if (enc.isRightH()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }    
      
      bool af_checkLeftHolded() {
        if (enc.isLeftH()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }    
          
      bool af_checkFastRight() {
        if (enc.isFastR()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }

      bool af_checkFastLeft() {
        if (enc.isFastL()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }

      bool af_checkRight() {
        if (enc.isRight()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }

      bool af_checkLeft() {
        if (enc.isLeft()) {
          Md_autoPowerOff(apo_restart_time);
          Md_displayTimeout(timeout_restart);
          return true;
        }
        return false;
      }        
    
    //
    
    //Shooting effects
      
      void af_triggerShootingEffects(byte acceptedCommand){//функція запускає ефекти викликається в analogReadTriggerRightPress
        
        if (physicalButtons[t_r].triggerRightGetStatus()) { //працює лише коли підключений Bluetooth
          
          af_triggerLight(color_two);
          af_shotgunBolt(bolt_start);
          af_vibration(vibration_start);             
        
        } 
        
        else if (!physicalButtons[t_r].triggerRightGetStatus()) {// пісня відпущення кнопки буде одноразове повернення брехня
          
          af_triggerLight(color_one);
          af_shotgunBolt(bolt_stop);
          af_vibration(vibration_stop);            
        
        }                        
        
        af_triggerLight();
        af_shotgunBolt();
        af_vibration();
        
      }    
      
      byte af_shotgunBolt(byte acceptedCommand){
         
        static byte boltPermission = 1;
        
        if (acceptedCommand){
          
          if (acceptedCommand == bolt_start && boltPermission){
              
            digitalWrite(p_bolt_rifle_12, HIGH);
              
          }
          
          else if (acceptedCommand == bolt_stop && boltPermission){
            
            digitalWrite(p_bolt_rifle_12, LOW);
            
          }              
          
          else if (acceptedCommand == bolt_change){ 
             
            if (mdf_magnifier(boltPermission, 0, 1, 1, 1)){
               
              if (!boltPermission){digitalWrite(p_bolt_rifle_12, LOW);} 
            
            }
            
          }
          
          else if (acceptedCommand == bolt_get_permission){ //використовується для відображення включена чи виключено 
            
            return boltPermission;
          
          }
          
          else if (acceptedCommand == bolt_pin_activate){ 
            
            pinMode(p_bolt_rifle_12, OUTPUT);
            digitalWrite(p_bolt_rifle_12, LOW);
          
          }            
          
          else if (acceptedCommand == acceptedCommand == tf_reset_settings) {  
          
            boltPermission = 1; 
          
          }
          
          else if (acceptedCommand == get_eeprom) { 
            
            af_saveToEEPROM(get_eeprom, &boltPermission, sizeof(boltPermission));
            
          }               
          
          else if (acceptedCommand == set_eeprom) { 
            
            af_saveToEEPROM(set_eeprom, &boltPermission, sizeof(boltPermission));
            
          }             
        
        }
        
        return 0;        
      
      }      
      
      byte af_vibration(byte acceptedCommand){
         
        static byte vibrationPermission = 1;
        
        if (acceptedCommand){
            
          if (acceptedCommand == vibration_start && vibrationPermission){
              
            digitalWrite(p_vibration_motor_18, HIGH);
              
          }
          
          else if (acceptedCommand == vibration_stop && vibrationPermission){
            
            digitalWrite(p_vibration_motor_18, LOW);
            
          }              
          
          else if (acceptedCommand == vt_change){
              
            if (mdf_magnifier(vibrationPermission, 0, 1, 1, 1)){
              
              if (vibrationPermission){
                digitalWrite(p_vibration_motor_18, HIGH); //test  можливо заребриє на секунду потрібно тестувати
                digitalWrite(p_vibration_motor_18, LOW);
              }
              else {digitalWrite(p_vibration_motor_18, LOW);}
            
            } 
            
          }
          
          else if (acceptedCommand == vt_get_permission){ 
            
            return vibrationPermission;
          
          }
          
          else if (acceptedCommand == vt_pin_activate){ 
            
            pinMode(p_vibration_motor_18, OUTPUT);
            digitalWrite(p_vibration_motor_18, LOW);
          
          }            
          
          else if (acceptedCommand == tf_reset_settings) { 
            
            vibrationPermission = 1;
          
          }
          
          else if (acceptedCommand == get_eeprom) { 
            
            af_saveToEEPROM(get_eeprom, &vibrationPermission, sizeof(vibrationPermission));
            
          } 

          else if (acceptedCommand == set_eeprom) { 
            
            af_saveToEEPROM(set_eeprom, &vibrationPermission, sizeof(vibrationPermission));
            
          }             
        
        }
        
        return 0;        
      
      }   

      int af_triggerLight(byte acceptedCommand, int acceptedData){
        
        static byte light1 = 100;
        static byte light2 = 100;
        static int color1 = 260;
        static int color2 = 0;
        static byte lom = color_switching; // lom = light operating mode
        
        if (acceptedCommand){
        
          if (acceptedCommand == color_one){
            if (lom == color_switching){
              af_setColorByValue(color1, light1);  
            }
          }
          
          else if (acceptedCommand == color_two){
            if (lom == color_switching){
              af_setColorByValue(color2, light2);  
            }
          }          
            
          else if (acceptedCommand == get_color1){ 
            return color1;      
          }           
        
          else if (acceptedCommand == get_color2){
            return color2;      
          }            
          
          else if (acceptedCommand == get_light1){
            return light1;      
          }           
        
          else if (acceptedCommand == get_light2){
            return light2;      
          }                     
          
          else if (acceptedCommand == set_color1){
              
            color1 = acceptedData;
            af_setColorByValue(color1, light1);  
          
          }           
        
          else if (acceptedCommand == set_color2){
              
            color2 = acceptedData;
            af_setColorByValue(color2, light2);   
          
          }            
          
          else if (acceptedCommand == set_light1){
            light1 = acceptedData;
            af_setColorByValue(color1, light1);     
          }           
        
          else if (acceptedCommand == set_light2){
            light2 = acceptedData;
            af_setColorByValue(color2, light2);       
          }              
        
          else if (acceptedCommand == clssc){  //clssc = color light standard settings check
            
            if (light1 == 100 && light2 == 100 && color1 == 260 && color2 == 0){
              return color_light_default;
            }
            
          }                    
          
          else if (acceptedCommand == color_light_reset){
            
            light1 = 100;
            light2 = 100;
            color1 = 260;
            color2 = 0;
            af_setColorByValue(color1, light1);     
          
          }
          
          else if (acceptedCommand == color_switching){//один з двох режимів переключення кольорів або настройка кольору
            lom = color_switching;
          }              
          
          else if (acceptedCommand == color_light_setting){
            lom = color_light_setting;
          }            
        
        }
        
        return 0;
      
      
      
      }    
      
      void af_setColorByValue(uint16_t colorIndex, uint8_t brightnessPercent) {
        // Обмеження: не нижче 1, не вище 1000
        colorIndex = constrain(colorIndex, 1, 1000);
        brightnessPercent = constrain(brightnessPercent, 0, 100);

        uint8_t hue;
        uint8_t sat;

        if (colorIndex <= 700) {
          // Відтінки кольору (насиченість максимальна)
          hue = map(colorIndex, 1, 700, 0, 255);
          sat = 255;
        } else {
          // Перехід до білого — зменшуємо насиченість
          hue = map(700, 1, 700, 0, 255); // Зберігаємо останній hue
          sat = map(1000 - colorIndex, 0, 300, 0, 255);
        }

        // Яскравість
        uint8_t val = map(brightnessPercent, 0, 100, 0, 255);

        leds[0] = CHSV(hue, sat, val);
        FastLED.show();
      }    
    
    //
    
    String af_animatePointer() {
      static Timer anim(400);
      static byte pos = 0;

      if (anim.gp()) {
        if (++pos > 2) pos = 0;
      }

      const char arrow = (char)16; // код символа зі шрифту OLED
      String out = "";
      for (byte i = 0; i < 3; i++) {
        out += (i == pos) ? String(arrow) : ">";
      }

      return out;
    }
    
    // Функція для зупинки вимірювання та обробки статистики
      
      unsigned long overallMinTime = 99999999;
      unsigned long overallMaxTime = 0;
      unsigned long avgTotalTime = 0;
      unsigned int avgMeasurements = 0;
      unsigned long startMicros = 0;

      // Змінні для керування логікою "за секунду"
      unsigned long lastSecondStartTime = 0;
      bool isMeasuring = true;
      bool isDataReady = false;


      // Функція для старту вимірювання
      void startPerfMeasurement() {
          // Вимірювання відбувається лише якщо ми у стані "збору"
          if (isMeasuring) {
              startMicros = micros();
          }
      }


      // Функція для зупинки вимірювання та обробки статистики
      void endPerfMeasurement() {
          // Обробляємо команду з Serial Port
          if (Serial.available()) {
              char command = Serial.read();
              if (command == '1') {
                  // Якщо команда '1' отримана і дані готові
                  if (isDataReady) {
                      // Виводимо звіт
                      float avgTime = (float)avgTotalTime / avgMeasurements;
                      
                      Serial.println("--- Статистика за останній замір ---");
                      Serial.print("Середній час: ");
                      Serial.print(avgTime / 1000.0, 3);
                      Serial.println(" мс");
                      
                      Serial.print("Мінімальний час (за весь час): ");
                      Serial.print((unsigned long)overallMinTime / 1000.0, 3);
                      Serial.println(" мс");
                      
                      Serial.print("Максимальний час (за весь час): ");
                      Serial.print((unsigned long)overallMaxTime / 1000.0, 3);
                      Serial.println(" мс");
                      
                      Serial.print("Кількість вимірів: ");
                      Serial.println(avgMeasurements);
                      Serial.println("-------------------------------------");

                      // Перезапускаємо збір даних
                      isMeasuring = true;
                      isDataReady = false;
                      lastSecondStartTime = millis();
                      avgTotalTime = 0;
                      avgMeasurements = 0;
                  } else {
                      Serial.println("Збір даних ще не завершено.");
                  }
              }
          }
          
          // Якщо ми у стані "збору", оновлюємо статистику
          if (isMeasuring) {
              unsigned long endMicros = micros();
              unsigned long elapsed = endMicros - startMicros;
              
              // Оновлюємо абсолютні мінімальні та максимальні значення
              if (elapsed < overallMinTime) {
                  overallMinTime = elapsed;
              }
              if (elapsed > overallMaxTime) {
                  overallMaxTime = elapsed;
              }

              // Накопичуємо дані для середнього часу
              avgTotalTime += elapsed;
              avgMeasurements++;

              // Перевіряємо, чи пройшла секунда
              if (millis() - lastSecondStartTime >= 1000) {
                  isMeasuring = false;
                  isDataReady = true;
              }
          }
      }
    //
    
    void af_powerOffExecution(){
      
      //af_saveToEEPROM(eeprom_seve);
      display.clearDisplay();
      display.display();   
      leds[0] = CHSV(0, 0, 0);
      FastLED.show();     
      btStop();              // Вимкнути Bluetooth, якщо був увімкнений
      esp_deep_sleep_start();
    
    }
    
    // !!! нагадування можна просто викликати всі функції які мають мати дані з енергонезалежної пам'яті по черзі і проінтеризувати зміни всередині тих функцій через лямбда функцію     
    
    int af_saveToEEPROM(int acceptedCommand, void* address, size_t dataSize) {//TEST
      
      static int addInd = 1;///перший байт використовується для флажка
      uint8_t* bytePointer = (uint8_t*)address;
      
      if (acceptedCommand == set_eeprom) { 
        
        bool dataChanged = false;  // Флаг для перевірки змін
        
        for (size_t i = 0; i < dataSize; i++) {
          
          if (*(bytePointer + i) != EEPROM.read(addInd + i)) {//економія ресурсів перед записом Перевіряємо чи дані відрізняються якщо відрізняються відбудеться перезапис
            dataChanged = true;  // Дані змінилися
            break;  // Якщо знайшли різницю, не потрібно перевіряти далі
          }
        
        }

        if (dataChanged) {//якщо стан важка змінився значить дані потрібно перезаписати
            
          for (size_t i = 0; i < dataSize; i++) {
            EEPROM.write(addInd + i, *(bytePointer + i));  // Побайтово записуємо в EEPROM
          }
          
          EEPROM.commit();  // Фіксуємо зміни
           
        } 
        
        addInd += dataSize;
      
      } 
      
      else if (acceptedCommand == get_eeprom || acceptedCommand == get_eeprom_last_read) {//по байтах зчитуємо збережені дані
      
        for (size_t i = 0; i < dataSize; i++) {
         *(bytePointer + i) = EEPROM.read(addInd+i); 
        }
        if (acceptedCommand == get_eeprom) {
          addInd += dataSize;// Переходимо до наступного індексу
        } else{addInd = 1;}//якщо в нас get_eeprom_last_read то потрібно скинути щоб записувати знову з першого байта
        
      }
      else if (acceptedCommand == address_indicator_reset) {
       addInd = 1;      
      }
      
      else if (acceptedCommand == eeprom_initialization && !EEPROM.read(0)) {
        
       for (int i = 8; i < 14; i++) {
        //profil[i].eepromProfile(get_eeprom);
       }
      
       af_vibration(get_eeprom);
       af_shotgunBolt(get_eeprom);
       af_triggerLight(get_eeprom);
       Md_displayTimeout(get_eeprom);
       Md_autoPowerOff(get_eeprom);       
       Md_gyroCalibrationExecution(get_eeprom);
       af_saveToEEPROM(address_indicator_reset);
      }
      
      else if (acceptedCommand == eeprom_seve) {  
        
       if (EEPROM.read(0)) {EEPROM.put(0, 0);EEPROM.commit();}
       
       for (int i = 8; i < 14; i++) {
        //profil[i].eepromProfile(set_eeprom);
       }
       
        
        
       af_vibration(set_eeprom);
       af_shotgunBolt(set_eeprom);
       af_triggerLight(set_eeprom);
       Md_displayTimeout(set_eeprom);
       Md_autoPowerOff(set_eeprom);             
            
       Md_gyroCalibrationExecution(set_eeprom); 
     
      }
      
      return 0;
    
    }
 
    byte af_passwordEntry(byte acceptedCommand) {
      
      static byte currentStage = 0; // Поточний етап (0 - клік, 1 - утримання, 2 - клік)
      
      if (currentStage != 2 && acceptedCommand == typing_a_password){ 
      
        switch (currentStage) {
            
          case 0: // Етап 1: Очікування утримання
            if (enc.isHolded()) {     
             currentStage = 1; // Переходимо до наступного етапу   
            } 
           break;
          
          case 1: // Етап 2: Очікування кліку
            if (af_checkClick()) {
             currentStage = 2; // Переходимо до наступного етапу
             return password_entered;
            }
           break;
        
        }
       
        return password_not_entered;
      
      } 
          
      else if (acceptedCommand == password_reset){ 
        currentStage = 0;
      }       
     
      return 0;
      
    }
    
    void af_centerTextX(int x, int y, auto input, bool minusNo = false) {
      
      // Перетворюємо вхідне значення у рядок
      static String text;
      static int adjustedLength;
      static int textWidth;
      
      // Якщо треба ігнорувати мінус, коригуємо довжину тексту
      text = String(input);
      adjustedLength = text.length();
      
      if (minusNo && text[0] == '-') {
        adjustedLength--; // Ігноруємо мінус
      }

      // Обчислюємо ширину тексту
      textWidth = adjustedLength * 6; // 6 пікселів на символ

      // Встановлюємо курсор
      display.setCursor(x - (textWidth / 2), y);

      // Виводимо текст
      display.print(text);
    
    }

    void af_displayPrintLain(String text, byte x, byte y, byte linePosition, byte cropText) {// (ДИВИТИСЬ ПОЯСНЕННЯ)

      // Статичні змінні для збереження стану між викликами
      static Timer tmr(10);            // Таймер для контролю автоматичної прокрутки також включаємо оновлення дисплея при кожному зміщенні тексту
      static byte lps;                 // Змінна для збереження line Position seve
      static int stx;                 // Позиція прокрутки по горизонталі
      byte stxt;                      // Тимчасова змінна для прокрутки  stxt =crolling text x temporary
      static int tlip;                // Довжина тексту в пікселях  tlip = text Length In Pixels

      if (mdf_cursor(get_pos) != lps) {//тут відбувається скидання прокрутки  якщо курс змінив позицію
        
        tlip = text.length() * 6;   // Довжина тексту у пікселях (6 пікселів на символ)
        stx = 0;                    // Початкова позиція прокрутки
        lps = linePosition;         // Оновлення  
      
      } 
      
      if (mdf_cursor(get_pos) == linePosition) {//якщо номер строки співпадає з позицією kурсора відбувається прокрутка тексту
        
        // Автоматична прокрутка за таймером, якщо кнопка не натиснута
       if (tmr.ta()) {// test здається має бути інший таймер
          if (tlip > stx) {
            stx += 1;                 // Збільшення позиції прокрутки
          } else {
            stx = 0;                  // Скидання прокрутки до початку тексту
          }
        }
        
        stxt = stx;                   // Присвоєння тимчасової змінної значення прокрутки
      }
      
      // Встановлення курсора з урахуванням прокрутки та виведення тексту
      //if (linePosition) {display.drawRect((x + cropText * 6)-12, y, 5, 8, 1);}
      display.setCursor(x - stxt, y);
      display.print(text);
      
      //чорні прямокутники для закриття потрібні лише тоді коли даний параметр приймає любе значення окрім нуля 
      //якщо даний параметр брехня То це означає що текст поміщається виділену область
      if (linePosition) {

        display.fillRect(0, y, x, 8, 0);                    // Ліва область
        display.fillRect(x + cropText * 6, y, 128, 8, 0);   // Права область відповідно до обрізаного тексту
        display.fillRect(0, y + 7, 128, 64, 0);             // Очищення області під текстом
        display.setCursor((x + cropText * 6)-3, y);
        display.write(16);  // це стрілочка ►             
      
      }

    }
      
    uint32_t af_clamp(int value, int minVal, int maxVal) {//якщо вийти за рамки то поверне в початок або кінець
      
      if (value < minVal) {
        
        return  maxVal; 
      } 
      
      else if (value > maxVal) {
        
        return minVal;  
      
      }
      
      return value;  
    
    }
    
    void af_startAnimation(){
      
      display.clearDisplay();
       
       
      af_centerTextX(X(64), Y(28), "FS G36" );
      
      display.display();
      delay(2000);
      display.clearDisplay();
      display.display();
      
    }
    
    // Controls check
      
      void af_controlsCheck(){
        
        byte stage = stage_1;
        
        while (stage) {
         
          enc.tick();
          Md_autoPowerOff();          
          
          display.clearDisplay(); 
          
          display.drawRect(0, 0, 128, 48, WHITE);
          
          switch (stage) {
            
            case stage_1:           
           
              stage = af_deviceCheck(stage_1);//якщо успішна тоді одразу кейс stage_4   якщо ні перейдемо до stage_2 виведемо повідомлення
              
             break;
            
            case stage_2:           
            
              stage = af_pleaseDoNotPress();//просmo не чіпати і вибрати Next після вибору Next або завершення часу відображення переходимо до  stage_3
              
             break;
            
            case stage_3:           
            
              stage = af_deviceCheck(stage_3);// якщо виконуємо другий раз перевірку то можливі два варіанти завершення stage_4 означає що натиснуте було відпущене stage_5 означає що є проблеми з елементами керування виконалось відключення несправного або натиснутого
              
             break;    
            
            case stage_4:           
            
              stage = af_endMessage(stage_4);//якщо перевірка успішна то виводимо Device OK
              
             break;           
            
            case stage_5:           
            
              stage = af_endMessage(stage_5);// якщо була помилка то виводимо Controls ERROR

              
             break;            
         
         
         }
          
          display.display();
        
        }
        
       delay(1000);//секунда затримки щоб відобразити повідомлення успішне чи погане завершення
      
      }
      
      // dead zones calibration button check
        
        byte af_deviceCheck(byte stage){
        
          static Timer tmr(4000, false);
          
          if (stage == stage_1) {
            
            if (af_controlsCheckСalibration(false)) {//якщо на першій провірці є відхилення переключимося на екран прохання //виконуємо калібрування провірку
             
             af_controlsCheckСalibration(true);//потрібно скинути щоб можна було повторно получити правда if (af_controlsCheckСalibration(false)) {
             tmr.st(4000, false);
             af_drawCountdown(false);//перезапускаємо анімацію таймера тому що є відхилення
             return stage_2;
            
            }
            
            if (tmr.ts()) {// якщо таймер дойде до кінця значить провірка успішна
              
              return stage_4;//просто завершуємо 
            
            }      
          
          }
          
          else if (stage == stage_3) {
            
            af_controlsCheckСalibration(false);//якщо тут будуть відхилення то відбудеться відключення попередження не буде
             
            if (tmr.ts()) {//таймер доходить до кінця є два варіанти завершення
              
              if (af_controlsCheckСalibration(true)) {//тест завершення з помилкою означає що відбулось відключення елементів керування
               return stage_5;// 
              }
              else{//означає що при другій спр Все пройшло добре елементи керування були відпущені
               return stage_4;
              }
           
            }      
          
          }      
          
           af_p_deviceCheck();//відображаємо повідомлення Device check і анімацію таймера
        
          return stage;
        
        }
        
        void af_p_deviceCheck(){
          
          const byte l = 1, p = 0, s = 48/2; 
          byte y[l];
              
          af_menuLinesCenterY(l, p, s, y);     
          af_centerTextX(X(65), y[0], "Device check");
          af_drawCountdown(true);
        
        }
      
        void af_drawCountdown(bool start) {
            
          static Timer tmr(4000, false);
            
          static int inspectionLine = 114;//лінія перевірки
          static bool digitJump; // цифра стрибок
          static bool displayPermission = true; // дозвіл відображення
          
          if (displayPermission){
            
            fd_drawCenteredFilledRect(X(64), Y(56), W(inspectionLine), H(3));//Смужка яка зменшується в центр
            
            inspectionLine = map(tmr.gmt(), 0, 4000, 14, 114);//зменшуємо розмір смужки до мінімума
            
            if (inspectionLine % 2 != 0) {//робимо це рівномірно відрізаємо по одному Пікселю Зліва і справа
            inspectionLine = inspectionLine - 1;
            }
            
            fd_drawCenteredHollowRect(X(64), Y(56), W(14), H(13));//прямокутник в центрі в якому відображаються цифри
            fd_drawCenteredFilledRect(X(64), Y(56), W(12), H(11), BLACK);//робимо чорне полотно в центрі прямокутника накриваємо смужку
            
            int temp = tmr.gst();
            
            if (temp) {// якщо таймер не вийшов відображаємо секунди
              af_centerTextX(X(64+digitJump), Y(53), temp);
              digitJump = !digitJump;
            }
            
            else{fd_drawCenteredHollowRect(X(64), Y(56), W(6), H(7));}//якщо час вийшов відображаємо прямокутник замість Нолика так красивіше
            
            if (tmr.ts()){displayPermission = false; delay(500);}//час вийшов завершуємо додатково трошки зупиняємося щоб було видно наш Нулик
          
          }
          
          if (!start){
            
            tmr.st(4000, false);
            inspectionLine = 114;
            displayPermission = true;
            
          } 

        }             
      
      //
      
      // please Do Not Press
        
        byte af_pleaseDoNotPress(){

         if (af_selectNextRestart()) {
           
          return stage_3;
         
         }
         
         af_p_pleaseDoNotPress();
         
         return stage_2;
        
        }      
      
        void af_p_pleaseDoNotPress(){
          
          const byte l = 2, p = 1, s = 48/2; 
          byte y[l];
              
          af_menuLinesCenterY(l, p, s, y);          
          
          af_centerTextX(X(65), y[0], "Please don't" );  
          af_centerTextX(X(65), y[1], "press anything");                
            
        }      
        
        // Select next restart
          
          void af_p_selectNextRestart(byte selection) {
             
            display.fillRect(19, 4 + 51, 21, 3, WHITE); //жирна риска -
               
            display.setCursor(86, 2 + 51);
            display.print("Next");

            // Рамки навколо тексту
            if (selection == 0) {
              display.drawRect(16, 0 + 51, 27, 11, WHITE);  //жирна риска -
            } else {
              display.drawRect(84, 0 + 51, 27, 11, WHITE);  // Next
            }
           
          }

          byte af_selectNextRestart() {//
            
            static Timer tmr(5000, false);
            static byte selection = 0; // 0 = Restart, 1 = Next
            
            af_p_selectNextRestart(selection);
            
            if (af_checkTurn()) {
              selection = !selection;
            }
            
            if ((af_checkClick() && selection) || tmr.ts()) {
            
              selection = 0; 
              return true;
            
            }
             
            return false; // поки нічого не обираємо
          
          }      
        
        //       
     
      //
     
      // end message
      
        byte af_endMessage(byte stage){
          
          af_p_endMessage(stage);
               
          return stage_0; // одразу завершуємо функцію в кінці циклу затримка  delay(1000); дозволить побачити виведене повідомлення
        
        }
      
        void af_p_endMessage(byte stage){
      
          if (stage == stage_4) {

            af_centerTextX(X(65), (48/2)-4, "Device OK");
              
          }
          
          else if (stage == stage_5) {

           af_centerTextX(X(65), (48/2)-4, "Controls ERROR");
          
          }              
       
        }
      
      //
      
      bool af_controlsCheckСalibration(bool reset) {
         
        static byte st;
          
        if (!reset) {//означає виконати перевірку
          
          if (Gf_leftJoystick(c_c_j) || //якщо получим правда перший раз виведемо прохання не чіпати якщо викл дану функцію другий раз виконується відключення якщо є критичні відхилення
            Gf_rj(c_c_j) || 
            physicalButtons[t_l].calibrationTrigger() ||
            physicalButtons[t_r].calibrationTrigger() ||
            bgc_checkingAllButtons() 
          
          ) 
          
          {
          
          st = true; 
            
          }
        }
        
        else if (reset){//скидаємо і одночасно получаємо результат перевірки в першому виклику потрібно скинути в другому потрібен взяти результат
         
         bool temp = st;
         st = false;  
         return temp;//
        
        }        
        
        return st;
      
      }

    //      
  
  //
  
  // For display (різне для дисплею)
    
    void fd_drawCenteredFilledRect(int centerX, int centerY, int width, int height, uint16_t color) {//прямокутник білий або BLACK
        
        int startX = centerX - (width / 2);
        int startY = centerY - (height / 2);
        display.fillRect(startX, startY, width, height, color);//якщо непарна кількість зміщення вправо вниз

    }
   
    void fd_drawCenteredHollowRect(int centerX, int centerY, int width, int height, uint16_t color) {//прямокутник рамка
        // Обчислюємо початкові координати для верхнього лівого кута, щоб прямокутник був по центру
        int startX = centerX - (width / 2);
        int startY = centerY - (height / 2);
        
        // Викликаємо стандартний метод для малювання прямокутника з рамкою
        display.drawRect(startX, startY, width, height, color);
    }  
    
    const char** fd_getButtonNames() {//функція яка повертає масив з іменами кнопок  
      
      static const char* buttonNames[] = {
         
        "A",// не міняти нічого не добавляти нічого
        "B",
        "X",
        "Y",       
        "A1",
        "A2",
        "RB",
        "LB",
        "Se",
        "St",          
        "H",
        "dU",
        "dD",   
        "dL",
        "dR",          
        "RT",
        "LT"
        
      };
    
      return buttonNames;
    
    }        
    
    void fd_bluetoothSymbol(){
      
      const byte bluArr[9] = {
          0b00100,
          0b00110,
          0b10101,
          0b01110,
          0b00100,
          0b01110,
          0b10101,
          0b00110,
          0b00100
      };
      
      display.drawBitmap(1, 2, bluArr, 8, 9, WHITE);
    
    }  
   
    void fd_curvedArrow(int x, int y) {//крива стрілка Вверх
      
      display.setCursor(x, y);
      display.println("_");
      
      display.setCursor(x + 3, y);  // Зсув на 3 пікселі для другого символу
      display.write(24);

    } 
         
    void fd_arrowLowercaseLetters(int xOffset, int yOffset) {//символ малі букви
      
      // Масив, який описує символ "стрілка"
      uint8_t pixelArray[10][9] = {
        {0, 0, 0, 0, 1, 0, 0, 0, 0},
        {0, 0, 0, 1, 0, 1, 0, 0, 0},
        {0, 0, 1, 0, 0, 0, 1, 0, 0},
        {0, 1, 0, 0, 0, 0, 0, 1, 0},
        {1, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 1, 1, 0, 0, 0, 1, 1, 1},
        {0, 0, 1, 0, 0, 0, 1, 0, 0},
        {0, 0, 1, 0, 0, 0, 1, 0, 0},
        {0, 0, 1, 0, 0, 0, 1, 0, 0},
        {0, 0, 1, 1, 1, 1, 1, 0, 0}
      };

      for (int y = 0; y < 10; y++) { // 10 рядків у масиві
        for (int x = 0; x < 9; x++) { // 9 стовпців у масиві
          if (pixelArray[y][x] == 1) {
            display.drawPixel(x + xOffset, y + yOffset, SSD1306_WHITE); // Малюємо білий піксель
          }  
        }
      }
    }
    
    void fd_arrowCapitalLetters(int xOffset, int yOffset) {//символ великі букви
      // Масив, який описує заповнену стрілку
      uint8_t pixelArray[10][9] = {
        {0, 0, 0, 0, 1, 0, 0, 0, 0},
        {0, 0, 0, 1, 1, 1, 0, 0, 0},
        {0, 0, 1, 1, 1, 1, 1, 0, 0},
        {0, 1, 1, 1, 1, 1, 1, 1, 0},
        {1, 1, 1, 1, 1, 1, 1, 1, 1},
        {1, 1, 1, 1, 1, 1, 1, 1, 1},
        {0, 0, 1, 1, 1, 1, 1, 0, 0},
        {0, 0, 1, 1, 1, 1, 1, 0, 0},
        {0, 0, 1, 1, 1, 1, 1, 0, 0},
        {0, 0, 1, 1, 1, 1, 1, 0, 0}
      };

      for (int y = 0; y < 10; y++) { // 10 рядків у масиві
        for (int x = 0; x < 9; x++) { // 9 стовпців у масиві
          if (pixelArray[y][x] == 1) {
            display.drawPixel(x + xOffset, y + yOffset, SSD1306_WHITE); // Малюємо білий піксель
          }  
        }
      }
    }     
    
    void fd_letterDeletion(int xOffset, int yOffset) {//символи видалення
      
      uint8_t pixelArray[7][9] = {
        {0, 0, 0, 1, 1, 1, 1, 1, 1},
        {0, 0, 1, 0, 0, 0, 0, 0, 1},
        {0, 1, 0, 0, 1, 0, 1, 0, 1},
        {1, 0, 0, 0, 0, 1, 0, 0, 1},
        {0, 1, 0, 0, 1, 0, 1, 0, 1},
        {0, 0, 1, 0, 0, 0, 0, 0, 1},
        {0, 0, 0, 1, 1, 1, 1, 1, 1}
      };  
      
      for (int y = 0; y < 7; y++) { // 7 рядків у масиві
        for (int x = 0; x < 9; x++) { // 9 стовпців у масиві
          if (pixelArray[y][x] == 1) {
            display.drawPixel(x + xOffset, y + yOffset, SSD1306_WHITE); // Малюємо білий піксель
          }  
        }
      }
    }        
    
    void fd_arrowReturn(int xOffset, int yOffset) {//символ повернення
      // Масив, який описує символ "стрілка повернення"
      uint8_t pixelArray[9][12] = {
        {0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0},
        {0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0},
        {0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0},
        {1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1},
        {1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1},
        {1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1},
        {0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0},
        {0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0},
        {0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0}
      };

      for (int y = 0; y < 9; y++) { // 9 рядків у масиві
        for (int x = 0; x < 12; x++) { // 12 стовпців у масиві
          if (pixelArray[y][x] == 1) {
            display.drawPixel(x + xOffset, y + yOffset, SSD1306_WHITE); // Малюємо білий піксель
          }  
        }
      }
    }  
        
    void fd_square2x2(int xOffset, int yOffset) {
      display.drawPixel(xOffset,     yOffset,     SSD1306_WHITE);
      display.drawPixel(xOffset + 1, yOffset,     SSD1306_WHITE);
      display.drawPixel(xOffset,     yOffset + 1, SSD1306_WHITE);
      display.drawPixel(xOffset + 1, yOffset + 1, SSD1306_WHITE);
    }

    void fd_horizontal6(int xOffset, int yOffset) {
      for (int x = 0; x < 6; x++) {
        display.drawPixel(x + xOffset, yOffset, SSD1306_WHITE);
      }
    }

    void fd_vertical6(int xOffset, int yOffset) {
      for (int y = 0; y < 6; y++) {
        display.drawPixel(xOffset, y + yOffset, SSD1306_WHITE);
      }
    } 
  
    void fd_miniTesterSmiley(int xOffset, int yOffset) {


    
    
    
    
    }
  
  //

// Af Fs

// Main display
  
  // add0--------------------------------------------------------------
    
    // Info display
      
      void Md_infoDisplay() {//  головна фунція виклик решта функцій дисплея
        
        switch (mdf_addres(check_emb, 0)) {
          
          case address_not_entered: 
            
            Md_p_infoDisplay();//виводимо перший пункт меню який буде викликати решту пунктів
            
          break;
          
          case 1:
            
            Md_mainDisplay();
          
          break;  
          
        }
      
      }
    
      void Md_p_infoDisplay() {
        
        static Timer tmr(1000);
        const byte Lines[] = {255};//щоб стрілка курсора не відображалася ставимо невідому координату
        mdf_cursor(cursor_read_encoder, 1, Lines);
      
        mdf_bluetoothPrint(); 
        mdf_typeNumberPrint();
        //mdf_batteryPrint();

        display.drawRect(0, 14, 127, 19, WHITE);// РАМКА НАВКОЛО НАЗВИ
        
        if (!ap->tape){ //якщо профіль не вибрано виводимо SELECT PROFILE
          
          if (60000 < millis() || tmr.ta()){ 
            
            af_centerTextX(X(64), Y(20), ap->nameProfiles(get_name));
                                                        
          }
          
        }
        
        else{ 
         af_centerTextX(X(64), Y(20), ap->nameProfiles(get_name));//назва діючого профілю
        }
        
        display.setCursor(44,44);//щоб стрілка відображалася там де треба вручну виводимо значок
        display.write(26);
        
        display.drawRect(50, 42, 27, 11, WHITE);//рамка навколо слога
        display.setCursor(52,44);
        display.print("Menu");

      }  
  
    //
  
  //
  
  // add1--------------------------------------------------------------  
    
    // Main display
      
      void Md_mainDisplay() {//  головна фунція виклик решта функцій дисплея
        
        switch (mdf_addres(check_emb, 1)) {
          
          case address_not_entered: 
            
            Md_p_mainDisplay();
            mdf_bluetoothPrint(); 
            mdf_typeNumberPrint(); 
            //mdf_batteryPrint();

          break;//
        
          case 1:
            if(!ap->tape){//якщо профіль не вибрано переходимо в пункт selectProfile
             Md_selectProfile();
            }else{
             ap->tape == t_sp ? Md_ProfileSp() : Md_ProfileMp();//відображаємо меню залежності від типу профіля
            }
          break;
          
          case 2:
            
            Md_generalSettings();
          
          break;
          
          case 3:
            
            // qr-код ссылка на інструкцію
          
          break;
          
          case 4: //back
            
            af_saveToEEPROM(eeprom_seve);
            mdf_cursor(set_pos, 1);
            mdf_addres(back_add, 0);         
            
          break;
          
          case address_entered:
            
            mdf_cursor(set_pos, 1);
            
          break;
        
        }
      
      }
      
      void Md_p_mainDisplay(){
        
          const byte Lines[] = {22, 32, 42, 52};
          mdf_cursor(cursor_read_encoder, 4, Lines);
          if(!ap->tape){//якщо профіль не вибрано то попадаємо в пункт для вибору
            display.setCursor(0, 22);
            display.println("  Select profile");
          }else{          
           display.setCursor(0, 22);
           display.println("  Profile");
          }
          display.setCursor(0, 32);
          display.println("  Settings");
          display.setCursor(0, 42);
          display.println("  Instruction (!)");
          display.setCursor(0, 52);
          display.println("  Exit ");
      
      }
  
    //
  
  //
    
  // add2-----------------------------------------------------------------------------------------------------------
    
    // Profile  
      
      // Profile Sp  // залежить від типу профіля викликається Sp або Mp 
        
        void Md_ProfileSp() {
      
          switch (mdf_addres(check_emb, 2)) {
              
            case address_not_entered: 
              
              Md_p_ProfileSp();
              
              break;
                
            case 1:
              
              Md_profileSettingsSp();
              
              break;
                
            case 2: // QR code 
              
              // Додайте код для обробки QR-коду тут, якщо потрібно
              break;
                
            case 3:
              
              Md_selectProfile();
            
              break;
                
            case 4: //back
              
              mdf_cursor(set_pos, mdf_addres(get_add, 1));
              mdf_addres(back_add, 1);  
            
              break;          
            
            case address_entered:
              
              mdf_cursor(set_pos, 1);
            
              break;
          
          }
      
        }

        void Md_p_ProfileSp() {
            
          const byte LinesSp[] = {31, 39, 49, 57};
        
          mdf_cursor(cursor_read_encoder, 4, LinesSp);
          
          display.setCursor(3, 1);// стрілки по боках активний профіль
          display.write(25);
          display.setCursor(118, 1);
          display.write(25);
          
          display.drawRoundRect(0, 0, 127, 10, 2, WHITE);//  РАМКА АКТИВ ПРОФ НАЗВА ГРИ
          display.drawRect(0, 9, 127, 19, WHITE);
          display.drawRect(10, 29, 51, 19, WHITE);//  РАМКА НАСТРОЙКИ КЮАР КОД
          
          display.setCursor(21, 1);
          display.print("Active profile");
          
          display.setCursor(98, 36);       // РИСКА В лыво РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.println("_" );
          display.setCursor(93, 36);
          display.println("_" );
          display.setCursor(91, 36);//  СТРЫЛКА ВВЕРХ РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.write(24);
          display.setCursor(91, 34);
          display.write(30);
          
          display.drawCircle(113, 42, 11, WHITE);//  КРУГ НАВК Sp
          
          display.setCursor(105, 39);
          
          
          display.print("Sp");
          display.println(ap->number);
          
          af_centerTextX(X(64), Y(15), ap->nameProfiles(get_name));
          
          display.setCursor(0, 32);       // РИСКА В ПРАВО РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.println("          _" );
          display.setCursor(4, 32);
          display.println("          _" );
          
          display.setCursor(66, 32);//  СТРЫЛКА ВВЕРХ РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.write(24);
          display.setCursor(66, 30);
          display.write(30);
          
          
          display.setCursor(0, 31);
          display.println("  Settings   " );
          display.println("  QR code");
          
        
          display.setCursor(0, 49);
          display.println(" Select profile ");
          display.println(" Back" );
          
        }
      
      //   
      
      // Profile Mp
        
        void Md_ProfileMp() {
          
          switch (mdf_addres(check_emb, 2)) {
            
            case address_not_entered: 
              
              Md_p_ProfileMp();
            
            break;
                
            case 1:
              
              Md_profileSettingsMp();
            
            break;
                
            case 2:
              
              Md_selectProfile();
              
            break;
                
            case 3: //back
              
              mdf_cursor(set_pos, mdf_addres(get_add, 1));
              mdf_addres(back_add, 1); 
              
            break;         
            
            case address_entered:
            
              mdf_cursor(set_pos, 1);
            
            break;
          
          }
        
        }

        void Md_p_ProfileMp() {
            
          const byte LinesMp[] = {35, 49, 57};
          
          mdf_cursor(cursor_read_encoder, 3, LinesMp);
          
          display.setCursor(3, 1);// стрілки по боках активний профіль
          display.write(25);
          display.setCursor(118, 1);
          display.write(25);
          
          display.drawRoundRect(0, 0, 127, 10, 2, WHITE);//  РАМКА АКТИВ ПРОФ НАЗВА ГРИ
          display.drawRect(0, 9, 127, 19, WHITE);
          display.drawRect(10, 29, 51, 19, WHITE);//  РАМКА НАСТРОЙКИ КЮАР КОД
          
          display.setCursor(21, 1);
          display.print("Active profile");
          
          display.setCursor(98, 36);       // РИСКА В лыво РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.println("_" );
          display.setCursor(93, 36);
          display.println("_" );
          display.setCursor(91, 36);//  СТРЫЛКА ВВЕРХ РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.write(24);
          display.setCursor(91, 34);
          display.write(30);
          
          display.drawCircle(113, 42, 11, WHITE);//  КРУГ НАВК Sp
          
          display.setCursor(105, 39);
          
          display.print("Mp");
          display.println(ap->number);
          af_centerTextX(X(64), Y(15), ap->nameProfiles(get_name));
          
          display.setCursor(0, 32);       // РИСКА В ПРАВО РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.println("          _" );
          display.setCursor(4, 32);
          display.println("          _" );
          
          display.setCursor(66, 32);//  СТРЫЛКА ВВЕРХ РАЗОМ ПОЛУЧАЭТСЯ КРИВА СТРЫЛКА
          display.write(24);
          display.setCursor(66, 30);
          display.write(30);
          
          display.setCursor(0, 35);
          display.println("  Settings   " );
          
          display.setCursor(0, 49);
          display.println(" Select profile ");
          display.println(" Back" );
          
        }
      
      //  
    
    //
    
    // General settings
      
      void Md_generalSettings(){
        
        switch (mdf_addres(check_emb, 2)) {
          
          case 0: 
            
            Md_p_generalSettings();
          
           break;     
          
          case 1: 
            
            Md_various();//1
          
           break;
          
          case 2: 
            
            Md_controls();
          
           break;          
          
          
          case 3: 
          
            Md_effects();
          
           break;
          
          case 4: 
          
            Md_expertSettings();//потрібно добавити пароль
          
           break;          
          
          
          case address_entered:
            
            if (mdf_addres(get_add, 2) == 5){//back
              mdf_cursor(set_pos, mdf_addres(back_add, 1));
            }
            else {
              mdf_cursor(set_pos, 1); 
            }
            
           break;          
        
        }  
        /*
        if (mdf_addres(get_add, 2) == 4){   //набравши пароль попадам в експерт настройки      
          
          switch (af_passwordEntry(typing_a_password)) {
            
            case password_not_entered:
              
              Md_p_generalSettings();
              if (mdf_cursor(get_pos) != 3){
                af_passwordEntry(password_reset);
                mdf_addres(back_add, 2);
              }       
            
             break;     
          
            case password_entered:
              mdf_cursor(set_pos, 1); 
             break;        
          
            default:
              Md_expertSettings();
             break; 
          
          }        
        
        }
        */
      }
      
      void Md_p_generalSettings(){
    
        const byte l = 5, p = 2, s = 64/2; 
        byte y[l];
        af_menuLinesCenterY(l, p, s, y);    
        
        af_displayPrintLain("Various", X(6), y[0]);
        af_displayPrintLain("Controls", X(6), y[1]);
        af_displayPrintLain("Effects", X(6), y[2]);
        af_displayPrintLain("Expert settings", X(6), y[3]);
        af_displayPrintLain("Back", X(6), y[4]);
        
        mdf_cursor(cursor_read_encoder, sizeof(y), y);   
      
      }   
    
    //
  
  //      
  
  // add3-----------------------------------------------------------------------------------------------------------
  
    // Profile
      
      // Profile settings Sp  (Buttons, Gyroscope settings) // залежить від типу профіля викликається Sp або Mp 
        
        void Md_profileSettingsSp() {
          
          switch (mdf_addres(check_emb, 3)) {
            
            case address_not_entered: 
              
              Md_p_profileSettingsSp();
            
            break;
            
            case 1:
              
              Md_Buttons();
            
            break;// Buttons
            
            case 2:// back  //якщо були зміни то повернення відбудеться через функцію prof mdf_profileStorage 
              
               mdf_cursor(set_pos, mdf_addres(get_add, 2)); //повернення 
               mdf_addres(back_add, 2);
                
              break;
            
            case address_entered: 
              
              if (mdf_addres(get_add, 3) == 1){mdf_cursor(set_pos, 1);}
              
            break;
          
          }
          
        }
          
        void  Md_p_profileSettingsSp() {
          
          const byte l = 2, p = 3, s = 64/2; 
          byte y[l];
              
          af_menuLinesCenterY(l, p, s, y);        
          
          af_displayPrintLain("Buttons", X(6), y[0]);
          af_displayPrintLain("Back", X(6), y[1]);
          
          mdf_cursor(cursor_read_encoder, sizeof(y), y);
        
        }
      
      //     
      
      // Profile settings Mp  (Buttons, Gyroscope settings, changeNameProfile)
        
        void Md_profileSettingsMp(){
          
          switch (mdf_addres(check_emb, 3)) {
            
            case address_not_entered: 

              Md_p_profileSettingsMp();// відображення пунктів настройки
    
              break;
            
            case 1:// Gyroscope 
              
              Md_gyroscopeSettings();
              
            break;
            
            case 2:// Buttons
              
              Md_Buttons();
              
            break;
            
            case 3:// Name
            
              Md_changeNameProfile();
            
            break;

            case 4:// back 
              
               mdf_cursor(set_pos, mdf_addres(get_add, 2));
               mdf_addres(back_add, 2);
                
            break;
            
            case address_entered: 
              
             if (mdf_addres(get_add, 3) != 4 ){ mdf_cursor(set_pos, 1);}
              
            break;
            
          }
          
        }
          
        void  Md_p_profileSettingsMp() {
          
          const byte LinesMp[] = {16, 24, 32, 50};
          
          mdf_cursor(cursor_read_encoder, sizeof(LinesMp), LinesMp);
          
          display.drawRoundRect(9, 14, 59, 28, 0, WHITE);
          display.setCursor(0, 16);
          
          display.println("  Gyroscope" );
          display.println("  Buttons" );
          display.println("  Name" );
          
          display.setCursor(0, 50);
          display.println(" Back" );
          
        }
        
        // changeNameProfile 
          
          //change name profile additional elements
            
            int8_t cnpaX, cnpaY; // Змінні для координат X та Y
            
            char letterBig[6][10] = { // Масив символів для великих букв
              
              {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
              {'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P'},
              {'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', '_'},
              {'\0', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '.','\0'},
              {',', ':', '&', '!', ' ', ' ', '(', ')', '?','\0'}
              
            };
            
            char letterSmall[5][10] = {// Масив символів для малих букв
            
              {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
              {'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'},
              {'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '_'},
              {'\0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', '.','\0'},
              {',', ':', '&', '!', ' ', ' ', '(', ')', '?','\0'}
            
            };

            
            char (*ptrLetter)[10] = letterSmall;// // Вказівник на поточний масив символів (великі або малі букви)
            
            int8_t getActionSelection() {//якщо навелись то функція поверне координату яка відповідає символу
              
              if (cnpaY == 3 && cnpaX == 0) return cl;
              if (cnpaY == 3 && cnpaX == 9) return dl;
              if (cnpaY == 4 && cnpaX == 9) return tb;
              if ((cnpaY == 4) && (cnpaX == 4 || cnpaX == 5)) return sb;
              return 0; // Значення за замовчуванням
            
            }       
          //
          
          void Md_changeNameProfile(){
            
            static int8_t magnitude = 1;// костилі використовується для вибору пробілу і виходу
            static int8_t fl;// Перемикач між великими та малими літерами костилі вказівник не працює належним чином
            
            if (af_checkRightHolded()){cnpaY--;cnpaY = af_clamp(cnpaY, 0, 4);}
            else if (af_checkLeftHolded()){ cnpaY++;cnpaY = af_clamp(cnpaY, 0, 4);}
            
            else{
            
              if(mdf_magnifier(cnpaX, -1, 10, 1, 1)) {//якщо X вийшло за межі допустимих чисел виконуємо пробірку і  збільшення або зменшення Y
                
                if (cnpaX == 10) {cnpaY += 1;}//зменшуємо або збільшуємо y для того щоб перемістити курсор вниз після досягнення максимуму по X
                else if (cnpaX == -1) {cnpaY -= 1;} 
                cnpaY = af_clamp(cnpaY, 0, 4);//додатково перевіряємо y щоб не Вийти за межі
              
              }
              
              cnpaX = af_clamp(cnpaX, 0, 9);//скидання на мінімальне і наоборот якщо перевищили значення

            }
            
            if (af_checkClick()) {//Клік виконує зміну бук видалення пробіл додавання букви вихід
              
              if (getActionSelection() == cl) {//міняємо величину бук
              
                ptrLetter = (ptrLetter == letterSmall) ? letterBig : letterSmall;
              
              }   
              
              else if (getActionSelection() == dl) {//видаляємо букву
                
                ap->nameProfiles(delete_letter);
                if (!ap->lettersTakeNumber()) {ptrLetter = letterBig;}//якщо видаляємо останню букву робимо всі букви великими одноразово          
              
              }          
              
              else if (getActionSelection() == tb) {//вихід плюс скидання і перевірка набраного тексту
                
                ap->nameProfiles(g_s_n_i_n_l_a_r_s);  //(give standard name if no letters and remove spaces ) TEST якщо Видалити всі букви  то заміниться ім'я на стандартне
                cnpaX = cnpaY = 0;
                ptrLetter = letterSmall;
                mdf_cursor(set_pos, mdf_addres(get_add, 3));
                mdf_addres(back_add, 3);
              
              }
              
              else{ //доплюсовуємо до речення вибрано букву
                
                ap->nameProfiles(add_letter, ptrLetter[cnpaY][cnpaX]);
                if (ap->lettersTakeNumber() == 1) {ptrLetter = letterSmall;}//речення починається з великої букви і автоматично скидається на Малі            
              
              }
            
            }   
            
            Md_p_changeNameProfile();// віалізуємо програму
          
          }
          
          byte Md_p_changeNameProfile(){
            
            static Timer tmr(500);
            display.setCursor(2, 1);// виводи ім'я профіля
            display.print(ap->nameProfiles(get_name));
            
            if(tmr.ta()){// вертикальна риска біля букви
            
              display.drawRect(2+6*ap->lettersTakeNumber(), 0, 1, 9, WHITE);
            
            }
            
            if(!getActionSelection()){//відображаємо рамку навколо букви якщо навелись на стандартний символ
                  
              display.drawRect(4+cnpaX*12, 12+cnpaY*10, 9, 11, WHITE);// рамка курса 10 вверх вниз, вліво вправо 12 
            
            }
            
            for (int i = 0; i <= 4; i++) {// виводим масив букв на дисплей
              
              for (int j = 0; j < 10; j++) {
                
                display.setCursor(6+j*12, 14+i*10);
                display.print(ptrLetter[i][j]);
                
              }
            
            }        
            
            if(getActionSelection() != cl){//якщо координата вказує на спеціальний символ починаємо ним мигати
            
            ptrLetter == letterSmall ? fd_arrowLowercaseLetters(4, 42) : fd_arrowCapitalLetters(4, 42);
            
            }
            
            else if(getActionSelection() == cl && !tmr.ta()){
            
              ptrLetter == letterSmall ? fd_arrowLowercaseLetters(4, 42) : fd_arrowCapitalLetters(4, 42);

            }
            
            if(getActionSelection() != dl){
            
            fd_letterDeletion(110, 44);
            
            }
            
            else if(getActionSelection() == dl && !tmr.ta()){
            
            fd_letterDeletion(110, 44);

            }        
            
            if(getActionSelection() != sb){
            
            display.fillRect(50, 55, 25, 6, WHITE);
            
            }
            
            else if(getActionSelection() == sb && !tmr.ta()){
            
            display.fillRect(50, 55, 25, 6, WHITE);

            }        
            
            if(getActionSelection() != tb){
            
            fd_arrowReturn(110, 54);
            
            }
            
            else if(getActionSelection() == tb && !tmr.ta()){
            
             fd_arrowReturn(110, 54);

            }           
            
          return 0; 
          
          }
        
        // cNP      
      
      //    
      
      // Select profile
        
        void Md_selectProfile() {
        
          switch (mdf_addres(check_emb, 3)) {
            
            case address_not_entered: 
              
              Md_p_selectProfile();
            
            break;
            
            case 1: 
              
              Md_standardProfiles();
            
            break;
            
            case 2: 
            
              Md_myProfiles();
            
            break;
            
            case 3: // back 
              
              if(!ap->tape){//якщо профіль все одно не вибрана то повертаємося в головний пункт
               mdf_cursor(set_pos, mdf_addres(back_add, 1));
              }else{//якщо хотіли змінити профіль і передумали повертаємося в попередній пункт і ставимо курсор в залежності від типу профіля
               mdf_addres(back_add, 2); 
               ap->tape == t_sp ? mdf_cursor(set_pos, 3) : mdf_cursor(set_pos, 2);//вказуємо вручну попередній пункт може мінятися Залежно від типу
              }              
              
            break;          
            
            case address_entered: 
      
              mdf_cursor(set_pos, 1);
            
            break;          
          
          }
        
        }
        
        void Md_p_selectProfile() {
          
          const byte Lines[] = {16, 24, 32};
          mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);
        
          display.setCursor(0, 16);
          display.println(" Standard profiles" );
          display.println(" My profiles");
          display.println(" Back" );
        
        }
      
      // Sp
      
    //     
    
    // General settings
      
      // Various (кінець гілки)
      
        void Md_various(){
        
          switch (mdf_addres(check_emb, 3)) {
             
            case 1: 
              
              //Volume
             
             break;
           
            case 2: 
              
              Md_saveSelectedProfile(ssp_change_setting);
             
             break;            
           
            case 3: 
              
              Md_autoPowerOff(apo_change_time);
             
             break;
            
            case 4: 
              
              Md_displayTimeout(dt_change_time);
             
             break;
          
            case address_entered:
              
              if (mdf_addres(get_add, 3) == 5){//back
               mdf_cursor(set_pos, mdf_addres(back_add, 2));
              }
              
              else {
               mdf_addres(mode_click_back);
              }
                
             break;
          
          }  
          
          Md_p_Various();
          
        }
        
        void Md_p_Various(){
          
          const byte l = 5, p = 2, s = 64/2; 
          byte y[l];
              
          af_menuLinesCenterY(l, p, s, y);          
          
          Md_p_volume(y[0]);
          Md_p_saveSelectedProfile(y[1], L(2));//L(?) також передаємо номер строки щоб відбулося прокручування тексту
          Md_p_autoPowerOff(y[2]);
          Md_p_displayTimeout(y[3]);//потрібно зробити окремий пункт і додати настройку яскравості
         
          af_displayPrintLain("Back", X(6), y[4]);  
            
          mdf_cursor(cursor_read_encoder, sizeof(y), y);          
          
        }       
         
        // Various(виклик)
          
          // Volume?
          
            void Md_p_volume(byte y){        //test
             af_displayPrintLain("Volume", X(6), y);
            }          
          
          //
          
          // Save selected profile

            bool Md_saveSelectedProfile(byte acceptedCommand){
              
              static bool ssps;//ssps = save Selected Profile switch
              
              if (acceptedCommand == ssp_change_setting){
                    
                mdf_magnifier(ssps, false, true, 1, 1);
              
              }      
                
              else if (acceptedCommand == ssp_get_setting){
                  
                return ssps;
                  
              }              
              
              else if (acceptedCommand == ssp_reset_settings) { 
                
               ssps = 0;
              
              }            
              
              else if (acceptedCommand == ssp_get_eeprom) { 
                
                af_saveToEEPROM(get_eeprom, &ssps, sizeof(ssps));
              
              }
              
              else if (acceptedCommand == ssp_set_eeprom) { //не забути добавити
                
                af_saveToEEPROM(set_eeprom, &ssps, sizeof(ssps));
                
              }            
            
            
             return 0;
            
            }       
          
            void Md_p_saveSelectedProfile(byte y, byte l){
            
              af_displayPrintLain("Save selected profile", X(6), y, l, N(13));  
              
              if (Md_saveSelectedProfile(ssp_get_setting)){
                      
                af_displayPrintLain("on", X(128-12), y);
                              
              } else{

                af_displayPrintLain("off", X(128-18), y);
            
              }

            }
          
          //
          
          // Auto power off
            
            byte Md_autoPowerOff(byte acceptedCommand){
              
              static byte tmrRestartMinutes = 10;
              static uint32_t tmrRestartMillis = 3*60000;// = 3 хвилини
              
              static Timer tmr(tmrRestartMillis, false);//вказуємо тут час і правда повернеться не одразу а по завершенню часу tmr. gp()
              
              if (acceptedCommand) {
                
                if (acceptedCommand == apo_restart_time) { 
                  
                tmr.st(tmrRestartMillis, false);
                  
                }
                
                else if (acceptedCommand == apo_change_time) { 
                  
                  if (mdf_magnifier(tmrRestartMinutes, 1, 10, 1, 2)) {
                    tmrRestartMillis = tmrRestartMinutes*60000;
                  }   
                
                }
                
                else if (acceptedCommand == apo_get_time) { 
                  
                  return tmrRestartMinutes;
                  
                }
                
                else if (acceptedCommand == get_eeprom) { //
                
                  af_saveToEEPROM(get_eeprom, &tmrRestartMinutes, sizeof(tmrRestartMinutes));
                  tmr.st(tmrRestartMillis, false);//якщо беремо дані з енергонезалежної пам'яті потрібно перезапуск
                
                }
                
                else if (acceptedCommand == set_eeprom) { 
                  
                  af_saveToEEPROM(set_eeprom, &tmrRestartMinutes, sizeof(tmrRestartMinutes));
                  
                }            
                
                else if (acceptedCommand == tf_reset_settings) { 
                
                  tmrRestartMillis = 3*60000;
                  tmrRestartMinutes = 3;
                  
                }   
              
              }
              
              else if (tmr.ts()){
              Serial.println("p off"); 
              af_powerOffExecution();
              
              }
            
              return 0;
            
            }
            
            void Md_p_autoPowerOff(byte y){
              
              af_displayPrintLain("Auto power off    m.", X(6), y);    
              af_centerTextX(X(107), y, Md_autoPowerOff(apo_get_time));
              
            }      
          
          //
          
          // Display timeout

            byte Md_displayTimeout(byte acceptedCommand){
              
              static byte status = tf_function_not_completed;
              const unsigned int shutdownTime[] = {0, 5000, 15000, 30000, 60000, 120000, 300000, 600000};
              static int8_t oti = 7; //oti = off time indicator вказівник на час відключення
              static Timer tmr(shutdownTime[oti], false);
              static byte bss;  //bss = Bluetooth status saving
              
              if (acceptedCommand) {
                
                if (oti && acceptedCommand == timeout_restart) { //в основному якщо модуль encorder працює то виключення дисплею перезапускається
                  
                  tmr.st(shutdownTime[oti],false);
                
                }
                
                else if (acceptedCommand == dt_change_time) {
                  
                  mdf_magnifier(oti, 0, 7, 1, 1); 
                  if (!oti) {tmr.st(false, false);} //захист від миттєвого згасання якщо перейдемо з off на вказаний час (5s.-10m.)

                }
                
                else if (acceptedCommand == dt_get_tim_minutes) { 
                  
                  if (4 <= oti) {
                    return shutdownTime[oti] / 60000;
                  }else{
                    return 0; 
                  }
                
                }
              
                else if (acceptedCommand == dt_get_tim_seconds) { 
                  
                  if (oti <= 3 && oti) {
                    return shutdownTime[oti] / 1000;
                  }else{
                    return 0; 
                  }
                }          
                
                else if (acceptedCommand == tf_reset_settings) { 
                
                oti = 1;
                
                }
                
                else if (acceptedCommand == get_eeprom) { 
                  
                  af_saveToEEPROM(get_eeprom, &oti, sizeof(oti));
                  Md_displayTimeout(timeout_restart);//потрібно перезапустити з новим часом взятим з енергонезалежною пам'яті
                
                }        
                
                else if (acceptedCommand == set_eeprom) { 
                  
                  af_saveToEEPROM(set_eeprom, &oti, sizeof(oti));
                  
                }            
                
                /*
                else if (acceptedCommand == timeout_reset) {//використовується коли скидаємо всі настройки    
                  
                  tmr.st(shutdownTime[oti]);
                
                }
              */
              }
              
              else if (oti && tmr.ts()){
              
                return true;
              
              }
              
              return 0;        
            
            }
            
            void Md_p_displayTimeout(byte y){
              
              if (Md_displayTimeout(dt_get_tim_minutes)){

              af_centerTextX(X(107), y, Md_displayTimeout(dt_get_tim_minutes));
              af_displayPrintLain("Display timeout   m.", X(6), y);
              
              }
              
              else if (Md_displayTimeout(dt_get_tim_seconds)){
                
              af_centerTextX(X(107), y, Md_displayTimeout(dt_get_tim_seconds));
              af_displayPrintLain("Display timeout   s.", X(6), y);
              }            
              
              else {
              af_displayPrintLain("Display timeout  off", X(6), y);
              }
            
            }    
          
          //
        
        //      
      
      //  
      
      // Controls
      
        void Md_controls(){
       
          switch (mdf_addres(check_emb, 3)) {
            
            case 0: 
              
             Md_p_controls();
            
            break;     
            
            case 1: 
              
             Md_calibration();
            
            break;          
            
            case address_entered:
              
              if (mdf_addres(get_add, 3) == 2){//back
                mdf_cursor(set_pos, mdf_addres(back_add, 2));
              }
              else{mdf_cursor(set_pos, 1);}
              
            break;          
          
          }         
        
        
        }
        
        void Md_p_controls(){
        
          const byte l = 2, p = 4, s = 64/2; 
          byte y[l];
              
          af_menuLinesCenterY(l, p, s, y);          
          
          af_displayPrintLain("Calibration", X(6), y[0]);
          af_displayPrintLain("Back", X(6), y[1]);      
          
          mdf_cursor(cursor_read_encoder, sizeof(y), y);
       
        }
      
      //
      
      // Effects
      
        void Md_effects(){
          
          switch (mdf_addres(check_emb, 3)) {
          
            case 1: 
              
              af_triggerLightSettings();//тут перехід решта кінцеві
             
             break;
            
            case 2: 
              
              af_shotgunBolt(bolt_change);
             
             break;
            
            case 3: 
              
              af_vibration(vt_change);
             
             break;
            
            case address_entered:
              
              if (mdf_addres(get_add, 3) == 2 || mdf_addres(get_add, 3) == 3){
               mdf_addres(mode_click_back);
              }
              else if (mdf_addres(get_add, 3) == 4){//back
               mdf_cursor(set_pos, mdf_addres(back_add, 2));
              }
                
             break;
          
          }  
          
          if (mdf_addres(get_add, 3) != 1){//
           Md_p_Effects();
          }
        
        }
        
        void Md_p_Effects(){
        
          const byte Lines[] = {16, 24, 32, 40};
          mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines); 
            
          af_displayPrintLain(" Trigger light " + af_animatePointer(), 0, 16);
          Md_p_shotgunBoltSettings();
          Md_p_vibration();
          af_displayPrintLain(" Back ", 0, 40);
          
        }       
        
      //    
      
      // Expert settings
      
        void Md_expertSettings(){
         
          switch (mdf_addres(check_emb, 3)) {
            
            case 0: 
              
               Md_p_expertSettings();
             
             break;          
            
            case 1: 
              
              Md_gyroCalibration();
             
             break;
            
            case 2: 
              
              Md_disableButton(); 
             
             break;
            
            case 3: 
              
              Md_resetAll(); 
             
             break;            
            
            case address_entered:
             
              if (mdf_addres(get_add, 3) == 4) { //back
                af_passwordEntry(password_reset);
                mdf_cursor(set_pos, mdf_addres(back_add, 2));    
              }else{
                mdf_cursor(set_pos, 1);
              }
               
             break;
          
          }  
          
         
        }
        
        void Md_p_expertSettings(){
        
          af_displayPrintLain("Gyro calibration", X(6), Y(16));
          af_displayPrintLain("Stuck buttons", X(6), Y(25));
          af_displayPrintLain("Reset all", X(6), Y(34));
          af_displayPrintLain("Back", X(6), Y(43));
          
          const byte Lines[] = {16, 25, 34, 43};
          mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);         
        
        }       
        
      //      
    
    //  
                   
  //
  
  // add4-----------------------------------------------------------------------------------------------------------  
    
    // Profile
      
      // Profile settings Sp або Mp
      
        // Gyroscope settings Sp  Mp
          
          void Md_gyroscopeSettings(){
            
            Md_p_gyroscopeSettings();//відображаємо пункти меню постійно
            
            switch (mdf_addres(check_emb, 4)) {
              
              case address_not_entered:
              
              break;
              
              case 1:
                
                mdf_magnifier(ap->dzxa, 0, 9999, 1, 100);  //міняємо чутливість в профілю            
                
              break;
              
              case 2:
                
                mdf_magnifier(ap->sxa, 50, 150, 1, 5);//якщо функція поверне -1 значить передане число Не збільшувалось і не зменшувалось і тому не потрібно виконувати перезапис
                  
              break;
              
              case 3:
                
                mdf_magnifier(ap->dzya, 0, 9999, 1, 100);              
                
              break;
              
              case 4:
                
                mdf_magnifier(ap->sya, 50, 150, 1 , 5);           
                
              break;
              
              case 5: 
                
                if (mps(reset_gyro) == tf_function_completed) {mdf_addres(back_add, 4);}//скидаємо настройки гіроскопа після вибору так
              
              break;            
              
              case 6: //back
                
                mdf_cursor(set_pos, mdf_addres(get_add, 3));
                mdf_addres(back_add, 3);   
              
              break;
              
              case address_entered: 
              
                if (mdf_addres(get_add, 4) <= 4) {
                  
                  mdf_addres(mode_click_back);
                
                }
                
                else if (mdf_addres(get_add, 4) == 5 ) {//якщо вибрали даний пункт значить робимо скидання до стандартних настройок
                
                 mdf_addres(mode_function_returns);//
                 mdf_confirm(output_by_coordinates, X(39), Y(46));//
                  
                }
              
              break;
            
            }
          
          }
        
          void Md_p_gyroscopeSettings(){
            
            static Timer tmr(500);
            const byte Lines[] = {2, 11, 26, 35, 46, 55};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);
          
            display.setCursor(8, 2);
            display.println("Dead zone ");
            display.setCursor(8, 11);
            display.println("Sensitivity");
            display.setCursor(8, 26);
            display.println("Dead zone ");
            display.setCursor(8, 35);
            display.println("Sensitivity");
            
            display.setCursor(8, 46);
            display.println("Reset");
                      
            display.setCursor(8, 55);
            display.println("Back");
            
            display.setCursor(84, 6);
            display.println("H");
          
            display.setCursor(84, 6+24);
            display.println("V");
            
            
            af_centerTextX(X(113), Y(2), ap->dzxa);//виводимо настройки гіроскопа центруємо значення в рамці
            
            int temp = map(ap->sxa, 50, 150, 100, 0);//відображаємо в процентному співвідношенні а не в одиницях
            af_centerTextX(X(113), Y(11), temp);
            
            af_centerTextX(X(113), Y(26), ap->dzya);
            
            temp = map(ap->sya, 50, 150, 100, 0);
            af_centerTextX(X(113), Y(35), temp);
            
            display.drawRoundRect(6, 0, 69, 20, 3, WHITE); // РАМКА НАВКОЛО Dead zone Sensitivity H
            display.drawRoundRect(6, 0+24, 69, 20, 3, WHITE);// РАМКА НАВКОЛО Dead zone Sensitivity V
            
            display.drawRect(128-30, 0, 29, 20, WHITE);//dzh значення показники
            
            display.drawRect(128-30, 0+24, 29, 20, WHITE);//dzv значення показники
            
            
            if(2 <= mdf_cursor(get_pos) || tmr.ta()){// РАМКА  H
            
            display.drawRoundRect(79, 2, 15, 15, 0, WHITE);
            
            }
            
            if((3 != mdf_cursor(get_pos) && 4 != mdf_cursor(get_pos)) || tmr.ta()){// РАМКА V
            
            display.drawRoundRect(79, 2+24, 15, 15, 0, WHITE);
            
            }          
            
          }
        
        // Gs
        
        // Buttons Sp Mp
          
          void Md_Buttons(){
          
            switch (mdf_addres(check_emb, 4)) {
                    
              case address_not_entered: // address_not_entered == 0
                
              Md_p_Buttons();
              
              break;
              
              case 1:
                
                Md_moveButtons();
              
              break;
              
              case 2: 
                
                Md_duplicateButtons();
              
              break;
              
              case 3:// back         
              
                mdf_cursor(set_pos, mdf_addres(get_add, 3));
                mdf_addres(back_add, 3);
              
              break;
            
              case address_entered: // address_not_entered == 21
                
                mdf_cursor(set_pos, 1);
              
              break;        
            
            }
          
          }  
          
          void Md_p_Buttons(){        
            
            static Timer tmr(500);
            const byte LinesSp[] = {17, 28, 40};
            
            mdf_cursor(cursor_read_encoder, sizeof(LinesSp), LinesSp);
            
            af_displayPrintLain("Move button", X(6), Y(17)); 
            af_displayPrintLain("Duplicate buttons", X(6), Y(28)); 
            af_displayPrintLain("Back", X(6), Y(40)); 
            
            
            display.drawRect(77, 15, 45, 11, WHITE); //рамка навколо слів
            if (ap->malb(check_location) == non_standard_location) {//якщо кнопки мінялися місцями виводимо повідомлення про це
              if (tmr.ta()) {af_displayPrintLain("Changed", X(79), Y(17));}
            }
            else{
              af_displayPrintLain("Default", X(79), Y(17));
            }

          
          
          }
          
        // B 
       
      //
      
      // Select profile
        
        // Standard profiles
          
          void Md_standardProfiles(){
          
            switch (mdf_addres(check_emb, 4)) {
              
              case address_not_entered: 
                
                Md_p_standardProfiles();// відображення списку профілів вибір
              
              break;
              
              case 8: //back повертаємося в пункт де можна вибрати стандартний або власний профіль
              
              mdf_cursor(set_pos, mdf_addres(get_add, 3));
              mdf_addres(back_add, 3); 
                
              break;          
            
              case address_entered: 
              
                if (mdf_addres(get_add, 4) != 8){
                
                  if(!ap->tape){// після того як перший раз вибрали профіль повертаємося в основне меню
                   
                   mps(activate_sp, mdf_addres(get_add, 4)-1);
                   mdf_cursor(set_pos, mdf_addres(back_add, 0));//закриваємо меню
                  
                  }
                  
                  else{// 
                   
                   mps(activate_sp, mdf_addres(get_add, 4)-1);
                   mdf_cursor(set_pos, 3);//в даному випадку вказуємо позицію три тому що є три пункти
                   mdf_addres(back_add, 2);//повертаємося через один пункт 
                  
                  }  
                  
                  bgc_buttonGamepadResetlAll();//коли вибираємо або міняємо профіль розташування кнопок потрібно перевстановити керуючись настройками профілю
                
                }
              
              break;
      
            }
          
          }
          
          void Md_p_standardProfiles(){
            
            static Timer tmr(500);
            const byte Lines[] = {0, 8, 16, 24, 32, 40, 48, 56};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);
          
            for (int i = 0; i < 7; i++) {// виводим імена профілів діючий профіль мигає
            
              display.setCursor(6, i*8);
              display.print(profilSp[i].nameProfiles(get_name));
              
            }
            
            if (ap->tape == t_sp && tmr.ta()){display.fillRect(6, (ap->number - 1)*8, 128-6, 8, BLACK);}//активний профіль буде мигати
            
            display.setCursor(0, 56);
            display.println(" Back" );
          
          }
        
        // Sp  
        
        // My profiles  
        
          void Md_myProfiles(){
          
            switch (mdf_addres(check_emb, 4)){// третій параметр забороняє вибирати діючий профіль
              
              case address_not_entered: 
                
                Md_p_MyProfiles();
                
              break;
              
              case 8: //back повертаємося в пункт де можна вибрати стандартний або власний профіль
                
                mdf_cursor(set_pos, mdf_addres(get_add, 3));
                mdf_addres(back_add, 3);
              
              break;          
              
              case address_entered: 
              
                if (mdf_addres(get_add, 4) != 8){
                  
                  if(!ap->tape){// якщо вибираємо профіль перший раз
                   
                   mps(activate_mp, mdf_addres(get_add, 4)-1);
                   mdf_cursor(set_pos, mdf_addres(back_add, 0));
                  
                  }
                  
                  else{//  
                  
                   mps(activate_mp, mdf_addres(get_add, 4)-1);
                   mdf_cursor(set_pos, 2);
                   mdf_addres(back_add, 2);// не міняти двоєчку будуть глюки        
                  
                  }                  
                  
                  bgc_buttonGamepadResetlAll();//коли вибираємо або міняємо профіль розташування кнопок потрібно перевстановити керуючись настройками профілю
                
                }
                
              break;
              
            }
          
          }
          
          void Md_p_MyProfiles() {
            
            static Timer tmr(500);
            const byte Lines[] = {0, 8, 16, 24, 32, 40, 48, 56};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);
            
            for (int i = 0; i < 7; i++) {
            
             display.setCursor(6, i*8);
             display.print(profilMp[i].nameProfiles(get_name));
            
            }
            
            if (ap->tape == t_mp && tmr.ta()){display.fillRect(6, (ap->number - 1)*8, 128-6, 8, BLACK);}
            
            display.setCursor(6, 56);
            display.println("Back" );
          
          }
        
        // Mp
      
      //

    // 
  
    // General settings
      
      // Controls     
        
        // Calibration
          
          void Md_calibration(){
        
            switch (mdf_addres(check_emb, 4)) {
              
              case 0: 
                
                Md_p_calibration();
               
               break;     
              
              case 1: 
                
                Md_joysticksCalibration();
               
               break;
              
              case 2: 
                
                //Md_triggersCalibration();
               
               break;          
              
              case 3: 
                
                //Md_gyroscopeCalibration();
               
               break;                
              
              case 4://back
               
                mdf_cursor(set_pos, mdf_addres(back_add, 3));
               
               break;          
            
            }         
          
          }
          
          void Md_p_calibration(){
          
            const byte l = 4, p = 4, s = 64/2; 
            byte y[l];
              
            af_menuLinesCenterY(l, p, s, y);//af_menuLinesCenterY(кількість рядків , відстань між рядками, центр розміщення рядків,  масив який потрібно заповнити координатами),
              
            af_displayPrintLain("Joysticks", X(6), y[0]);
            af_displayPrintLain("Triggers", X(6), y[1]);
            af_displayPrintLain("Gyroscope", X(6), y[2]);      
            af_displayPrintLain("Back", X(6), y[3]);
            
            mdf_cursor(cursor_read_encoder, sizeof(y), y);
        
          }        
        
        //
      
      //
      
      // Effects    
         
        // Trigger light

          void af_triggerLightSettings(){
            
            int seveDataTemp;
            
            switch (mdf_addres(check_emb, 4)) {
            
              case 1: 
                
                seveDataTemp = af_triggerLight(get_light1); 
                if (mdf_magnifier(seveDataTemp, 0, 100, 1, 10)) {af_triggerLight(set_light1, seveDataTemp);}
               
               break;
              
              case 2: 
                
                seveDataTemp = af_triggerLight(get_light2); 
                if (mdf_magnifier(seveDataTemp, 0, 100, 1, 10)) {af_triggerLight(set_light2, seveDataTemp);}              
              
               break;
              
              case 3: 
                
                seveDataTemp = af_triggerLight(get_color1); 
                if (mdf_magnifier(seveDataTemp, 0, 1000, 1, 50)) { 
                  af_triggerLight(set_color1, seveDataTemp);
                  if (!af_triggerLight(get_light1)) {af_triggerLight(set_light1, 100);}
                }
                    
               break;            
              
              case 4: 
                
                seveDataTemp = af_triggerLight(get_color2); 
                if (mdf_magnifier(seveDataTemp, 0, 1000, 1, 50)) {
                  af_triggerLight(set_color2, seveDataTemp);
                  if (!af_triggerLight(get_light2)) {af_triggerLight(set_light2, 100);}
                }                   
                
               break;              
              
              case 5: 
                
                if (af_triggerLight(clssc) == color_light_default) {  //clssc = color light standard settings check
                
                  if (mdf_confirm(print_not_need) == tf_function_completed) {
                   mdf_addres(back_add, 4);
                  }
                
                }       
                
                else if (mdf_confirm(offer_a_choice) == tf_data_ready) {
                
                  if (mdf_confirm(tf_get_data) == choice_yes) {
                    af_triggerLight(color_light_reset);
                  }
                  mdf_addres(back_add, 4);
                
                }                    
                
               break;               
              
              case address_entered:
                
                if (mdf_addres(get_add, 4) <= 4){
                 
                 if (mdf_addres(get_add, 4) == 1 || mdf_addres(get_add, 4) == 3){
                  af_triggerLight(color_one);
                 }
                 else if (mdf_addres(get_add, 4) == 2 || mdf_addres(get_add, 4) == 4){
                  af_triggerLight(color_two);
                 }
                 
                 af_triggerLight(color_light_setting);//забороняємо переключати колір перед тим включили колір який потрібно настроїти
                 mdf_addres(mode_click_back);
                
                }
                
                else if (mdf_addres(get_add, 4) == 5){
                 mdf_addres(mode_function_returns);
                 mdf_confirm(output_by_coordinates, X(47), Y(47));
                }
                
                else {
                 mdf_cursor(set_pos, mdf_addres(back_add, 3));
                }
                  
               break;              
              
              case address_deleted: //якщо повертаємося назад включаємо стандартний режим роботи
                af_triggerLight(color_switching);
                af_triggerLight(color_one); //включаємо на всяк випадок перший колір невідомо в якому стані  гачок
               break;   
            
            }
          
            Md_p_triggerLightSettings();
          
          }
          
          void Md_p_triggerLightSettings(){

            byte tc = 0;
            int temp;
            
            af_displayPrintLain(" Light 1", 0, 0+tc);
            af_displayPrintLain(" Light 2", 0, 8+tc);
            
            af_displayPrintLain(" Color 1", 0, 24+tc);
            af_displayPrintLain(" Color 2", 0, 32+tc);
            
            af_displayPrintLain(" Reset ", 0, 48+tc);
            af_displayPrintLain(" Back ", 0, 56+tc);
            
            if (af_triggerLight(get_light1)){//перемо яскравість і відображаємо її   якщо нуль показуємо off
             temp = af_triggerLight(get_light1); 
             af_centerTextX(X(65), Y(0), temp);  
             af_displayPrintLain("             %", 0, 0);
            }else{
              af_displayPrintLain("off", 55, 0+tc);      
            }
            
            if (af_triggerLight(get_light2)){
             temp = af_triggerLight(get_light2); 
             af_centerTextX(X(65), Y(8), temp); 
             af_displayPrintLain("             %", 0, 8);
            }else{
              af_displayPrintLain("off", 55, 8+tc);  
            }          
            
            temp = af_triggerLight(get_color1); //беремо колір і відображаємо його відтінок
            af_centerTextX(X(65), Y(24), temp);
            
            temp = af_triggerLight(get_color2); 
            af_centerTextX(X(65), Y(32), temp);
            
            const byte Lines[] = {0, 8, 24, 32, 48, 56};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);              
          
          }   
        
        //
    
        void Md_p_shotgunBoltSettings(){

          if (af_shotgunBolt(bolt_get_permission)){
            
            af_displayPrintLain(" Shotgun bolt      on", 0, 24);
            
          }else{
            
            af_displayPrintLain(" Shotgun bolt     off", 0, 24);
          
          }
        
        
        }        
        
        void Md_p_vibration(){

          if (af_vibration(vt_get_permission)){
            
            af_displayPrintLain(" Vibration         on", 0, 32);
            
          }else{
            
            af_displayPrintLain(" Vibration        off", 0, 32);
          
          }
        
        }        
        
      //
      
      // Expert settings    
        
        // Gyroscope calibration
          
          void Md_gyroCalibration(){
            
            Md_p_gyroCalibration();
            
            switch (mdf_addres(check_emb, 4)) {
              
              case 0: 
                
                Md_gyroDataPrint();
              
               break;          
                          
              case 1: 
                
                Md_gyroCalibrationExecution();
              
               break;          
              
              case 2: 
                
                mdf_cursor(set_pos, mdf_addres(back_add, 3));             
              
               break; 
              
              case address_entered:
                if (mdf_addres(get_add, 4) == 1) {
                 mdf_addres(mode_click_back);          
                }
               break;           
              
              case address_deleted:
                Md_gyroCalibrationExecution(tf_reset);
               break;              
            
            }
            
          }          
          
          void Md_p_gyroCalibration(){
            
            const byte Lines[] = {36, 46};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);            
            
            display.drawRect(0, 0, 128, 33, WHITE);//великий прямокутник вверху
            
            af_displayPrintLain("Calibrate", X(6), Y(36));
            af_displayPrintLain("Back", X(6), Y(46));
             
          }
          
          void Md_gyroDataPrint(){
            
            int temp;   //test
           
            
            if (1 < temp) {
             display.setCursor(20, 13);
             display.write(27); // Код символу "←"
            }else if (temp < -1){
              display.setCursor(56, 13);
              display.write(26); // Код символу "→"
            }
            
            if (1 < abs(temp)) {
              af_centerTextX(X(38), Y(13), abs(temp)-1);
            }else{
              af_centerTextX(X(38), Y(13), 0); 
            }
            
            
            
            if (1 < temp) {
             display.setCursor(91, 3);
             display.write(24); // Код символу "↑"
            }else if (temp < -1){
             display.setCursor(91, 22);
             display.write(25); // Код символу "↓"
            } 
            
            if (1 < abs(temp)) {
              af_centerTextX(X(93), Y(13), abs(temp)-1);
            }else{
              af_centerTextX(X(95), Y(13), 0); 
            }                 
          }          
          
          // Gyro calibration execution
          
            void Md_gyroCalibrationExecution(byte acceptedCommand) {  
              
              static int countdown = 10;
              static Timer tmr(500); 
              
              if (acceptedCommand) {
                  
                if (acceptedCommand == tf_reset) {
                  countdown = 10;
                  tmr.st(500);//перед виходом перезапускаємо таймер правда при першому виклику
                  mdf_addres(back_add, 4);         
                }          
                
                else if (acceptedCommand == set_eeprom) { 
                  
                  int avgX, avgY, avgZ;
                  avgX = mpu.getXGyroOffset();
                  avgY = mpu.getYGyroOffset();
                  avgZ = mpu.getZGyroOffset();           
                  
                  af_saveToEEPROM(set_eeprom, &avgX, sizeof(avgX));
                  af_saveToEEPROM(set_eeprom, &avgY, sizeof(avgY));
                  af_saveToEEPROM(set_eeprom, &avgZ, sizeof(avgZ));          
                
                }
                
                else if (acceptedCommand == get_eeprom) { 
                  
                  int avgX, avgY, avgZ;
                  af_saveToEEPROM(get_eeprom, &avgX, sizeof(avgX));
                  af_saveToEEPROM(get_eeprom, &avgY, sizeof(avgY));
                  af_saveToEEPROM(get_eeprom, &avgZ, sizeof(avgZ));
                  
                  // Встановлення корекції для осі X
                  mpu.setXGyroOffset(avgY);  // Встановлення корекції для осі Y
                  mpu.setYGyroOffset(avgZ);  // Встановлення корекції для осі Z            
                  mpu.setZGyroOffset(avgZ);
                
                }            
              
              }
              
              else if (tmr.gp()) {
                countdown--;    
                if (countdown == -1) {
                  mpu.CalibrateGyro(5);//TEST
                }               
                else if (countdown <= -4) {
                  countdown = 10;
                  tmr.st(500);
                  mdf_addres(back_add, 4);
                }               
              
              }           
            
              Md_p_gyroCalibrationExecution(countdown);
            
            }
            
            void Md_p_gyroCalibrationExecution(int acceptedData) {

              if (0 < acceptedData) {
                af_centerTextX(X(64), Y((33/2)-8), "Don't move"); 
                af_centerTextX(X(64), Y(33/2), "Beginning in-"+String(acceptedData));            
              }
              
              else if (acceptedData == 0){
                af_centerTextX(X(64), Y((33/2)-8), "Don't move"); 
                af_centerTextX(X(64), Y(33/2), "Wait for completion");   
              }              
              
              else if (acceptedData <= -1){
                af_centerTextX(X(64), Y((33/2)-4), "Calibration completed");   
              } 

            }
          
          //
          
        //

        // Disabling buttons
         
          void Md_disableButton(){
            
            Md_p_disableButton();
            
            switch (mdf_addres(check_emb, 4)) {
            
              case 1: 
                
                if (mdf_confirm(offer_a_choice) == tf_data_ready) {// після вибору робимо дію відключення кнопок або нічого
                  if (mdf_confirm(tf_get_data) == choice_yes) {
                   Md_tactileButtonsDeactivation(deactivation_buttons_start);
                  } 
                 mdf_addres(back_add, 4);
                }              
              
              break;          
              
              case 2: 
                
                Md_tactileButtonsDeactivation(reset_deactivation_buttons);//скидаємо всі відключені кнопки
                mdf_addres(back_add, 4);
              
              break;            
              
              case address_entered:          
                
                if (mdf_addres(get_add, 4) == 1) {//перед виключенням Перевіряємо чи є зажаті кнопки
                  
                  mdf_addres(mode_function_returns);
                  if (Md_tactileButtonsDeactivation(check_for_pressed_buttons)) {
                   mdf_confirm(output_by_coordinates, X(60), Y(30));
                  }else {
                    mdf_addres(back_add, 4);
                  }
                 
                }
                else if (mdf_addres(get_add, 4) == 2) {mdf_addres(mode_function_returns);}//не чіпати інакше не працює
                else {mdf_cursor(set_pos, mdf_addres(back_add, 3));}//back
              
              
              break; 
            
            }
          
          }
        
          void Md_p_disableButton(){
            
            display.drawRect(0, 0, 127, 19, WHITE); 
            
            
            af_centerTextX(X(127/2), Y(19/2-4), "Turned off("+ String(Md_tactileButtonsDeactivation(deactivated_buttons_get))+")");
            
            af_displayPrintLain("Deactivation start", X(6), Y(22));
            af_displayPrintLain("Reset", X(6), Y(32));
            af_displayPrintLain("Back", X(6), Y(42));
            
            const byte Lines[] = {22, 32, 42};
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);         
          
          }
          
          byte Md_tactileButtonsDeactivation(byte acceptedCommand){
            
            static byte maxFive;
            static byte pinDeactivat[14];      
            
            const uint8_t pinList[14] = {//TEST
              23, 23, 23, 23, 23, 23, 23,
              23, 23, 23, 23, 23, 23, 5
            };
            
            if (acceptedCommand == deactivated_buttons_get) {            
            
             return maxFive;
            
            }
            
            else if (acceptedCommand == deactivation_buttons_start) {

              for (int i = 0; i <= 13; i++) {
                
                if (maxFive != 5 && digitalRead(pinList[i]) == LOW) {
                  // Якщо пін у низькому стані — міняємо його на вихід і ставимо HIGH
                  pinDeactivat[i] = true;
                  maxFive++;
                  pinMode(pinList[i], OUTPUT);
                  digitalWrite(pinList[i], HIGH);
                  
                }
              
              }                
            
            }
            
            else if (acceptedCommand == check_for_pressed_buttons) { 
              
              for (int i = 0; i <= 13; i++) {
                if (digitalRead(pinList[i]) == LOW) {
                 return true;
                }
              }
            
            }
            
            else if (acceptedCommand == reset_deactivation_buttons) { 
              
             maxFive = 0;
            
            }           
            
           return 0;
          
          }
          
        
        //
        
        // Reset all
         
          void Md_resetAll(){
            
            switch (mdf_addres(check_emb, 4)) {
            
              case 1: 
                
                if (mdf_confirm(offer_a_choice) == tf_data_ready) {// після вибору робимо дію відключення кнопок або нічого
                  
                  mdf_addres(back_add, 4);
                  
                  if ( mdf_confirm(tf_get_data) == choice_yes) {
                  
                    Md_saveSelectedProfile(ssp_reset_settings);
                    af_vibration(tf_reset_settings);
                    af_shotgunBolt(tf_reset_settings);
                    af_triggerLight(tf_reset_settings);
                    Md_displayTimeout(tf_reset_settings);
                    Md_autoPowerOff(tf_reset_settings);
                    mps(tf_reset_settings);
                    for (int i = 0; i <= 6; i++) {
                      profilMp[i].profileResetAll();//test
                    }                  
                     
                  }               
                
                }
              
              break;          
              
              case 2: 
                
                mdf_cursor(set_pos, mdf_addres(back_add, 3));             
              
              break; 
              
              case address_entered:
                
                if (mdf_addres(get_add, 4) == 1) {
                 mdf_confirm(output_by_coordinates, X(50), Y(40));
                 mdf_addres(mode_function_returns);          
                }
              break;           
            
            }        
            
            Md_p_resetAll();   

          }   
          
          void Md_p_resetAll(){
          
          display.drawRect(0, 0, 128, 37, WHITE);
          af_displayPrintLain("Reset all my profiles", X(2), Y(5));
          af_displayPrintLain("and", X(56), Y(14));
          af_displayPrintLain("general settings", X(17), Y(23));
          
          
          af_displayPrintLain("Reset", X(6), Y(42));
          af_displayPrintLain("Back", X(6), Y(52));
          
          const byte Lines[] = {42, 52};
          mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);        
          
          }
        
        //
      
      //
    
    //    
  
  //  
  
  // add5-----------------------------------------------------------------------------------------------------------
    
    // Profile
      
      // Profile settings // Buttons Sp Mp  
        
        // Moving buttons
          
          void Md_moveButtons(){
          
            Md_p_moveButtons();
          
            switch (mdf_addres(check_emb, 5)) {
              
              case address_not_entered:

              break;
              
              case 1:
                if (Md_moveButtonsExecute(select_button) == tf_function_completed){//якщо функція завершена повертаємось назад дозволяємо дії геймпада
                  mdf_addres(back_add, 5); 
                  Gf_functionsGamepad(functions_gamepad_start);
                }
              break;
              
              case 2: 
              
                Md_moveButtonsExecute(return_default) == tf_function_completed ? mdf_addres(back_add, 5) : [](){return 0;}();
                
              break;
              
              case 3: //back
                
                mdf_cursor(set_pos, mdf_addres(get_add, 4));
                mdf_addres(back_add, 4);
              
              break;
              
              case address_entered:
              
                mdf_addres(mode_function_returns);
                if (mdf_addres(get_add, 5) == 1){Gf_functionsGamepad(functions_gamepad_stop);}//якщо міняємо кнопки місцями забороняємо дії геймпада
                mdf_addres(get_add, 5) == 2 ? mdf_confirm(output_by_coordinates, X(37), Y(46)) : [](){return 0;}();
              
              break;

            }
            
          }
          
          void Md_p_moveButtons(){
            
            const byte Lines[] = {40, 48, 56};// передаємо координати переміщення функції
            mdf_cursor(cursor_read_encoder, sizeof(Lines), Lines);
            
            display.setCursor(0, 40);// понятно
            display.println(" Select-move");
            display.println(" Reset");      
            display.println(" Back");          
            
          }  

          int Md_moveButtonsExecute(int acceptedCommand){// test
            
            static byte snpb1; //  sequence number physical batton 
            static byte snpb2;  
            
            static byte executionStage;
            static Timer tmr(1000, false);//
             
            switch (acceptedCommand) {
              
              case select_button: 
                
                Md_moveButtonsAnimation(executionStage,  physicalButtons[snpb1].getVirtualButtonName(), physicalButtons[snpb2].getVirtualButtonName());//відображаємо процес виконання
                
                if (af_checkClick()){//виконання можна прервати і вийти якщо натиснути кнопку
                  
                  tmr.st(1000, false);
                  executionStage = false; 
                  return tf_function_completed;           
                
                }                
                
                else {
                  
                  switch (executionStage) {
                    case 0://очікуємо натиску двох кнопок для заміни місцями
                    case 1:
                      for (int i = 0; i <= 16; i++) {
                        if (physicalButtons[i].gamepadBatton(read_button_state) == release_button) { //очікуємо release_button не міняємо ти код
                           
                          if (executionStage == 0) {// зберігаємо порядковий номер екземпляра класу який спрацював може бути любий порядковий номер фізична кнопка  виконуємо це два рази
                            snpb1 = i;// 
                          } else {
                            snpb2 = i;
                          }
                          executionStage++;
                          break;
                        
                        }
                      }
                      
                     break;

                    case 2://після натискання двох кнопок ще секунду відображаємо натиснуті кнопки
                        if (tmr.ts()) {//по завершенню секунди міняємо їх місцями 
                          
                          byte oldVirtualName1 = physicalButtons[snpb1].getVirtualButtonName();//звертаємося до екземплярів класу які спрацювали і зберігаємо віртуальні кнопки які вони натискають для подальшої перестановки місцями
                          byte oldVirtualName2 = physicalButtons[snpb2].getVirtualButtonName();
                          
                          physicalButtons[snpb1].virtualButtonReinstall(oldVirtualName2); // дальше перевстановлюємо віртуальні кнопки місцями
                          physicalButtons[snpb2].virtualButtonReinstall(oldVirtualName1);

                          ap->virtualButtonsList[snpb1] = oldVirtualName2; // 1 попередньо ми перевстановили віртуальні кнопки місцями всередині екземплярів класу physicalButtons тепер потрібно зробити це всередині virtualButtonsList                 
                          ap->virtualButtonsList[snpb2] = oldVirtualName1; // 2 для подальшого збереження енергонезалежній пам'яті, і ініціалізації на старті екземплярів класу physicalButtons
                          
                          executionStage++;
                          tmr.st(2000, false);//вказуємо новий час для відображення вже поміняних кнопок місцями
                        
                        }
                      
                      break; //основна логіка опитуємо фізичні кнопки по порядку і запитуємося яку віртуальну кнопку вона натискає щоб в кінці поміняти їх місцями перша кнопка яку ми натиснемо може бути  Любою і друга також

                    case 3://відображаємо ще дві секунди кнопки які поміняли місцями
                      if (tmr.ts()) {//по завершенню часу виходимо
                        tmr.st(1000, false);
                        executionStage = 0; 
                        return tf_function_completed;
                      }
                      break;
                  }

                }  
                  
              break;     
              
              case return_default://виконується reset або якщо нема потреби відображення надпису not_need
              
                if (ap->malb(check_location) == standard_location) {
                
                  if (mdf_confirm(print_not_need) == tf_function_completed) {
                
                   return tf_function_completed;
                
                  }
                
                }            
                
                else{
                  
                  if (mdf_confirm(offer_a_choice) == tf_data_ready) {//пропонуємо вибір якщо вибір зроблено получимо tf_data_ready для подальшої перевірки
                  
                    if (mdf_confirm(tf_get_data) == choice_yes) {//Перевіряємо чи вибір так Якщо так тоді скидаємо
                      
                      ap->malb(enter_default_location); //повертаємо стандартну номер-назву
                      bgc_buttonGamepadResetlAll();//перенастройка всіх екземплярів класу тому що значення в virtualButtonsList[] помінялись
                    
                    }
                    
                    return tf_function_completed;
                  
                  }
                
                }  
                  
              break;             
            
            }
            
            return 0;
          
          }
          
          void Md_moveButtonsAnimation(byte cmd, byte buttonOne, byte buttonTwo) {
            
            static Timer tmr(500); // таймер для виконання анімації //і накопичення ТІК
            const char** buttonNames = fd_getButtonNames();
            static bsd ra(7);// ra = Running Arrow
            
            display.drawRect(6, 5, 31, 31, WHITE); //  квадрат L
            display.drawRect(90, 5, 31, 31, WHITE);//  квадрат R
            
            display.drawCircle(21, 20, 8, WHITE);// кружки над кнопками
            display.drawCircle(105, 20, 8, WHITE);
            
            
            if (!cmd ){//1//Очікуємо на натиск кнопки 1
              
              if (tmr.ta()){          
               af_centerTextX(X(22), Y(17), '?');        
              }    
            
            }             
            
            else if (cmd == 1){//2//очікуємо натиску кнопки 2
              
              af_centerTextX(X(22), Y(17), buttonNames[buttonOne]);
            
              if (tmr.ta()){
                ra.p(1);
                af_centerTextX(X(106), Y(17), '?');
              }
            
              for (int i = 0; i < 8; ++i) {// відображаємо кутові скобки
              
                display.setCursor(40+i*6, 13);
                display.write(62);
                display.setCursor(40+i*6, 23);
                display.write(60);
              
              }           
              
              display.setCursor(40+ra.g()*6, 13);// трикутник переміщається по углових скобках анімація
              display.write(16);
              display.setCursor(83-ra.g()*6, 23);// трикутник переміщається по углових скобках анімація
              display.write(17);             
              
            }               
            
            else{
              
              if (ra.g()){
                ra.r(); 
                tmr.st(500,true);
              } 
              af_centerTextX(X(22), Y(17), buttonNames[buttonOne]);
              af_centerTextX(X(106), Y(17), buttonNames[buttonTwo]); 
            
            }
             
          }        
        
        //
        
        // Duplicate buttons
          
          void Md_duplicateButtons(){//вибираємо Яку кнопку будемо дублювати або яку кнопку потрібно відключити від дублюючої кнопки
            
            byte regime[] = {d_b_d_m, select_button_r_s, r_s_button_reset, select_button_r_m, r_m_button_reset};
            Md_p_duplicateButtons(regime[mdf_addres(get_add, 5)]);//змінюємо анімацію в залежності від набраного адресу          
            
            switch (mdf_addres(check_emb, 5)) {
              
              case 1:
                
                if (Md_duplicateButtonsExecute(select_button_r_s) == tf_function_completed){
                Gf_functionsGamepad(functions_gamepad_start);  
                mdf_addres(back_add, 5);
                }
                
                break;
              
              case 2: 
                
                if (Md_duplicateButtonsExecute(r_s_button_reset) == tf_function_completed){mdf_addres(back_add, 5);}
              
                break;               
              
              case 3: 
                
                if (Md_duplicateButtonsExecute(select_button_r_m) == tf_function_completed){
                mdf_addres(back_add, 5);
                Gf_functionsGamepad(functions_gamepad_start);
                }
                
              break;
              
              case 4: 
                
                if (Md_duplicateButtonsExecute(r_m_button_reset) == tf_function_completed){mdf_addres(back_add, 5);}
                
              break;          
              
              case 5: //back
                
                mdf_cursor(set_pos, mdf_addres(back_add, 4));
                
              break;
              
              case address_entered:
                
                Md_p_duplicateButtons();
                
                if (mdf_addres(get_add, 5) == 1 || mdf_addres(get_add, 5) == 3){
                Gf_functionsGamepad(functions_gamepad_stop);
                mdf_addres(mode_click_back);
                }    
                else if (mdf_addres(get_add, 5) == 2 || mdf_addres(get_add, 4) == 5){
                mdf_addres(mode_function_returns);
                }
                
              break;
            
            }
            
          } 
          
          void Md_p_duplicateButtons(byte acceptedCommand){
            
            static Timer tmr(300, false);
            
            const char** buttonNames = fd_getButtonNames(); 

            af_displayPrintLain("Rifle stock", X(10), Y(4)); 
            af_displayPrintLain("Reset", X(6), Y(14));     
          
            af_displayPrintLain("Rifle magazine", X(10), Y(35), L(3), N(9)); 
            af_displayPrintLain("Reset", X(6), Y(45));
            
            af_displayPrintLain("Back", X(6), Y(56));        
            
            for (int y = 0; y <= 31; y += 31) {//відображаємо прямокутники і Квадрати і символи
            
              display.drawRect(6, y+2, 72, 11, WHITE); // прямокутник
              display.drawRect(103, y, 15, 15, WHITE);//квадрат ? - ім'я кнопки
              display.setCursor(88, y+4);
              display.println("=");
            
            }        
          
            const byte LinesSp[] = {4, 14, 35, 45, 56};
            mdf_cursor(cursor_read_encoder, sizeof(LinesSp), LinesSp);         
            
            // віалізація вибору кнопка ручка рукоятки
              
              if (acceptedCommand == select_button_r_s){//якщо хочемо вибрати кнопку яку будемо дублювати мигаємо знаком запитання
                
                if (tmr.ta()) { 
                  display.setCursor(111, 4);
                  display.println('?'); 
                }              
              
              }
              
              else if (!ap->virtualButtonsList[r_s]){// якщо кнопка не вибрана відображаємо знак запитання постійно
                
                af_centerTextX(X(111), Y(4), "?");
              
              }
              
              else{af_centerTextX(X(111), Y(4), buttonNames[ap->virtualButtonsList[r_s]]);}//якщо кнопка вибрана відображає її
            
            //
            
            //візуалізація вибору магазин кнопка
              
              if (acceptedCommand == select_button_r_m) {// та сама схема що і вище
                
                if (tmr.ta()) { 
                  display.setCursor(108, 35);
                  display.println('?'); 
                }
                
              }             
            
              else if (!ap->virtualButtonsList[r_m]){af_centerTextX(X(111), Y(35), "?");}
                
              else{af_centerTextX(X(111), Y(35), buttonNames[ap->virtualButtonsList[r_m]]);}
            
            //    
             
          }

          byte Md_duplicateButtonsExecute(byte acceptedCommand){

            if (acceptedCommand == select_button_r_s || acceptedCommand == select_button_r_m) { 
                
              for (byte i = 0; i <= 16; i++) {
              
                if (physicalButtons[i].gamepadBatton(read_button_state) == release_button) {//очікуємо натиску і відпущення кнопки яку будемо дублювати
                  
                  if (acceptedCommand == select_button_r_s) { // в залежності від вибраної кнопки для дублювання виконуємо копіювання
                    
                    ap->virtualButtonsList[r_s] = physicalButtons[i].getVirtualButtonName();
                    physicalButtons[r_s].virtualButtonReinstall(ap->virtualButtonsList[r_s]); 
                    
                  }
                  
                  else if (acceptedCommand == select_button_r_m) {
                    
                    ap->virtualButtonsList[r_m] = physicalButtons[i].getVirtualButtonName();
                    physicalButtons[r_m].virtualButtonReinstall(ap->virtualButtonsList[r_m]);
                  
                  }
                  
                  return tf_function_completed; 
                  
                }  
              
              }              
                
            }

            else if (acceptedCommand == r_s_button_reset){//в залежності від вибору вибираємо кнопку яку будемо скидати
                  
              ap->virtualButtonsList[r_s] = button_0;
              physicalButtons[r_s].virtualButtonReinstall(button_0);
              return tf_function_completed;  
            
            }

            else if (acceptedCommand == r_m_button_reset) {//логіка Та ж сама що і описано зверху

              ap->virtualButtonsList[r_m] = button_0;
              physicalButtons[r_m].virtualButtonReinstall(button_0);
              return tf_function_completed;
              
            }            
            
            return 0;

          }
        
        //
      
      //
    
    //
    
    // General settings
     
      // Controls // Calibration
       
        void Md_joysticksCalibration(){
        
          static byte executionStage;        
          
          switch (executionStage) {
            
            case 0: //просимо не чіпати джойстики і натиснути Next
              
              if (Md_jC_exitNext()){
                
                Md_dzcdrj(false, true);//зберігаємо положення джойстиків в даний момент щоб було від чого відштовхуватися
                Md_dzcdlj(false, true);
                executionStage++;
              
              }
              
              break;     
            
            case 1: //виконується калібрування мертвої зони 
            
              if (Md_joysticksCalibrationDeadZones()){
                
                Md_mvcdrj(false, true);//
                Md_mvcdlj(false, true);                
                executionStage++;
              
              }
              
              break;
            
            case 2: //просимо обертати джойстик впродовж 10 секунд і натиснути далі
              
              Md_joysticksCalibrationMaximumValues();//виконуємо калібрування
              if (Md_jC_exitNext()){executionStage++;}
              
              break;         
            
            case 3: //просимо натиснути далі Щоб завершити і зберегти
              
              if (Md_jC_exitNext()){
                
                Gf_rj(s_d_z, Md_dzcdrj(true, false));//записуємо нові мертві зони для джойстиків
                Gf_leftJoystick(s_d_z, Md_dzcdlj(true, false));
                
                Gf_rj(s_m_m, Md_mvcdrj(true, false));//записуємо нові максимальні мінімальні значення для джойстиків
                Gf_leftJoystick(s_m_m, Md_mvcdlj(true, false));
                
                //Gf_rj(c_c_d);//Перевіряємо чи калібровочні дані відповідають мінімальним параметрам якщо ні ставимо стандартні
                //Gf_leftJoystick(c_c_d);                
                printgetCalibrationData();//test просто для тесту виводить значення в серіал порт
                mdf_cursor(set_pos, mdf_addres(back_add, 4));
                executionStage = 0;                
                
              }
              
              break;            
            
                
          }
          
          Md_p_joysticksCalibration(executionStage);//повідомлення будуть змінюватися залежно від етапу (executionStage)
       
        }
       
        void Md_p_joysticksCalibration(byte executionStage){
        
          display.drawRect(0, 0, 128, 64-14, WHITE); 
          
          switch (executionStage) {
            
            case 0: 
              
              af_centerTextX(64, 10, "Please don't touch");
              af_centerTextX(64, 22, "the joysticks");
              af_centerTextX(64, 34, "and select NEXT");            
            
              break;     
            
            case 1: 
              
              af_centerTextX(64, 15, "Dead zone");
              af_centerTextX(64, 27, "calibration");             
              
              break;
            
            case 2: 
              
              af_centerTextX(64,  3, "For about 10 seconds,");
              af_centerTextX(64, 15, "rotate the joysticks");
              af_centerTextX(64, 27, "in full circles,");
              af_centerTextX(64, 39, "then select NEXT");         
              
              break;         
            
            case 3: 
              
              af_centerTextX(64, 10, "Calibration completed");
              af_centerTextX(64, 22, "to save and exit");
              af_centerTextX(64, 34, "select NEXT");                 
              
              break;              
            
          }
        
        }     
        
        // Joystick calibration functions
        
          // Joystick calibration dead zones
          
            int* Md_dzcdrj(bool getArr, bool arrClearFill){ //dzcd = Dead zone calibration data right joystick
            
             static int jd[4];
             
             if (getArr) {//false, true беремо масив в якій попередньо записували дані
              
              return jd;

             }
             
             else if (arrClearFill) {//false, true беремо нові дані по осям
              
              int rjd[2];
              Gf_rjar(rjd); 
              
              jd[x_l] = jd[x_r] = rjd[x_a];
              jd[y_u] = jd[y_d] = rjd[y_a];
                 
             }
             
             else {//видаляємо дані по осям
              memset(jd, 0, sizeof(jd));
             }             
             
             return nullptr;
            
            }
            
            int* Md_dzcdlj(bool getArr, bool arrClearFill){ // 
            
             static int jd[4];
             
             if (getArr) {
              
              return jd;

             }
             
             else if (arrClearFill) {
              
              int ljd[2];
              Gf_ljar(ljd); 
              
              jd[x_l] = jd[x_r] = ljd[x_a];
              jd[y_u] = jd[y_d] = ljd[y_a];
                 
             }
             
             else {
              memset(jd, 0, sizeof(jd));
             }             
             
             return nullptr;
            
            }        
            
            byte Md_joysticksCalibrationDeadZones(){
              
              int rjd[2];  //right joystick data 
              int ljd[2];
              int* dzrj = Md_dzcdrj(true, false);//Беремо зчитані збережені на старті дані
              int* dzlj = Md_dzcdlj(true, false);
              
              for (int i = 0; i < 100; i++) {
                
                Gf_rjar(rjd); //получаємо дані з джойстиків
                Gf_ljar(ljd); 
                
                //rj
                
                if (rjd[x_a] < dzrj[x_l]) {//
                
                  dzrj[x_l] = rjd[x_a];
                
                }

                if (dzrj[x_r] < rjd[x_a]) {//
                  
                  dzrj[x_r] = rjd[x_a];
                
                }                
                
                if (rjd[y_a] < dzrj[y_u]) {//
                
                  dzrj[y_u] = rjd[y_a];
                
                }

                if (dzrj[y_d] < rjd[y_a]) {//
                  
                  dzrj[y_d] = rjd[y_a];
                
                }                 
                
                //lj
                
                if (ljd[x_a] < dzlj[x_l]) {//
                
                  dzlj[x_l] = ljd[x_a];
                
                }

                if (dzlj[x_r] < ljd[x_a]) {//
                  
                  dzlj[x_r] = ljd[x_a];
                
                }                
                
                if (ljd[y_a] < dzlj[y_u]) {//
                
                  dzlj[y_u] = ljd[y_a];
                
                }

                if (dzlj[y_d] < ljd[y_a]) {//
                  
                  dzlj[y_d] = ljd[y_a];
                
                }                 
                
                delay(30); // Затримка перед наступним зчитуванням
             
              }
              // правий джойстик
              dzrj[x_l] -= 20;
              dzrj[x_r] += 20;
              dzrj[y_u] -= 20;
              dzrj[y_d] += 20;

              // лівий джойстик
              dzlj[x_l] -= 20;
              dzlj[x_r] += 20;
              dzlj[y_u] -= 20;
              dzlj[y_d] += 20;              
             
             return true;
            
            }
            
          //
          
          // Joystick calibration maximum values     
           
            int* Md_mvcdrj(bool getArr, bool arrClearFill){ //mvcdrj = Maximum Values calibration data right joystick
             
             static int jd[4];
             
             if (getArr) {//якщо перший периметр правда повертаємо масив
              
              return jd;

             }
             
             else if (arrClearFill) {//Якщо другий параметр правда на старті зберігаємо дані
              
              int rjd[2];
              Gf_rjar(rjd); 
              
              jd[x_l] = jd[x_r] = rjd[x_a];
              jd[y_u] = jd[y_d] = rjd[y_a];
                 
             }
             
             else {//видаляємо збережені попередньо дані
              memset(jd, 0, sizeof(jd));
             }             
             
             return nullptr;
            
            }
            
            int* Md_mvcdlj(bool getArr, bool arrClearFill){ //
             
             static int jd[4];
             
             if (getArr) {
              
              return jd;

             }
             
             else if (arrClearFill) {
              
              int ljd[2];
              Gf_ljar(ljd); 
              
              jd[x_l] = jd[x_r] = ljd[x_a];
              jd[y_u] = jd[y_d] = ljd[y_a];
                 
             }
             
             else {
              memset(jd, 0, sizeof(jd));
             }             
             
             return nullptr;
            
            }               
            
            void Md_joysticksCalibrationMaximumValues(){
              
              static int rjd[2];//right joystick data 
              static int ljd[2];
              
              Gf_rjar(rjd);   
              Gf_ljar(ljd);              
              
              int* mvrj = Md_mvcdrj(true, false);//беремо попередньо збережені дані 
              int* mvlj = Md_mvcdlj(true, false);////Беремо зчитані збережені на старті дані
                
                //r
                
                if (rjd[x_a] < mvrj[x_l]) {//шукаємо максимальні мінімальні значення джойстика
                
                  mvrj[x_l] = rjd[x_a];//записуємо нові дані
                
                }

                if (mvrj[x_r] < rjd[x_a]) {//
                  
                  mvrj[x_r] = rjd[x_a];
                
                }                
                
                if (rjd[y_a] < mvrj[y_u]) {//
                
                  mvrj[y_u] = rjd[y_a];
                
                }

                if (mvrj[y_d] < rjd[y_a]) {//
                  
                  mvrj[y_d] = rjd[y_a];
                
                }                 
                
                //l
                
                if (ljd[x_a] < mvlj[x_l]) {//
                
                  mvlj[x_l] = ljd[x_a];
                
                }

                if (mvlj[x_r] < ljd[x_a]) {//
                  
                  mvlj[x_r] = ljd[x_a];
                
                }                
                
                if (ljd[y_a] < mvlj[y_u]) {//
                
                  mvlj[y_u] = ljd[y_a];
                
                }

                if (mvlj[y_d] < ljd[y_a]) {//
                  
                  mvlj[y_d] = ljd[y_a];
                
                }                 
                   
            }
          
          //
            
            void printgetCalibrationData() {
                
                const char* names[] = {
                    "Dead zone calib right joystick",
                    "Dead zone calib left joystick",
                    "Max values calib right joystick",
                    "Max values calib left joystick"
                };

                // Масив вказівників на функції, щоб не писати 4 рази одне й те саме
                int* (*funcs[])(bool, bool) = {
                    Md_dzcdrj,
                    Md_dzcdlj,
                    Md_mvcdrj,
                    Md_mvcdlj
                };

                for (int i = 0; i < 4; i++) {
                    int* arr = funcs[i](true, false); // Отримуємо масив
                    Serial.print(names[i]);
                    Serial.print(": ");

                    for (int j = 0; j < 4; j++) {
                        Serial.print(arr[j]);
                        if (j < 3) Serial.print(", ");
                    }
                    Serial.println();
                }
            }
        
        //
        
        // Exit next
        
          byte Md_jC_exitNext(){

            static byte choice;
            
            mdf_magnifier(choice, 0, 1, 1, 1);
            Md_jC__p_exitNext(choice);
            
            if (af_checkClick()) {
              
              if (choice) {//повертаємо правда якщо вибрали Next
                
                choice = false;
                return true;
              
              }
              
              mdf_cursor(set_pos, mdf_addres(back_add, 4));//виходимо якщо вибрали Exit
              
            }            
              
           return 0;
          
          }     
            
          void Md_jC__p_exitNext(byte position){
          
            static byte frame[] = {23, 77};
            
            display.drawRect(frame[position], 52, 27, 11, WHITE);
            af_centerTextX(X(64), Y(64-10), "EXIT     NEXT");

          }
        
        //
      
      //
    
    //
  
  //
  
  // Main display functions  
     
    void mdf_displayOutput() { 
      /*
      void applyContrast(byte val) {//потрібно щоб змінювати яскравість
        display.ssd1306_command(SSD1306_SETCONTRAST);
        display.ssd1306_command(val);//0-255
      }
      */
      static byte switchOnOff = e_u_d;  //переключатель включено виключено
       
      if (switchOnOff == e_u_d){
        
        display.clearDisplay(); 
       
        Md_infoDisplay(); //перший пункт меню який викликає решту пунктів       
        
        display.display(); 
        
        if (Md_displayTimeout()){//відключаємо дисплей якщо не було ні дій n-кодера
         switchOnOff = d_u_d;
         display.clearDisplay();
         display.display();         
        }       
      
      }  //Md_displayTimeout(timeout_restart);
   
      else if (af_checkFastRight() || af_checkFastLeft() || af_checkRight() || af_checkLeft() || af_checkClick()) {//включаємо дисплей якщо зафіксували роботу енкодера
         
        switchOnOff = e_u_d;
      
      }    
    
    }
     
    // Cursor 
      
      byte mdf_cursor(byte acceptedCommand, byte getY, const byte* coordinate) { 
        
        static int8_t y = 0;
        static int8_t cursorVisualTypes = cursor_type_one;

        switch (acceptedCommand) {
          
          case cursor_read_encoder: 
            // переміщаємо курсор якщо тип стрілки є cursor_type_one
            // і якщо кнопка нкодра не натиснута при натиску  і обертання використовується для прокрутки тексту Тому потрібно заборона на переміщення
            if(cursorVisualTypes == cursor_type_one){
              mdf_magnifier(y, 0 , getY-1 , 1 , 1);  
            }           
            mdf_p_cursor(cursorVisualTypes, coordinate[y]);
           
           break;  
          
          case cursor_type_one: 
               
            cursorVisualTypes = cursor_type_one;
            
           break;
          
          case cursor_type_two: 
              
            cursorVisualTypes = cursor_type_two;
            
           break;        
          
          case get_pos: 
            
            return y+1; 
          
           break;
          
          case set_pos: //вказуємо позицію курс при переходах вперед або назад по адресу
              
            y = getY-1;
            cursorVisualTypes = cursor_type_one;//зазвичай Після цього потрібно вказати візуальний тип один щоб лишній раз не викликати робимо це автоматично
            
           break;      
        
        } 
         
        return 0;
      
      } 
        
      byte mdf_p_cursor(int visualTypes, int coordinateY) { 
        
        const byte cursor[] = {26, 16}; //cursor_type_one == 0 cursor_type_two == 1
            
        display.setCursor(0, coordinateY); 
        display.write(cursor[visualTypes]);//вибираємо один з двох видів курсора з таблиці символів
        
        return 0;      
      
      }
    
    //
    
    int mdf_addres(byte acceptedCommand, byte addNumb) {//N
     
      static byte add[10];//для коректної роботи можна використати тільки вісім адресів 1-8
      static byte inputMode = mode_click_input;
      
      switch (acceptedCommand) {
         
        case back_add:
          
          {
            
            mdf_cursor(cursor_type_one);
            inputMode = mode_click_input;
            byte temp = add[addNumb];
            
            for (int i=9; i >= addNumb; i--){// команда back виконує видалення всіх адресів до числа вказаного в addNumb
              
              add[i] = address_not_entered;
              
            }
            
            return temp;//також повертаємо адрес після видалення щоб можна було скористатися mdf_cursor(set_pos, mdf_addres(back_add, 1));
          
          }
         
         break;
        
        case mode_click_back:
          
          mdf_cursor(cursor_type_two);       
          inputMode = mode_click_back;
        
         break;         
        
        case mode_function_returns:
          
          mdf_cursor(cursor_type_two);  
          inputMode = mode_function_returns;
        
         break;         
        
        case get_add:
        
          return add[addNumb];
        
         break;
        
        case check_emb:
            
            if (inputMode == mode_click_input){
              //printArrayEverySecond(add, sizeof( add));
              
              if (add[addNumb] == address_not_entered && af_checkClick()){// набір адреса
              
               add[addNumb] = mdf_cursor(get_pos);//позиція курсора означає номер набраного адресу
               return address_entered;//одноразово повертаємо повідомлення що адрес набрано щоб виконати якісь дії перед тим  коли переходимо по адресу
              }
            
            }
            
            else if (inputMode == mode_click_back){            
               
              if (add[addNumb+1] == address_not_entered && af_checkClick()){//якщо попадемо на нуль повертаємося
                
                mdf_addres(back_add, addNumb);
                return address_deleted;
              
              }          
            
            }
            
            return add[addNumb];
         
         break;         
      
      }
      
      return 0;

    }
    
    // magnifier 
      
      template <typename T>//функція працює безпосередньо з змінною напряму
      bool mdf_magnifier(T &numeric, int minNam, int maxNam, int Speed1, int Speed2) {
         
        if (af_checkFastRight()) {
          numeric += Speed2;
          Serial.println(2);
        } else if (af_checkFastLeft()) {
          numeric -= Speed2;
          Serial.println(-2);
        } else if (af_checkRight()) {
          numeric += Speed1;
          Serial.println(1);
        } else if (af_checkLeft()) {
          numeric -= Speed1;
          Serial.println(-1);
        } else {
          return false;
        }
        
        numeric = af_clamp(numeric, minNam, maxNam);
        return true;
        
      }
      
    //
    
    void mdf_typeNumberPrint(){//функція відображає номер і тип профілю в інфодисплей і першому пункті меню
       
      if (ap->tape == t_sp) {//номер тип відображається лише коли вибрано профіль
         
        display.setCursor(49, 0);
         
        display.print("(Sp");
        display.print(ap->number);
        display.print(")");
        
      }       
      
      else if (ap->tape == t_mp) {//номер тип відображається лише коли вибрано профіль
         
        display.setCursor(49, 0);
        display.print("(Mp");
        display.print(ap->number);//
        display.print(")");
        
      } 
    
    }  
    
    // Confirm 
      
      byte mdf_confirm(byte acceptedCommand, byte x, byte y){//функція надає варіант для вибору та каву ні або виводить повідомлення що не потрібно якщо нема потреби
        
        static bsd selection(1);//вибір так або ні
        static bsd clicksCount(3);//зміна накопичує вказані ліки при досягненні виконається дія
        byte variants[] = {choice_no, choice_yes};      
        
        if (acceptedCommand == output_by_coordinates) {// кожен раз перед основним викликом одноразово  функція приймає координати 
          
          mdf_p_confirm(output_by_coordinates, x, y);//  переправляє координати  в mdf_p_confirm для збереження
          
        } 
        
        else if (acceptedCommand == output_by_center_x) {
         
         mdf_p_confirm(output_by_coordinates, 64-27, y);
        
        }
        
        else if (acceptedCommand == print_not_need) {//після перевірки можна подати команду вивести повідомлення якщо підтвердження не потрібне
          
          if (mdf_p_confirm(print_not_need) == tf_function_completed || af_checkClick()) {
           
           mdf_p_confirm(tf_reset); 
           return tf_function_completed;
         
          }
        
        }
       
        else if (acceptedCommand == offer_a_choice) {//якщо підтвердження потрібне запропоновуємо вибір виводимо так або ні
          
          if (af_checkTurn()) {//при обертах енкодера в залежності від накопичених значень відбудеться різні дії
            
            selection.p(1);//якщо вже є одиничка і ми доплюсуємо один змінна скинеться на нуль
            mdf_p_confirm(change_selection); // міняємо позицію відображення рамки так або ні
            clicksCount.r();//якщо було накопичення ліків відбудеться скидання із-за того що позиція рамки змінилася
           
          }        
        
          if (af_checkClick()) {//робимо кліки і накопичуємо їх 
          
            clicksCount.p(1);
           
            if (clicksCount.m()) {  //  якщо максимум повідомляємо що дані готові 
              mdf_p_confirm(tf_reset);
              return tf_data_ready;
            }
             
            else if (variants[selection.g()] == choice_no) {  //   
              mdf_p_confirm(tf_reset);
              return tf_data_ready;
            }           
           
           mdf_p_confirm(accelerate_frame_blinking); 
          
          }              
          
          mdf_p_confirm(offer_a_choice);
        
        }    
        
        else if (acceptedCommand == tf_get_data) {//якщо получили tf_data_ready беремо дані-вибір
           
          return variants[selection.r()]; //метод .r() одноразово повертає накопичне число і скидає його
       
        }      
        
        return 0;
      
      }  
        
      byte mdf_p_confirm(byte acceptedCommand, byte x, byte y){ 
        
        const byte frameSizeWidth[] = {15, 21};// розмір рамки міняємо в залежності   yes no
        const byte framePosition[] = {2, 33};//координати для позиції рамки так ні
        const int frameBlink[] = {1000, 500, 100};//test частота мигання рамки якщо натискаємо кнопку
        
        static byte frequency;//frequency ЧАСТОТА вказує на частоту мигання рамки
        static byte flashFlag;
        static Timer tmr(frameBlink[frequency]);
        static byte selection;

        static byte azixX;
        static byte azixY;   
        
        switch (acceptedCommand) {
          
          case output_by_coordinates://зберігаємо координати для виведення
           
            azixX = x;
            azixY = y;             
          
           break;          
          
          case change_selection://якщо ми міняємо позицію рамки то скидання
            
            selection = !selection;
            frequency = 0;
            tmr.st(frameBlink[frequency], true);           
              
           break;             
          
          case accelerate_frame_blinking://при накопиченні кліків збільшується частота блимання рамки навколо вибору
            
            frequency++;
            tmr.st(frameBlink[frequency], true);
           
           break;          
          
          case tf_reset://якщо накопичили необхідну кількість bліків відбудеться скидання до початкового стану
            
            selection = frequency = 0;
            tmr.st(frameBlink[frequency], true);//після того як скинули frequency вказуємо знову чистоту
            
          
           break;            
          
          case print_not_need://якщо настройки не мінялись виводимо повідомлення що не потрібне скидання
            //test Потрібно провести перевірку логіка така що при скиданні встановлювалась секунда а тут секунда буде правда потім стане брехня
            if (!tmr.ta()) {//це означає що пів секунди будемо виводити повідомлення допоки тут не появиться True
              tmr.st(frameBlink[frequency], true);
              return tf_function_completed;
            } 
            
            display.setCursor(azixX+4,azixY+3); //
            display.print("not need");
            display.drawRect(azixX, azixY, 56, 15, WHITE);// велика рамка навколо
           
           break;          
          
          case offer_a_choice://якщо настройки мінялись пропонується вибір
            
            display.setCursor(azixX+4, azixY+4);
            display.println("NO");
          
            display.setCursor(azixX+35, azixY+4);
            display.println("YES");        
            
            if (tmr.ta()) {//рамка світилась одразу після запуску або змінні вибору
               
              display.drawRect(azixX + framePosition[selection], azixY + 2, frameSizeWidth[selection], 11, WHITE);//рамка навколо так або ні
             
            }
          
            display.drawRect(azixX, azixY, 56, 15, WHITE);// велика рамка навколо так ні
                       
           
           break;              
          
        }
        
        return 0; 
      
      } 
      
    //  
    
    void mdf_bluetoothPrint() {
        
      static Timer tmr(600);
      
      display.drawCircle(6, 6, 6, WHITE);// кружок
      
      if (bleGamepad.isConnected() || tmr.ta()) {

       fd_bluetoothSymbol();
      
      }
      
    }
    
    /*
    byte mdf_batteryCheck(byte acceptedCommand) {
      
      static float batLevels[] = {3.05, 3.10, 3.20, 3.29, 3.39, 3.48, 3.58, 3.67, 3.77, 3.86, 3.96, 4.06, 4.14, 4.18};  //1-14 0-13
      
      static Timer tmr;
      static byte li = []()->byte {
        if (ina219.getCurrent_mA() > 50){
         batLevels[12] = 4.18;
         return 1;
        }
        return 12;
      }(); //li = level Indicator;
      static byte csf = []()->byte {return ina219.getCurrent_mA() > 50 ? b_c_p : b_c_m;}();//на старті Перевіряємо чи зарядка підключена
      
      if (tmr.gp()) {
        
        float voltageNewData = ina219.getBusVoltage_V();
        float currentMa = ina219.getCurrent_mA();
        
        if (currentMa <= 0){
          
          if (csf == b_c_m && voltageNewData < batLevels[li]){
           li--;
          }
          
          else if (li <= 4) {
           Md_displayTimeout(timeout_reset);
           if (li == 1) {af_powerOffExecution();}   
          }        
          
          else if (csf == b_c_p) {
           Md_displayTimeout(timeout_reset);
           tmr.ft(2000);          
           csf = b_c_m;  
          } 
         
        }
      
        else if (50 < currentMa){
        
          if (csf == b_c_p && batLevels[li+1] < voltageNewData && li !=12){
           li++;     
           if (batLevels[12] < voltageNewData){batLevels[12] = 4.14;}
          }
          
          else if (csf == b_c_m){
           batLevels[12] = 4.18;
           Md_displayTimeout(timeout_reset);
           tmr.ft(2000);
           csf = b_c_p;
           li++;
          }     
        
        tmr.st(2000);
      
      } 
      
      if (acceptedCommand == g_b_s) { 
        return csf == b_c_p ? b_c_p : li;
      }
      
      return 0;
    
    }

    void mdf_batteryPrint() {
      
      static byte sevedChargeScale; //sevedChargeScale = збереження шкали заряду
      static Timer tmr(300);
      static bsd ca(12, mdf_batteryCheck(g_b_l)); //ca = charging animation
      
      display.drawRect(111, 2, 1, 4, WHITE);// картинка батареї
      display.drawRect(112, 0, 16, 8, WHITE);
                
      if (mdf_batteryCheck(b_c_p)) {
       display.fillRect(126-ca.tnar(), 2, ca.tnar(), 4, WHITE);
      }
      
      else if ((3 <= ca.g()) || tmr.ta()) {
        ca.s(mdf_batteryCheck(g_b_l));
        display.fillRect(126-ca.g(), 2, ca.g(), 4, WHITE);// шкала заряду батареї
      }
     
    } 
    */
  // Mdf

// Md

// Gamepad function
  
  // Right joystick + Gyroscope (Z(V) RZ(H))
      
    // Gyroscope
       
      int16_t* Gf_g(int cmd){//перетворюємо дані з гіроскопа і керуємо правим аналогом джойстика
        
        static byte ed = tf_enabled;  // ed =  enabled disabled  ed = tf_enabled; завжди має бути так тому що гіроскоп пріоритетний
        static bool fs;  // flag return
        static int16_t pd[3]; // previous data
        static int16_t ud[3]; // unconverted data неперетворені
        static int16_t gd[3]; // Get Data
        
        static uint8_t fifoBuffer[42];  
        static Timer tmr(10);//таймер щоб опитувати кожні 10 мілісекунд 
      
        if (cmd == r_g_d) {  
          
          switch (ed) {
            
            case tf_enabled:
          
              if (tmr.gp() && mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) {//  коли берем дані одразу зчитуємо нові якщо є
              
                mpu.dmpGetGyro(ud, fifoBuffer);
                
                // X-axis
                  
                  if (map(abs(ud[g_z]), 0, 150, 1, 30) < abs(ud[g_y])) {// получ  знач  мають бути більше одинички // h=x // Перевіряємо чи є вихід динамічної мертвої зони
                        
                    fs = true;
                    
                    ud[g_y] = constrain(ud[g_y], -(ap->sya), ap->sya);
                      
                    if (0 < ud[g_y]) {
                      gd[x_a] = map(ud[g_y], 1, ap->sya, -(ap->dzya), -32767);
                    }
                    
                    else if(ud[g_y] < 0){
                      gd[x_a] = map(ud[g_y], -1, -(ap->sya), ap->dzya, 32767);
                    }            
                    
                  }
                  
                  else if(gd[x_a]){
                    fs = true;
                    gd[x_a] = 0;
                  }
                
                //
                
                // Y-axis
                  
                  if (map(abs(ud[g_y]), 0, 150, 1, 30) < abs(ud[g_z])) {//v=y V якщо є вихід за динамічну мертву зону тоді можна виконати перетворення даних
                        
                    fs = true;
                    
                    ud[g_z] = constrain(ud[g_z], -(ap->sxa), ap->sxa);
                      
                    if (0 < ud[g_z]) {
                      gd[y_a] = map(ud[g_z], 1, ap->sxa, -(ap->dzxa), -32767);
                    }
                    else if(ud[g_z] < 0){
                      gd[y_a] = map(ud[g_z], -1, -(ap->sxa), ap->dzxa, 32767);
                    }            
                      
                  }  
                  
                  else if(gd[y_a]){
                    fs = true;
                    gd[y_a] = 0;
                  }            
                  
                //
                
                if (fs) {//останній раз ще поверн правда і можна буде становити нуль 
                  fs = false;
                  return gd;
                }            
                
              }               
             
             break;        
            
            case tf_disabled:          
              
              ed = g_non_bool;
              if (gd[x_a] || gd[y_a]){
                gd[x_a] = gd[y_a] = 0;
                return gd;
              }             
             
             break;   
          
          } 
        
        }
        
        else if (cmd == g_e) {ed = tf_enabled;}
        else if (cmd == g_d) {ed = tf_disabled;}//звертаємося до цього масиву pd за даними щоб користуватися звичайними константами x_a y_a
        else if (cmd == g_g_d) {return gd;}  
        
        return nullptr;    
      
      }  
      
    //
    
    // Right joystick  
     
      void Gf_rjar(int dest[2]) { //rjadf = right joystick analog readings
        
        dest[x_a] = analogRead(p_s_t_x_39);//0-4095=l-r
        dest[y_a] = analogRead(p_s_t_y_36);//0-4095=u=d
      
      }
      
      int* Gf_rj(int cmd, int newData[]){ //rjadf = right joystick analog data filtered
        
        static Timer tmr(false, false);
        static byte executionPath = path_0;// execution path шлях виконання        
        
        static int dz[4] = {4095, 0, 4095, 0}; // дані параметри потрібні для калібрування /// !!!В майбутньому потрібно щоб була ініціалізація 0 потрібна для eeprom
        static int mm[4] = {0 + 100, 4095 - 100, 0 + 100, 4095 - 100}; // minimum maximum x y  
        static int dasu[2]; // data analog seve unfiltered
        static int cds[2]; // converted data saved
        static int da[2]; // data analog дані аналог  
        static byte fr;  // 
        static byte ed = g_non_bool; // ed = g_non_bool тому що нічого не треба повертати гіроскоп пріоритетний з самого початку в Незалежності від позиції кнопки
        
        if (cmd == r_a_d) {
          
          switch (executionPath) {// один раз викликається в коді
            
            case path_0: 
              
              Gf_rjar(da); // передаємо масив получаємо дані з аналогових пінів      
              
              // X-axis
              
                if (da[x_a] < dz[x_l]) {//Перевіряємо чи є вихід за мертву зону          
                  
                  if (da[x_a] != dasu[x_a]) {//щоб лишній раз не робити розрахунки Перевіряємо чи вони відрізняються від старих
                    
                    dasu[x_a] = da[x_a];
                    da[x_a] = constrain(da[x_a], mm[x_l], mm[x_r]);
                    cds[x_a] = map(da[x_a], dz[x_l], mm[x_l], 0, -32767);
                    fr = true;
                
                  }
                  
                  else {fr = true;}//якщо дані не змінилися відправляємо перетворені старі дані
                
                }
                
                else if (dz[x_r] < da[x_a]) {
                  
                  if (da[x_a] != dasu[x_a]) {
                    
                    dasu[x_a] = da[x_a];         
                    da[x_a] = constrain(da[x_a], mm[x_l], mm[x_r]);
                    cds[x_a] = map(da[x_a], dz[x_r], mm[x_r], 0, 32767);         
                    fr = true;
                  
                  }
                  
                  else {fr = true;}
                
                }
                
                else if (cds[x_a]) { 
                
                  fr = true;
                  cds[x_a] = 0;
                
                }
              
              //
              
              // Y-axis
              
                if (da[y_a] < dz[y_u]) {//Перевіряємо чи є вихід за мертву зону          
                  
                  if (da[y_a] != dasu[y_a]) {
                    
                    dasu[y_a] = da[y_a];             
                    da[y_a] = constrain(da[y_a], mm[y_u], mm[y_d]);
                    cds[y_a] = map(da[y_a], dz[y_u], mm[y_u], 0, -32767);
                    fr = true;
                  
                  }
                  else {fr = true;}
                
                }
                
                else if (dz[y_d] < da[y_a]) {
                  
                  if (da[y_a] != dasu[y_a]) {
                    
                    dasu[y_a] = da[y_a];          
                    da[y_a] = constrain(da[y_a], mm[y_u], mm[y_d]);
                    cds[y_a] = map(da[y_a], dz[y_d], mm[y_d], 0, 32767);         
                    fr = true;
                  
                  } 
                  else {fr = true;}
                
                }         
                
                else if (cds[y_a]) { 
                
                  fr = true;
                  cds[y_a] = 0;
                
                }           
              
              //           
              
              switch (ed) {// в залежності від стану відправляємо масив щоб моніторити позицію джойстика
                
                case tf_enabled:// кнопка перемикач відпущена значить працює даний режим
                  
                  if (fr) {// якщо правда значить дані потрібно відправити дані перетворюються флажок підноситься Вверх
                    
                    fr = false;
                    return cds;// відправлення масиву рахується як правда дальше його потрібно викликати через команду
                    
                  }             
                  
                break;
                
                case tf_disabled:// кнопка перемикач натиснути одноразово потрібно повернути масив щоб встановити нолики
                  
                  ed = g_non_bool; // ставим неіснуючий кейс щоб більше нічого не виконувалось
                  cds[x_a] = cds[y_a] = false; // ставим нулі по осям
                  return cds;// одноразова повертаємо ці нулики
                  
                break;          
              
              }
             
             break;   
            
            case path_1: //додаткова перевірка після калібрування
          
              Gf_rjar(da);        
              
              if (da[x_a] < dz[x_l] || da[x_a] > dz[x_r] || da[y_a] < dz[y_u] || da[y_a] > dz[y_d]) { //при виході з dz відбувається постійно скидання і вказання нового часу
               tmr.st(2000, false); // тут відбувається тільки запис в зміну часу, нема ариxметики
              }                    
              
              else if (tmr.ts()) {executionPath = path_0;} // тут можливa правда лише коли таймер перестане перезапускатися            
              
             break;   
            
            case path_2: // роботи заборонена перевірка на початку не пройдена
          
              return nullptr;
             
             break;             
          
          }  
        
        }
        else if (cmd == g_a_d) {return cds;}
        
        else if (cmd == r_j_e) {ed = tf_enabled;}//тут барану навіть зрозуміло
        
        else if (cmd == r_j_d){ed = tf_disabled;}
         
        //беремо зчитані збережені дані
        else if (cmd == g_d_z) {return dz;}
        else if (cmd == g_m_m) {return mm;}       
        else if (cmd == s_m_m) {memcpy(mm, newData, sizeof(mm));} //  Вказуємо мінімальне !! максимальне значення мінімальне значення не може бути нулем буде конфлікт
        else if (cmd == s_d_z) {memcpy(dz, newData, sizeof(dz));} // Вказуємо мертві зони  !!! нагадування Мертва зона може бути в певних межах зробити перевірку     
        
        else if (cmd == c_c_j) {// check calibration data

          Gf_rjar(da);

          if (abs(da[x_a] - 2048) > 300 || abs(da[y_a] - 2048) > 300) {//1he спрацювання виводимо повідомлення 2ge спрацювання виконуємо відключення
            Serial.println("r Joystick 3");
            executionPath = path_2;// ставим режим відключено
            int initialValues[] = {4095, 0, 4095, 0};//скидаємо записані дані камбрування
            memcpy(dz, initialValues, sizeof(dz));
            return da;//повертаємо правда виконуємо дії залежності від етапу перезапуск або відключення
          
          }    
          
          else{
            
            executionPath = path_1; // додаткова перевірка після калібрування
            
            if (da[x_a] < dz[x_l]) {//калібруємо мертву зону //при першому виклику умова завжди буде правильно тому що сказали необхідні значення при створенні масиву дз
                dz[x_l] = da[x_a]-20;
            }
            
            if (da[x_a] > dz[x_r]) {
                dz[x_r] = da[x_a]+20;
            }

            if (da[y_a] < dz[y_u]) {
                dz[y_u] = da[y_a]-20;
            }
            
            if (da[y_a] > dz[y_d]) {
                dz[y_d] = da[y_a]+20;
            }        
          
          }
        
        }         
        
        return nullptr;
        
      }   
      
    //
    
    // Combined gyro right joystick  
    
      byte Gf_handleButton(){ // handle Button test потрібно перемістити на приклад встановити дві кнопки сенсорна і тактильна
        
        static Timer tmr(false, false);
        static byte counter = 2;
        static byte executionPath = path_0;
        const int TDZ = 30;
        static bool previousValue; // 
        
        uint16_t buttonState = touchRead(p_h_b_14) < TDZ;// моніторимо новий стан постійн
        
        switch (executionPath) {
            
          case path_0: // перше тестування потрібно два натиски кнопки       
        
            if (buttonState != previousValue){ //
              
              previousValue = buttonState; //
              
              if (buttonState){
                
                counter--;
                if (!counter){
                  tmr.st(2000, false);
                  executionPath = path_1;
                }
              
              }
            
            }             
            
           break;
          
          case path_1: // одразу після другого натиску потрібно утримувати кнопку 2s          
           
            if (buttonState){
              
              if (tmr.ts()){
               previousValue = false;
               executionPath = path_2;
              }
            
            }
           
            else{tmr.st(2000, false);}
           
           break;
          
            case path_2: // звичайний режим включаємо виключаємо гіроскоп і джойстик
            
            if (buttonState != previousValue){//сliткуємо чи стан змінився
              
              previousValue = buttonState;
              if (buttonState){return tf_enabled;}
              else{return tf_disabled;}
             
            }         
           
           break;
        
        }
          
        return g_non_bool;
      
      }      
      
      int Gf_da(int cmd, int data){// data axis функція зберігає відправляє і повертає попередні дані по осям
        
        static int pd[2];// 
          
        switch (cmd) {
          case g_x:
            return pd[x_a];
          break;  
          case g_y:
            return pd[y_a];
          break;        
          case s_x:
            pd[x_a] = data;
            bleGamepad.setRZ(data); 
            Gf_sendReport(send_report);   
          break;      
          case s_y:
            pd[y_a] = data;
            bleGamepad.setZ(data);
            Gf_sendReport(send_report);
          break;      
        }
        
        return 0;
      
      }
      
      void Gf_combinedGyroRightJoystick(){
         
        switch (Gf_handleButton()){//test сенсор рукоятки
          
          case tf_enabled:  
            
            Gf_g(g_e); // якщо відповідальнa  кнопка натиснута включаємо і розкоп виключаємо джойстик
            Gf_rj(r_j_d);
           
           break;         
            
          case tf_disabled:  
            
            Gf_g(g_d); // тут все наоборот
            Gf_rj(r_j_e);
           
           break;         
          
        }        
        
        bool gyroActive = Gf_g(r_g_d); // якщо повернення правда потрібно виконати відправлення даних
        bool joyActive = Gf_rj(r_a_d); //  
        
        
        if (gyroActive && joyActive) {//даний варіант якщо кнопка натискається або відпускається потрібно перевірити масив хто має дані
        
          if (Gf_g(g_g_d)[x_a] || Gf_g(g_g_d)[y_a]) { 
            
            if (Gf_da(g_x) != Gf_g(g_g_d)[x_a]) { 
              Gf_da(s_x, Gf_g(g_g_d)[x_a]);
            }
            if (Gf_da(g_y) != Gf_g(g_g_d)[y_a]) {
              Gf_da(s_y, Gf_g(g_g_d)[y_a]); 
            }          
          
          }
          
          else if (Gf_rj(g_a_d)[x_a] || Gf_rj(g_a_d)[y_a]) {
            
            if (Gf_da(g_x) != Gf_rj(g_a_d)[x_a]) { 
              Gf_da(s_x, Gf_rj(g_a_d)[x_a]);
            }
            if (Gf_da(g_y) != Gf_rj(g_a_d)[y_a]) {
              Gf_da(s_y, Gf_rj(g_a_d)[y_a]);
            }         
          
          }
          
          else {//можливі варіант якщо ніхто не буде мати даних при відпущенні або натисканні кнопки
           
           Gf_da(s_x, 0);
           Gf_da(s_y, 0);
          
          }
        
        }
        
        else if (gyroActive) {//получаем правда якщо є зміна даних або завершили перетворення даних получаємо нулики в масиві
          
          if (Gf_da(g_x) != Gf_g(g_g_d)[x_a]) { 
            Gf_da(s_x, Gf_g(g_g_d)[x_a]);
          }
          if (Gf_da(g_y) != Gf_g(g_g_d)[y_a]) {
            Gf_da(s_y, Gf_g(g_g_d)[y_a]); 
          }   
          
        }              
        
        else if (joyActive) {
          
          if (Gf_da(g_x) != Gf_rj(g_a_d)[x_a]) { 
            Gf_da(s_x, Gf_rj(g_a_d)[x_a]);
          }
          if (Gf_da(g_y) != Gf_rj(g_a_d)[y_a]) {
            Gf_da(s_y, Gf_rj(g_a_d)[y_a]);
          }                
          
        }
        
      }
    
    //
  
  //
  
  // left joystick
    
    void Gf_ljar(int dest[2]) { //ljadf = left joystick analog readings
      
      dest[x_a] = analogRead(p_s_t_x_39);//test
      dest[y_a] = analogRead(p_s_t_y_36);
    
    }    
    
    int* Gf_leftJoystick(int cmd, int newData[]){//test
      
      static Timer tmr(false, false);
      static byte executionPath = path_0;// execution path шлях виконання
      
      static int cds[2]; // cds = converted data saved (x y) (-32767 0 32767)
      static int dz[4] = {4095, 0, 4095, 0}; // дані параметри потрібні для калібрування
      static int mm[4] = {0+100, 4095-100, 0+100, 4095-100}; // minimum maximum x y
      
      static int da[2]; // data analog 
      static int dasu[2] = {2048, 2048}; //data analog seve unfiltered // вказуємо 2048 тому що може бути звернення навіть якщо є заборона
      
      
      if (!cmd) {//коли нема команди виконується основний код i коли пройшли перевірку  checkLeftJoystick
      
        switch (executionPath) {
          
          case path_0: // зчитуємо перетворюємо відправляємо
                    
            Gf_ljar(da);
          
            // X-axis  
              
              if (da[x_a] < dz[x_l]) { // незалежна як підключити кабель тут буде реакція на зменшення опору  
                
                if (dasu[x_a] != da[x_a]) {
                  
                  da[x_a] = constrain(da[x_a], mm[x_l], dz[x_l]);// тому помилки не буде
                  cds[x_a] = map(da[x_a], mm[x_l], dz[x_l], -32767, 0);//можна переставити місцями 0 i -32767 якщо буде інверсія
                  dasu[x_a] = da[x_a];
                  bleGamepad.setX(cds[x_a]);
                  Gf_sendReport(send_report);
                
                }
                
              }

              else if (da[x_a] > dz[x_r]) {
              
                if (dasu[x_a] != da[x_a]) {
                  
                  da[x_a] = constrain(da[x_a], dz[x_r], mm[x_r]);
                  cds[x_a] = map(da[x_a], dz[x_r], mm[x_r], 0, 32767);
                  dasu[x_a] = da[x_a];
                  bleGamepad.setX(cds[x_a]);
                  Gf_sendReport(send_report);
                
                }
              
              }
              
              else if (cds[x_a]){
                
                cds[x_a] = 0;
                bleGamepad.setX(cds[x_a]);
                Gf_sendReport(send_report);            
                
              } 
            
            //
            
            // Y-axis
              
              if (da[y_a] < dz[y_u]) {
                
                if (dasu[y_a] != da[y_a]) {
                  
                  da[y_a] = constrain(da[y_a], mm[y_u], dz[y_u]);
                  cds[y_a] = map(da[y_a], mm[y_u], dz[y_u], -32767, 0);
                  dasu[y_a] = da[y_a];
                  bleGamepad.setY(cds[y_a]);
                  Gf_sendReport(send_report);
                
                }
              
              } 
              
              else if (da[y_a] > dz[y_d]) {
                
                if (dasu[y_a] != da[y_a]) {
                  
                  da[y_a] = constrain(da[y_a], dz[y_d], mm[y_d]);
                  cds[y_a] = map(da[y_a], dz[y_d], mm[y_d], 0, 32767);
                  dasu[y_a] = da[y_a];
                  bleGamepad.setY(cds[y_a]);
                  Gf_sendReport(send_report);
                }
              
              } 
              
              else if (cds[y_a]) {
                
                cds[y_a] = 0;
                bleGamepad.setY(cds[y_a]);
                Gf_sendReport(send_report);             
                
              }  
            
            //                     
              
           break;   
          
          case path_1:// додаткова перевірка мертвої зони  (логіка вихід, захід на 2 секунди, перевірка пройдена)
            
            Gf_ljar(da);        
            
            if (da[x_a] < dz[x_l] || da[x_a] > dz[x_r] || da[y_a] < dz[y_u] || da[y_a] > dz[y_d]) { //при виході з dz відбувається постійно скидання і вказання нового часу
             
             tmr.st(2000, false);//тут відбувається тільки запис в зміну часу, нема арифметики
            
            }                    
            
            else if (tmr.ts()) {executionPath = path_0;Serial.println( " L J timer DZ END");} // тут можливa правда лише коли таймер перестане перезапускатися
            
           break;        
          
          case path_2:// робота заборонена перевірка не пройдена
            Serial.println( " L J  return nullptr; ");
            return nullptr;                                    
            
           break;         
        
        }
        
      } else{
        
        if (cmd == g_a_d) {return cds;}
        else if (cmd == g_d_z) {return dz;}
        else if (cmd == g_m_m) {return mm;}
        else if (cmd == s_d_z) {memcpy(dz, newData, sizeof(dz));}
        else if (cmd == s_m_m) {memcpy(mm, newData, sizeof(mm));}
        else if (cmd == c_c_j) {// check calibrate joystick
          
          Gf_ljar(da);

          if (abs(da[x_a] - 2048) > 300 || abs(da[y_a] - 2048) > 300) {//1he спрацювання виводимо повідомлення 2ge спрацювання виконуємо відключення
            
            executionPath = path_2;//ставим режим відключено
            int initialValues[] = {4095, 0, 4095, 0};//скидаємо записані дані камбрування
            memcpy(dz, initialValues, sizeof(dz));
            return da;//повертаємо правда виконуємо дії залежності від етапу перезапуск або відключення
          
          }    
          
          else{
            
            executionPath = path_1;//вказуємо режим перевірка мертвої зони після калібрування
            
            if (da[x_a] < dz[x_l]) {//калібруємо мертву зону //при першому виклику умова завжди буде правильно тому що сказали необхідні значення при створенні масиву дз
               dz[x_l] = da[x_a]-20;//TEST це лайно треба буде замінити на датчики Хола
            }
            
            if (da[x_a] > dz[x_r]) {
                dz[x_r] = da[x_a]+20;
            }

            if (da[y_a] < dz[y_u]) {
                dz[y_u] = da[y_a]-20;
            }
            
            if (da[y_a] > dz[y_d]) {
                dz[y_d] = da[y_a]+20;
            }        
          
          }
        
        }
      
      }
      
      return nullptr;
    
    }  
    
  //
  
  void Gf_gamepadButtons(){
    
    static byte flagSendReport; 
    
    for (byte i = b_1; i <= t_r; i++) {//Перевіряємо чи натиснуті кнопки
      
      if (physicalButtons[i].gamepadBatton(read_button_state)){//в любому випадку якщо відпустити або натиснути получим правда
        flagSendReport = send_report;//записуємо змінu щоб постійно не викликати функцію
      } 
    
    }
    
    if (flagSendReport){
     Gf_sendReport(flagSendReport);
     flagSendReport = false;
    }
  
  }
  
  /* 
  byte Gf_gamepadButtonsDuplicators(byte acceptedCommand){
   
    if (ap->rrsps){//беремо режим роботи
      physicalButtons[16].gamepadBatton(read_button_state);
    }
    else{
      physicalButtons[16].gamepadBatton(r_b_double_press);//зазвичай кнопка дублює кнопку приціл Тому потрібно деколи спеціальний режим подвійного натиску якщо немає можливості змінити в настройках
    }
    
    physicalButtons[17].gamepadBatton(read_button_state);
    
    if (acceptedCommand){
    
      if (acceptedCommand == dbrs_change_mode){
       ap->rrsps = !ap->rrsps;//режим роботи зберігається в профілі
      }
      else if (acceptedCommand == dbrs_get_mode){
       return ap->rrsps;
      }   
      else if (acceptedCommand == dbrs_reset){
       ap->rrsps = 1;
      }    
    
    }
    
    return 0;
  
  }
  */

  void Gf_functionsGamepad(byte acceptedCommand){
     
    //START_TIMER();
  
    static byte fep = true; // fep = flag execution permission 
    
    if (acceptedCommand) {// TEST Для зупинки потрібно використати Gf_sendReport(stop); ому що гіроскоп може перестати працювати
     if (acceptedCommand == functions_gamepad_stop) {Gf_controlElementsStope(); fep = false;}
     else if (acceptedCommand == functions_gamepad_start) {fep = true;}
    }
    
    else if (bleGamepad.isConnected() && fep) {
       
      Gf_leftJoystick();//!!!
      Gf_combinedGyroRightJoystick();
      Gf_gamepadButtons();  
      Gf_sendReport(send_report_execute);  
     
    
    }
    //END_TIMER();
  }
  
  void Gf_sendReport(byte acceptedCommand){
   
    static byte gamepadSendReport = waiting_command; 
   
    switch (acceptedCommand) {
      
      case send_report_execute:
        
        if (gamepadSendReport == send_report) {
          Md_autoPowerOff(apo_restart_time);
          gamepadSendReport = waiting_command;
          bleGamepad.sendReport();
        }
       
       break;

      case send_report:
        
        gamepadSendReport = send_report;
        
       break;

    }
  
  }
  
  void Gf_controlElementsStope(){

    for (int i = 1; i <= 8; i++) {// перед тим як заборонити відправку потрібно відмінити все що відбувалось перед тим
      bleGamepad.release(i);       
    }

    
    // Відпустити кнопки Start та Select
    bleGamepad.releaseStart();
    bleGamepad.releaseSelect();

    //курки
    bleGamepad.setRightTrigger(0); 
    bleGamepad.setLeftTrigger(0);  
    
    //правий джойстик
    bleGamepad.setRZ(0); 
    bleGamepad.setZ(0);
    
    //лівий джойстик
    bleGamepad.setX(0);
    bleGamepad.setY(0);
    
    // Якщо ти використовуєш AutoReport = 0
    bleGamepad.sendReport(); 
  
  }

// Gf

void setup() {
  
  Wire.begin();
  Serial.begin(115200);
  delay(1000);
  Serial.println("Serial.println("");");
   
  //виконуємо настройки геймпада
    
    //добавити кнопку home можливо буде потрібно при підключенні до приставок
    bleGamepadConfig.setAutoReport(0);
    bleGamepadConfig.setButtonCount(8);
    bleGamepadConfig.setIncludeStart(true);
    bleGamepadConfig.setIncludeSelect(true);
    bleGamepadConfig.setIncludeHome(true);
    bleGamepadConfig.setHatSwitchCount(1);
    bleGamepadConfig.setAxesMin(-32767); 
    bleGamepadConfig.setAxesMax(32767); 
    bleGamepadConfig.setWhichAxes(1, 1, 1, 1, 1, 1, 0, 0);     
    bleGamepad.begin(&bleGamepadConfig);
  
  //
  
  // Encoder setting 
    
    enc.setFastTimeout(2000);    // Таймаут для швидкого повороту енкодера (в мс)
    enc.setType(TYPE2);
  
  //
  
  // ----------Display--------------
   
   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.clearDisplay();
   display.display();  
   
  //
 
  // запуск гороскопа
    
    mpu.initialize();
    if (!mpu.dmpInitialize()) {
      mpu.setFullScaleGyroRange(MPU6050_GYRO_FS_250);//встановлюємо максимальну чутливість
      mpu.CalibrateGyro(5);  // калібрування гіроскопа test
      Serial.println("Enabling DMP...");
      mpu.setDMPEnabled(true);  // вмикаємо DMP 
    }  
  
  //
   
   af_startAnimation();// анімація при включенні. до робити в кінці!
  
  //робота з енергонезалежною пам'яттю
    EEPROM.begin(512);
    delay(50);
    EEPROM.put(0, 1);EEPROM.commit();//test
    //af_saveToEEPROM(eeprom_initialization); //беремо збереження настройки з енергонезалежної пам'яті
  // 
   
  //настройка rgb стрічки  test 
    FastLED.addLeds<WS2812, p_led_pin_13, GRB>(leds,1);
    FastLED.setBrightness(255); // глобальна яскравість (0–255)
  //    
  
  // геймпад додатково 
    
    bgc_buttonConnectionResistor();//виконує підключення до резисторів якщо кнопка тактильна
    af_controlsCheck();//
  
  //  

  //настрою необхідні параметри для роботи ефектів  
    af_triggerLight(color_one); // встановлюємо початковий колір
    af_shotgunBolt(bolt_pin_activate); // настроюємо піни
    af_vibration(vt_pin_activate);
  //
  
  
  // EEPROM TEST
    

  //
  
   
}

void loop() {
   
   //startPerfMeasurement();
   // tick
   enc.tick();
   // Md_autoPowerOff();//    при тестах поки що не потрібно   якщо є дозвіл автоматичне відключення по завершенню часу викликається перезапуск в Gf_sendReportExecute encoderModule
   
   af_triggerShootingEffects();//постійно моніторимо функцію функція запускає ефекти після того як дається команда (дивитись вище)
    
   Gf_functionsGamepad();
   mdf_displayOutput();
   
    // display.clearDisplay();
    
    // Md_disableButton();
  
    //display.display();  
  
  //endPerfMeasurement();
  
}// void loop()