Прошу помощи в отладке Arduino Mega 2560

[BABOS]

1 для информации
2 бабло

ой все, ну вас, хоть бы написали кому выгода… а то опять на новые вопросы отвечать придется)))

[Diskless]

@BABOS

ой все, ну вас, хоть бы написали кому выгода… а то опять на новые вопросы отвечать придется)))

Это второй Ваш порок. Надо уметь отстаивать свое мнение и уметь грамотно излагать.

[xDriver]

@BABOS

у меня алгоритм с помощью которого можно записать и прочитать из байта больше чем 256 значений

Давай до бита сократим, больше двух состояний если сможешь, я пошел а банкомат…

[Diskless]

@xDriver

Давай до бита сократим, больше двух состояний если сможешь, я пошел а банкомат…

Если до бита, то я могу 3 сделать.

[PPeterr]

@NMi

Между БП 12В поставь диод Шоттки и конденсатор ближе к меге мокрофарад на 100-500 и 16 Вольт

@NMi

Входы от счетчика и водомера около меги (ближе) зашунтируй керамикой 1-10nf

@NMi

В цепь контактора (или пускателя) либо снаббер, либо RC гаситель

@BABOS

лучше наверное переписать…

Переписал. И вернул подсветку некорректных значений, как было.
Код такой:

Спойлер

#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;

#include <OneWire.h>
OneWire ds(21);  // выбор пина ардуино, на котором висит шина 1-wire

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_RESET A4

// Цвета
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
#define WHITEGREY  0xC638
#define DARKGREY  0x7BEF
#define DARKGREEN 0x0C80

#define pinVoda_tick        18
boolean stateCheck_voda;

#define pinElectr_tick       19
boolean stateCheck_electr;

uint8_t relay;

// Адреса датчиков
byte ADDR_DS18B20 [6][8] = {
  {0x28, 0xD5, 0x97, 0x76, 0x0, 0x0, 0x0, 0x76}, // KompressorC   0
  {0x28, 0x4F, 0x9C, 0x73, 0x0, 0x0, 0x0, 0xF9}, // WaterInC      1
  {0x28, 0xFC, 0xD1, 0x72, 0x0, 0x0, 0x0, 0x2D}, // WaterOutC     2
  {0x28, 0x95, 0x28, 0x75, 0x0, 0x0, 0x0, 0xAB}, // temp3C        3
  {0x28, 0xEF, 0x8C, 0x76, 0x0, 0x0, 0x0, 0x58}, // DefrostC      4
  {0x28, 0x8C, 0x3A, 0xB4, 0xE, 0x0, 0x0, 0xDB}  // EvaporatorC    5
};

// Массивы для графиков
uint8_t tEvaporator[320];
uint8_t tOverheat[320];
uint8_t tKompressor[320];
uint8_t tWaterIn[320];
uint8_t tWaterOut[320];
uint8_t tDefrost[320];
uint8_t heatPower[320];
uint8_t gWater[320];
uint8_t ElectrPow[320];
uint8_t COP[320];

// Точные значения
int16_t tOverheatReal;
int32_t gWaterReal;
int32_t heatPowerReal;
int32_t ElectrPowReal;
int32_t COPreal;

int32_t gWaterRealPrew;
boolean FlagWater = false;
boolean FirstImpulsWater = false;
boolean SecondImpulsWater = false;

// Средние значения
int32_t countHeatAndElectr = 0;
int32_t countHeat = 0;
int32_t countElectr = 0;

// Флаги цикла
boolean Flag1 = true;
boolean Flag2 = true;
boolean Flag3 = true;
boolean Flag4 = true;
uint8_t countGetGrafic = 9;
uint32_t Timer;

// Графики реле
int16_t trend_fan[20];
int16_t trend_kompressor[20];
int16_t trend_pump[20];
int16_t trend_4way_valve[20];

// Водомер
uint32_t tmr;
boolean gWaterFlag = false;
uint32_t WaterStartTimer;
uint32_t WaterCountTimer;

// Электросчётчик
uint32_t tmr2;
boolean ElectrFlag = false;
uint32_t ElectrStartTimer;
uint32_t ElectrCountTimer;

// Режимы
boolean StartHeatFlag;
boolean StopFlag;
boolean HeatOptionFlag;
boolean HeatOptionPauseFlag;
boolean DefrostOptionFlag;

uint8_t tKompressorCounter = 0;
uint8_t HeatOptionCout = 0;
uint8_t HeatOptionPauseCout = 0;
uint8_t defrostCount = 0;
uint8_t StopMaxTemp = 0;
uint8_t StopMaxElectr = 0;
uint8_t StopMinTempHeater = 0;
uint8_t StopNo4xvalve = 0;
uint8_t StopNoElectric = 0;

uint8_t StopKind = 0;
uint8_t MistakeTemp[6] = {};
boolean getMistakeFlag = false;

uint32_t HeatOptionPauseStartTime;
uint32_t StartHeatTime;
uint32_t StopTime;
uint32_t DefrostTime;

