ew8zo wiki

Вы загрузили старую версию документа! Сохранив её, вы создадите новую текущую версию с этим содержимым.

код 3.45

<code>
/*
        EW8ZO Rotator Controller v3.45
        
        === ОСНОВНЫЕ ФУНКЦИИ ===
        - Автоматическая калибровка COUNTS_PER_REV (CW + CCW)
        - Режим Overlap: North 360° / South 180°
        - DX-индикатор направления (префиксы стран)
        - Chase-mode: реальное время следование за энкодером
        - Многоуровневое меню с энкодером
        - Ручная настройка CPR через меню
        
        === ЖЕЛЕЗО ===
        - Геркон на D2 (прямой подсчет импульсов в ISR)
        - Энкодер EncButton на пинах 5,6,7
        - Реле: RELAY_1 = 8 (CCW), RELAY_2 = 9 (CW)
        - START/STOP кнопка на D3 (INPUT_PULLUP)
        - LCD 16x2 I2C (0x27)
        
        === МЕНЮ ===
        1. Overlap (North/South)
        2. Correct azimuth
        3. Calibration
        4. DX Indicator ON/OFF
        5. Chase Mode
        6. Change CPR
        7. Exit
        
        === КАЛИБРОВКА v3.04 ===
        Фаза 1: Подтверждение входа (показ CPR)
        Фаза 2: Настройка CPR (энкодер + двигатель)
        Фаза 3: Сохранение CPR + финальный круг CCW до 0°
        Фаза 4: Выход в NORMAL режим
        
        === ПОСЛЕДНИЕ ИЗМЕНЕНИЯ ===
        - v3.45: Исправлен выход из Change CPR в NORMAL mode
        - v3.44: Добавлен пункт меню Change CPR для ручной настройки CPR
        - v3.43: Исправлена обработка энкодера в chase-mode во время движения
        - v3.42: Добавлен chase-mode с динамическим следованием за энкодером
        - v3.41: Исправлена синхронизация eb.counter с displayAzimuth
        - v3.40: Добавлена фильтрация чувствительности chase-mode (5°)
        - v3.39: Исправлено сохранение chase-mode в EEPROM
        - v3.38: Добавлен toggle chase-mode через энкодер в меню
        - v3.37: Исправлена логика сохранения chase-mode
        - v3.36: Добавлена поддержка chase-mode (real-time tracking)
  */
      #include <Arduino.h>
      #include <EncButton.h>
      #include <LiquidCrystal_I2C.h>
      #include <EEPROM.h>
    
      // ===== LCD и энкодер =====
      LiquidCrystal_I2C lcd(0x27, 16, 2);
      EncButton eb(5, 6, 7);
    
      // ===== Реле =====
      #define RELAY_1 8
      #define RELAY_2 9
      const bool RELAY_ACTIVE_HIGH = false;
    
      inline void relayWriteRaw(uint8_t pin, bool level) { digitalWrite(pin, level ? HIGH : LOW); }
      inline void relayWrite(uint8_t pin, bool active) {
        if (RELAY_ACTIVE_HIGH) relayWriteRaw(pin, active);
        else relayWriteRaw(pin, !active);
      }
    
      // ===== Константы =====
      const long COUNTS_PER_REV_DEFAULT = 151; 
      const unsigned long SAVE_DELAY_MS = 1000;
      const unsigned long LCD_UPDATE_MS = 100;
      const unsigned long SPLASH_MS = 2000;
      const unsigned long SAVE_DEDUP_MS = 1500;      
      const char* FW_VERSION = "3.45";
    
      // EEPROM
      const int EEPROM_ADDR_MAGIC = 0;
      const int EEPROM_ADDR_VALUE = 2; 
      const int EEPROM_ADDR_OVERLAP = 6; // адрес для настройки overlap
      const int EEPROM_ADDR_CPR = 8; // адрес для настройки CPR
      const int EEPROM_ADDR_DX = 12; // адрес для настройки DX
      const int EEPROM_ADDR_CHASE = 14;  // адрес для настройки chase-mode
      const uint16_t EEPROM_MAGIC = 0xA5A5;
    
      // ===== START/STOP кнопка =====
      const int STARTSTOP_PIN = 3;
      const unsigned long BTN_DEBOUNCE_MS = 50;
      bool startStopLastState = HIGH;
      unsigned long startStopLastChange = 0;
      bool startStopPressedHandled = false;
    
      // ===== Геркон =====
      const int REED_PIN = 2;
    
      // ===== Глобальные переменные =====
      volatile long sensor = 0;
      volatile long temp_sensor = 0;
      long prevSensor = 0;
      long prevCur = 0;  // Для точной остановки
      unsigned long lastMoveMillis = 0;
      bool movedSinceLastSave = false;
      unsigned long lastLcdMillis = 0;
    
      enum Mode {
        MODE_NORMAL,
        MODE_ADD,
        MODE_MENU,
        MODE_OVERLAP_SELECT,
        MODE_DX_SELECT,         // Новый режим: включение/выключение DX
        MODE_CHASE_SELECT,      // Новый режим: chase-mode toggle
        MODE_CPR_CHANGE,        // Новый режим: изменение CPR
        MODE_CALIB_CONFIRM,     // Новый режим: подтверждение входа в калибровку
        MODE_CALIB_MANUAL_SELECT,   // Новый режим: выбор импульсов
        MODE_CALIB_MANUAL_RUN,      // Новый режим: движение CW/CCW
        MODE_CALIB_MANUAL_DONE      // Новый режим: результат
      };
      
      // ===== Menu table structure =====
      struct MenuItem {
          const char* label;      // указатель на строку в PROGMEM
          Mode nextMode;          // режим, в который переходим
      };
      
      // Строки меню в PROGMEM
      const char menu_overlap[] PROGMEM = "Overlap";
      const char menu_change_azimuth[] PROGMEM = "Change Azimuth";
      const char menu_calibration[] PROGMEM = "Calibration";
      const char menu_dx[] PROGMEM = "DX Indicator";
      const char menu_chase[] PROGMEM = "Chase Mode";
      const char menu_cpr_change[] PROGMEM = "Change CPR";
      const char menu_exit[] PROGMEM = "Exit";
      
      const MenuItem menuItems[] PROGMEM = {
          {menu_overlap,       MODE_OVERLAP_SELECT},
          {menu_change_azimuth, MODE_ADD},
          {menu_calibration,   MODE_CALIB_MANUAL_SELECT},
          {menu_dx,            MODE_DX_SELECT},
          {menu_chase,         MODE_CHASE_SELECT},
          {menu_cpr_change,    MODE_CPR_CHANGE},
          {menu_exit,          MODE_NORMAL}
      };
      
      const uint8_t MENU_COUNT = 7;  // 7 пунктов меню
      Mode mode = MODE_NORMAL;
    
      // Overlap mode: 0 = North (360), 1 = South (180)
      int overlapMode = 0;
      int menuSelection = 1;
      
      // DX indicator enable/disable
      bool dxEnabled = true;
      int dxSelectValue = 1;  // 1 = ON, 0 = OFF
      
      // Chase-mode enable/disable
      bool chaseModeEnabled = false;
    
      // Для сохранения overlap режима во время калибровки
      int savedOverlapForCalib = 0;
    
      int addAzimuth = 1;
      
      // Для подтверждения калибровки
      int calibConfirmSelection = 0;  // 0 = Да, 1 = Нет
      bool suppressNextClick = false;
    
      bool movementActive = false;
      long movementTargetCounts = -1;
      int movementDir = 0;
    
      unsigned long savedDisplayMillis = 0;
      unsigned long lastSavedMillis = 0;
    
      // ===== Флаги направления =====
      volatile bool dirRightFlag = false;
      volatile bool dirLeftFlag  = false;
      
    
      // ===== Debug =====
      volatile unsigned long reedEvents = 0;
      volatile unsigned long lastReedTime = 0;
    
      // ===== Отображаемый азимут =====
      int displayAzimuth = 0;
    
      // ===== LCD cache =====
      int lastDisplayedAzimuth = -1;
      int lastDisplayedNew = -1;
      int lastDisplayedAddAzimuth = -1;
      Mode lastDisplayedMode = MODE_NORMAL;
      int lastMenuSelection = -1;
      int lastOverlapMode = -1;
      bool lastDxEnabled = false;  // ← добавляем для отслеживания изменений
      bool lastMovementActive = false;
      int lastMovementDir = 0;
      // ===== Calibration variables =====
      long countsPerRev = COUNTS_PER_REV_DEFAULT;
    
      
      // ===== Manual calibration variables =====
      long manualTargetCounts;   // желаемое CPR
      
    
      // ===== DX direction table tuned for KO52mk, refined =====
      struct Sector {
        int16_t azMin;
        int16_t azMax;
        char prefix[4];   // храним сам текст, НЕ указатель
      };
    
      const Sector dirSectors[] PROGMEM = {
    
        // --- 0–50: Океания ---
        {  0,   4,  "FO"  },
        {  5,  12,  "KH6" },
        { 16,  22,  "E5"  },
        { 49,  54,  "C21" },
    
        // --- Азия / Тихий океан ---
        { 54,  66,  "JA"  },
        { 59,  67,  "UA9" },
        { 68,  84,  "BY"  },
        { 80,  88,  "ZL"  },
        { 94,  98,  "HS"  },
        {102, 108,  "YB"  },
        {113, 121,  "VU"  },
    
        // --- Middle East ---
        {140, 145,  "A4"  },
    
        // --- Africa ---
        {167, 175,  "5H"  },
        {186, 194,  "ZS"  },
    
        // --- South America ---
        {238, 247,  "PY"  },
        {248, 253,  "CX"  },
        {254, 261,  "CE"  },
    
        // --- Atlantic / Azores ---
        {268, 274,  "CU"  },
    
        // --- Central Europe ---
        {269, 273,  "DL"  },
        {259, 263,  "OK"  },
        {246, 250,  "OM"  },
        {278, 283,  "SP"  },
    
        // --- UK ---
        {284, 288,  "G"   },
    
        // --- North America ---
        {311, 319,  "W"   },
        {331, 339,  "VE"  },
    
        // --- Northern Europe ---
        {307, 313,  "LY"  },
        {332, 342,  "ES"  },
        {340, 349,  "OH"  },
        {350, 359,  "SM"  }
      };
    
      const uint8_t DIR_SECTORS_COUNT = sizeof(dirSectors) / sizeof(dirSectors[0]);
    
      void printDXPrefixToLCD(int az, LiquidCrystal_I2C& lcd) {
        for (uint8_t i = 0; i < DIR_SECTORS_COUNT; i++) {
          Sector s;
          memcpy_P(&s, &dirSectors[i], sizeof(Sector));
      
          if (az >= s.azMin && az <= s.azMax) {
            lcd.print(s.prefix);
            return;
          }
        }
        lcd.print("   ");
      }
      
      // Совместимость для старого кода
      const char* getDXPrefix(int az) {
        static char prefixBuf[4];
        
        for (uint8_t i = 0; i < DIR_SECTORS_COUNT; i++) {
          Sector s;
          memcpy_P(&s, &dirSectors[i], sizeof(Sector));
      
          if (az >= s.azMin && az <= s.azMax) {
            strcpy(prefixBuf, s.prefix);
            return prefixBuf;
          }
        }
        strcpy(prefixBuf, "   ");
        return prefixBuf;
      }

