Pomoc Poszukuję sposobu na wysterowanie mojej podłogówki

Wszystko jest możliwe....

Ja bym do komunikacji z HA wykorzystał wifi z esp8266, które by się łączyło z Arduino przez port serial. Łączność z HA dla esp była by np. przez MQTT. 

Można też próbować bezpośrednio połączyć Arduino z serwerem z HA za pomocą tez portu serial. Dużo jest możliwości. Tylko wszystkie trzeba jakoś oprogramować w urządzeniach IoT. 

Nie wiem czy tak w ciemno ktoś coś napisze.  To może daj jakiś punkt wyjścia. Jak masz napisany skrypt. Może wystarczy go dopasować do potrzeb?

Co do termostatu, histerezy oraz stref. To powinieneś mieć w każdej strefie czujnik temperatury, który się komunikuje z Arduino np. właśnie przez ESP.

Generalnie, wydaje się, będzie ciężko to co napisałeś robić na odległość.

Ja aktualnie sobie połączyłem z siecią i domoticzem 2 liczniki energii przez rs485, konwerter rs485<->TTL oraz ESP8266. Komunikacja działa właśnie przez MQTT. Całe oprogramowanie pisałem z 2 tygodnie zanim byłem zadowolony. 

Dodane przez: @marekmazurek

↑

jak wskazać Generic Thermostat z której czujki ma czerpać informację o temperaturze?

Cały opis integracji termostatu jest w dokumentacji https://www.home-assistant.io/integrations/generic_thermostat/

Przykładowa konfiguracja gdzie ustalasz sobie nazwę tego termostatu, wskazujesz czym ma sterować i na podstawie którego czujnika.

climate:
  - platform: generic_thermostat
    name: Pokój 1
    heater: encja przekaźnik grzanie pokój 1
    target_sensor: encja czujnik pokój 1
    min_temp: 15
    max_temp: 25
    ac_mode: false
    target_temp: 21
    cold_tolerance: 0.3
    hot_tolerance: 0
    min_cycle_duration:
      seconds: 5
    keep_alive:
      minutes: 3
    initial_hvac_mode: "off"
    precision: 0.1

Sketch, który napisałeś jest twoją słodką tajemnicą, więc trudno się odnieść do tego co jest możliwe. Możliwe jest na 100% np wykorzystując Node Red wysłanie wartości z czujnika podłączonego do arduino, do HA. Na podstawie tej wartości termostat może wysłać informacje o swoim stanie do arduino. Generalnie wszystkie opcje termostatu zapisywane są w atrybutach encji, więc używając natywnych nodów https://flows.nodered.org/node/node-red-node-serialport   można wysłać - odebrać , lub wysłać komunikat z żądaniem odpowiedzi przed wysłaniem kolejnego.

Kod jest w kilku plikach. Chętnie go opublikuję tylko nie bardzo wiem jak to zrobić,  więc jeśli nabałaganię to proszę o wyrozumiałość. 

Wkleję poszczególne katalogi. 

1.

#include <avr/wdt.h>
#include <Wire.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "MsDelay.h"
#include "consts.h"
#include "utils.h"


#define ONE_WIRE_BUS 53
//One Wire
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);                    //Przekazania informacji do biblioteki

//###############################################################################################

int stan_Elektrozawor_Panorama = LOW;
int stan_Elektrozawor_Sypialnia_Spanie = LOW;
int stan_Elektrozawor_Jadalnia_Wykusz = LOW;
int stan_Elektrozawor_Przedpokoj = LOW;
int stan_Elektrozawor_Lazienka_Gora = LOW;
int stan_Elektrozawor_Sypialnia = LOW;
int stan_Elektrozawor_Taras_Polnoc = LOW;
int stan_Elektrozawor_Salon = LOW;
int stan_Elektrozawor_Przybudowka = LOW;
int stan_Elektrozawor_Lazienka_Dol = LOW;
int stan_Grzalka_Suszarki_Dol = LOW;
int stan_Grzalka_Suszarki_Gora = LOW;
int stan_Pompa_Suszarek = LOW;
int state = stateA;
int state0 = stateA0;
int state1 = stateA1;
int state2 = stateA2;
int state3 = stateA3;
int state4 = stateA4;
int state5 = stateA5;
int state6 = stateA6;
int state7 = stateA7;
int state8 = stateA8;

//################################################################################################

boolean stan_Bufor4 = false;
boolean stan_Bufor3 = false;
boolean stan_Bufor2 = false;
boolean stan_Histereza_Bufor2 = false;
boolean stan_Bufor1 = false;
boolean stan_Pompa_Podlogowki = false;
boolean stan_Podlogowka_Wykusz_Jadalnia = false;
boolean stan_Histereza_Wykusz_Jadalnia = false;
boolean stan_Podlogowka_Salon = false;
boolean stan_Histereza_Salon = false;
boolean stan_Salon_Regulator_Scienny = false;
boolean stan_Podlogowka_Przedpokoj = false;
boolean stan_Histereza_Przedpokoj= false;
boolean stan_Podlogowka_Lazienka_dol = false;
boolean stan_Histereza_Lazienka_dol = false;
boolean stan_Suszarki_Lazienka_Dol = false;
boolean stan_Podlogowka_Przybudowka = false;
boolean stan_Histereza_Podlogowka_Przybudowka = false;
boolean stan_Podlogowka_Panorama = false;
boolean stan_Histereza_Panorama= false;
boolean stan_Podlogowka_Sypialnia_Spanie = false;
boolean stan_Histereza_Sypialnia_Spanie = false;
boolean stan_Podlogowka_Sypialnia = false;
boolean stan_Histereza_Sypialnia = false;
boolean stan_Sypialnia_Regulator_Scienny  = false;
boolean stan_Podlogowka_Lazienka_Gora = false;
boolean stan_Histereza_Lazienka_Gora = false;
boolean stan_Suszarki_Lazienka_Gora = false;
boolean stan_Taras_Polnoc = false;

//###############################################################################################


float Temperatura17,Temperatura6;


int readIndex = 0;              // the index of the current reading

unsigned long opoznienie = 60000;

/*utworzenie obiektów delay*/

MsDelay delayCzasPompy;
MsDelay odczytTemperatury;
MsDelay odczytCisnienia;



void setup()
{
  Serial.begin(115200);
  Wire.begin();
  {
    wdt_enable(WDTO_8S);
  }


  sensors.begin(); //Inicjalizacja czujnikow
  sensors.setResolution(adresTemperatura1, 12);
  sensors.setResolution(adresTemperatura2, 12);
  sensors.setResolution(adresTemperatura3, 12);
  sensors.setResolution(adresTemperatura4, 12);
  sensors.setResolution(adresTemperatura5, 12);
  sensors.setResolution(adresTemperatura6, 12);
  sensors.setResolution(adresTemperatura7, 12);
  sensors.setResolution(adresTemperatura8, 12);
  sensors.setResolution(adresTemperatura9, 12);
  sensors.setResolution(adresTemperatura10, 12);
  sensors.setResolution(adresTemperatura11, 12);
  sensors.setResolution(adresTemperatura12, 12);
  sensors.setResolution(adresTemperatura13, 12);
  sensors.setResolution(adresTemperatura14, 12);
  sensors.setResolution(adresTemperatura15, 12);
  sensors.setResolution(adresTemperatura16, 12);
  sensors.setResolution(adresTemperatura17, 12);
  //sensors.setResolution(adresTemperatura18, 12);
  sensors.setResolution(adresTemperatura19, 12);
  sensors.setResolution(adresTemperatura20, 12);
  sensors.setResolution(adresTemperatura21, 12);
  sensors.setResolution(adresTemperatura22, 12);
  //sensors.setResolution(adresTemperatura23, 12);
  //sensors.setResolution(adresTemperatura24, 12);

  pinMode(ONE_WIRE_BUS, INPUT);
  pinMode(Elektrozawor_Panorama, OUTPUT);
  pinMode(Elektrozawor_Sypialnia_Spanie, OUTPUT);
  pinMode(Elektrozawor_Jadalnia_Wykusz, OUTPUT);
  pinMode(Elektrozawor_Przedpokoj, OUTPUT);
  pinMode(Elektrozawor_Lazienka_Gora, OUTPUT);
  pinMode(Elektrozawor_Sypialnia, OUTPUT);
  pinMode(Elektrozawor_Taras_Polnoc, OUTPUT);
  pinMode(Elektrozawor_Salon, OUTPUT);
  pinMode(Elektrozawor_Przybudowka, OUTPUT);
  pinMode(Elektrozawor_Lazienka_Dol,  OUTPUT);
  pinMode(Pompa_Podlogowki, OUTPUT);
  pinMode(Grzalka_Suszarki_Dow, OUTPUT);
  pinMode(Grzalka_Suszarki_Gora, OUTPUT);
  pinMode(Pompa_Suszarek, OUTPUT);


  odczytTemperatury.delay(8000);
  delayCzasPompy.delay(opoznienie);  // wstępna inicjalizacja delay


}


   