// Переменные температур
int16_t Temper[6] = {0, 0, 0, 0, 0, 0};
int16_t TemperPrev[6];

// ============== CRC8 ДЛЯ DS18B20 ==============
uint8_t dallas_crc8(const uint8_t *data, uint8_t len) {
  uint8_t crc = 0;
  for (uint8_t i = 0; i < len; i++) {
    uint8_t inbyte = data[i];
    for (uint8_t j = 0; j < 8; j++) {
      uint8_t mix = (crc ^ inbyte) & 0x01;
      crc >>= 1;
      if (mix) crc ^= 0x8C;
      inbyte >>= 1;
    }
  }
  return crc;
}

// ============== НОВАЯ ФУНКЦИЯ ЧТЕНИЯ С ПРОВЕРКОЙ CRC ==============
// Возвращает температуру в десятых долях (например, 156 = 15.6°C)
// Возвращает 0x7FFF при ошибке CRC
int16_t readDS18B20(byte *addr) {
  uint8_t data[9];
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);
  for (uint8_t i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
  if (dallas_crc8(data, 8) != data[8]) {
    return 0x7FFF; // Ошибка CRC
  }
  int16_t raw = (int16_t)((data[1] << 8) | data[0]);
  // Правильная формула для int16_t (работает с отрицательными):
  return (raw * 5) / 8; // Десятые доли °C
}

// ============== СБРОС ШИНЫ (запуск конвертации) ==============
void resetTemp() {
  ds.reset();
  ds.write(0xCC); // Ко всем датчикам
  ds.write(0x44); // Конвертация
}

// ============== ПОЛУЧЕНИЕ ТЕМПЕРАТУР ==============
void gettingTemp() {
  for (uint8_t i = 0; i < 6; i++) {
    int16_t temp = readDS18B20(ADDR_DS18B20[i]);

    if (temp != 0x7FFF) {
      // Данные достоверны
      Temper[i] = temp;
      TemperPrev[i] = temp;
      if (MistakeTemp[i] <= 6) MistakeTemp[i] = 0;
    } else {
      // Ошибка CRC
      Temper[i] = TemperPrev[i];
      if (StopFlag == false) {
        MistakeTemp[i]++;
        if (MistakeTemp[i] > 6) {
          StopFlag = true;
          StopTime = millis();
          StopKind = 6;
        }
      }
    }
  }
}

// ============== ПРОВЕРКА ГРАНИЦ ТЕМПЕРАТУР ==============
void tempMistake(uint8_t a, int16_t b, int16_t c, int16_t d) {
  // Эта функция теперь только для физических проверок,
  // так как CRC уже отсеяла помехи.
  // Но оставляем на всякий случай.
  if (MistakeTemp[a] > 0) return; // Уже есть ошибка CRC

  if (Temper[a] >= b && Temper[a] <= c && abs(Temper[a] - TemperPrev[a]) <= d) {
    // Норма
  } else {
    Temper[a] = TemperPrev[a];
    if (StopFlag == false) MistakeTemp[a]++;
    if (MistakeTemp[a] > 6 && StopFlag == false) {
      StopFlag = true;
      StopTime = millis();
      StopKind = 6;
    }
  }
}

// ============== ВОДОМЕР ==============
void voda_tick() {
  boolean current_status = digitalRead(pinVoda_tick);
  if (stateCheck_voda && !current_status) {
    tmr = millis();
    gWaterFlag = true;
    stateCheck_voda = current_status;
  }
  if (!stateCheck_voda && current_status) stateCheck_voda = current_status;
  if (current_status) gWaterFlag = false;
  if (!current_status && millis() - tmr >= 1000 && gWaterFlag == true) {
    WaterCountTimer = millis() - WaterStartTimer;
    WaterStartTimer = millis();
    gWaterFlag = false;
    if (FirstImpulsWater == true) SecondImpulsWater = true;
    FirstImpulsWater = true;
  }
}

// ============== ЭЛЕКТРОСЧЁТЧИК ==============
void electr_tick() {
  boolean current_status = digitalRead(pinElectr_tick);
  if (stateCheck_electr && !current_status) {
    tmr2 = millis();
    ElectrFlag = true;
    stateCheck_electr = current_status;
  }
  if (!stateCheck_electr && current_status) stateCheck_electr = current_status;
  if (current_status) ElectrFlag = false;
  if (!current_status && millis() - tmr2 >= 50 && ElectrFlag == true) {
    ElectrCountTimer = millis() - ElectrStartTimer;
    ElectrStartTimer = millis();
    ElectrFlag = false;
  }
}

// ============== ВЫВОД ЗНАЧЕНИЙ НА ДИСПЛЕЙ ==============
void getDataInt100(int16_t a) {
  if (a >= -9 && a < 0) {
    tft.print("-0.0");
    tft.print(abs(a));
  } else if (a < 9 && a >= 0) {
    tft.print("0.0");
    tft.print(a);
  } else if (a <= -10 && a > -100) {
    tft.print("-0.");
    tft.print(abs(a % 100));
  } else {
    tft.print(a / 100);
    tft.print(".");
    if (abs(a % 100) < 10) tft.print("0");
    tft.print(abs(a % 100));
  }
}