// ===== EEPROM helpers =====
      void savePositionToEEPROM(long val) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) EEPROM.put(EEPROM_ADDR_MAGIC, EEPROM_MAGIC);
        long stored; EEPROM.get(EEPROM_ADDR_VALUE, stored);
        if (stored != val) EEPROM.put(EEPROM_ADDR_VALUE, val);
        lastSavedMillis = millis();
      }
    
      bool loadPositionFromEEPROM(long &outVal) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) return false;
        EEPROM.get(EEPROM_ADDR_VALUE, outVal);
        return true;
      }
    
      void saveOverlapModeToEEPROM(int mode) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) EEPROM.put(EEPROM_ADDR_MAGIC, EEPROM_MAGIC);
        int stored; EEPROM.get(EEPROM_ADDR_OVERLAP, stored);
        if (stored != mode) EEPROM.put(EEPROM_ADDR_OVERLAP, mode);
      }
    
      bool loadOverlapModeFromEEPROM(int &outMode) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) return false;
        EEPROM.get(EEPROM_ADDR_OVERLAP, outMode);
        return true;
      }
    
      bool loadCPRFromEEPROM(long &outCPR) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) return false;
        EEPROM.get(EEPROM_ADDR_CPR, outCPR);
        return true;
      }
      
      // ===== DX setting EEPROM helpers =====
      void saveDXSettingToEEPROM(bool enabled) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) EEPROM.put(EEPROM_ADDR_MAGIC, EEPROM_MAGIC);
        bool stored; EEPROM.get(EEPROM_ADDR_DX, stored);
        if (stored != enabled) EEPROM.put(EEPROM_ADDR_DX, enabled);
      }
      
      bool loadDXSettingFromEEPROM(bool &outEnabled) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) return false;
        EEPROM.get(EEPROM_ADDR_DX, outEnabled);
        return true;
      }
      
      // ===== Chase-mode EEPROM helpers =====
      void saveChaseModeToEEPROM(bool enabled) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) EEPROM.put(EEPROM_ADDR_MAGIC, EEPROM_MAGIC);
        // Always save current value
        EEPROM.put(EEPROM_ADDR_CHASE, enabled);
        Serial.print(F("EEPROM: Chase-mode saved as "));
        Serial.println(enabled ? F("ON") : F("OFF"));
      }
      
      bool loadChaseModeFromEEPROM(bool &outEnabled) {
        uint16_t magic; EEPROM.get(EEPROM_ADDR_MAGIC, magic);
        if (magic != EEPROM_MAGIC) return false;
        EEPROM.get(EEPROM_ADDR_CHASE, outEnabled);
        return true;
      }

