#include <Wire.h>
#include <EEPROM.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>

// Автополив и фитолампа на Arduino Nano.
//
// Три канала: фитолампа 230 В по расписанию и два насоса 12 В, каждый
// со своим периодом полива. Настройка — одной ручкой энкодера, экран
// LCD 16x2. Настройки живут в EEPROM и переживают выключение.
//
// Экран. Верхняя строка всегда одна: часы, температура, влажность.
// Нижняя — один из экранов, поворот ручки их листает:
//
//   20:00  23.5C 45%   часы, температура и влажность (всегда)
//   L 07:00-21:00 ON   фитолампа: включить в 07:00, выключить в 21:00
//   1 100s 3d(2) 20h   насос P1: качать 100 с, раз в 3 дня, осталось
//                      2 дня (0 — сегодня), поливать в 20:00
//   2  60s 2d(1) 08h   насос P2: 60 с раз в 2 дня, завтра в 08:00
//
// Во время полива после номера насоса стоит «>», а вместо длительности
// идёт обратный отсчёт.
//
// Нажатие на ручку — правка: мигает первое поле, поворот меняет его,
// следующее нажатие — следующее поле, после последнего всё сохраняется.
// Долгое нажатие во время правки — отмена. Долгое нажатие на экране
// насоса — полить сейчас (или остановить полив).
//
// Надписи латинские: в знакогенераторе HD44780 кириллицы нет.
//
// Часы через монитор порта: «time 19:59:50», «date 29.09.2026»,
// «status» — все настройки и состояние.
//
// На схеме: три выключателя каналов (sw1–sw3) стоят в силовой цепи
// последовательно с контактами реле, как тумблеры на корпусе. Щелчок по
// выключателю отключает канал, что бы ни решила прошивка. Температуру и
// влажность меняют в свойствах датчика ht1 прямо во время работы.

// --- выводы -----------------------------------------------------------

const byte ENC_A = 2, ENC_B = 3, ENC_KEY = 4;   // энкодер S1, S2, KEY
const byte RELAY_LAMP = 5;                       // реле 1 — фитолампа
const byte RELAY_PUMP[] = { 6, 7 };              // реле 2 и 3 — насосы P1, P2
// Запасные реле модуля — выводы 8, 9, 10. Третий насос — это третий
// вывод в RELAY_PUMP и третья строка в DEFAULT_PUMPS: экран, настройка,
// EEPROM и полив подхватят его сами.
const byte PUMPS = sizeof(RELAY_PUMP);

// Уровень, которым модуль реле включает канал. Модуль в модели
// включается высоким уровнем. У шестиканальных модулей с оптронами
// (HL-56S и похожие) вход часто инверсный — включает LOW. Проверьте свой
// модуль и поменяйте здесь одну константу.
const byte RELAY_ON = HIGH;
const byte RELAY_OFF = RELAY_ON == HIGH ? LOW : HIGH;

const byte HTU21D = 0x40;                        // датчик на шине I2C

// --- настройки --------------------------------------------------------

struct Pump {
  uint16_t seconds;   // сколько секунд качать
  byte period;        // раз в сколько дней
  byte left;          // сколько дней осталось; 0 — сегодня
  byte hour;          // в котором часу
};

struct Settings {
  byte magic;
  uint16_t lampOn, lampOff;   // минуты от полуночи
  Pump pump[PUMPS];
  uint16_t day;               // номер дня последнего пересчёта (от 2000 г.)
};

// Нажатие на ручку. Объявлено здесь, выше всех функций: Arduino
// вставляет прототипы функций перед первой из них, и тип, объявленный
// ниже, в прототипе был бы ещё неизвестен.
enum Press { NONE, SHORT, LONG };

const byte MAGIC = 0xA8;      // поменяйте — и EEPROM заполнится заново
const Pump DEFAULT_PUMPS[] = { { 100, 3, 2, 20 }, { 60, 2, 1, 8 } };

Settings cfg;

void loadSettings() {
  EEPROM.get(0, cfg);
  if (cfg.magic == MAGIC) return;
  cfg.magic = MAGIC;
  cfg.lampOn = 7 * 60;
  cfg.lampOff = 21 * 60;
  for (byte i = 0; i < PUMPS; i++) cfg.pump[i] = DEFAULT_PUMPS[i];
  cfg.day = 0;
  EEPROM.put(0, cfg);
}