void getDataInt10(int16_t a) {
  if (a >= -9 && a < 0) {
    tft.print("-0.");
    tft.print(abs(a));
  } else if (a < 9 && a >= 0) {
    tft.print("0.");
    tft.print(a);
  } else {
    tft.print(a / 10);
    tft.print(".");
    tft.print(abs(a % 10));
  }
}

int16_t getDataForUintMassiv(int16_t a) {
  int16_t LastInMassive;
  if (a < -400) LastInMassive = 0;
  else if (a >= -400 && a < 500) LastInMassive = round((a + 400) / 5);
  else if (a >= 500 && a < 1250) LastInMassive = round(180 + (a - 500) / 10);
  else LastInMassive = 255;
  return LastInMassive;
}

int32_t getDataForUintMassiv32(int32_t a) {
  int32_t LastInMassive;
  if (a < -400) LastInMassive = 0;
  else if (a >= -400 && a < 0) LastInMassive = round((a + 400) / 10);
  else if (a >= 0 && a <= 160) LastInMassive = round(40 + a);
  else if (a > 160 && a < 710) LastInMassive = round(200 + (a - 160) / 10);
  else LastInMassive = 255;
  return LastInMassive;
}

void getGraphics(uint16_t c, uint16_t d, uint8_t g[320]) {
  int16_t oldX = 0;
  int16_t oldY = g[0];
  for (int16_t x = 1; x < 320; x++) {
    int16_t nxt_x = x;
    tft.drawLine(oldX, (c - oldY), nxt_x, (c - g[x]), d);
    oldY = g[x];
    oldX = nxt_x;
  }
}

// ============== ОТРИСОВКА ДИСПЛЕЯ ==============
void getMainDisplay() {
  tft.fillScreen(BLACK);

  // Сетка по времени
  for (uint8_t i = 1; i < 8; i++) {
    tft.drawFastVLine((40 * i), 20, 190, DARKGREY);
    tft.drawFastVLine((40 * i), 230, 210, DARKGREY);
  }

  // Сетка по температуре
  for (uint8_t i = 0; i < 11; i++) {
    if (i == 4 || i == 5 || i == 6 || i == 7 || i == 9 || i == 10)
      tft.drawFastHLine(0, (5 + 20 * i), 320, DARKGREEN);
    else if (i == 1 || i == 2 || i == 3 || i == 8)
      tft.drawFastHLine(0, (5 + 20 * i), 320, BLUE);
  }
  for (uint8_t i = 0; i < 5; i++)
    tft.drawFastHLine(0, (231 + 10 * i), 320, BLUE);
  tft.drawFastHLine(0, 275, 320, BLUE);
  for (uint8_t i = 0; i < 8; i++)
    tft.drawFastHLine(0, (295 + 20 * i), 320, DARKGREEN);

  // Подписи
  tft.setTextSize(1);

  tft.setCursor(0, 22); tft.setTextColor(WHITE, BLACK); tft.print("90");
  tft.setCursor(0, 42); tft.print("70");
  tft.setCursor(0, 62); tft.print("50");
  tft.setCursor(0, 82); tft.print("40");
  tft.setCursor(0, 102); tft.print("30");
  tft.setCursor(0, 122); tft.print("20");
  tft.setCursor(0, 142); tft.print("10");
  tft.setCursor(0, 162); tft.print("0");
  tft.setCursor(0, 182); tft.print("-10");
  tft.setCursor(0, 202); tft.print("-20");

  tft.setCursor(0, 238); tft.print("5");
  tft.setCursor(0, 258); tft.print("3");
  tft.setCursor(0, 272); tft.print("1.6");
  tft.setCursor(0, 292); tft.print("1.4");
  tft.setCursor(0, 312); tft.print("1.2");
  tft.setCursor(0, 332); tft.print("1");
  tft.setCursor(0, 352); tft.print("0.8");
  tft.setCursor(0, 372); tft.print("0.6");
  tft.setCursor(0, 392); tft.print("0.4");
  tft.setCursor(0, 412); tft.print("0.2");
  tft.setCursor(0, 432); tft.print("0");

  // Назначения датчиков
  tft.setCursor(0, 0); tft.setTextColor(RED); tft.print("Kompressor:");
  tft.setCursor(10, 10); tft.setTextColor(MAGENTA); tft.print("Overheat:");
  tft.setCursor(125, 10); tft.setTextColor(CYAN); tft.print("Defrost:");
  tft.setCursor(215, 10); tft.setTextColor(RED); tft.print("Evaporator:");
  tft.setCursor(120, 0); tft.setTextColor(YELLOW); tft.print("Water in:");
  tft.setCursor(220, 0); tft.setTextColor(GREEN); tft.print("Water out:");
  tft.setCursor(5, 210); tft.setTextColor(RED); tft.print("Heat power:");
  tft.setCursor(152, 210); tft.setTextColor(YELLOW); tft.print("COP:");
  tft.setCursor(218, 210); tft.setTextColor(GREEN); tft.print("Electr pow:");
  tft.setCursor(22, 220); tft.setTextColor(MAGENTA); tft.print("G water:");
}