int getNewState()
{
    int value = Temperatura17;

    int stateXLeftMin = Temperatura17- sizeRangeB - sizeRangeX;
    int stateXLeftMax = Temperatura17 - sizeRangeB;

    int stateXRightMin = Temperatura17 + sizeRangeB;
    int stateXRightMax = Temperatura17 + sizeRangeB + sizeRangeX;

    if (value >= stateXLeftMin && value <= stateXLeftMax)
        return stateX;
    if (value >= stateXRightMin && value <= stateXRightMax)
        return stateX;

    if (value < stateXLeftMin)
        return stateA;
    if (value > stateXRightMax)
        return stateC;
    if (value > 40)
        return stateC;
    if (value < -40)
        return stateC;
    return stateB;
}

void setStateA()
{
    if (state == stateA)
        return;
stan_Histereza_Lazienka_dol = false;
    
}

void setStateB()
{
    if (state == stateB)
        return;
stan_Histereza_Lazienka_dol = true;
}

void setStateC()
{
    if (state == stateC)
        return;
stan_Histereza_Lazienka_dol = true;
}

int getNewState0()
{
    int value = Temperatura3;

    int stateX0LeftMin = Temperatura3 - sizeRangeB0 - sizeRangeX0;
    int stateX0LeftMax = Temperatura3 - sizeRangeB0;

    int stateX0RightMin = Temperatura3 + sizeRangeB0;
    int stateX0RightMax = Temperatura3 + sizeRangeB0 + sizeRangeX0;

    if (value >= stateX0LeftMin && value <= stateX0LeftMax)
        return stateX0;
    if (value >= stateX0RightMin && value <= stateX0RightMax)
        return stateX0;

    if (value < stateX0LeftMin)
        return stateA0;
    if (value > stateX0RightMax)
        return stateC0;
        
    return stateB0;
}

void setStateA0()
{
    if (state0 == stateA0)
        return;
stan_Histereza_Bufor2 = false;

}

void setStateB0()
{
    if (state0 == stateB0)
        return;
stan_Histereza_Bufor2 = true;
}

void setStateC0()
{
    if (state0 == stateC0)
        return;
stan_Histereza_Bufor2 = true;
}


int getNewState1()
{
    int value = Temperatura6;

    int stateX1LeftMin = Temperatura6 - sizeRangeB1 - sizeRangeX1;
    int stateX1LeftMax = Temperatura6 - sizeRangeB1;

    int stateX1RightMin = Temperatura6 + sizeRangeB1;
    int stateX1RightMax = Temperatura6 + sizeRangeB1 + sizeRangeX1;

    if (value >= stateX1LeftMin && value <= stateX1LeftMax)
        return stateX;
    if (value >= stateX1RightMin && value <= stateX1RightMax)
        return stateX;

    if (value < stateX1LeftMin)
        return stateA1;
    if (value > stateX1RightMax)
        return stateC1;
    if (value > 40)
        return stateC1;
    if (value < -40)
        return stateC1;

    return stateB1;
}

void setStateA1()
{
    if (state1 == stateA1)
        return;
stan_Histereza_Wykusz_Jadalnia = false;

}

void setStateB1()
{
    if (state1 == stateB)
        return;
stan_Histereza_Wykusz_Jadalnia = true;
}

void setStateC1()
{
    if (state1 == stateC)
        return;
stan_Histereza_Wykusz_Jadalnia = true;
}


int getNewState2()
{
    int value = Temperatura9;

    int stateX2LeftMin = Temperatura9 - sizeRangeB2 - sizeRangeX2;
    int stateX2LeftMax = Temperatura9 - sizeRangeB2;

    int stateX2RightMin = Temperatura9 + sizeRangeB2;
    int stateX2RightMax = Temperatura9 + sizeRangeB2 + sizeRangeX2;

    if (value >= stateX2LeftMin && value <= stateX2LeftMax)
        return stateX2;
    if (value >= stateX2RightMin && value <= stateX2RightMax)
        return stateX2;

    if (value < stateX2LeftMin)
        return stateA2;
    if (value > stateX2RightMax)
        return stateC2;
    if (value > 40)
        return stateC2;
    if (value < -40)
        return stateC2;
    return stateB2;
}

void setStateA2()
{
    if (state2 == stateA2)
        return;
stan_Histereza_Salon = false;

}

void setStateB2()
{
    if (state2 == stateB2)
        return;
stan_Histereza_Salon = true;
}

void setStateC2()
{
    if (state2 == stateC2)
        return;
stan_Histereza_Salon = true;
}

int getNewState3()
{
    int value = Temperatura12;

    int stateX3LeftMin = Temperatura12 - sizeRangeB3 - sizeRangeX3;
    int stateX3LeftMax = Temperatura12 - sizeRangeB3;

    int stateX3RightMin = Temperatura12 + sizeRangeB3;
    int stateX3RightMax = Temperatura12 + sizeRangeB3 + sizeRangeX3;

    if (value >= stateX3LeftMin && value <= stateX3LeftMax)
        return stateX3;
    if (value >= stateX3RightMin && value <= stateX3RightMax)
        return stateX3;

    if (value < stateX3LeftMin)
        return stateA3;
    if (value > stateX3RightMax)
        return stateC3;
          
    if (value > 40)
        return stateC3;
    if (value < -40)
        return stateC3;

    return stateB3;
}

void setStateA3()
{
    if (state3 == stateA3)
        return;
stan_Histereza_Przedpokoj = false;

}

void setStateB3()
{
    if (state3 == stateB3)
        return;
stan_Histereza_Przedpokoj= true;
}

void setStateC3()
{
    if (state3 == stateC3)
        return;
stan_Histereza_Przedpokoj = true;
}



int getNewState4()
{
    int value = Temperatura19;

    int stateX4LeftMin = Temperatura19 - sizeRangeB4 - sizeRangeX4;
    int stateX4LeftMax = Temperatura19 - sizeRangeB4;

    int stateX4RightMin = Temperatura19 + sizeRangeB4;
    int stateX4RightMax = Temperatura19 + sizeRangeB4 + sizeRangeX4;

    if (value >= stateX4LeftMin && value <= stateX4LeftMax)
        return stateX4;
    if (value >= stateX4RightMin && value <= stateX4RightMax)
        return stateX4;

    if (value < stateX4LeftMin)
        return stateA4;
    if (value > stateX4RightMax)
        return stateC4;
    if (value > 40)
        return stateC4;
    if (value < -40)
        return stateC4;

    return stateB4;
}

void setStateA4()
{
    if (state4 == stateA4)
        return;
stan_Histereza_Panorama = false;

}

void setStateB4()
{
    if (state4 == stateB4)
        return;
stan_Histereza_Panorama = true;
}

void setStateC4()
{
    if (state4 == stateC4)
        return;
stan_Histereza_Panorama = true;
}