// put пишет только изменившиеся байты: ресурс EEPROM — сто тысяч
// перезаписей ячейки, и сохранение раз в день его не тронет.
void saveSettings() { EEPROM.put(0, cfg); }

// --- железо -----------------------------------------------------------

RTC_DS3231 rtc;
LiquidCrystal_I2C lcd(0x27, 16, 2);

volatile int clicks = 0;
void onEncoder() {
  if (digitalRead(ENC_B)) clicks++; else clicks--;
}

// HTU21D без библиотеки: команда «измерь», ожидание, три байта ответа —
// старший, младший и CRC-8. Два младших бита — служебные, их обнуляем.
bool htuRead(byte cmd, float &out) {
  Wire.beginTransmission(HTU21D);
  Wire.write(cmd);
  if (Wire.endTransmission() != 0) return false;
  delay(55);                                     // измерение до 50 мс
  if (Wire.requestFrom(HTU21D, (byte)3) != 3) return false;
  byte msb = Wire.read(), lsb = Wire.read(), crc = Wire.read();
  byte c = 0;
  byte data[2] = { msb, lsb };
  for (byte i = 0; i < 2; i++) {
    c ^= data[i];
    for (byte k = 0; k < 8; k++) c = (c & 0x80) ? (c << 1) ^ 0x31 : c << 1;
  }
  if (c != crc) return false;
  uint16_t raw = ((uint16_t)msb << 8 | lsb) & 0xFFFC;
  out = cmd == 0xF3 ? -46.85 + 175.72 * raw / 65536.0 : -6.0 + 125.0 * raw / 65536.0;
  return true;
}

float temperature = NAN, humidity = NAN;

void readClimate() {
  float t, h;
  temperature = htuRead(0xF3, t) ? t : NAN;
  humidity = htuRead(0xF5, h) ? constrain(h, 0, 100) : NAN;
}

// --- каналы -----------------------------------------------------------

bool lampLit = false;
bool running[PUMPS];
unsigned long startedAt[PUMPS];

bool lampShouldBeOn(uint16_t minute) {
  if (cfg.lampOn == cfg.lampOff) return false;
  if (cfg.lampOn < cfg.lampOff) return minute >= cfg.lampOn && minute < cfg.lampOff;
  return minute >= cfg.lampOn || minute < cfg.lampOff;    // через полночь
}

void startPump(byte i, const char *why) {
  running[i] = true;
  startedAt[i] = millis();
  Serial.print(F("P")); Serial.print(i + 1);
  Serial.print(F(": полив ")); Serial.print(cfg.pump[i].seconds);
  Serial.print(F(" с (")); Serial.print(why); Serial.println(F(")"));
}

void stopPump(byte i) {
  running[i] = false;
  Serial.print(F("P")); Serial.print(i + 1); Serial.println(F(": полив закончен"));
}

// Смена суток: у каждого насоса «осталось дней» уменьшается. Номер дня
// хранится в EEPROM, поэтому пропущенные выключенным прибором сутки тоже
// засчитываются.
void newDay(uint16_t today) {
  if (cfg.day != 0 && today > cfg.day) {
    uint16_t passed = today - cfg.day;
    for (byte i = 0; i < PUMPS; i++) {
      cfg.pump[i].left = cfg.pump[i].left > passed ? cfg.pump[i].left - passed : 0;
    }
  }
  cfg.day = today;
  saveSettings();
}

void control(const DateTime &now, bool editing) {
  uint16_t today = now.unixtime() / 86400UL - 10957;    // дней с 2000 года
  if (today != cfg.day) newDay(today);

  bool lamp = lampShouldBeOn(now.hour() * 60 + now.minute());
  if (lamp != lampLit) {
    lampLit = lamp;
    Serial.println(lamp ? F("лампа включена") : F("лампа выключена"));
  }
  digitalWrite(RELAY_LAMP, lampLit ? RELAY_ON : RELAY_OFF);

  for (byte i = 0; i < PUMPS; i++) {
    Pump &p = cfg.pump[i];
    // Полив сегодня и час уже настал. «Уже», а не «ровно»: прибор,
    // включённый в 20:30, польёт, а не пропустит день. Пока идёт правка,
    // решение откладывается — значения ещё не окончательные.
    if (!editing && !running[i] && p.left == 0 && now.hour() >= p.hour) {
      startPump(i, "по расписанию");
      p.left = p.period;          // следующий — через period суток
      saveSettings();
    }
    if (running[i] && millis() - startedAt[i] >= p.seconds * 1000UL) stopPump(i);
    digitalWrite(RELAY_PUMP[i], running[i] ? RELAY_ON : RELAY_OFF);
  }
}