// ============== SETUP ==============
void setup() {
  Serial.begin(9600);

  tft.reset();
  tft.begin(38022);
  tft.invertDisplay(true);

  pinMode(18, INPUT_PULLUP);
  stateCheck_voda = digitalRead(pinVoda_tick);

  pinMode(19, INPUT_PULLUP);
  stateCheck_electr = digitalRead(pinElectr_tick);

  for (int i = 0; i < 320; i++) {
    tEvaporator[i] = 80;
    tOverheat[i] = 80;
    tKompressor[i] = 80;
    tWaterIn[i] = 80;
    tWaterOut[i] = 80;
    tDefrost[i] = 80;
    heatPower[i] = 40;
    gWater[i] = 40;
    ElectrPow[i] = 40;
    COP[i] = 40;
  }

  pinMode(48, OUTPUT); digitalWrite(48, HIGH);
  pinMode(49, OUTPUT); digitalWrite(49, HIGH);
  pinMode(50, OUTPUT); digitalWrite(50, HIGH);
  pinMode(51, OUTPUT); digitalWrite(51, HIGH);

  StopFlag = false;
  HeatOptionFlag = false;
  HeatOptionPauseFlag = false;
  DefrostOptionFlag = false;
  StartHeatFlag = true;
  StartHeatTime = millis();
  Timer = millis();

  delay(1000);
}