int getNewState5()
{
    int value = Temperatura20;

    int stateX5LeftMin = Temperatura20 - sizeRangeB5 - sizeRangeX5;
    int stateX5LeftMax = Temperatura20 - sizeRangeB5;

    int stateX5RightMin = Temperatura20 + sizeRangeB5;
    int stateX5RightMax = Temperatura20 + sizeRangeB5 + sizeRangeX5;

    if (value >= stateX5LeftMin && value <= stateX5LeftMax)
        return stateX5;
    if (value >= stateX5RightMin && value <= stateX5RightMax)
        return stateX5;

    if (value < stateX5LeftMin)
        return stateA5;
    if (value > stateX5RightMax)
        return stateC5;
    if (value > 40)
        return stateC5;
    if (value < -40)
        return stateC5;
    return stateB5;
}

void setStateA5()
{
    if (state5 == stateA5)
        return;
stan_Histereza_Sypialnia_Spanie = false;

}

void setStateB5()
{
    if (state5 == stateB5)
        return;
stan_Histereza_Sypialnia_Spanie  = true;
}

void setStateC5()
{
    if (state5 == stateC5)
        return;
stan_Histereza_Sypialnia_Spanie  = true;
}

int getNewState6()
{
    int value = Temperatura21;

    int stateX6LeftMin = Temperatura21 - sizeRangeB6 - sizeRangeX6;
    int stateX6LeftMax = Temperatura21 - sizeRangeB6;

    int stateX6RightMin = Temperatura21 + sizeRangeB6;
    int stateX6RightMax = Temperatura21 + sizeRangeB6 + sizeRangeX6;

    if (value >= stateX6LeftMin && value <= stateX6LeftMax)
        return stateX6;
    if (value >= stateX6RightMin && value <= stateX6RightMax)
        return stateX6;

    if (value < stateX6LeftMin)
        return stateA6;
    if (value > stateX6RightMax)
        return stateC6;
 if (value > 40)
        return stateC6;
    if (value < -40)
        return stateC6;
       
    return stateB6;
}

void setStateA6()
{
    if (state6 == stateA6)
        return;
stan_Histereza_Sypialnia = false;

}

void setStateB6()
{
    if (state6 == stateB6)
        return;
stan_Histereza_Sypialnia = true;
}

void setStateC6()
{
    if (state6 == stateC6)
        return;
stan_Histereza_Sypialnia = true;
}


int getNewState7()
{
    int value = Temperatura22;

    int stateX7LeftMin = Temperatura22 - sizeRangeB7 - sizeRangeX7;
    int stateX7LeftMax = Temperatura22 - sizeRangeB7;

    int stateX7RightMin = Temperatura22 + sizeRangeB7;
    int stateX7RightMax = Temperatura22 + sizeRangeB7 + sizeRangeX7;

    if (value >= stateX7LeftMin && value <= stateX7LeftMax)
        return stateX7;
    if (value >= stateX7RightMin && value <= stateX7RightMax)
        return stateX7;

    if (value < stateX7LeftMin)
        return stateA7;
    if (value > stateX7RightMax)
        return stateC7;
 if (value > 40)
        return stateC7;
    if (value < -40)
        return stateC7;
       
    return stateB7;
}

void setStateA7()
{
    if (state7 == stateA7)
        return;
stan_Histereza_Lazienka_Gora = false;

}

void setStateB7()
{
    if (state6 == stateB7)
        return;
stan_Histereza_Lazienka_Gora = true;
}

void setStateC7()
{
    if (state7 == stateC7)
        return;
stan_Histereza_Lazienka_Gora = true;
}
  
int getNewState8()
{
    int value = Temperatura15;

    int stateX8LeftMin = Temperatura15 - sizeRangeB8 - sizeRangeX8;
    int stateX8LeftMax = Temperatura15 - sizeRangeB8;

    int stateX8RightMin = Temperatura15 + sizeRangeB8;
    int stateX8RightMax = Temperatura15 + sizeRangeB8 + sizeRangeX8;

    if (value >= stateX8LeftMin && value <= stateX8LeftMax)
        return stateX8;
    if (value >= stateX8RightMin && value <= stateX8RightMax)
        return stateX8;

    if (value < stateX8LeftMin)
        return stateA8;
    if (value > stateX8RightMax)
        return stateC8;
 if (value > 40)
        return stateC8;
    if (value < -40)
        return stateC8;
       
    return stateB8;
}

void setStateA8()
{
    if (state8 == stateA8)
        return;
stan_Histereza_Podlogowka_Przybudowka = false;

}

void setStateB8()
{
    if (state8 == stateB8)
        return;
stan_Histereza_Podlogowka_Przybudowka = true;
}

void setStateC8()
{
    if (state8 == stateC8)
        return;
stan_Histereza_Podlogowka_Przybudowka = true;
}
  

static void stan_Pompy(boolean state)
{
  if (state)   
  digitalWrite(14,LOW);
  else
  digitalWrite(14,HIGH);

  }


static void Ogrzewanie_Wykusz_Jadalnia(boolean state)
{
  if(state)
  digitalWrite(6,LOW);
  else
  digitalWrite(6,HIGH);
  
  
}

static void Ogrzewanie_Salonu(boolean state)
{
  if(state)
  digitalWrite(11,LOW);
  else
  digitalWrite(11,HIGH);
  
  
}
static void Ogrzewanie_Przedpokoj(boolean state)
{ 
 if(state)
  digitalWrite(7,LOW);
  else
  digitalWrite(7,HIGH);
 
}
static void Ogrzewanie_Dolnej_Lazienki(boolean state)
{
if(state)
  digitalWrite(13,LOW);
  else
  digitalWrite(13,HIGH);
  
}
static void Ogrzewanie_Przybudowki(boolean state)
{
if(state)
  digitalWrite(12,LOW);
  else
  digitalWrite(12,HIGH);
  
}