// ===== Conversions =====
      int roundToMultipleOf5(int value) {
          // нормализуем в диапазон 1..360
          if (value <= 0) value = 1;
          if (value > 360) value = ((value - 1) % 360) + 1;

int mod = value % 5;
          int base = value - mod;

if (mod == 1 || mod == 2) return base;       // округляем вниз
          if (mod == 3 || mod == 4) return base + 5;   // округляем вверх
          return base;                                  // если делится на 5 — оставляем
      }
      
      // ===== LCD timer reset =====
      void resetLcdTimer() {
          lastLcdMillis = 0;
      }
    
      int countsToAzimuth(long counts) {
          if (countsPerRev < 10) return 0;  // защита от деления на 0

// нормализуем в диапазон 0..countsPerRev-1
          long c = counts % countsPerRev;
          if (c < 0) c += countsPerRev;

// классическое округление до ближайшего целого градуса
          long degTimes10 = (c * 3600L) / countsPerRev;  // умножаем на 10, чтобы учесть десятые
          int az = (int)((degTimes10 + 5) / 10);        // +5 → округление: 0.5 → вверх

if (az == 0) az = 360;  // 0° → 360°
          return az;
      }
    
    
      long azimuthToCounts(int az) {
        int a = az % 360;
        long c = ((long)a * countsPerRev + 180) / 360;
        if (az == 360) c = 0;
        c = c % countsPerRev;
        if (c < 0) c += countsPerRev;
        return c;
      }
    
        
    int shortestTurnDirection(int curAz, int tgtAz) {
          // === 1. Калибровка — всегда кратчайший путь ===
          if (mode == MODE_CALIB_MANUAL_RUN)
              return (tgtAz - curAz > 0 ? +1 : -1);
      
          // === 2. Переводим в counts ===
          long cur = sensor % countsPerRev;
          if (cur < 0) cur += countsPerRev;
      
          long tgt = azimuthToCounts(tgtAz);
      
          long diff = tgt - cur;
      
          // нормализация разницы в диапазон -CPR/2 .. +CPR/2
          if (diff > countsPerRev / 2) diff -= countsPerRev;
          if (diff < -countsPerRev / 2) diff += countsPerRev;
      
          int dirShort = (diff > 0) ? +1 : -1;
      
          // === 3. Если overlap выключен — просто кратчайший путь ===
          if (overlapMode == -1)
              return dirShort;
      
          // === 4. OVERLAP = NORTH (360°) ===
          if (overlapMode == 0) {
              if (dirShort > 0) {
                  if (cur > tgt) return -1;
              } else {
                  if (cur < tgt) return +1;
              }
              return dirShort;
          }
      
          // === 5. OVERLAP = SOUTH (180°) ===
          if (overlapMode == 1) {
              if (dirShort > 0) {
                  if (curAz < 180 && tgtAz > 180) return -1;
              } else {
                  if (curAz > 180 && tgtAz < 180) return +1;
              }
              return dirShort;
          }
      
          return dirShort;
      }