// ============== LOOP ==============
void loop() {
  voda_tick();
  electr_tick();

  // Шаг 1: запуск конвертации (3-5 сек)
  if (millis() - Timer >= 3000 && millis() - Timer < 5000 && Flag1 == true) {
    resetTemp();
    Flag1 = false;
  }

  // Шаг 2: чтение температур (5-7 сек)
  if (millis() - Timer >= 5000 && millis() - Timer < 7000 && Flag2 == true) {
    gettingTemp();
    Flag2 = false;
  }

  // Шаг 3: расчёты и логика (7-9 сек)
  if (millis() - Timer >= 7000 && millis() - Timer < 9000 && Flag3 == true) {
    if (getMistakeFlag == false) {
      for (uint8_t i = 0; i < 6; i++) {
        TemperPrev[i] = Temper[i];
      }
      getMistakeFlag = true;
    }

    // Проверка границ (дополнительная, CRC уже отсеяла мусор)
    tempMistake(0, -100, 1200, 200);
    tempMistake(1, 0, 600, 100);
    tempMistake(2, 0, 900, 50);
    tempMistake(3, -400, 800, 400);
    tempMistake(4, -400, 600, 400);
    tempMistake(5, -400, 800, 200);

    tOverheatReal = (Temper[3] - Temper[5]);

    // Расход воды
    if (digitalRead(51) == HIGH) {
      gWaterReal = 0;
      gWaterRealPrew = gWaterReal;
      FlagWater = false;
    } else if (digitalRead(51) == LOW && millis() - WaterStartTimer > 400000) {
      StopFlag = true;
      StopTime = millis();
      StopKind = 7;
    } else if (SecondImpulsWater == false) {
      gWaterReal = gWaterRealPrew;
      FlagWater = true;
    } else {
      gWaterReal = round(3600000 / WaterCountTimer);
      gWaterRealPrew = gWaterReal;
      FlagWater = false;
    }

    // Электрическая мощность
    if (millis() - ElectrStartTimer > 60000)
      ElectrPowReal = 0;
    else
      ElectrPowReal = 72000 / ElectrCountTimer;

    // Тепловая мощность
    heatPowerReal = ((int32_t)Temper[2] - (int32_t)Temper[1]) * gWaterReal * 1163 / 10000;

    // COP
    if (ElectrPowReal < 10)
      COPreal = 0;
    else
      COPreal = 100 * heatPowerReal / ElectrPowReal;

    // Средние значения
    countHeat = countHeat + heatPowerReal;
    countElectr = countElectr + ElectrPowReal;
    countHeatAndElectr++;

    // Управление вентилятором при перегреве
    if (HeatOptionFlag == true && Temper[0] >= 850 && tOverheatReal >= 300 && digitalRead(48) == LOW) {
      tKompressorCounter++;
      if (tKompressorCounter >= 4) {
        bitClear(relay, 0);
        tKompressorCounter = 0;
      }
    } else if (HeatOptionFlag == true && (Temper[0] <= 750 || tOverheatReal <= 200) && digitalRead(48) == HIGH) {
      tKompressorCounter++;
      if (tKompressorCounter >= 2) {
        bitSet(relay, 0);
        tKompressorCounter = 0;
      }
    } else {
      tKompressorCounter = 0;
    }

    // Режимы нагрева
    if (HeatOptionFlag == true && Temper[1] >= 360) {
      HeatOptionCout++;
      if (HeatOptionCout >= 6) {
        HeatOptionFlag = false;
        HeatOptionPauseFlag = true;
        HeatOptionCout = 0;
        HeatOptionPauseStartTime = millis();
        bitClear(relay, 2);
        bitClear(relay, 0);
      }
    } else {
      HeatOptionCout = 0;
    }

    if (HeatOptionPauseFlag == true && digitalRead(49) == LOW && millis() - HeatOptionPauseStartTime >= 120000)
      bitClear(relay, 1);

    if (HeatOptionPauseFlag == true && digitalRead(51) == HIGH && millis() - HeatOptionPauseStartTime >= 960000) {
      if (digitalRead(51) == HIGH) {
        WaterStartTimer = millis();
        FirstImpulsWater = false;
        SecondImpulsWater = false;
      }
      bitSet(relay, 3);
      HeatOptionPauseStartTime = millis();
    }

    if (HeatOptionPauseFlag == true && digitalRead(51) == LOW && millis() - HeatOptionPauseStartTime >= 60000) {
      bitClear(relay, 3);
      HeatOptionPauseStartTime = millis();
    }

    if (HeatOptionPauseFlag == true && Temper[1] <= 280) {
      HeatOptionPauseCout++;
      if (HeatOptionPauseCout >= 5) {
        HeatOptionPauseFlag = false;
        HeatOptionPauseCout = 0;
        StartHeatTime = millis();
        StartHeatFlag = true;
      }
    } else {
      HeatOptionPauseCout = 0;
    }

    // Defrost
    if (HeatOptionFlag == true && Temper[5] < -100) {
      defrostCount++;
      if (defrostCount >= 6) {
        HeatOptionFlag = false;
        DefrostOptionFlag = true;
        DefrostTime = millis();
        defrostCount = 0;
      }
    } else {
      defrostCount = 0;
    }

    // Защиты
    if (HeatOptionFlag == true && digitalRead(49) == HIGH) {
      StopNo4xvalve++;
      if (StopNo4xvalve >= 3) {
        bitClear(relay, 2);
        StopFlag = true;
        StopTime = millis();
        StopKind = 1;
        StopNo4xvalve = 0;
      }
    } else {
      StopNo4xvalve = 0;
    }

    if ((StartHeatFlag == true || HeatOptionFlag == true || HeatOptionPauseFlag == true || DefrostOptionFlag == true) && Temper[0] >= 1000) {
      StopMaxTemp++;
      if (StopMaxTemp >= 5) {
        StopFlag = true;
        StopTime = millis();
        StopKind = 2;
        StopMaxTemp = 0;
      }
    } else {
      StopMaxTemp = 0;
    }

    if ((StartHeatFlag == true || HeatOptionFlag == true || HeatOptionPauseFlag == true || DefrostOptionFlag == true) && ElectrPowReal >= 151) {
      StopMaxElectr++;
      if (StopMaxElectr >= 6) {
        StopFlag = true;
        StopTime = millis();
        StopKind = 3;
        StopMaxElectr = 0;
      }
    } else {
      StopMaxElectr = 0;
    }

    if ((StartHeatFlag == true || HeatOptionFlag == true || HeatOptionPauseFlag == true) && Temper[4] <= 50) {
      StopMinTempHeater++;
      if (StopMinTempHeater >= 3) {
        StopFlag = true;
        StopTime = millis();
        StopKind = 4;
        StopMinTempHeater = 0;
      }
    } else {
      StopMinTempHeater = 0;
    }

    if (digitalRead(50) == LOW && ElectrPowReal <= 10) {
      StopNoElectric++;
      if (StopNoElectric >= 6) {
        StopFlag = true;
        StopTime = millis();
        StopKind = 5;
        StopNoElectric = 0;
      }
    } else {
      StopNoElectric = 0;
    }

    // Start heat
    if (StartHeatFlag == true && millis() - StartHeatTime >= 20000 && Temper[1] >= 50) {
      if (digitalRead(51) == HIGH) {
        WaterStartTimer = millis();
        FirstImpulsWater = false;
        SecondImpulsWater = false;
      }
      bitSet(relay, 3);
    }

    if (StartHeatFlag == true && digitalRead(51) == LOW && millis() - StartHeatTime >= 30000 && Temper[0] <= 850)
      bitSet(relay, 0);

    if (StartHeatFlag == true && digitalRead(51) == LOW && digitalRead(48) == LOW && millis() - StartHeatTime >= 40000)
      bitSet(relay, 1);

    if (StartHeatFlag == true && digitalRead(51) == LOW && digitalRead(48) == LOW && digitalRead(49) == LOW && millis() - StartHeatTime >= 45000)
      bitSet(relay, 2);

    if (StartHeatFlag == true && digitalRead(51) == LOW && digitalRead(48) == LOW && digitalRead(50) == LOW && digitalRead(49) == LOW) {
      StartHeatFlag = false;
      HeatOptionFlag = true;
    }

    // Stop
    if (StopFlag == true) {
      StartHeatFlag = false;
      HeatOptionFlag = false;
      HeatOptionPauseFlag = false;
      DefrostOptionFlag = false;
      bitClear(relay, 2);
      bitClear(relay, 0);
      if (millis() - StopTime >= 120000) bitClear(relay, 1);
      if (millis() - StopTime >= 180000) bitClear(relay, 3);
    }

    // Defrost
    if (DefrostOptionFlag == true) {
      if (digitalRead(51) == HIGH) {
        WaterStartTimer = millis();
        FirstImpulsWater = false;
        SecondImpulsWater = false;
      }
      bitSet(relay, 3);
      bitClear(relay, 2);
      bitSet(relay, 0);
      if (millis() - DefrostTime >= 120000) bitClear(relay, 1);
      if (millis() - DefrostTime >= 900000 && Temper[5] >= 20) {
        DefrostOptionFlag = false;
        StartHeatTime = millis();
        StartHeatFlag = true;
      }
    }

    // Очистка старых значений
    tft.fillRect(74, 0, 30, 20, BLACK);
    tft.fillRect(181, 0, 30, 20, BLACK);
    tft.fillRect(289, 0, 30, 20, BLACK);
    tft.fillRect(74, 210, 30, 20, BLACK);
    tft.fillRect(181, 210, 30, 10, BLACK);
    tft.fillRect(289, 210, 30, 10, BLACK);
    tft.fillRect(152, 220, 60, 10, BLACK);
    tft.fillRect(100, 470, 30, 8, BLACK);
    tft.fillRect(200, 470, 30, 8, BLACK);

    // Вывод значений на дисплей
    tft.setCursor(74, 0); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[0] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(RED); // Указываем цвет текста
    getDataInt10(Temper[0]);

    tft.setCursor(181, 0); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[1] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(YELLOW); // Указываем цвет текста
    getDataInt10(Temper[1]);

    tft.setCursor(289, 0); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[2] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(GREEN); // Указываем цвет текста
    getDataInt10(Temper[2]);

    tft.setCursor(74, 10); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[3] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(MAGENTA); // Указываем цвет текста
    getDataInt10(tOverheatReal);

    tft.setCursor(181, 10); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[4] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(CYAN); // Указываем цвет текста
    getDataInt10(Temper[4]);

    tft.setCursor(289, 10); // Устанавливаем курсор (X = , Y = )
    if (MistakeTemp[5] > 0)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(RED); // Указываем цвет текста
    getDataInt10(Temper[5]);

    tft.setCursor(74, 210); tft.setTextColor(RED); getDataInt100(heatPowerReal);
    tft.setCursor(181, 210); tft.setTextColor(YELLOW); getDataInt100(COPreal);
    tft.setCursor(289, 210); tft.setTextColor(GREEN); getDataInt100(ElectrPowReal);

    tft.setCursor(74, 220);
    if (FlagWater == true)
      tft.setTextColor(CYAN, MAGENTA); // Указываем цвет текста
    else
      tft.setTextColor(MAGENTA); // Указываем цвет текста
    getDataInt100(gWaterReal);

    tft.setCursor(100, 470); tft.setTextColor(RED);
    getDataInt100(countHeat / countHeatAndElectr);
    tft.setCursor(200, 470); tft.setTextColor(GREEN);
    getDataInt100(countElectr / countHeatAndElectr);

    tft.setCursor(152, 220); tft.setTextColor(RED);
    if (StopFlag == true) {
      tft.print("Stop");
      switch (StopKind) {
        case 1: tft.print(" No 4x valve"); break;
        case 2: tft.print(" maxT Kompr"); break;
        case 3: tft.print(" maxW Electr"); break;
        case 4: tft.print(" minT Heater"); break;
        case 5: tft.print(" No Electr"); break;
        case 6: tft.print(" Err Temp"); break;
        case 7: tft.print(" No G_water"); break;
        case 8: tft.print(" No Option"); break;
      }
    } else if (StartHeatFlag == true) {
      tft.print("Start heat");
    } else if (HeatOptionFlag == true) {
      tft.print("Heat option");
    } else if (HeatOptionPauseFlag == true) {
      tft.print("Pause heat");
    } else if (DefrostOptionFlag == true) {
      tft.print("Defrost");
    } else {
      StopFlag = true;
      StopTime = millis();
      StopKind = 8;
    }

    // Состояния реле
    tft.setCursor(0, 440);
    tft.setTextColor(bitRead(relay, 2) ? RED : BLUE);
    tft.print("Kompressor");

    tft.setCursor(0, 450);
    tft.setTextColor(bitRead(relay, 3) ? RED : BLUE);
    tft.print("Pump");

    tft.setCursor(0, 460);
    tft.setTextColor(bitRead(relay, 1) ? RED : BLUE);
    tft.print("4 way valve");

    tft.setCursor(0, 470);
    tft.setTextColor(bitRead(relay, 0) ? RED : BLUE);
    tft.print("Fan");

    Flag3 = false;
  }

  // Шаг 4: управление реле (9-10 сек)
  if (millis() - Timer >= 9000 && millis() - Timer < 10000 && Flag4 == true) {
    digitalWrite(48, bitRead(relay, 0) ? LOW : HIGH);
    digitalWrite(49, bitRead(relay, 1) ? LOW : HIGH);
    digitalWrite(50, bitRead(relay, 2) ? LOW : HIGH);
    digitalWrite(51, bitRead(relay, 3) ? LOW : HIGH);
    Flag4 = false;
  }

  // Шаг 5: обновление графиков (сброс цикла)
  if (millis() - Timer >= 10000) {
    Timer = millis();

    if (countGetGrafic >= 9) {
      // Сдвиг массивов
      for (uint16_t x = 0; x < 319; x++) {
        tEvaporator[x] = tEvaporator[x + 1];
        tOverheat[x] = tOverheat[x + 1];
        tKompressor[x] = tKompressor[x + 1];
        tWaterIn[x] = tWaterIn[x + 1];
        tWaterOut[x] = tWaterOut[x + 1];
        gWater[x] = gWater[x + 1];
        heatPower[x] = heatPower[x + 1];
        ElectrPow[x] = ElectrPow[x + 1];
        COP[x] = COP[x + 1];
        tDefrost[x] = tDefrost[x + 1];
      }

      // Новые значения
      tKompressor[319] = (uint8_t)getDataForUintMassiv(Temper[0]);
      tWaterIn[319] = (uint8_t)getDataForUintMassiv(Temper[1]);
      tWaterOut[319] = (uint8_t)getDataForUintMassiv(Temper[2]);
      tOverheat[319] = (uint8_t)getDataForUintMassiv(tOverheatReal);
      tDefrost[319] = (uint8_t)getDataForUintMassiv(Temper[4]);
      tEvaporator[319] = (uint8_t)getDataForUintMassiv(Temper[5]);
      heatPower[319] = (uint8_t)getDataForUintMassiv32(heatPowerReal);
      COP[319] = (uint8_t)getDataForUintMassiv32(COPreal);
      ElectrPow[319] = (uint8_t)getDataForUintMassiv32(ElectrPowReal);
      gWater[319] = (uint8_t)getDataForUintMassiv32(gWaterReal);

      // Графики реле
      for (uint8_t i = 0; i < 20; i++) {
        trend_fan[i] = trend_fan[i] << 1;
        bitWrite(trend_fan[i], 0, bitRead(trend_fan[i + 1], 15));
        trend_kompressor[i] = trend_kompressor[i] << 1;
        bitWrite(trend_kompressor[i], 0, bitRead(trend_kompressor[i + 1], 15));
        trend_pump[i] = trend_pump[i] << 1;
        bitWrite(trend_pump[i], 0, bitRead(trend_pump[i + 1], 15));
        trend_4way_valve[i] = trend_4way_valve[i] << 1;
        bitWrite(trend_4way_valve[i], 0, bitRead(trend_4way_valve[i + 1], 15));
      }
      bitWrite(trend_fan[19], 0, bitRead(relay, 0));
      bitWrite(trend_kompressor[19], 0, bitRead(relay, 2));
      bitWrite(trend_pump[19], 0, bitRead(relay, 3));
      bitWrite(trend_4way_valve[19], 0, bitRead(relay, 1));

      getMainDisplay();

      getGraphics(245, RED, tKompressor);
      getGraphics(245, YELLOW, tWaterIn);
      getGraphics(245, GREEN, tWaterOut);
      getGraphics(245, MAGENTA, tOverheat);
      getGraphics(245, CYAN, tDefrost);
      getGraphics(245, RED, tEvaporator);
      getGraphics(475, RED, heatPower);
      getGraphics(475, YELLOW, COP);
      getGraphics(475, GREEN, ElectrPow);
      getGraphics(475, MAGENTA, gWater);

      for (uint8_t i = 0; i < 20; i++) {
        for (uint8_t j = 0; j < 16; j++) {
          if (bitRead(trend_fan[i], j) == 1) tft.drawPixel((i * 16 + (15 - j)), 479, YELLOW);
          if (bitRead(trend_kompressor[i], j) == 1) tft.drawPixel((i * 16 + (15 - j)), 449, YELLOW);
          if (bitRead(trend_pump[i], j) == 1) tft.drawPixel((i * 16 + (15 - j)), 459, YELLOW);
          if (bitRead(trend_4way_valve[i], j) == 1) tft.drawPixel((i * 16 + (15 - j)), 469, YELLOW);
        }
      }

      countGetGrafic = 0;
    }

    countGetGrafic++;
    Flag1 = true;
    Flag2 = true;
    Flag3 = true;
    Flag4 = true;
  }
}

