нет я про большее напряжение, которое у вас идет через реле
а еще пины реле у вас вот так выключаются ? digitalWrite(48, HIGH); верно ? а не digitalWrite(48, LOW);
вот новый код для теста
/*
ПРОГРАММА ДЛЯ МОНИТОРИНГА ТЕПЛОВОГО НАСОСА
ТЕСТОВАЯ ВЕРСИЯ: БЕЗ ДИСПЛЕЯ, БЕЗ РЕЛЕ, ТОЛЬКО ЛОГ В МОНИТОР ПОРТА
*/
#include <OneWire.h>
OneWire ds(21);
// Пины для счётчиков
#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},
{0x28, 0x4F, 0x9C, 0x73, 0x0, 0x0, 0x0, 0xF9},
{0x28, 0xFC, 0xD1, 0x72, 0x0, 0x0, 0x0, 0x2D},
{0x28, 0x95, 0x28, 0x75, 0x0, 0x0, 0x0, 0xAB},
{0x28, 0xEF, 0x8C, 0x76, 0x0, 0x0, 0x0, 0x58},
{0x28, 0x8C, 0x3A, 0xB4, 0xE, 0x0, 0x0, 0xDB}
};
// Точные значения
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;
uint32_t Timer;
// Переменные для расходомера воды
uint32_t tmr;
boolean gWaterFlag = false;
uint32_t WaterStartTimer = 0;
uint32_t WaterCountTimer;
// Переменные для электросчётчика
uint32_t tmr2;
boolean ElectrFlag = false;
uint32_t ElectrStartTimer = 0;
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];
// ========== ФУНКЦИЯ ПРОВЕРКИ CRC ==========
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;
}
// ========== ЧТЕНИЕ ТЕМПЕРАТУРЫ С ДАТЧИКА ==========
bool readDS18B20(byte *addr, int16_t *dest) {
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 false;
}
int16_t raw = (int16_t)((data[1] << 8) | data[0]);
*dest = (raw * 5) / 8;
return true;
}
// ========== ЗАПУСК ИЗМЕРЕНИЯ ТЕМПЕРАТУРЫ ==========
void resetTemp() {
ds.reset();
ds.write(0xCC);
ds.write(0x44);
}
// ========== ПОЛУЧЕНИЕ ТЕМПЕРАТУР ==========
void gettingTemp() {
int16_t temp;
for (uint8_t i = 0; i < 6; i++) {
if (readDS18B20(ADDR_DS18B20[i], &temp)) {
Temper[i] = temp;
TemperPrev[i] = temp;
if (MistakeTemp[i] <= 6) MistakeTemp[i] = 0;
}
}
}
// ========== ПРОВЕРКА ГРАНИЦ ТЕМПЕРАТУР ==========
void tempMistake(uint8_t a, int16_t b, int16_t c, int16_t d) {
if (Temper[a] >= b && Temper[a] <= c && abs(Temper[a] - TemperPrev[a]) <= d) {
MistakeTemp[a] = 0;
return;
}
Temper[a] = TemperPrev[a];
if (StopFlag == false) {
MistakeTemp[a]++;
if (MistakeTemp[a] > 6) {
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;
return;
}
if (!stateCheck_voda && current_status) {
stateCheck_voda = current_status;
return;
}
if (current_status) {
gWaterFlag = false;
return;
}
if (!current_status && (millis() - tmr >= 1000) && gWaterFlag == true) {
if (WaterStartTimer == 0) {
WaterStartTimer = millis();
gWaterFlag = false;
return;
}
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;
return;
}
if (!stateCheck_electr && current_status) {
stateCheck_electr = current_status;
return;
}
if (current_status) {
ElectrFlag = false;
return;
}
if (!current_status && (millis() - tmr2 >= 50) && ElectrFlag == true) {
if (ElectrStartTimer == 0) {
ElectrStartTimer = millis();
ElectrFlag = false;
return;
}
ElectrCountTimer = millis() - ElectrStartTimer;
ElectrStartTimer = millis();
ElectrFlag = false;
}
}
// ========== НАЧАЛЬНАЯ НАСТРОЙКА ==========
void setup() {
Serial.begin(9600);
// Детектор причины перезагрузки
Serial.print("MCUSR=0x");
Serial.println(MCUSR, HEX);
if (MCUSR & (1 << PORF)) Serial.println("RESET: Power-on reset");
if (MCUSR & (1 << EXTRF)) Serial.println("RESET: External reset (пин RESET)");
if (MCUSR & (1 << BORF)) Serial.println("RESET: Brown-out (просадка питания)");
if (MCUSR & (1 << WDRF)) Serial.println("RESET: Watchdog (зависание)");
MCUSR = 0;
pinMode(18, INPUT_PULLUP);
stateCheck_voda = digitalRead(pinVoda_tick);
pinMode(19, INPUT_PULLUP);
stateCheck_electr = digitalRead(pinElectr_tick);
// Пины реле настраиваем как выходы, но НЕ включаем
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();
Serial.println("=== SETUP COMPLETE ===");
delay(1000);
}
// ========== ГЛАВНЫЙ ЦИКЛ ==========
void loop() {
Serial.print("L ms=");
Serial.print(millis());
Serial.print(" T=");
Serial.println(Timer);
Serial.println(" voda_tick IN");
voda_tick();
Serial.println(" voda_tick OUT");
Serial.println(" electr_tick IN");
electr_tick();
Serial.println(" electr_tick OUT");
// Шаг 1: запуск конвертации (3-5 сек)
if (millis() - Timer >= 3000 && millis() - Timer < 5000 && Flag1 == true) {
Serial.println(">>> Step 1 START");
resetTemp();
Flag1 = false;
Serial.println(">>> Step 1 END");
}
// Шаг 2: чтение температур (5-7 сек)
if (millis() - Timer >= 5000 && millis() - Timer < 7000 && Flag2 == true) {
Serial.println(">>> Step 2 START");
gettingTemp();
Flag2 = false;
Serial.print(" T0="); Serial.print(Temper[0]);
Serial.print(" T1="); Serial.print(Temper[1]);
Serial.print(" T2="); Serial.print(Temper[2]);
Serial.print(" T3="); Serial.print(Temper[3]);
Serial.print(" T4="); Serial.print(Temper[4]);
Serial.print(" T5="); Serial.println(Temper[5]);
Serial.println(">>> Step 2 END");
}
// Шаг 3: расчёты и логика (7-9 сек)
if (millis() - Timer >= 7000 && millis() - Timer < 9000 && Flag3 == true) {
Serial.println(">>> Step 3 START");
if (getMistakeFlag == false) {
for (uint8_t i = 0; i < 6; i++) TemperPrev[i] = Temper[i];
getMistakeFlag = true;
}
tempMistake(0, -100, 1200, 200);
tempMistake(1, 0, 600, 100);
tempMistake(2, 0, 900, 50);
tempMistake(3, -400, 800, 400);
tempMistake(4, -400, 600, 300);
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++;
// Логика управления (relay) работает, но физически реле не включаются
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;
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 || HeatOptionFlag || HeatOptionPauseFlag || DefrostOptionFlag) && Temper[0] >= 1000) {
StopMaxTemp++;
if (StopMaxTemp >= 5) { StopFlag = true; StopTime = millis(); StopKind = 2; StopMaxTemp = 0; }
} else StopMaxTemp = 0;
if ((StartHeatFlag || HeatOptionFlag || HeatOptionPauseFlag || DefrostOptionFlag) && ElectrPowReal >= 151) {
StopMaxElectr++;
if (StopMaxElectr >= 6) { StopFlag = true; StopTime = millis(); StopKind = 3; StopMaxElectr = 0; }
} else StopMaxElectr = 0;
if ((StartHeatFlag || HeatOptionFlag || HeatOptionPauseFlag) && 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 && millis() - StartHeatTime >= 20000 && Temper[1] >= 50) {
if (digitalRead(51) == HIGH) {
WaterStartTimer = millis(); FirstImpulsWater = false; SecondImpulsWater = false;
}
bitSet(relay, 3);
}
if (StartHeatFlag && digitalRead(51) == LOW && millis() - StartHeatTime >= 30000 && Temper[0] <= 850) bitSet(relay, 0);
if (StartHeatFlag && digitalRead(51) == LOW && digitalRead(48) == LOW && millis() - StartHeatTime >= 40000) bitSet(relay, 1);
if (StartHeatFlag && digitalRead(51) == LOW && digitalRead(48) == LOW && digitalRead(49) == LOW && millis() - StartHeatTime >= 45000) bitSet(relay, 2);
if (StartHeatFlag && digitalRead(51) == LOW && digitalRead(48) == LOW && digitalRead(50) == LOW && digitalRead(49) == LOW) {
StartHeatFlag = false; HeatOptionFlag = true;
}
// Stop
if (StopFlag) {
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) {
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;
}
}
Serial.print(" Relay bits: Fan="); Serial.print(bitRead(relay, 0));
Serial.print(" 4way="); Serial.print(bitRead(relay, 1));
Serial.print(" Kompr="); Serial.print(bitRead(relay, 2));
Serial.print(" Pump="); Serial.print(bitRead(relay, 3));
Serial.print(" Mode=");
if (StopFlag) Serial.print("STOP"); else if (StartHeatFlag) Serial.print("START"); else if (HeatOptionFlag) Serial.print("HEAT"); else if (HeatOptionPauseFlag) Serial.print("PAUSE"); else if (DefrostOptionFlag) Serial.print("DEFROST");
Serial.println();
Flag3 = false;
Serial.println(">>> Step 3 END");
}
// Шаг 4: реле НЕ включаются физически (безопасный тест)
if (millis() - Timer >= 9000 && millis() - Timer < 10000 && Flag4 == true) {
Serial.print(">>> Step 4 (no relays): Fan="); Serial.print(bitRead(relay, 0));
Serial.print(" 4way="); Serial.print(bitRead(relay, 1));
Serial.print(" Kompr="); Serial.print(bitRead(relay, 2));
Serial.print(" Pump="); Serial.println(bitRead(relay, 3));
Flag4 = false;
}
// Шаг 5: сброс цикла
if (millis() - Timer >= 10000) {
Serial.println(">>> Step 5: Cycle END");
Timer = millis();
Flag1 = true;
Flag2 = true;
Flag3 = true;
Flag4 = true;
}
}
то что на дисплей нечего не выводится теперь это нормально, давайте просто посмотрим что будет в мониторе порта