MISv1

/*******************************************************************
V1 - vLED OK - tak

v7 - vLED przełącznik OnOff na A6

v10 - przycisk pompa
v11 - temp set pieca
V12 - ds18b20
v13 - terminal
v14 - +temperatura
v15 - -temmperatura
v16 - MIS

v20 - menu wybór pilota
v21 - button pilota
v30 - timer do pompy

********************************************************************/

char kod[] = "**MIS  v1.0**";
char auth[] = "xxxxxxxxxxxxxxxxxxxxx"; //MIS
char ssid[] = "aaa";
char pass[] = "bbbbbbbbbbbbbbb";


#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266_Lib.h>
#include <BlynkSimpleShieldEsp8266.h>
#define resetesp  4

#include <Timers.h> // ulubiona biblioteka Timers
Timers <6> akcja; // n niezależnych wątków

#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch(); //nie wiem co to - pewnie nadanie nazwy własnej procedurze

#define BLYNK_GREEN     "#23C48E"
#define BLYNK_BLUE      "#04C0F8"
#define BLYNK_YELLOW    "#ED9D00"
#define BLYNK_RED       "#D3435C"
#define BLYNK_DARK_BLUE "#5F7CD8"
#define _RED            "#FF0000"
#define _GREEN          "#00FF00"

#define EspSerial Serial // Set ESP8266 Serial object
ESP8266 wifi(&EspSerial);

#include <OneWire.h>
#include <DS18B20.h>
const byte ONEWIRE_PIN = 13; // 1-Wire bus Arduino pin
byte sensorAddress[8] = {0x28, 0xFF, 0x46, 0xD2, 0x46, 0x16, 0x3, 0x7F}; // // brama2 płytka2
OneWire onewire(ONEWIRE_PIN); // 1-Wire object
DS18B20 sensors(&onewire); // DS18B20 sensors object


WidgetLED led1(V1); // vLED_ok
WidgetLED led9(V9); // test timer
WidgetTerminal terminal(V13);

#define led_ok  7  //na D7
#define led_error  8 // na D8
#define czasobiegu  5  // ilość sek włączenia pompy x 20

#define k1on 5522769
#define k1off 5522772
#define k2on 5525841
#define k2off 5525844

#define piecon 5592332
#define piecoff 5592323

#define pompaoff 266580
#define pompaon 266577

#define pirpompa 14013756

#define piechistereza 2
int temppiec = 210; //temparatura zadana o włączeniu urządzenia

void test1s()
{

}
 void printverMIS()
 {
 // String str = String(temperature) + "." + String(dziesietne) + " ℃"; // oszczedzam 3 kB pamieci
  Blynk.virtualWrite(V16, kod);
 }