Загрузил в микроконтроллер. Запустил установку. Буду наблюдать.
Схема теперь такая:

[xDriver]

@Diskless

то я могу 3 сделать.

Ответить же придётся, не напрягает?
Только пургу про Z состояние не надо…

[Diskless]

@xDriver

Ответить же придётся, не напрягает?
Только пургу про Z состояние не надо…

Ну сам же просил?

P.S. Мы друг друга поняли. ))

[PPeterr]

Проработал час. Продолжает работать.
Наблюдаю проблемы. Каким-то образом контроллер фиксирует импульсы от водомера, которых нет. Вроде, сделал “антидребезг” большого размера - а всё равно, прилетает…
Можно, конечно, сделать что-то наподобие “если получается слишком большой расход воды - то принять предыдущее значение”… но так же неправильно…
Возможно, как-то связано с длинным (порядка 4 м) проводом до водомера. Но я специально переложил его в хороший экранированный, экран посадил на “GND” возле микроконтроллера…

[PPeterr]

@BABOS

заменяются ваши реле, на реле с опторазвязкой,

По-моему, у меня с опторазвязкой:

[BABOS]

@xDriver

Давай до бита сократим, больше двух состояний если сможешь, я пошел а банкомат…

это не реально, и как минимум надо хранить еще счетчик операций для восстановления! я то думал седня Пятница будет…