static void Ogrzewanie_Panoramy(boolean state)
{
 if(state)
  digitalWrite(4,LOW);
  else
  digitalWrite(4,HIGH);
  
}
static void Ogrzewanie_Sypialni_Spanie(boolean state)
{ 
  if(state)
  digitalWrite(5,LOW);
  else
  digitalWrite(5,HIGH);
 
}
static void Ogrzewanie_Sypialni(boolean state)
{
   if(state)
  digitalWrite(9,LOW);
  else
  digitalWrite(9,HIGH);
  
}
static void Ogrzewanie_Gornej_Lazienki(boolean state)
{
if(state)
  digitalWrite(8,LOW);
  else
  digitalWrite(8,HIGH);
  
}
static void Ogrzewanie_Tarasu_Polnocnego(boolean state)
{
  if(state)
  digitalWrite(10,LOW);
  else
  digitalWrite(10,HIGH);
}
void loop(void) {
  
  unsigned long time_start = micros();

  sensors.requestTemperatures();
  float Temperatura1 = (sensors.getTempC(adresTemperatura1));
  float Temperatura2 = (sensors.getTempC(adresTemperatura2));
  float Temperatura3 = (sensors.getTempC(adresTemperatura3));
  float Temperatura4 = (sensors.getTempC(adresTemperatura4));
  float Temperatura5 = (sensors.getTempC(adresTemperatura5));
  float Temperatura6 = (sensors.getTempC(adresTemperatura6));
  float Temperatura7 = (sensors.getTempC(adresTemperatura7));
  float Temperatura8 = (sensors.getTempC(adresTemperatura8));
  float Temperatura9 = (sensors.getTempC(adresTemperatura9));
  float Temperatura10 = (sensors.getTempC(adresTemperatura10));
  float Temperatura11 = (sensors.getTempC(adresTemperatura11));
  float Temperatura12 = (sensors.getTempC(adresTemperatura12));
  float Temperatura13 = (sensors.getTempC(adresTemperatura13));
  float Temperatura14 = (sensors.getTempC(adresTemperatura14));
  float Temperatura15 = (sensors.getTempC(adresTemperatura15));
  float Temperatura16 = (sensors.getTempC(adresTemperatura16));
  float Temperatura17 = (sensors.getTempC(adresTemperatura17));
  // float Temperatura18 = (sensors.getTempC(adresTemperatura18));
  float Temperatura19 = (sensors.getTempC(adresTemperatura19));
  float Temperatura20 = (sensors.getTempC(adresTemperatura20));
  float Temperatura21 = (sensors.getTempC(adresTemperatura21));
  float Temperatura22 = (sensors.getTempC(adresTemperatura22));
  // float Temperatura23 = (sensors.getTempC(adresTemperatura23));
  // float Temperatura24 = (sensors.getTempC(adresTemperatura24));





  if (odczytTemperatury.expire())                                 // Kiedy cykl odczytu czujnika temperatury minie


  {
    odczytTemperatury.delay(8000);                                          // odczytaj ponownie za chwilkę
  }

  if (Temperatura3 > Zadana_Temperatura_Bufor2 &&  Temperatura3  > 0
  )
  {
   stan_Bufor2 = true;
    
  }

  else
  {
    stan_Bufor2 = false;
  }

int newState0 = getNewState0();

    switch (newState0) {
    case stateA0:
        setStateA0();
        break;
    case stateB0:
        setStateB0();
        break;
    case stateC0:
        setStateC0();
        break;
    }

  /*Panorama*/

  int newState4 = getNewState4();

    switch (newState4) {
    case stateA4:
        setStateA4();
        break;
    case stateB4:
        setStateB4();
        break;
    case stateC4:
        setStateC4();
        break;
    }
  if ((Temperatura19 < Zadana_Temperatura_Panorama
      && stan_Histereza_Panorama
      && Temperatura3 > Temperatura19)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Panorama  = true;
    
  }

  else
  {
    stan_Podlogowka_Panorama = false;
  }
  Ogrzewanie_Panoramy(stan_Podlogowka_Panorama);
  

  /*Sypialnia Spanie*/

  int newState5 = getNewState5();

    switch (newState5) {
    case stateA5:
        setStateA5();
        break;
    case stateB5:
        setStateB5();
        break;
    case stateC5:
        setStateC5();
        break;
    }
  if ((Temperatura20 < Zadana_Temperatura_Sypialnia_Spanie
      && stan_Histereza_Sypialnia_Spanie
      && Temperatura3 > Temperatura20)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Sypialnia_Spanie  = true;
  }

  else
  {
    stan_Podlogowka_Sypialnia_Spanie = false;
  }
Ogrzewanie_Sypialni_Spanie(stan_Podlogowka_Sypialnia_Spanie);


  /*Ogrzewanie Wykusz i Jadalnia*/

  int newState1 = getNewState1();

    switch (newState1) {
    case stateA1:
        setStateA1();
        break;
    case stateB1:
        setStateB1();
        break;
    case stateC1:
        setStateC1();
        break;
    }

  if ((Temperatura5 < Zadana_Temperatura_Wykusz_Jadalnia
      && stan_Histereza_Wykusz_Jadalnia
      || Temperatura6 < Zadana_Temperatura_Wykusz_Jadalnia
      && Temperatura3 > Temperatura5
      && Temperatura3 > Temperatura6)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Wykusz_Jadalnia  = true;
  }

  else
  {
    stan_Podlogowka_Wykusz_Jadalnia = false;
  }
 Ogrzewanie_Wykusz_Jadalnia(stan_Podlogowka_Wykusz_Jadalnia);

 
  /*Ogrzewanie Przedpokój*/

  int newState3 = getNewState3();

    switch (newState3) {
    case stateA3:
        setStateA3();
        break;
    case stateB3:
        setStateB3();
        break;
    case stateC3:
        setStateC3();
        break;
    }
  if ((Temperatura12 < Zadana_Temperatura_Przedpokoj
      && stan_Histereza_Przedpokoj 
      || Temperatura13 < Zadana_Temperatura_Przedpokoj
      && Temperatura3 > Temperatura12
      && Temperatura3 > Temperatura13)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Przedpokoj = true;
  }
  else
  {
    stan_Podlogowka_Przedpokoj = false;
  }
  Ogrzewanie_Przedpokoj(stan_Podlogowka_Przedpokoj);
  


  /*Ogrzewanie Łazienka Góra*/
  
  int newState7 = getNewState7();

    switch (newState7) {
    case stateA7:
        setStateA7();
        break;
    case stateB7:
        setStateB7();
        break;
    case stateC7:
        setStateC7();
        break;
    }

  if ((Temperatura22 < Zadana_Temperatura_Lazienka_Gora
      && stan_Histereza_Lazienka_Gora
      && Temperatura3 > Temperatura22)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Lazienka_Gora = true;
  }
  else
  {
    stan_Podlogowka_Lazienka_Gora = false;
  }
  Ogrzewanie_Gornej_Lazienki(stan_Podlogowka_Lazienka_Gora);
 
  
  /*Ogrzewanie Sypialnia*/

  int newState6 = getNewState6();

    switch (newState6) {
    case stateA6:
        setStateA6();
        break;
    case stateB6:
        setStateB6();
        break;
    case stateC6:
        setStateC6();
        break;
    }

  if ((Temperatura21 < Zadana_Temperatura_Sypialnia
      && stan_Histereza_Sypialnia
      && Temperatura3 > Temperatura21)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Sypialnia = true;  
  }

  else
  {
    stan_Podlogowka_Sypialnia = false;
  }
  Ogrzewanie_Sypialni(stan_Podlogowka_Sypialnia);


  /*Taras Północny*/

  if ((Temperatura7 < Zadana_Temperatura_Taras_Polnoc
      && Temperatura3 > Temperatura7)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Taras_Polnoc = true;
  }

  else
  {
    stan_Taras_Polnoc = false;
  }
 Ogrzewanie_Tarasu_Polnocnego(stan_Taras_Polnoc);


  /*Ogrzewanie Salon*/

  int newState2 = getNewState2();

    switch (newState2) {
    case stateA2:
        setStateA2();
        break;
    case stateB2:
        setStateB2();
        break;
    case stateC2:
        setStateC2();
        break;
    }

  if ((Temperatura7< Zadana_Temperatura_Salon
      || Temperatura8 < Zadana_Temperatura_Salon
      || Temperatura9 < Zadana_Temperatura_Salon
      || Temperatura10 < Zadana_Temperatura_Salon
      || Temperatura11 < Zadana_Temperatura_Salon
      && Temperatura3 > Temperatura7
      && Temperatura3 > Temperatura8
      && Temperatura3 > Temperatura9
      && Temperatura3 > Temperatura10
      && Temperatura3 > Temperatura11
      && stan_Histereza_Salon)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Salon  = true;
  }

  else
  {
    stan_Podlogowka_Salon = false;
  }
  Ogrzewanie_Salonu(stan_Podlogowka_Salon);

  /*Przybudówka*/
   int newState8 = getNewState8();
 switch (newState8) {
    case stateA8:
        setStateA8();
        break;
    case stateB8:
        setStateB8();
        break;
    case stateC8:
        setStateC8();
        break;
    }
  if (Temperatura15 < Zadana_Temperatura_Przybudowka
  && Temperatura3 >= Zadana_Temperatura_Bufor2)
  {
    stan_Podlogowka_Przybudowka = true;
  }

  else
  {
    stan_Podlogowka_Przybudowka = false;
  }
 Ogrzewanie_Przybudowki(stan_Podlogowka_Przybudowka);

  /*Łazienka Parter*/

  int newState = getNewState();

    switch (newState) {
    case stateA:
        setStateA();
        break;
    case stateB:
        setStateB();
        break;
    case stateC:
        setStateC();
        break;
    }

  if ((Temperatura16 <= Zadana_Temperatura_Lazienka_dol 
      && stan_Histereza_Lazienka_dol
      || Temperatura17 < Zadana_Temperatura_Lazienka_dol)
      && Temperatura3 >= Zadana_Temperatura_Bufor2)
    
  {
    stan_Podlogowka_Lazienka_dol = true;
   
  }

  else
  {
    stan_Podlogowka_Lazienka_dol = false;
  }
  Ogrzewanie_Dolnej_Lazienki(stan_Podlogowka_Lazienka_dol);

  if ((stan_Podlogowka_Wykusz_Jadalnia 
|| stan_Podlogowka_Salon  
|| stan_Podlogowka_Przedpokoj 
|| stan_Podlogowka_Lazienka_dol
|| stan_Suszarki_Lazienka_Dol
|| stan_Podlogowka_Przybudowka
|| stan_Podlogowka_Panorama 
|| stan_Podlogowka_Sypialnia_Spanie
|| stan_Podlogowka_Sypialnia
|| stan_Sypialnia_Regulator_Scienny
|| stan_Podlogowka_Lazienka_Gora
|| stan_Suszarki_Lazienka_Gora
|| stan_Taras_Polnoc)
&& Temperatura3 >= Zadana_Temperatura_Bufor2
)
  
{
    stan_Pompa_Podlogowki  = true;
    
  }

  else
  {
    stan_Pompa_Podlogowki = false;
  }
  stan_Pompy(stan_Pompa_Podlogowki);
  
  Serial.println("");
  Serial.print("Bufor Góra: ");
  Serial.print(Temperatura1);
  Serial.println(" °C");
  Serial.print("Bufor 3/4: ");
  Serial.print(Temperatura2);
  Serial.println(" °C");
  Serial.print("Bufor 2/4: ");
  Serial.print(Temperatura3);
  Serial.println(" °C");
  Serial.print("Bufor Dół: ");
  Serial.print(Temperatura4);
  Serial.println(" °C");
   if (stan_Bufor2) {
   
    Serial.println("Temperatura minimalna Bufora osiągnieta ");
  Serial.println("");
  }
  if (!stan_Bufor2) {
    Serial.println("Temperatura minimalna Bufora nie osiągnieta ");
  Serial.println("");
  }
  if (stan_Pompa_Podlogowki) {
    Serial.println("Pompa aktywna");
  Serial.println("");
  }
  Serial.println("");
  Serial.print("Wykusz: ");
  Serial.print(Temperatura5);
  Serial.println(" °C");
  Serial.print("Jadalnia: ");
  Serial.print(Temperatura6);
  Serial.println(" °C");

  if (stan_Podlogowka_Wykusz_Jadalnia) {
    Serial.println("Wykusz i Jadalnia są ogrzewane");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Salon róg prawy: ");
  Serial.print(Temperatura11 );
  Serial.println(" °C");
  Serial.print("Salon róg lewy: ");
  Serial.print(Temperatura7 );
  Serial.println(" °C");
  Serial.print("Salon środek: ");
  Serial.print(Temperatura10 );
  Serial.println(" °C");
  Serial.print("Salon pod oknem: ");
  Serial.print(Temperatura8 );
  Serial.println(" °C");
  Serial.print("Salon przed kanapą: ");
  Serial.print(Temperatura9 );
  Serial.println(" °C");
  if (stan_Podlogowka_Salon) {
    Serial.print("Salon jest ogrzewany");
  }
  Serial.println("");
  Serial.println("");
  Serial.print("Przedpokój przy drzwiach: ");
  Serial.print(Temperatura12 );
  Serial.println(" °C");
  Serial.print("Nad Buforem: ");
  Serial.print(Temperatura13 );
  Serial.println(" °C");
  if (stan_Podlogowka_Przedpokoj) {
    Serial.print("Przedpokój jest ogrzewany");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Łazienka dolna przód: ");
  Serial.print(Temperatura16 );
  Serial.println(" °C");
  Serial.print("Łzienka dolna Kabina ");
  Serial.print(Temperatura17 );
  Serial.println(" °C");
  if (stan_Podlogowka_Lazienka_dol) {
    Serial.print("Łazienka dolna jest ogrzewana");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Panorama: ");
  Serial.print(Temperatura19 );
  Serial.println(" °C");
  if (stan_Podlogowka_Panorama) {
    Serial.print("Panorama jest ogrzewana");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Sypialnia Spanie: ");
  Serial.print(Temperatura20 );
  Serial.println(" °C");
  if (stan_Podlogowka_Sypialnia_Spanie) {
    Serial.print("Sypialnia Spanie jest ogrzewana");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Sypialnia: ");
  Serial.print(Temperatura21 );
  Serial.println(" °C");
  if (stan_Podlogowka_Sypialnia) {
    Serial.print("Sypialnia jest ogrzewana");
    Serial.println("");
  }
  Serial.println("");
  Serial.print("Łazienka góra: ");
  Serial.print(Temperatura22 );
  Serial.println(" °C");
  if (stan_Podlogowka_Lazienka_Gora) {
    Serial.print("Górna łazienka jest ogrzewana");
    Serial.println("");
     }
  Serial.println("");
  Serial.print("Przybudówka: ");
  Serial.print(Temperatura15);
  Serial.println(" °C");
  Serial.print(Temperatura14);
  Serial.println(" °C");
  if (stan_Podlogowka_Przybudowka) {
    Serial.print("Przybudówka jest ogrzewana");
    Serial.println("");
 }
  odczytTemperatury.delay(10000);  // odnowienie opóźnienia*/
  wdt_reset();
}

#include "MsDelay.h"

MsDelay::MsDelay(){
  
}
MsDelay::~MsDelay(){
  
}
void  MsDelay::delay(unsigned long del){
    this->delay_cnt = del + millis();
}
    
bool  MsDelay::expire(void){
    return !(this->delay_cnt > millis());
}

/***************************************************
MsDelay class
 ****************************************************/

#ifndef MS_DELAY_H
#define MS_DELAY_H

#include "Arduino.h"


class MsDelay
{
  public:
    MsDelay();
    ~MsDelay();

     void delay(unsigned long del);
     bool expire(void);


private:
    unsigned long delay_cnt;
};  

#endif

#ifndef CONSTS_H
#define CONSTS_H

//Adresy oneWire
DeviceAddress adresTemperatura1 = {0x28, 0xA4, 0x15, 0x40, 0x13, 0x21, 0x1, 0x25 };//Bufor góra
DeviceAddress adresTemperatura2 = {0x28, 0x70, 0x10, 0xDE, 0x17, 0x20, 0x6, 0xC2 }; //Bufor 3/4
DeviceAddress adresTemperatura3 = {0x28, 0xCF, 0x3, 0x2B, 0x13, 0x21, 0x1, 0xFA}; //Bufor 2/4
DeviceAddress adresTemperatura4 = {0x28, 0x70, 0x9E, 0x1C, 0x13, 0x21, 0x1, 0x4C}; //Bufor dół
DeviceAddress adresTemperatura5 = {0x28, 0xCE, 0x6D, 0xED, 0x17, 0x20, 0x6, 0x97 }; //Wykusz
DeviceAddress adresTemperatura6 = {0x28, 0xFE, 0x35, 0x3E, 0x13, 0x21, 0x1, 0x81 }; //Jadalnia
DeviceAddress adresTemperatura7 = {0x28, 0xE7, 0xAF, 0xE5, 0x17, 0x20, 0x6, 0xA };//Salon lewy róg
DeviceAddress adresTemperatura8 = {0x28, 0xAA, 0xB1, 0xC4, 0x4F, 0x14, 0x1, 0xDF };// Salon pod oknem
DeviceAddress adresTemperatura9 = {0x28, 0xC6, 0x56, 0x25, 0x13, 0x21, 0x1, 0x3E };// Salon przed kanapą
DeviceAddress adresTemperatura10 = {0x28, 0x23, 0xCC, 0x95, 0xF0, 0x1, 0x3C, 0xC6 };//Salon środek
DeviceAddress adresTemperatura11 = {0x28, 0xAA, 0x41, 0xB6, 0x3B, 0x14, 0x1, 0xA7 };//Salon prawy róg
DeviceAddress adresTemperatura12 = {0x28, 0xAA, 0xE2, 0xCD, 0x4F, 0x14, 0x1, 0x97 };//Przedpokój pod drzwiami
DeviceAddress adresTemperatura13 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Przedpokój nad buforem
//DeviceAddress adresTemperatura14 = {};//Przedpokuj środek
//DeviceAddress adresTemperatura15 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Przedpokój/ salon
DeviceAddress adresTemperatura16 = {0x28, 0xAA, 0xB0, 0xE4, 0x4F, 0x14, 0x1, 0x62 };//Łazienka dolna przód
DeviceAddress adresTemperatura17 = {0x28, 0xAA, 0xF0, 0xD7, 0x4F, 0x14, 0x1, 0x4B };//Łazienka dolna kabina
//DeviceAddress adresTemperatura18 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Łazienka dolna suszarka
DeviceAddress adresTemperatura19 = {0x28, 0x20, 0xA, 0xDC, 0x17, 0x20, 0x6, 0x2A };//Panorama
DeviceAddress adresTemperatura20 = {0x28, 0x5, 0x5F, 0x95, 0xF0, 0x1, 0x3C, 0x3B };//Sypialnia pod łużkiem
DeviceAddress adresTemperatura21 = {0x28, 0x62, 0x24, 0x45, 0x13, 0x21, 0x1, 0xC0};//Sypialnia
//DeviceAddress adresTemperatura22 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Łazienka górna podłoga
//DeviceAddress adresTemperatura23 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Łazienka górna suszarka
//DeviceAddress adresTemperatura24 = {0x28, 0xAA, 0x5B, 0xD1, 0x4F, 0x14, 0x1, 0x1 };//Taras północny


//Piny
const int Elektrozawor_Panorama = 4;
const int Elektrozawor_Sypialnia_Spanie = 5;
const int Elektrozawor_Jadalnia_Wykusz = 6;
const int Elektrozawor_Przedpokoj = 7;                                   
const int Elektrozawor_Lazienka_Gora = 8;                                  
const int Elektrozawor_Sypialnia = 9;                                  
const int Elektrozawor_Taras_Polnoc = 10;                              
const int Elektrozawor_Salon = 11;                              
const int Elektrozawor_Przybudowka = 12; 
const int Elektrozawor_Lazienka_Dol = 13;
const int Pompa_Podlogowki = 14;
const int Grzalka_Suszarki_Dow =15;
const int Grzalka_Suszarki_Gora =16;
const int Pompa_Suszarek =17;
const float Zadana_Temperatura_Bufor2 = 60;
const float Zadana_Temperatura_Panorama = 25;
const float Zadana_Temperatura_Sypialnia_Spanie = 23;
const float Zadana_Temperatura_Wykusz_Jadalnia = 25;
const float Zadana_Temperatura_Przedpokoj = 25;
const float Zadana_Temperatura_Lazienka_Gora = 0;
const float Zadana_Temperatura_Suszarki_Lazienka_Gora = 25;
const float Zadana_Temperatura_Sypialnia = 24;
const float Zadana_Temperatura_Sypialnia_Regulator_Scienny = 24;
const float Zadana_Temperatura_Lazienka_dol = 33;
const float Zadana_Temperatura_Suszarki_Lazienka_Dol = 2;
const float Zadana_Temperatura_Przybudowka = 0;
const float Zadana_Temperatura_Taras_Polnoc = 0;
const float Zadana_Temperatura_Salon = 25;
const float Zadana_Temperatura_Salon_Regulator_Scienny = 24;



const int Temperatura3 = Zadana_Temperatura_Bufor2; 

const int sizeRangeX0 = 1;
const int sizeRangeB0 = 1;

const int state_X0_left_min = Temperatura3 - sizeRangeB0 - sizeRangeX0;
const int state_X0_left_max = Temperatura3 - sizeRangeB0;

const int state_X8_right_min = Temperatura3 + sizeRangeB0;
const int state_X8_right_max = Temperatura3 + sizeRangeB0 + sizeRangeX0;

const int stateX0 = 0;
const int stateA0 = 1;
const int stateB0 = 2;
const int stateC0 = 3;

const int temperatura17 = Zadana_Temperatura_Lazienka_dol;

const int sizeRangeX = 1;
const int sizeRangeB = 1;

const int state_X_left_min = temperatura17 - sizeRangeB - sizeRangeX;
const int state_X_left_max = temperatura17 - sizeRangeB;

const int state_X_right_min = temperatura17 + sizeRangeB;
const int state_X_right_max = temperatura17 + sizeRangeB + sizeRangeX;

const int stateX = 0;
const int stateA = 1;
const int stateB = 2;
const int stateC = 3;



const int temperatura6 = Zadana_Temperatura_Wykusz_Jadalnia;

const int sizeRangeX1 = 2;
const int sizeRangeB1 = 2;

const int state_X1_left_min = temperatura6 - sizeRangeB1 - sizeRangeX1;
const int state_X1_left_max = temperatura6 - sizeRangeB1;

const int state_X1_right_min = temperatura6 + sizeRangeB1;
const int state_X1_right_max = temperatura6 + sizeRangeB1 + sizeRangeX1;

const int stateX1 = 0;
const int stateA1 = 1;
const int stateB1 = 2;
const int stateC1 = 3;


const int Temperatura9 = Zadana_Temperatura_Salon; 

const int sizeRangeX2 = 1;
const int sizeRangeB2 = 1;

const int state_X2_left_min = Temperatura9 - sizeRangeB2 - sizeRangeX2;
const int state_X2_left_max = Temperatura9 - sizeRangeB2;

const int state_X2_right_min = Temperatura9 + sizeRangeB2;
const int state_X2_right_max = Temperatura9 + sizeRangeB2 + sizeRangeX2;

const int stateX2 = 0;
const int stateA2 = 1;
const int stateB2 = 2;
const int stateC2 = 3;

const int Temperatura12 = Zadana_Temperatura_Przedpokoj; 

const int sizeRangeX3 = 1;
const int sizeRangeB3 = 1;

const int state_X3_left_min = Temperatura12 - sizeRangeB3 - sizeRangeX3;
const int state_X3_left_max = Temperatura12 - sizeRangeB3;

const int state_X3_right_min = Temperatura12 + sizeRangeB3;
const int state_X3_right_max = Temperatura12 + sizeRangeB3 + sizeRangeX3;

const int stateX3 = 0;
const int stateA3 = 1;
const int stateB3 = 2;
const int stateC3 = 3;


const int Temperatura19 = Zadana_Temperatura_Panorama; 

const int sizeRangeX4 = 1;
const int sizeRangeB4 = 1;

const int state_X4_left_min = Temperatura19 - sizeRangeB4 - sizeRangeX4;
const int state_X4_left_max = Temperatura19 - sizeRangeB4;

const int state_X4_right_min = Temperatura19 + sizeRangeB4;
const int state_X4_right_max = Temperatura19 + sizeRangeB4 + sizeRangeX4;

const int stateX4 = 0;
const int stateA4 = 1;
const int stateB4 = 2;
const int stateC4 = 3;


const int Temperatura20 = Zadana_Temperatura_Sypialnia_Spanie; 

const int sizeRangeX5 = 1;
const int sizeRangeB5 = 1;

const int state_X5_left_min = Temperatura20 - sizeRangeB5 - sizeRangeX5;
const int state_X5_left_max = Temperatura20 - sizeRangeB5;

const int state_X5_right_min = Temperatura20 + sizeRangeB5;
const int state_X5_right_max = Temperatura20 + sizeRangeB5 + sizeRangeX5;

const int stateX5 = 0;
const int stateA5 = 1;
const int stateB5 = 2;
const int stateC5 = 3;


const int Temperatura21 = Zadana_Temperatura_Sypialnia_Spanie; 

const int sizeRangeX6 = 1;
const int sizeRangeB6 = 1;

const int state_X6_left_min = Temperatura21 - sizeRangeB6 - sizeRangeX6;
const int state_X6_left_max = Temperatura21 - sizeRangeB6;

const int state_X6_right_min = Temperatura21 + sizeRangeB6;
const int state_X6_right_max = Temperatura21 + sizeRangeB6 + sizeRangeX6;

const int stateX6 = 0;
const int stateA6 = 1;
const int stateB6 = 2;
const int stateC6 = 3;




// Stałe do przeliczeń



//Zewnetrzne warunki pogodowe
const float Temperatura_Zewnetrzna= 30;
const float Wilgotnosc_Zewnetrzna= 30;
//Kominek
//Czujnik tlenku węgla
const float Maksymalne_stezenie_CO_Komory_Wietrzenia_Komina= 30;
// Czujnik wilgotności
const float Wilgotnosc_Komory_Wietrzenia_Komina= 0;
const float Wilgotnosc_Powietrza_Zasilajacego_Kominek= 0;
const float Wilgotnosc_Powietrza_Zasilajacego_Wietrzenie_Komina= 0;

//Temperatury Kominka
const float Temperatura_Spalin= 30;
const float Maxymalna_Temperatura_Spalin= 300;
const float Temperatura_Placzcza_Wodnego= 300;
const float Maxymalna_Temperatura_Placzcza_Wodnego= 85;
const float Temperatura_Powietrza_Zasilajacego_Kominek= 0;
const float Temperatura_Komory_Wietrzenia_Komina = 100;
const float Krytyczna_Temperatura_Komory_Wietrzenia_Komina = 200;
const float Temperatura_Powietrza_Zasilajacego_Wietrzenie_Komina = 100;
const float HISTEREZA_Komory_Wietrzenia_Komina= 1;


// Temperatury zasilania suszarek ręczników
const float Minimalna_Temperatura_Zasilania_Suszarek_Recznikow= 30;
const float HISTEREZA_Suszarek_Recznikow= 1;

// Temperatury rozdzielacza podłogówki
const float Zadana_Temperatura_Zasilania_Podlogowki = 24;
const float Zadana_Temperatura_Powrotu_Podlogowki = 24;
const float HISTEREZA_Podlogowki = 1;

// Trmperatura Bufor
const float Zadana_Temperatura_Bufor_Izolacja1 = 24;// Trmperatura Piwnica 3 (izolacja bufora wewnątrz)
const float Zadana_Temperatura_PBufor_Izolacja2 = 24;// Trmperatura Piwnica 3 (izolacja bufora zewnątrz)
const float Zadana_Temperatura_Bufor4 = 80;
const float HISTEREZA_Bufor4 = 1;
const float Zadana_Temperatura_Bufor3 = 65;
const float HISTEREZA_Bufor3  = 1;

const float HISTEREZA_Bufor2  = 1;
const float Zadana_Temperatura_Bufor1 = 25;
const float HISTEREZA_Bufor1  = 1;
const float Zadana_Temperatura_Bufor0= 24;// Trmperatura Piwnica 3(pod buforem)
const float HISTEREZA_Bufor0 = 1;





// Trmperatura Piwnica
const float Zadana_Temperatura_Piwnica1 = 24;
const float HISTEREZA_Piwnica1  = 1;
const float Zadana_Temperatura_Piwnica1_Podloga = 24;
const float HISTEREZA_Piwnica1_Podloga  = 1;
const float Zadana_Temperatura_Piwnica2 = 24;
const float HISTEREZA_Piwnica2 = 1;
const float Zadana_Temperatura_Piwnica2_Podloga = 24;
const float HISTEREZA_Piwnica2_Podloga  = 1;
const float Zadana_Temperatura_Piwnica3 = 24;
const float HISTEREZA_Piwnica3 = 1;
const float Zadana_Temperatura_Piwnica3_Podloga = 24;
const float HISTEREZA_Piwnica3_Podloga  = 1;




// Temperatura Suszarka lazienka góra

const float HISTEREZA_Suszarki_Lazienka_Gora = 1;

// Temperatura Taras Północny

const float HISTEREZA_Taras_Polnoc = 1;


#endif

#ifndef UTILS_H
#define UTILS_H

#include <OneWire.h>

#include "consts.h"


#endif

Co prawda nie jestem profesjonalistą ale może uda się ogarnąć kod. Na razie zauważyłem zmienne które się dublują, redefiniują, i w ogóle nie wiadomo która wartość w funkcjach jest brana pod uwagę tak dla przykładu:

w pliku consts.h jest taka definicja

"const int Temperatura3 = Zadana_Temperatura_Bufor2;"

potem w kodzie jest

"float Temperatura3 = (sensors.getTempC(adresTemperatura3));"

no to w końcu Temperatura3 jest stałą czy zmienną. w rezultacie wydaje mi się że funkcja

int getNewState0()
{
    int value = Temperatura3;

    int stateX0LeftMin = Temperatura3 - sizeRangeB0 - sizeRangeX0;
    int stateX0LeftMax = Temperatura3 - sizeRangeB0;

    int stateX0RightMin = Temperatura3 + sizeRangeB0;
    int stateX0RightMax = Temperatura3 + sizeRangeB0 + sizeRangeX0;

    if (value >= stateX0LeftMin && value <= stateX0LeftMax)
        return stateX0;
    if (value >= stateX0RightMin && value <= stateX0RightMax)
        return stateX0;

    if (value < stateX0LeftMin)
        return stateA0;
    if (value > stateX0RightMax)
        return stateC0;
        
    return stateB0;
}

ma "value"  równe to co jest ustawione jako stała a nie zmienna... i nigdy się nie zmienia.

Ja realizuję to przy pomocy ESP32 z wgraną Tasmotą, czujniki temp. zigbee wszystko "złączone" w HA po mqtt i automatyka w node-red. Bardzo proste i bezawaryjne (3 lata 4 pętle grzewcze).

@Marek Mazurek sobie tak dalej przeglądam kod i mam parę pytań.

1) Jak jest w salonie 5 czujek a elektrozawór 1 to ogrzewanie ma się załączyć gdy chociaż jedna pokaże poniżej zadanej temperatury? Czy ma być jeden czujnik sterujący? (Dotyczy to też innych pomieszczeń gdzie jest więcej niż jeden czujnik) Na początku myślałem że tyle ile jest czujników w danym pomieszczeniu tyle jest elektrozaworów.

2) Suszarka/ki to jakiś osobny obwód?

3) Rozumiem, że jeśli spadnie temperatura buforu poniżej jakiejś wartości to np załączy się blokada pompy do podłogówki i suszarki?

4) Po co tyle czujników w buforze nie wystarczy jeden na górze?

Dodane przez: @steel_rat

↑

Co prawda nie jestem profesjonalistą ale może uda się ogarnąć kod. Na razie zauważyłem zmienne które się dublują, redefiniują, i w ogóle nie wiadomo która wartość w funkcjach jest brana pod uwagę tak dla przykładu:

w pliku consts.h jest taka definicja

"const int Temperatura3 = Zadana_Temperatura_Bufor2;"

potem w kodzie jest

"float Temperatura3 = (sensors.getTempC(adresTemperatura3));"

no to w końcu Temperatura3 jest stałą czy zmienną. w rezultacie wydaje mi się że funkcja

Rzeczywiście to może być przyczyną. Jak pisałem kod pracował sezony i poza histerezą nie maiłem z nim problemu. Upierdliwa była tylko zmiana temperatury zadanej poszczególnych stref i zastanawiałem się nad możliwością wysterowania tego przez Mysensor lub MQTT z poziomu Home Assistant.

Dodane przez: @irken

↑

Ja realizuję to przy pomocy ESP32 z wgraną Tasmotą, czujniki temp. zigbee wszystko "złączone" w HA po mqtt i automatyka w node-red. Bardzo proste i bezawaryjne (3 lata 4 pętle grzewcze).

Ja właśnie przejściowo zmieściłem wszystko na jednej płytce ESP 32 i ESP Home pod Home Assistant. Mimo to ogarnięcie tego na arduino mega i stworzenie możliwości sterowania z panelu HA daje o wiele bezpieczniejsze sterowanie.

1.Arduino mega jest jednostką niezależną która działa nawet kiedy padnie sieć - autonomicznie.

2. Ilość wejść-wyjść obsłuży praktycznie każdą instalację

ESPHome też może być jednostką autonomiczną , działającą bez HA , bez sieci... 

Dodane przez: @steel_rat

↑

1) Jak jest w salonie 5 czujek a elektrozawór 1 to ogrzewanie ma się załączyć gdy chociaż jedna pokaże poniżej zadanej temperatury? Czy ma być jeden czujnik sterujący? (Dotyczy to też innych pomieszczeń gdzie jest więcej niż jeden czujnik) Na początku myślałem że tyle ile jest czujników w danym pomieszczeniu tyle jest elektrozaworów.