void wyborwifi() {
  Blynk.begin(auth, wifi, ssid, pass);
}

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>                setup
void setup()
{


  pinMode(led_ok, OUTPUT); // dioda sygnalizacyjna pracy pętli 1 sek w przerwaniu
  pinMode(led_error, OUTPUT); // dioda sygnalizacyjna pracy pętli 1 sek w przerwaniu
  pinMode(A5, INPUT_PULLUP); //przełącznik

  digitalWrite(led_ok, HIGH);
  digitalWrite(led_error, HIGH);

  //reset ESP
  pinMode(resetesp, OUTPUT);
  digitalWrite(resetesp, LOW); //reset esp
  digitalWrite(led_ok, LOW);
  delay(2000);
  digitalWrite(resetesp, HIGH);
  delay(200); //stany przejściowe esp
  digitalWrite(led_ok, HIGH);


  akcja.attach(0, 3000, timer1sek); // uruchamianie timera 3 sek
  akcja.attach(1, 30000, restartArduino); // pętla dłuższa 30 s reset BLYNK gdy nie ma połączenia
  akcja.attach(2, 10000, licznikobiegu); // pętla dłuższa 10 s licznik grzania
   akcja.attach(3, 5000, pieconoff);

  Serial.begin(115200);  // Set console baud rate
  EspSerial.begin(115200);  // Set ESP8266 baud rate

  wyborwifi();
  Serial.println(__FILE__);

  mySwitch.enableReceive(0);  // Receiver on inerrupt 0 => that is pin #2
  mySwitch.enableTransmit(3); // Transmiter pin D3

  sensors.begin();  // DS18B20 sensors setup
  sensors.request(sensorAddress);  // Requests sensor for measurement
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    loop
void loop()
{
  akcja.process(); // inicjalizacja lub aktualizacja wszystkich procedur(wątków, zdarzeń itp.)
  Blynk.run();
  kod_run();
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> procedury

void timer1sek() //coś do zrobienia co 1 sek
{

  sprawdzBLYNK();
  miganieLED_ok();
  miganievLED();
  sensorT();        // czytanie DS18b20
  transmitBLYNK();   // wysyłanie różnych danych do APP
  miganiegrzanie(); //miganie v12 kiedy piec grzeje
  printverMIS();
  test1s();
}
bool stanLED_ok = HIGH;
void miganieLED_ok()
{
  stanLED_ok = !stanLED_ok;
  if (stanLED_ok == 0) {
    digitalWrite(led_ok, LOW);
  }
  else {
    digitalWrite(led_ok, HIGH);
  }
}


bool wskrunAr = 0; //vLED miga co sek
void miganievLED()
{
  wskrunAr = !wskrunAr ;
  if (wskrunAr == 0) {
    led1.on(); //miganie vLED dla kontroli połączenia z UNO
    Blynk.setProperty(V1, "color", "#007700");
  }
  else {
    led1.on();
    Blynk.setProperty(V1, "color", _GREEN);
  }
}

bool isFirstConnect = true;
// This function will run every time Blynk connection is established
BLYNK_CONNECTED() {
  if (isFirstConnect) {
    Blynk.syncAll();  //ważna procedura - po starcie arduino synchronizuje wszystkiw wirtualne piny ze zmiennymi programu
    isFirstConnect = false;
    wyslij_V11(); //synchro wartości początkowej po resecie
  }
}

int tempx10; // temperatura z czujnika x 10 liczba całkowita
void sensorT()
{
  if (sensors.available())
  {
    tempx10 = ((sensors.readTemperature(sensorAddress) * 10) - 5); // x 10 i kalibracja
    sensors.request(sensorAddress);
  }
}


bool piecgrzanie = 0; //flaga grzania on/off
void pieconoff()
{
  if (tempx10 < (temppiec - piechistereza))
  {
    piecgrzanie = 1;//włącz grzanie
    sendkodpiec(piecon);
    Blynk.setProperty(V12, "color", BLYNK_BLUE);
  }
    if (tempx10 > (temppiec + piechistereza))
  {
    piecgrzanie = 0;//wyłącz grzanie
    sendkodpiec(piecoff);
    Blynk.setProperty(V12, "color", _RED);
  }

}
bool flagagrzanie = 0;
void miganiegrzanie()
{
  flagagrzanie = !flagagrzanie;
  if (piecgrzanie)
  {
    if (flagagrzanie)
    {
    Blynk.setProperty(V12, "color", _RED);
  }else
  {
    Blynk.setProperty(V12, "color", BLYNK_BLUE);
  }
  }
}

void sendkodpiec (unsigned long codeA) //transmisja kodu dla termostatu
{
  mySwitch.setPulseLength(210);
  mySwitch.setProtocol(1);
  mySwitch.setRepeatTransmit(4);
  mySwitch.send(codeA, 24);
}

byte klawtemp_p = 0;
BLYNK_WRITE(V14) //zwiekszanie setup temperatury co 0,5 oC
{
  if (param.asInt())  //sprawdzanie zmiany stanu przycisku  vPIN V10 załączenie pompy
  {
    temppiec = temppiec + 5;
    if (temppiec > 260)
    {
      temppiec = 260;
    }
    wyslij_V11();
  }
}

byte klawtemp_m = 0;
BLYNK_WRITE(V15) //zmniejszanie setup temperatury co 0,5 oC
{
  if (param.asInt()) //sprawdzanie zmiany stanu przycisku  vPIN V10 załączenie pompy
  {
    temppiec = temppiec - 5;
    if (temppiec < 130)
    {
      temppiec = 130;
    }
    wyslij_V11();
  }
}



void transmitBLYNK() { //procedura wysyłania do serwera BLYNK
  wyslij_V12();
//  wyslij_V11();
}

void wyslij_V12() { //real T
  int temperature = 0;  // część całkowita mierzonej temperatury
  int dziesietne = 0;   // część dziesietna mierzonej temperatury
      temperature = (tempx10 / 10);
    dziesietne = (tempx10 % 10);
  String str = String(temperature) + "." + String(dziesietne) + " ℃"; // oszczedzam 3 kB pamieci
  Blynk.virtualWrite(V12, str);
}

void wyslij_V11() //setup T
{
    int temperature = 0;  // część całkowita mierzonej temperatury
  int dziesietne = 0;   // część dziesietna mierzonej temperatury
      temperature = (temppiec / 10);
    dziesietne = (temppiec % 10);
  String str = String(temperature) + "." + String(dziesietne) + " ℃"; // oszczedzam 3 kB pamieci
  Blynk.virtualWrite(V11, str);
}

byte vPin20 = 0;
BLYNK_WRITE(V20) //wybór pilota - menu rozwijane
{
  vPin20 = param.asInt();
}


bool ppilotold = 0;

BLYNK_WRITE(V21) //vprzycisk do pilotów on/off
{
  unsigned long codeA = 0;

  if (ppilotold == param.asInt()) {} //sprawdzanie zmiany stanu przycisku  vPIN pilot (V3)
  else {
    ppilotold = param.asInt();
    if ((ppilotold)) {
      Blynk.setProperty(V21, "color", "#FFFFFF");
      Blynk.setProperty(V21, "offLabel", "ON");
      switch (vPin20)  // Switch on Elro - wybór kodu pilota w zależności od ustawienia w menu rozwijanym
      {
        case 1: codeA = k1on;  break;
        case 2: codeA = k2on;  break;
        default: codeA = k1on;
      }

    } else {
      Blynk.setProperty(V21, "color", BLYNK_BLUE);
      Blynk.setProperty(V21, "offLabel", "PILOT");
      switch (vPin20)  // Switch on Elro - wybór kodu pilota w zależności od ustawienia w menu rozwijanym
      {
        case 1: codeA = k1off;  break;
        case 2: codeA = k2off;  break;
        default: codeA = k1off;
      }
    }
    sendkodpilot(codeA);
  }
}

void sendkodpilot (unsigned long codeA)
{
  mySwitch.setPulseLength(320);
  mySwitch.setProtocol(1);
  mySwitch.setRepeatTransmit(4);
  mySwitch.send(codeA, 24);
}

int obieg = -1; //licznik czasu włączenia pompy
byte oldtimeronoff = 1;

BLYNK_WRITE(V30) //timer do pompy obiegowej
{
  if (oldtimeronoff == param.asInt()) {}
  else {
    obieg = czasobiegu; // 2 razy na dobę załączanie pompy dla celów sanitarnych
    oldtimeronoff = param.asInt();
    if (oldtimeronoff == 0)
    {
      Blynk.setProperty(V30, "color", BLYNK_RED);
    }
    else {
      Blynk.setProperty(V30, "color", BLYNK_GREEN);
    }
  }
}

void licznikobiegu()
{
  obieg--;
  if (obieg < 0) {
    obieg = -1;
  }
  else {
    if (obieg == 0) {
      sendkodpilot(pompaoff);
      //  sendkodpilot(pompaoff);
      Blynk.setProperty(V10, "color", "#00FF00");
      Blynk.setProperty(V10, "offLabel", "POMPA");
    }
    else {
      pompazal();
    }
  }
}

void pompazal()
{
  //   sendkodpilot(pompaon);
  sendkodpilot(pompaon);

  String xString = String(obieg);
  Blynk.setProperty(V10, "color", "#FFFFFF");
  Blynk.setProperty(V10, "offLabel", xString); // wyświetlanie czasu obiegu
}

byte pompaonoffold = 0;
BLYNK_WRITE(V10) //vprzycisk załączenia pompy
{
  if (pompaonoffold == param.asInt()) {} //sprawdzanie zmiany stanu przycisku  vPIN V10 załączenie pompy
  else {
    pompaonoffold = param.asInt();
    obieg = czasobiegu;
    pompazal();
  }
}

void  kod_run()
{ // procedyra obsługi odebranego z 433MHz
  if (mySwitch.available()) {

    int value = mySwitch.getReceivedValue();
    //      Serial.print(F("----------------------kod ")); //testowanie co jest odbierane
    //      Serial.println( mySwitch.getReceivedValue() );
    terminal.println(mySwitch.getReceivedValue());
    terminal.flush();

    if ( pirpompa == mySwitch.getReceivedValue()) {
      if (oldtimeronoff == 1) {
        obieg = czasobiegu;
        pompazal();
      }
    }
    mySwitch.resetAvailable();
  }
}

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>restart
byte noconnection = 0;
byte czyrestartESP = 0;
byte czyrestart = 0;

void sprawdzBLYNK()
{
  digitalWrite(resetesp, HIGH); //dla pewności
  bool r = Blynk.connected();
  if (r == 1) { //jeśli jest połączenie to zgaś LED
    digitalWrite(led_error, LOW);  //zgaszenie LED gdy jest połaczenie z BLYNK server
    noconnection = 0;
    czyrestartESP = 0;
    czyrestart = 0;
  }
  else {
    digitalWrite(led_error, HIGH);
    noconnection = 1;
  }
}
void(* resetFunc) (void) = 0;//declare reset function at address 0


void restartArduino() { //długa pętla 10-30 sek
  if (noconnection == 1) {
    if (czyrestartESP == 1) {
      if (czyrestart == 1) {
        Serial.println(F("restart ALL"));
        resetFunc(); //call reset     //restart
      } else {
        czyrestart = 1;
      }
      restartESP();    //restart

    } else {
      czyrestartESP = 1;
    }
  }
}
void restartESP() {
  Serial.println(F("restart ESP"));
  digitalWrite(resetesp, LOW); //reset esp
  delay(500);
  digitalWrite(resetesp, HIGH);
  delay(200); //stany przejściowe esp
  //Blynk.begin(auth, wifi, ssid, pass);
  wyborwifi();
}

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    end restart

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>                testy