[толстый]

@PPeterr

По-моему, у меня с опторазвязкой:

А на кой вы тогда земли на модуле обьединили?

[PPeterr]

С праздником!

С утра посмотрел на дисплей, увидел такое:

но цикл идёт, микроконтроллер в работе. С момента запуска его - прошло ок. 12 часов.
Дисплей отображает, что были некорректные значения с датчиков температур. Проблема проявившаяся - похожа на ту, по которой я обратился на форум.
Но - “зависания” и перезагрузки микроконтроллера - не произошло. Возможно - это заслуга тех мероприятий, которые предложил NMi.
Подожду советов, что делать дальше. МК пока не отключаю - понаблюдаю хотя бы, произойдёт ли “reset” либо зависание.

@толстый

А на кой вы тогда земли на модуле обьединили?

На своей схеме - я лишь попытался отобразить ту информацию, что “земля” соединена общей широкой дорожкой на плате модуля. Я думал насчёт того, чтобы там разделить “земли” - но это очень проблемно на данной плате. Если критично - буду ковырять. Подожду советов.

[толстый]

@PPeterr

Если критично - буду ковырять.

У вас же реле управляются низким уронем, так что землю со стороны ардуино можно тупо отключить! А так там вроде джамперы есть.

[PPeterr]

@толстый