2) Suszarka/ki to jakiś osobny obwód?

3) Rozumiem, że jeśli spadnie temperatura buforu poniżej jakiejś wartości to np załączy się blokada pompy do podłogówki i suszarki?

4) Po co tyle czujników w buforze nie wystarczy jeden na górze?

1. Dokładnie tak. Na etapie prób chciałem sobie zostawić możliwość obserwacji i wyboru w której części pętli najlepiej zainstalować czujkę i jak wygląda rozkład temperatur w samej pętli. Jako kolejna dojdzie czujka  termostatu pokojowego tz. na ścianie 140 cm nad podłogą. Mam nadzieję w taki sposób znaleść najlepszy kompromis między promieniowaniem cieplnym podłogi a komfortem termicznym  powietrza w pomieszczeniu. W efekcie końcowym będą pracować tylko dwie. Jedna w podłodze i jedna na ścianie. Lub może wszystkie sześć. Zobaczymy.

2.Tak suszarki do ręczników to obwód na osobnej pompie. Suszarki wyposażone są dodatkowo w grzałki elektryczne. U mnie po dwóch sezonach nigdy nie używane (mam bufor z wężownicą CWU) ale jeśli ktoś ma np. piec gazowy i osobny obwód CWU to latem mogą się przydać.

3 i 4.Jeśli spadnie temperatura bufora... Bufor ma 4 czujki i wbrew pozorom wszystkie są potrzebne. Bufor posiada 3 wężownice. Górna dolna i  CWU. Czujki  Bufor dół, Bufor 2/4, Bufor 3/4, Bufor góra. Bufor dół i bufor góra będzie używana do uruchamianie pompy cyrkulacyjnej w samym buforze celem wymieszania wody i wyrównania temperatury całego bufora. Opcja korzystna przy fotowoltaice i grzałce elektrycznej bufora. Zapobiega wrzeniu wody w górnej części kiedy dolna jeszcze się dogrzewa. Umożliwia doładowanie termiczne bufora na max. Bufor 2/4  mierzy temperaturę na poziomie dolnej wężownicy i odpowiada za ogrzewanie podłogowe. Bufor 3/4 mierzy temperaturę górnej wężownicy i określa poziom CWU. Bufor góra to czujka o dwóch przeznaczeniach. Pierwsze to mieszanie jak już napisałem wody w buforze a druga to alarm. Mam kominek z płaszczem wodnym i jeśli temperatura w szczycie bufora przekroczy np.  95 stopni Ma nastąpić natychmiastowe awaryjne uruchomienie wszystkich obwodów podłogówki ale też CO czyli suszarek oraz mieszanie wody w buforze. Podłogówki to czujka Bufor 2/4 a suszarki Bufor 3/4.