// --- интерфейс --------------------------------------------------------

const byte SCREENS = 1 + PUMPS;
byte screen = 0;
int8_t field = -1;                // -1 — просмотр, иначе номер правимого поля
unsigned long touchedAt = 0;      // последнее действие человека

byte fieldsOf(byte s) { return s == 0 ? 2 : 4; }

// Правка поля на n щелчков. Пределы — в одном месте: здесь.
void adjust(int n) {
  if (screen == 0) {
    uint16_t &v = field == 0 ? cfg.lampOn : cfg.lampOff;
    v = (v + 1440 + n * 10) % 1440;            // шаг 10 минут, по кругу
    return;
  }
  Pump &p = cfg.pump[screen - 1];
  switch (field) {
    case 0: p.seconds = constrain((int)p.seconds + n * 5, 5, 995); break;
    case 1: p.period = constrain(p.period + n, 1, 9);
            if (p.left > p.period) p.left = p.period; break;
    case 2: p.left = constrain(p.left + n, 0, p.period); break;
    case 3: p.hour = (p.hour + 24 + n) % 24; break;
  }
}

// Где на экране лежит поле: начало и ширина — для мигания.
void fieldSpan(byte &at, byte &width) {
  static const byte LAMP[][2] = { { 2, 5 }, { 8, 5 } };
  static const byte PUMP[][2] = { { 2, 4 }, { 7, 2 }, { 9, 3 }, { 13, 3 } };
  const byte *f = screen == 0 ? LAMP[field] : PUMP[field];
  at = f[0]; width = f[1];
}

void drawTop(const DateTime &now) {
  char t[6] = "--.-", h[4] = "--";
  if (!isnan(temperature)) dtostrf(temperature, 4, 1, t);
  if (!isnan(humidity)) itoa(min((int)(humidity + 0.5), 99), h, 10);
  char line[24];
  // dtostrf — потому что sprintf на AVR не печатает float.
  snprintf(line, sizeof line, "%02d:%02d %5sC %2s%%", now.hour(), now.minute(), t, h);
  line[16] = 0;
  lcd.setCursor(0, 0);
  lcd.print(line);
}

void drawBottom() {
  char line[24];              // с запасом; на экран идут первые 16
  if (screen == 0) {
    snprintf(line, sizeof line, "L %02u:%02u-%02u:%02u %s",
             cfg.lampOn / 60, cfg.lampOn % 60, cfg.lampOff / 60, cfg.lampOff % 60,
             lampLit ? "ON" : "--");
  } else {
    byte i = screen - 1;
    Pump &p = cfg.pump[i];
    // Во время полива вместо длительности — сколько ещё осталось.
    unsigned int s = running[i] ? p.seconds - (millis() - startedAt[i]) / 1000 : p.seconds;
    snprintf(line, sizeof line, "%u%c%3us %ud(%u) %02uh",
             i + 1, running[i] ? '>' : ' ', s, p.period, p.left, p.hour);
  }
  line[16] = 0;
  // Правимое поле мигает: две трети времени видно, треть — пробелы.
  if (field >= 0 && (millis() - touchedAt) > 600 && (millis() / 300) % 3 == 0) {
    byte at, width;
    fieldSpan(at, width);
    for (byte k = 0; k < width; k++) line[at + k] = ' ';
  }
  lcd.setCursor(0, 1);
  lcd.print(line);
  for (byte k = strlen(line); k < 16; k++) lcd.print(' ');
}

// Кнопка ручки: короткое нажатие — по отпусканию, долгое — через
// секунду удержания, не дожидаясь отпускания.
Press readKey() {
  static bool down = false, longFired = false;
  static unsigned long since = 0;
  bool now = digitalRead(ENC_KEY) == LOW;
  if (now && !down) { down = true; longFired = false; since = millis(); }
  if (now && down && !longFired && millis() - since >= 1000) { longFired = true; return LONG; }
  if (!now && down) {
    down = false;
    if (!longFired && millis() - since >= 30) return SHORT;   // 30 мс — дребезг
  }
  return NONE;
}