У вас же реле управляются низким уронем, так что землю со стороны ардуино можно тупо отключить! А так там вроде джамперы есть.

Спасибо! Попробую отключить “землю” со стороны Ардуино.
Джампер - есть. Но он один. Соединяет питание от Ардуино с питанием катушек реле. Я джампер удалил и отдельно запитал катушки реле 5В (от DC/DC преобразователя) и управляющую сторону фоторазвязки (5В от Ардуино). (если я всё правильно понял)

[PPeterr]

Подключил так.
У меня подобный модуль, только 6 шт. реле.

[NMi]

@толстый

А на кой вы тогда земли на модуле обьединили?

Это ничего не поменяет. Это если только (L) “слабая” - но будем надеятся, что все ровно.

Мне единственное что не понятно = нафига столько БП. Один на (допустим) 12В или 5В и хватит.

Дисплей сколько потребляет?

[NMi]

@PPeterr

Подключил так.

Это не “шатай” пока. Это вариации TN или PEN. Рано тебе еще.

[NMi]

@PPeterr

Дисплей отображает, что были некорректные значения с датчиков температур.

А вот это уже интереснее. Ты-ж вроде как датчики тестировал на предмет “верности и девственности” с пристрастием, это раз, и там есть CRC = а это два.

[NMi]

void gettingTemp() {
  for (uint8_t i = 0; i < 6; i++) {
    int16_t temp = readDS18B20(ADDR_DS18B20[i]);

    if (temp != 0x7FFF) {
      // Данные достоверны
      Temper[i] = temp;
      TemperPrev[i] = temp;
      if (MistakeTemp[i] <= 6) MistakeTemp[i] = 0;
    } else {
      // Ошибка CRC
      Temper[i] = TemperPrev[i];
      if (StopFlag == false) {
        MistakeTemp[i]++;
        if (MistakeTemp[i] > 6) {
          StopFlag = true;
          StopTime = millis();
          StopKind = 6;

Витиевато. С названиями переменных просто пи===Ц

Ну считался у тебя “криво” даЧЧик - и шо мы делаем?

[BABOS]

вроде оно, те самые, тогда больше идей нет)))