Dodane przez: @marekmazurek

↑

1.Arduino mega jest jednostką niezależną która działa nawet kiedy padnie sieć - autonomicznie.

2. Ilość wejść-wyjść obsłuży praktycznie każdą instalację

 

Tak jak napisał @mig41 ESP32 może pracować jako autonomiczny sterownik i moim skromnym zdaniem powinien realizować podstawowe funkcje odpowiedzialne a zarządzanie całym systemem.

To wszystko jest spiętę na jednym arduino, to jedna zaleta i sporo wad, a podstawowa wada to jak coś zawiśnie nie działa nic.

W systemie rozproszonym gdzie mamy podział np na piętra lub pomieszczenia jak padnie jeden pokój , reszta może z powodzeniem działać.

Taki przykład, czujniki DS18B20 to najczęściej lepsze lub gorsze podróbki oryginałów, jak klęknie jeden z magistrali, to mogą przestać działać wszystkie. 

Ja staram się rozdzielać kontrolę na oddzielne moduły np CWU to jedno, kominek z płaszczem to drugie itd, pompa ciepła, kocioł na pellet, klimatyzacja.....

Dodane przez: @isom

↑

Dodane przez: @marekmazurek

↑

1.Arduino mega jest jednostką niezależną która działa nawet kiedy padnie sieć - autonomicznie.