void handleInput() {
  noInterrupts();
  int n = clicks;
  clicks = 0;
  interrupts();

  if (n) {
    touchedAt = millis();
    if (field < 0) screen = (screen + SCREENS + (n > 0 ? 1 : -1)) % SCREENS;
    else adjust(n);
  }

  Press k = readKey();
  if (k != NONE) touchedAt = millis();
  if (k == SHORT) {
    if (field < 0) field = 0;
    else if (++field >= fieldsOf(screen)) {
      field = -1;
      saveSettings();
      Serial.println(F("настройки сохранены"));
    }
  } else if (k == LONG) {
    if (field >= 0) {
      field = -1;
      loadSettings();             // отмена: вернуть то, что в EEPROM
      Serial.println(F("правка отменена"));
    } else if (screen > 0) {
      byte i = screen - 1;
      if (running[i]) stopPump(i); else startPump(i, "вручную");
    }
  }
  // Забытая правка через полминуты сохраняется сама: иначе полив
  // так и стоял бы в ожидании её окончания.
  if (field >= 0 && millis() - touchedAt > 30000UL) {
    field = -1;
    saveSettings();
  }
}

// --- монитор порта ----------------------------------------------------

void printStatus(const DateTime &now) {
  char buf[40];
  snprintf(buf, sizeof buf, "%02d.%02d.%04d %02d:%02d:%02d", now.day(), now.month(), now.year(),
           now.hour(), now.minute(), now.second());
  Serial.println(buf);
  snprintf(buf, sizeof buf, "лампа %02u:%02u-%02u:%02u %s", cfg.lampOn / 60, cfg.lampOn % 60,
           cfg.lampOff / 60, cfg.lampOff % 60, lampLit ? "вкл" : "выкл");
  Serial.println(buf);
  for (byte i = 0; i < PUMPS; i++) {
    Pump &p = cfg.pump[i];
    snprintf(buf, sizeof buf, "P%u %us %ud(%u) %02uh%s", i + 1, p.seconds, p.period, p.left, p.hour,
             running[i] ? " полив" : "");
    Serial.println(buf);
  }
}

void handleSerial() {
  static char buf[24];
  static byte len = 0;
  while (Serial.available()) {
    char c = Serial.read();
    if (c != '\n' && c != '\r') {
      if (len < sizeof buf - 1) buf[len++] = c;
      continue;
    }
    if (!len) continue;
    buf[len] = 0;
    len = 0;
    DateTime now = rtc.now();
    int a, b, c2 = 0;
    if (sscanf(buf, "time %d:%d:%d", &a, &b, &c2) >= 2) {
      rtc.adjust(DateTime(now.year(), now.month(), now.day(), a, b, c2));
      Serial.println(F("время установлено"));
    } else if (sscanf(buf, "date %d.%d.%d", &a, &b, &c2) == 3) {
      rtc.adjust(DateTime(c2, b, a, now.hour(), now.minute(), now.second()));
      Serial.println(F("дата установлена"));
    } else if (!strcmp(buf, "status")) {
      printStatus(now);
    } else {
      Serial.println(F("команды: time ЧЧ:ММ[:СС], date ДД.ММ.ГГГГ, status"));
    }
  }
}

// --- setup и loop -----------------------------------------------------

void setup() {
  Serial.begin(9600);
  pinMode(RELAY_LAMP, OUTPUT);
  digitalWrite(RELAY_LAMP, RELAY_OFF);
  for (byte i = 0; i < PUMPS; i++) {
    pinMode(RELAY_PUMP[i], OUTPUT);
    digitalWrite(RELAY_PUMP[i], RELAY_OFF);
  }
  pinMode(ENC_A, INPUT);          // подтяжка S1 и S2 — на плате энкодера
  pinMode(ENC_B, INPUT);
  pinMode(ENC_KEY, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ENC_A), onEncoder, FALLING);

  lcd.init();
  lcd.backlight();
  Wire.beginTransmission(HTU21D);
  Wire.write(0xFE);               // программный сброс датчика
  Wire.endTransmission();
  delay(15);

  if (!rtc.begin()) Serial.println(F("DS3231 молчит: проверьте A4 и A5"));
  if (rtc.lostPower()) rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  loadSettings();
  readClimate();
  Serial.println(F("автополив: готов, «status» — настройки"));
}

void loop() {
  static unsigned long lastClimate = 0, lastDraw = 0;
  handleInput();
  handleSerial();

  DateTime now = rtc.now();
  control(now, field >= 0);

  if (millis() - lastClimate >= 5000) {
    lastClimate = millis();
    readClimate();
  }
  if (millis() - lastDraw >= 100) {
    lastDraw = millis();
    drawTop(now);
    drawBottom();
  }
}