// ===== Target check ===== 
      bool isTargetReached(int currentAz, int targetAz, int dir) {
        long curCounts = sensor % countsPerRev;
        if (curCounts < 0) curCounts += countsPerRev;
    
        long tgtCounts = azimuthToCounts(targetAz);
    
        long diff = tgtCounts - curCounts;
    
        // нормализация разницы в диапазон -CPR/2 .. +CPR/2
        if (diff > countsPerRev / 2) diff -= countsPerRev;
        if (diff < -countsPerRev / 2) diff += countsPerRev;
        return diff == 0;
    }
    
    
      // ===== Interrupt control =====
      void enableReedInterrupt() {
        attachInterrupt(digitalPinToInterrupt(REED_PIN), reedISR, FALLING);
      }
    
      void disableReedInterrupt() {
        detachInterrupt(digitalPinToInterrupt(REED_PIN));
      }
    
      // ===== Motor control =====
      void motorForward() {
        Serial.println(F("DIR = CW"));
        disableReedInterrupt();
        relayWrite(RELAY_1, false);
        relayWrite(RELAY_2, false);
        delay(50);
        relayWrite(RELAY_2, true);
    
        dirRightFlag = true;
        dirLeftFlag = false;
        movementActive = true;
    
        enableReedInterrupt();
        Serial.println(F("Motor: FORWARD (RELAY_2 ON)"));
      }
    
      void motorBackward() {
        Serial.println(F("DIR = CCW"));
        disableReedInterrupt();
        relayWrite(RELAY_1, false);
        relayWrite(RELAY_2, false);
        delay(50);
        relayWrite(RELAY_1, true);
    
        dirRightFlag = false;
        dirLeftFlag = true;
        movementActive = true;
    
        enableReedInterrupt();
        Serial.println(F("Motor: BACKWARD (RELAY_1 ON)"));
      }
    
      void motorStop() {
        disableReedInterrupt();
        relayWrite(RELAY_1, false);
        relayWrite(RELAY_2, false);
        delay(50);
    
        movementActive = false;
        dirRightFlag = false;
        dirLeftFlag = false;
    
        Serial.println(F("Motor: STOP"));
      }
    
      // ===== Movement control =====
      void stopMovement() {
        motorStop();
    
        noInterrupts();
        long cur = sensor;
        interrupts();
    
        if (millis() - lastSavedMillis > SAVE_DEDUP_MS) {
          savePositionToEEPROM(cur);
          Serial.println(F("STOP: position saved"));
        } else {
          Serial.println(F("STOP: save skipped (recent)"));
        }
    
        savedDisplayMillis = millis();
        movementDir = 0;
    
        // === ДОБАВЛЕНО: корректная обработка STOP в калибровке ===
        if (mode == MODE_CALIB_MANUAL_RUN) {
            mode = MODE_CALIB_MANUAL_SELECT;
            
            resetLcdTimer();
            return;  // ← ВАЖНО: не выполнять код ниже
        }
    
        // === обычный режим ===
        int azimuth = countsToAzimuth(cur);
        eb.counter = roundToMultipleOf5(azimuth);
        
    }
    
    
      void startMovementTo(int targetAzimuth) {
        if (movementActive) return;
    
        // Калибровка — отдельная логика
        if (mode == MODE_CALIB_MANUAL_RUN) {
            if (movementDir > 0) motorForward();
            else motorBackward();
            return;
        }
    
        noInterrupts();
        long cur = sensor;
        interrupts();
    
        // Переводим градусы → импульсы
        long targetCounts = azimuthToCounts(targetAzimuth);
        
        // Определяем направление с учетом overlap
        int curAz = countsToAzimuth(cur);
        int dir = shortestTurnDirection(curAz, targetAzimuth);
    
        movementTargetCounts = targetCounts;
        movementDir = dir;
        prevCur = cur;
    
        if (dir > 0) motorForward();
        else motorBackward();
    
        Serial.print(F("START movement: targetCounts="));
        Serial.print(targetCounts);
        Serial.print(F(" cur="));
        Serial.print(cur);
        Serial.print(F(" dir="));
        Serial.println((dir > 0) ? F("CW") : F("CCW"));
      }
    
      // ===== ISR геркона =====
        void reedISR() {
          static unsigned long lastUs = 0;
          unsigned long now = micros();
      
          // Фильтр дребезга
          if (now - lastUs < 3000) return;
          unsigned long delta = now - lastUs;
          lastUs = now;
      
          if (!movementActive) return;
      
          // Направление
          int dir = 0;
          if (dirRightFlag) {
              if (sensor < 1000000) sensor++;
              dir = +1;
          } else if (dirLeftFlag) {
              if (sensor > -1000000) sensor--;
              dir = -1;
          }
    
          // Нормализация выполняется только при отображении, не здесь
          
          // Sensor debug disabled for production      
      }
    
    
      // ===== Setup =====
      void setup() {
          
    
        delay(10);
    
        Serial.begin(115200);
        Serial.println(F("=== CONTROLLER START ==="));
    
        // Reed sensor
        pinMode(REED_PIN, INPUT_PULLUP);
        
    
        // Relays
        pinMode(RELAY_1, OUTPUT);
        pinMode(RELAY_2, OUTPUT);
        if (RELAY_ACTIVE_HIGH) {
          relayWriteRaw(RELAY_1, LOW);
          relayWriteRaw(RELAY_2, LOW);
        } else {
          relayWriteRaw(RELAY_1, HIGH);
          relayWriteRaw(RELAY_2, HIGH);
        }
        //motorStop();
        dirRightFlag = false; dirLeftFlag = false; movementActive = false;
    
        // START/STOP button
        pinMode(STARTSTOP_PIN, INPUT_PULLUP);
        startStopLastState = digitalRead(STARTSTOP_PIN);
        startStopLastChange = millis();
    
        // LCD
        lcd.begin();
        lcd.backlight();
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print(F("EW8ZO Rotator"));
        lcd.setCursor(0,1);
        lcd.print(F("VER. "));
        lcd.print(FW_VERSION);
        delay(SPLASH_MS);
        lcd.clear();
    
        // Encoder
        eb.setBtnLevel(LOW);
        eb.setClickTimeout(800);
        eb.setDebTimeout(8);
        eb.setHoldTimeout(1500);
        eb.setEncType(EB_STEP4_LOW);
        eb.setEncReverse(0);
        eb.setFastTimeout(10);
        eb.counter = 0;
    
        // Load saved position
        long saved = 0;
        if (loadPositionFromEEPROM(saved)) {
          noInterrupts();
          sensor = saved;
          interrupts();
          Serial.print("Loaded pos counts: ");
          Serial.println(saved);
          lastSavedMillis = millis();
        } else {
          Serial.println(F("No saved pos in EEPROM"));
        }
    
        // Load overlap mode
        int savedOverlap = 0;
        if (loadOverlapModeFromEEPROM(savedOverlap)) {
          if (savedOverlap < -1 || savedOverlap > 1)
              overlapMode = -1;
          else
              overlapMode = savedOverlap;

Serial.print("Loaded overlap mode: ");
          if (overlapMode == -1) Serial.println(F("OFF"));
            else if (overlapMode == 0) Serial.println(F("North 360"));
            else if (overlapMode == 1) Serial.println(F("South 180"));

} else {
            overlapMode = 0;
            Serial.println(F("OFF"));
          }
    
        // Load CPR
        long savedCPR = 0;
        if (loadCPRFromEEPROM(savedCPR)) {
          if (savedCPR > 50 && savedCPR < 2000) {
            countsPerRev = savedCPR;
            Serial.print("Loaded CPR: ");
            Serial.println(countsPerRev);
          } else {
            countsPerRev = COUNTS_PER_REV_DEFAULT;
            Serial.println(F("Invalid CPR in EEPROM, using default"));
          }
        } else {
          countsPerRev = COUNTS_PER_REV_DEFAULT;
          Serial.println(F("No CPR in EEPROM, using default"));
        }
        
        // Load DX setting
        bool savedDX = true;
        if (loadDXSettingFromEEPROM(savedDX)) {
          dxEnabled = savedDX;
          dxSelectValue = dxEnabled ? 1 : 0;  // синхронизируем
          Serial.print("Loaded DX setting: ");
          Serial.println(dxEnabled ? "ON" : "OFF");
        } else {
          dxEnabled = true;
          dxSelectValue = 1;
          Serial.println(F("No DX setting in EEPROM, using default ON"));
        }
        
        // Load Chase-mode setting
        bool savedChase = false;
        if (loadChaseModeFromEEPROM(savedChase)) {
          chaseModeEnabled = savedChase;
          Serial.print(F("Loaded Chase-mode: "));
          Serial.println(chaseModeEnabled ? F("ON") : F("OFF"));
        } else {
          chaseModeEnabled = false;
          Serial.println(F("No Chase-mode in EEPROM, using default OFF"));
        }
    
        // Initial azimuth
        noInterrupts();
        int azimuth = countsToAzimuth(sensor);
        interrupts();
    
        displayAzimuth = (azimuth / 5) * 5;
        if (displayAzimuth <= 0) displayAzimuth = 360;
        eb.counter = displayAzimuth;
    
        lastLcdMillis = millis();
    
        Serial.print("Controller v");
        Serial.print(FW_VERSION);
        Serial.println(F(" started"));
    
        Serial.print("Initial Azimuth=");
        Serial.print(azimuth);
        Serial.print(" displayAzimuth=");
        Serial.println(displayAzimuth);
    
        Serial.print("CPR=");
        Serial.println(countsPerRev);
    
        attachInterrupt(digitalPinToInterrupt(REED_PIN), reedISR, FALLING);
      }
    
      // ===== Main loop =====
      void loop() {
        eb.tick();
      
        // ===== Encoder events (single read per loop) =====
        bool encTurn  = eb.turn();
        bool encClick = eb.click();
        int  encDir   = eb.dir();
    
        static int lastReed = HIGH;
        int cur = digitalRead(REED_PIN);
        if (cur != lastReed) {    
        lastReed = cur;
        }
            
        // Global STOP block REMOVED - was causing race conditions

// START/STOP кнопка — ТОЛЬКО STOP и ТОЛЬКО ВО ВРЕМЯ ДВИЖЕНИЯ
        bool curState = digitalRead(STARTSTOP_PIN);
        if (curState != startStopLastState) {
          startStopLastChange = millis();
          startStopLastState = curState;
          startStopPressedHandled = false;
        } else {
          if (!startStopPressedHandled && 
              (millis() - startStopLastChange) > BTN_DEBOUNCE_MS) {
      
              if (curState == LOW && movementActive) {
                  stopMovement();
                  suppressNextClick = true;
                  resetLcdTimer();
              }
      
              startStopPressedHandled = true;
          }
        }
    
        // Вход в MENU при удержании энкодера
        if (eb.hold() && mode == MODE_NORMAL && !movementActive) {
          mode = MODE_MENU;
          menuSelection = 1;  // Универсальный сброс - меню всегда начинается с пункта 1
          suppressNextClick = false;
          resetLcdTimer();
        }

// Track actual sensor value for consistency
          prevSensor = sensor;

// Отслеживание изменений sensor
        if (sensor != temp_sensor) {
          Serial.print("SENSOR CHANGE: "); 
          Serial.print(temp_sensor); 
          Serial.print(" -> "); 
          Serial.println(sensor);
          
          // ЗАЩИТА ОТ ПЕРЕПОЛНЕНИЯ 
          if (sensor > 1000000 || sensor < -1000000) { 
            sensor = 0; 
            Serial.println(F("Sensor overflow detected — reset to 0"));
          }
          temp_sensor = sensor;
          lastMoveMillis = millis();
          movedSinceLastSave = true;
        }
    
        // ===== Movement target check (IMPULSE-BASED STOP) =====
        if (movementActive && mode == MODE_NORMAL) {
            noInterrupts();
            long cur = sensor;
            interrupts();
            
            // === Chase-mode logic ===
            if (chaseModeEnabled) {
                // обновляем цель на лету
                long newTarget = azimuthToCounts(displayAzimuth);
                
                // если цель изменилась — пересчитать направление
                if (newTarget != movementTargetCounts) {
                    movementTargetCounts = newTarget;
                    
                    long diff = (movementTargetCounts - cur + countsPerRev) % countsPerRev;
                    int newDir = (diff <= countsPerRev / 2) ? +1 : -1;
                    
                    if (newDir != movementDir) {
                        Serial.print(F("CHASE: Direction change "));
                        Serial.print(movementDir > 0 ? F("CW") : F("CCW"));
                        Serial.print(F(" → "));
                        Serial.println(newDir > 0 ? F("CW") : F("CCW"));
                        
                        motorStop();
                        movementDir = newDir;
                        if (movementDir > 0) motorForward();
                        else motorBackward();
                    }
                }
            }
            
            // Нормализованная разница
            long diff = (movementTargetCounts - cur + countsPerRev) % countsPerRev;
            
            // CW
            if (movementDir > 0) {
                if (diff == 0 || prevCur > cur) {
                    Serial.println(F("STOPPING: Target reached (CW, impulse-based)"));
                    stopMovement();
                    resetLcdTimer();
                }
            }
            // CCW
            else {
                if (diff == 0 || prevCur < cur) {
                    Serial.println(F("STOPPING: Target reached (CCW, impulse-based)"));
                    stopMovement();
                    resetLcdTimer();
                }
            }
            
            prevCur = cur;
        }

// ===== EEPROM save after movement =====
        if (movedSinceLastSave && (millis() - lastMoveMillis >= SAVE_DELAY_MS)) {
          if (millis() - lastSavedMillis > SAVE_DEDUP_MS) {
            noInterrupts(); long toSave = sensor; interrupts();
            savePositionToEEPROM(toSave);
            movedSinceLastSave = false;
            savedDisplayMillis = millis();
    
            int newAz = countsToAzimuth(toSave);
            //eb.counter = roundToMultipleOf5(newAz);
            resetLcdTimer();
          } else movedSinceLastSave = false;
        }
        
        // =====================================================================
        // ========================= ENCODER TURN ===============================
        // =====================================================================
        
        // ===== TURN (общий) =====
        static unsigned long lastTurnMs = 0;
        if (encTurn) {
            unsigned long now = millis();
            unsigned long dt = now - lastTurnMs;
            lastTurnMs = now;
            int dir = encDir;
                  
            // ===== Special handling for chase-mode during movement =====
            if (mode == MODE_NORMAL && movementActive && chaseModeEnabled) {
                displayAzimuth += dir * 5;
                while (displayAzimuth <= 0) displayAzimuth += 360;
                displayAzimuth = ((displayAzimuth - 1) % 360) + 1;
                          
                eb.counter = displayAzimuth;
                resetLcdTimer();
            }
                      
            else if (mode == MODE_NORMAL) {
                if (!movementActive) {
                    displayAzimuth += dir * 5;
                    while (displayAzimuth <= 0) displayAzimuth += 360;
                    displayAzimuth = ((displayAzimuth - 1) % 360) + 1;
                    eb.counter = displayAzimuth;
                    resetLcdTimer();
                }
            }
        
            else if (mode == MODE_ADD) {
                int baseStep = 5;
                int mult = (dt < 30) ? 20 : (dt < 80 ? 5 : 1);
                int delta = dir * baseStep * mult;
        
                addAzimuth += delta;
                while (addAzimuth <= 0) addAzimuth += 360;
                addAzimuth = ((addAzimuth - 1) % 360) + 1;
                resetLcdTimer();
            }
        
            else if (mode == MODE_MENU) {
                menuSelection += dir;
                if (menuSelection < 0) menuSelection = MENU_COUNT - 1;
                if (menuSelection >= MENU_COUNT) menuSelection = 0;
                suppressNextClick = false;
                resetLcdTimer();
            }
        
            else if (mode == MODE_OVERLAP_SELECT) {
                if (dir > 0) {
                    overlapMode++;
                    if (overlapMode > 1) overlapMode = -1;
                } else {
                    overlapMode--;
                    if (overlapMode < -1) overlapMode = 1;
                }
                resetLcdTimer();
            }
            
            else if (mode == MODE_DX_SELECT) {
                if (dir > 0) {
                    dxSelectValue++;
                    if (dxSelectValue > 1) dxSelectValue = 0;
                } else {
                    dxSelectValue--;
                    if (dxSelectValue < 0) dxSelectValue = 1;
                }
                dxEnabled = (dxSelectValue == 1);
                resetLcdTimer();
            }
            
            else if (mode == MODE_CHASE_SELECT) {
                // Изменяем угол шагами по 5° (как везде)
                displayAzimuth += dir * 5;
                while (displayAzimuth <= 0) displayAzimuth += 360;
                displayAzimuth = ((displayAzimuth - 1) % 360) + 1;
                eb.counter = displayAzimuth;
                suppressNextClick = false;
                resetLcdTimer();
            }
            
            else if (mode == MODE_CPR_CHANGE) {
                // Изменяем CPR шагами по 1
                countsPerRev += dir;
                if (countsPerRev < 10) countsPerRev = 10;
                if (countsPerRev > 2000) countsPerRev = 2000;
                resetLcdTimer();
            }

}
    
      // =====================================================================
    // =================== CALIBRATION: SELECT ==============================
    // =====================================================================
    
    if (mode == MODE_CALIB_MANUAL_SELECT) {
    
        // Поворот энкодера — меняем CPR (только положительные значения)
        if (encTurn) {
            manualTargetCounts += encDir;
            if (manualTargetCounts < 10) manualTargetCounts = 10;
            if (manualTargetCounts > 2000) manualTargetCounts = 2000;
            resetLcdTimer();
        }
    
        // Клик — запускаем движение
        if (encClick) {
    
            noInterrupts();
            long cur = sensor;
            interrupts();
    
            if (manualTargetCounts > cur) {
                movementDir = +1;
                motorForward();
                Serial.println(F("CALIB: Moving CW to reach target CPR"));
            }
            else if (manualTargetCounts < cur) {
                movementDir = -1;
                motorBackward();
                Serial.println(F("CALIB: Moving CCW to reach target CPR"));
            }
            else {
                // CPR == sensor → сразу DONE
                mode = MODE_CALIB_MANUAL_DONE;
                resetLcdTimer();
                return;
            }
    
            movementActive = true;
            mode = MODE_CALIB_MANUAL_RUN;
            resetLcdTimer();
        }
    }
    
    
    
          // =====================================================================
    // =================== CALIBRATION: RUN ================================
    // =====================================================================
    
    if (mode == MODE_CALIB_MANUAL_RUN && movementActive) {
    
        noInterrupts();
        long cur = sensor;
        interrupts();
    
        // === Обычный RUN: едем к CPR ===
        if (manualTargetCounts > 0) {
    
            // Отладка условия остановки
            bool shouldStop = false;
            if (movementDir > 0) {
                shouldStop = (cur >= manualTargetCounts);
                if (shouldStop) {
                    Serial.print(F("CALIB STOP: CW cur="));
                    Serial.print(cur);
                    Serial.print(F(" target="));
                    Serial.println(manualTargetCounts);
                }
            } else if (movementDir < 0) {
                shouldStop = (cur <= manualTargetCounts);
                if (shouldStop) {
                    Serial.print(F("CALIB STOP: CCW cur="));
                    Serial.print(cur);
                    Serial.print(F(" target="));
                    Serial.println(manualTargetCounts);
                }
            }
            
            if (shouldStop) {
                motorStop();
                movementActive = false;
                mode = MODE_CALIB_MANUAL_DONE;
                resetLcdTimer();
            }
        }
    
        // === Финальный CCW круг до нуля (только после сохранения CPR) ===
        else if (manualTargetCounts == 0 && movementDir < 0) {
                
            // Останавливаемся точно на 0
            // (обнаруживаем переход через ноль)
            static long prevCalibCur = cur;
            bool shouldStop = (cur > prevCalibCur) || (cur == 0);  
            
            // Отладка финального круга
            if (shouldStop) {
                Serial.print(F("CALIB FINAL STOP: cur="));
                Serial.print(cur);
                Serial.print(F(" prev="));
                Serial.print(prevCalibCur);
                if (cur > prevCalibCur) Serial.println(F(" (wrap detected)"));
                else Serial.println(F(" (near zero)"));
            }
            
            prevCalibCur = cur;
                
            if (shouldStop) {
          
                motorStop();
                movementActive = false;
          
                // Не сбрасываем sensor=0 в режиме калибровки!
                // Это делается только после сохранения CPR
                Serial.println(F("CALIB: Full circle completed, exiting to NORMAL mode"));
          
                mode = MODE_NORMAL;
                suppressNextClick = true;
                resetLcdTimer();
            }
        }
    }
    
    
    
        /// =====================================================================
    // =================== CALIBRATION: DONE ===============================
    // =====================================================================
    
    if (mode == MODE_CALIB_MANUAL_DONE) {
    
        // Поворот энкодера → возвращаемся в SELECT
        if (encTurn) {
            manualTargetCounts += encDir;
            if (manualTargetCounts < 10) manualTargetCounts = 10;
            if (manualTargetCounts > 2000) manualTargetCounts = 2000;
    
            mode = MODE_CALIB_MANUAL_SELECT;
            resetLcdTimer();
        }
    
        // Клик → сохранить CPR → CCW полный круг → ноль → NORMAL
        if (encClick) {
    
            // 1. Сохраняем CPR
            countsPerRev = manualTargetCounts;
            EEPROM.put(EEPROM_ADDR_CPR, countsPerRev);
            Serial.print(F("CALIB: CPR saved to EEPROM: "));
            Serial.println(countsPerRev);
    
            // 2. Запускаем CCW полный круг
            movementDir = -1;
            movementActive = true;
            motorBackward();
            Serial.println(F("CALIB: Starting CCW full circle to zero"));
    
            // 3. RUN будет вести до sensor=0
            manualTargetCounts = 0;
    
            mode = MODE_CALIB_MANUAL_RUN;
            resetLcdTimer();
        }
    }
    
        
    
    
        // ===== MENU click =====
        if (mode == MODE_MENU && encClick && !suppressNextClick) {
            // Получаем режим из таблицы
            Mode nextMode;
            memcpy_P(&nextMode, &menuItems[menuSelection].nextMode, sizeof(Mode));
        
            mode = nextMode;
            suppressNextClick = true;
            
            // Special handling for certain modes
            if (mode == MODE_ADD) {
                noInterrupts(); int azimuth = countsToAzimuth(sensor); interrupts();
                addAzimuth = roundToMultipleOf5(azimuth);
            }
            else if (mode == MODE_CALIB_CONFIRM) {
                eb.reset();
                
                // Показываем текущее CPR и спрашиваем подтверждение
                manualTargetCounts = countsPerRev;
                if (manualTargetCounts < 10 || manualTargetCounts > 2000)
                    manualTargetCounts = 100;
                
                // Сброс sensor в 0 при отсутствии сохраненного CPR
                if (countsPerRev == COUNTS_PER_REV_DEFAULT) {
                    noInterrupts();
                    sensor = 0;
                    temp_sensor = 0;
                    prevSensor = 0;
                    interrupts();
                    Serial.println(F("CALIB: Reset sensor to 0 for initial calibration"));
                }
                
                calibConfirmSelection = 0;
                movementActive = false;
                movementDir = 0;
                movementTargetCounts = -1;
            }
            else if (mode == MODE_DX_SELECT) {
                lastDxEnabled = !dxEnabled;
                lastDisplayedMode = (Mode)-1;
            }
            else if (mode == MODE_NORMAL) {
                eb.counter = roundToMultipleOf5(eb.counter);
            }
            
            resetLcdTimer();
        }
    
        // ===== CHASE_SELECT click =====
        if (mode == MODE_CHASE_SELECT && encClick) {
          if (suppressNextClick) suppressNextClick = false;
          else {
            // По образцу DX - сохраняем текущее значение
            saveChaseModeToEEPROM(chaseModeEnabled);
            mode = MODE_NORMAL;
            suppressNextClick = true;
            
            Serial.print(F("Chase-mode: "));
            Serial.println(chaseModeEnabled ? F("ON") : F("OFF"));
            
            // Force LCD update
            lastDisplayedMode = (Mode)-1;
            lastMenuSelection = -1;
            resetLcdTimer();
          }
        }
        
        // ===== CPR_CHANGE click =====
        if (mode == MODE_CPR_CHANGE && encClick) {
          if (suppressNextClick) suppressNextClick = false;
          else {
            // Сохраняем CPR в EEPROM
            EEPROM.put(EEPROM_ADDR_CPR, countsPerRev);
            mode = MODE_NORMAL;
            suppressNextClick = true;
            
            Serial.print(F("CPR saved: "));
            Serial.println(countsPerRev);
            
            // Force LCD update
            lastDisplayedMode = (Mode)-1;
            lastMenuSelection = -1;
            resetLcdTimer();
          }
        }
        
        // ===== OVERLAP_SELECT click =====
        if (mode == MODE_OVERLAP_SELECT && encClick) {
          if (suppressNextClick) suppressNextClick = false;
          else {
            EEPROM.put(EEPROM_ADDR_OVERLAP, overlapMode);
            mode = MODE_NORMAL;
            suppressNextClick = true;
            resetLcdTimer();
          }
        }
        
        // ===== CALIB_CONFIRM encoder turn =====
        if (mode == MODE_CALIB_CONFIRM) {
            if (encTurn) {
                calibConfirmSelection += encDir;
                if (calibConfirmSelection < 0) calibConfirmSelection = 1;
                if (calibConfirmSelection > 1) calibConfirmSelection = 0;
                suppressNextClick = false;
                resetLcdTimer();
            }
            
            // ===== CALIB_CONFIRM click =====
            if (encClick) {
                if (suppressNextClick) suppressNextClick = false;
                else {
                    if (calibConfirmSelection == 0) {
                        // Да - переходим к настройке CPR
                        mode = MODE_CALIB_MANUAL_SELECT;
                    } else {
                        // Нет - возвращаемся в меню
                        mode = MODE_MENU;
                        menuSelection = 4; // Остаемся на пункте калибровки
                    }
                    suppressNextClick = true;
                    resetLcdTimer();
                }
            }
        }
        
        // ===== DX_SELECT click =====
        if (mode == MODE_DX_SELECT && encClick) {
          if (suppressNextClick) suppressNextClick = false;
          else {
            saveDXSettingToEEPROM(dxEnabled);  // сохраняем в EEPROM только при клике
            mode = MODE_NORMAL;
            suppressNextClick = true;
            resetLcdTimer();
          }
        }
    
        // ===== Normal mode encoder click =====
        if (mode == MODE_NORMAL && encClick) {
    
            if (suppressNextClick) {
                suppressNextClick = false;
                return;
            }
    
            // === 1. ЕСЛИ ДВИЖЕНИЕ → STOP ===
            if (movementActive) {
                stopMovement();
                resetLcdTimer();
                return;
            }
    
            // === 2. ПОКОЙ → возможный START ===
            noInterrupts();
            long curSensor = sensor;
            interrupts();
    
            int curAz = countsToAzimuth(curSensor);
            int desiredAz = eb.counter;
    
            if (desiredAz <= 0) desiredAz = 1;
            if (desiredAz > 360)
                desiredAz = ((desiredAz - 1) % 360) + 1;
    
            // кратчайшая разница
            int diff = abs(desiredAz - curAz);
            if (diff > 180) diff = 360 - diff;
    
            // === ПОРОГ 5° ===
            if (diff >= 5) {
                startMovementTo(desiredAz);
            }
    
            resetLcdTimer();
        }
    
        // ===== ADD click =====
        if (mode == MODE_ADD && encClick) {
          if (suppressNextClick) suppressNextClick = false;
          else {
            long newCounts = azimuthToCounts(addAzimuth);
            noInterrupts(); sensor = newCounts; interrupts();
    
            if (millis() - lastSavedMillis > SAVE_DEDUP_MS)
              savePositionToEEPROM(newCounts);
    
            eb.counter = roundToMultipleOf5(addAzimuth);
            mode = MODE_NORMAL;
            suppressNextClick = true;
            savedDisplayMillis = millis();
            resetLcdTimer();
            displayAzimuth = addAzimuth;
          }
        }
        
        // === LCD cache reset when entering NORMAL ===
        if (mode == MODE_NORMAL && lastDisplayedMode != MODE_NORMAL) {
            lastDisplayedMode = (Mode)-1;
            lastDisplayedAzimuth = -1;
            lastDisplayedNew = -1;
            lastDisplayedAddAzimuth = -1;
        }
        
        // === LCD cache reset when entering DX SELECT ===
        if (mode == MODE_DX_SELECT && lastDisplayedMode != MODE_DX_SELECT) {
            lastDxEnabled = !dxEnabled;  // гарантируем needUpdate
        }

// =====================================================================
        // =========================== LCD UPDATE ===============================
        // =====================================================================
    
        if (millis() - lastLcdMillis >= LCD_UPDATE_MS) {
          lastLcdMillis = millis();
    
          noInterrupts();
          long curSensor = sensor;
          interrupts();
    
          int azimuth = countsToAzimuth(curSensor);
    
          bool needUpdate = false;
    
          if (mode != lastDisplayedMode) {
            needUpdate = true;
            // lastDisplayedMode обновляется ПОСЛЕ успешной отрисовки LCD (строка 1270)
          }
    
          if (mode == MODE_MENU) {
            if (menuSelection != lastMenuSelection) {
              needUpdate = true;
              lastMenuSelection = menuSelection;
            }
          }
    
          else if (mode == MODE_OVERLAP_SELECT) {
            if (overlapMode != lastOverlapMode) {
              needUpdate = true;
              lastOverlapMode = overlapMode;
            }
          }
          
          else if (mode == MODE_DX_SELECT) {
            if (dxEnabled != lastDxEnabled) {  // отслеживаем изменения
              needUpdate = true;
              lastDxEnabled = dxEnabled;      // сохраняем предыдущее значение
            }
          }
    
          else if (mode == MODE_ADD) {
            if (addAzimuth != lastDisplayedAddAzimuth ||
                azimuth != lastDisplayedAzimuth) {
              needUpdate = true;
              lastDisplayedAddAzimuth = addAzimuth;
              lastDisplayedAzimuth = azimuth;
            }
          }
    
          else if (mode == MODE_NORMAL) {
            if (eb.counter != lastDisplayedNew ||
                azimuth != lastDisplayedAzimuth ||
                movementActive != lastMovementActive ||
                movementDir != lastMovementDir) {
    
              needUpdate = true;
              lastDisplayedNew = eb.counter;
              lastDisplayedAzimuth = azimuth;
              lastMovementActive = movementActive;
              lastMovementDir = movementDir;
            }
          }
    
          else {
            needUpdate = true;
          }
    
          if (needUpdate) {
            lcd.clear();
    
            // MENU
            if (mode == MODE_MENU) {
              // Получаем указатель на строку из PROGMEM
              const char* labelPtr;
              memcpy_P(&labelPtr, &menuItems[menuSelection].label, sizeof(const char*));
              
              // Копируем строку в буфер
              char labelBuffer[16];  // немного больше для безопасности
              strcpy_P(labelBuffer, labelPtr);
              
              lcd.setCursor(0,0); lcd.print(F("MENU:"));
              lcd.setCursor(0,1);
              lcd.print(F("> "));
              lcd.print(labelBuffer);
            }
    
            // OVERLAP SELECT
            else if (mode == MODE_OVERLAP_SELECT) {
                lcd.setCursor(0,0); lcd.print(F("Overlap:"));
                lcd.setCursor(0,1);
            
                if (overlapMode == -1) lcd.print(F("OFF"));
                else if (overlapMode == 0) lcd.print(F("North 360"));
                else if (overlapMode == 1) lcd.print(F("South 180"));
            }
            
            // DX SELECT
            else if (mode == MODE_DX_SELECT) {
                lcd.setCursor(0,0); lcd.print(F("DX Indicator:"));
                lcd.setCursor(0,1);
                if (dxEnabled) lcd.print(F("ON"));
                else lcd.print(F("OFF"));
            }
            
            // CHASE SELECT
            else if (mode == MODE_CHASE_SELECT) {
                lcd.setCursor(0,0); lcd.print(F("Chase Mode:"));
                lcd.setCursor(0,1);
                if (chaseModeEnabled) lcd.print(F("ON"));
                else lcd.print(F("OFF"));
            }
            
            // CPR CHANGE
            else if (mode == MODE_CPR_CHANGE) {
                lcd.setCursor(0,0); lcd.print(F("Change CPR"));
                lcd.setCursor(0,1); lcd.print(F("Value: "));
                lcd.print(countsPerRev);
            }
            
            // CALIBRATION CONFIRM
            else if (mode == MODE_CALIB_CONFIRM) {
                lcd.setCursor(0,0); lcd.print(F("Start calibration?"));
                lcd.setCursor(0,1);
                lcd.print(F("CPR: "));
                lcd.print(manualTargetCounts);
                lcd.print(F("  "));
                if (calibConfirmSelection == 0) lcd.print(F("YES"));
                else lcd.print(F("NO"));
            }

// ADD
            else if (mode == MODE_ADD) {
              lcd.setCursor(0,0); lcd.print(F("New Azimuth:"));
              lcd.setCursor(0,1); lcd.print(addAzimuth);
              lcd.setCursor(5,1); lcd.print(F(" Cur:"));
              lcd.setCursor(11,1); lcd.print(azimuth);
            }
    
            else if (mode == MODE_CALIB_MANUAL_SELECT) {
                lcd.setCursor(0,0); lcd.print("Manual Calib");
                lcd.setCursor(0,1); lcd.print("Impulses: ");
                lcd.print(manualTargetCounts);
            }
            
            else if (mode == MODE_CALIB_MANUAL_RUN) {
                lcd.setCursor(0,0);
                lcd.print(movementDir > 0 ? "Moving CW" : "Moving CCW");
                lcd.setCursor(0,1);
                lcd.print("Impulses: ");
                lcd.print(sensor);
            }
            
            else if (mode == MODE_CALIB_MANUAL_DONE) {
                lcd.setCursor(0,0); lcd.print("CPR OK:");
                lcd.setCursor(0,1); lcd.print(manualTargetCounts);
                lcd.print(" Click=Save");
            }
    
    
    
            // NORMAL
            else if (mode == MODE_NORMAL) {
              // Строка 1: New: 156   >
              lcd.setCursor(0,0); lcd.print(F("New:"));
              lcd.setCursor(5,0); lcd.print(eb.counter);
              lcd.setCursor(11,0);
              if (movementActive) {
                if (movementDir > 0) lcd.print(F("CW-->"));
                else lcd.print(F("<-CCW"));
              } else lcd.print(F("  "));  // 2 пробела когда нет движения
              
              // Строка 2: Azimuth: 187     KH6
              lcd.setCursor(0,1); lcd.print(F("Azimuth:"));
              lcd.setCursor(9,1); lcd.print(azimuth);
              
              // Очищаем 3 позиции для префикса (выравнивание по ширине)
              lcd.setCursor(14,1); lcd.print(F("   "));
              if (dxEnabled) {
                  lcd.setCursor(14,1); lcd.print(getDXPrefix(azimuth));
              }
            }
            
            lastDisplayedMode = mode;
          }
        }
        
      }

</code>

Сводка изменений

Примечание: редактируя эту страницу, вы соглашаетесь на использование своего вклада на условиях следующей лицензии: CC Attribution-Share Alike 4.0 International