2. Ilość wejść-wyjść obsłuży praktycznie każdą instalację

 

Tak jak napisał @mig41 ESP32 może pracować jako autonomiczny sterownik i moim skromnym zdaniem powinien realizować podstawowe funkcje odpowiedzialne a zarządzanie całym systemem.

To wszystko jest spiętę na jednym arduino, to jedna zaleta i sporo wad, a podstawowa wada to jak coś zawiśnie nie działa nic.

W systemie rozproszonym gdzie mamy podział np na piętra lub pomieszczenia jak padnie jeden pokój , reszta może z powodzeniem działać.

Taki przykład, czujniki DS18B20 to najczęściej lepsze lub gorsze podróbki oryginałów, jak klęknie jeden z magistrali, to mogą przestać działać wszystkie. 

Ja staram się rozdzielać kontrolę na oddzielne moduły np CWU to jedno, kominek z płaszczem to drugie itd, pompa ciepła, kocioł na pellet, klimatyzacja.....

 

Miałem przypadki awarii  DS18B28.  Identyfikacja jest bardzo prosta po adresie czujki. Inne działały z powodzeniem mimo że na linii było 21 sztuk.

Nie przekonuje się na siłe nieprzekonanego do dobrych rozwiazań, walcz z tym kodem w arduino i powodzenia. Czujniki u Ciebie nie padły na zwarcie, więc pozostałe działały, ale nigdy nie wiadomo. Ja wiem jak ważne jest ogrzewanie, szczególnie np kominek z płaszczem gdzie nie dopuszczam do wyższej temp niż 70 stopni , po prostu kontrolując dopływ powietrza. Bez kontroli na przyzwoitym poziomie nie bardzo sobie to wyobrażam, a już na pewno nie 21 szt DS-Ów na jednej magistrali. Powodzenia

Co prawda nie miałem wszystkich danych. Ale na Arduino mega wyszedł mi taki termostat.

Pisane na PlatformIO.

Program się kompiluje ale nie mam gdzie sprawdzić czy działa dobrze.

Co do innych funkcji to można dopisać..

W tej chwili tam mam temperaturę ustawioną na 25 st.c dla wszystkiego. Można na razie zmodyfikować i skompilować ponownie.

Np. w procedurze setup dodaj wpis 

sypialnia.zadanaTemperatura = 30;

O kurczę. Naprawdę mocno się przyłożyłeś. Jak tylko czas pozwoli biorę się za test. Czy czujek już nie trzeba adresować? a jeśli tak to jak?

Potrzeba jeszcze adresy czujek z 3 pomieszczeń. Nie było ich.

Na tą chwilę można zmienić temperaturę zadaną z poziomu serial monitora(lub czegoś podobnego) z PlatformIO.

Jak wpisze się "pomoc" to się pojawi co i jak.

Nowa wersja.

te trzy czujki to rezerwa na czas kiedy remont zostanie skończony. Ale mogę przydzielić jakieś do testów. Jaka jest możliwość wymiany uszkodzonej czujki? Tzn gdzie można podmienić adres?

Plik "main.h" tam wszystkie pokoje mają definicje i są im przydzielone wartości. 

Struktura takiego pokoju to najpierw gpio do elektrozaworu, temperatura zadana, histeraza max i min (tempzadana+max, tempzadana-min), ilość czujników, stan elektrozaworu, tablica z adresami czujników oraz miejsce na aktualna wartość czujnika.