Programmable Controller for the Heat Pump

Manage the operation of a heat pump with an Arduino-based controller.

May 14, 2019

•

2264 views

•

1 respects

energy efficiency

home automation

Components and supplies

Arduino Nano R3

Relay Module (Generic)

DS18B20 Programmable Resolution 1-Wire Digital Thermometer

Alphanumeric LCD, 16 x 2

Apps and platforms

Arduino IDE

Project description

Code

Sterownik do pompy ciepła

arduino

1/*
2    ARDUINO NANO ATMEGA328 AVR 5V 16 MHz z wywietlaczem LCD 1602  2x16 i HD44780.
3   Sterowanie grzaniem dwch piecy.
4   Pomiar temperatury na  2 czujnikach DS18B20.
5   Wywietlenie T1 i T2 oraz temperatury zadanej, programowanie  temperatury zadanej
6   , delty grzania pieca oraz korekty ( Offset2 ) czujnika  temperatury pieca 2.
7   Zastosowano filtr bdnych odczytw temperatury,
8   Autor  Andrzej Coojew.
9*/
10
11#include <avr/wdt.h>
12#include <OneWire.h>
13#include  <EEPROM.h>
14#include <LiquidCrystal_I2C.h>
15#include <DallasTemperature.h>
16
17#define  ONE_WIRE_BUS_1 2                    //nr PIN = D2 dla sensora T1
18#define ONE_WIRE_BUS_2  3                    //nr PIN = D3 dla sensora T2
19
20OneWire oneWire_1(ONE_WIRE_BUS_1);
21OneWire  oneWire_2(ONE_WIRE_BUS_2);
22DallasTemperature sensor_1(&oneWire_1);
23DallasTemperature  sensor_2(&oneWire_2);
24
25LiquidCrystal_I2C  lcd(0x27, 2, 1, 0, 4, 5, 6, 7);  // 0x27 is the I2C bus address
26float T1 ;
27float T2 ;
28byte Tu ;
29float  Tx ;
30float TxOld;
31byte Taryfa2;
32byte G1 = LOW;
33byte G2 = LOW;
34byte  SW1 = HIGH;
35byte SW2 = HIGH;
36byte S1 = HIGH;
37byte S2 = HIGH;
38byte TempError1  = LOW;
39byte TempError2 = LOW;
40float delta = 3.0;        // zajmuje 4 bajty
41float  deltaOld;
42float Offset2 = 0.0;
43float Offset2Old;
44byte K = 0;
45byte K2  = 0;
46short i;
47unsigned long start;
48unsigned long koniec;
49byte W1 = LOW;
50byte  W2 = LOW;
51
52void setup()
53{
54  cli();                      //wyczenie WDT
55  wdt_reset();                // wyzerowanie licznika WDT
56  WDTCSR |= (1 << WDCE)  | (1 << WDE); // inicjacja setup'u WDT
57  WDTCSR = (0 << WDIE) | (1 << WDE) |  (1 << WDP3) | (0 << WDP2) | (0 << WDP1) | (1 << WDP0); //zaprogramowanie WDT na  reset i czas 8 s.
58  sei();                          // wczenie WDT
59
60
61  // activate LCD module
62  lcd.begin (16, 2);                // for 16 x 2 LCD  module
63  lcd.setBacklightPin(3, POSITIVE);
64  lcd.backlight();                  //  zaczenie podwietlenia
65  sensor_1.begin();
66  sensor_2.begin();
67  pinMode(A2,  INPUT);               // Taryfa2
68  pinMode(4, INPUT_PULLUP);
69  pinMode(5,  INPUT_PULLUP);
70  pinMode(6, INPUT_PULLUP);
71  pinMode(7, INPUT_PULLUP);
72  pinMode(8, INPUT_PULLUP);
73  pinMode(9, OUTPUT);
74  pinMode(A3, OUTPUT);            //  buzzer
75  digitalWrite(9, LOW);
76  pinMode(10, OUTPUT);
77  digitalWrite(10,  LOW);
78  pinMode(11, OUTPUT);
79  digitalWrite(11, HIGH);
80  pinMode(12, OUTPUT);
81  digitalWrite(12, HIGH);
82  pinMode(13, OUTPUT);
83  digitalWrite(13, LOW);
84  Tu = EEPROM.read(0);
85  EEPROM.get(9, Tx);
86  if (Tu < 20 || Tu > 60)
87  {
88    Tu = 30;
89    Tx = 25;
90    EEPROM.write(0, Tu);
91    EEPROM.put(1,  delta);                     // zapisuje zmienn uamkow "delta"
92    EEPROM.put(5,  Offset2);                   // zapisuje zmienn uamkow "Offset2"
93    EEPROM.put(9,  Tx);
94  }
95  else
96  {
97    EEPROM.get(1, delta);
98    EEPROM.get(5, Offset2);
99    EEPROM.get(9, Tx);
100  }
101  lcd.clear();
102  lcd.print("STEROWNIK PIECOW");
103  lcd.setCursor (2, 1);
104  lcd.print("by A.Colojew");
105  delay(4000);
106  wdt_reset();
107  lcd.clear();
108  if (digitalRead(7) == HIGH)
109  {
110    lcd.print("Piec  nr 1 i nr 2");
111    lcd.setCursor (4, 1);
112    lcd.print("WYLACZONY");
113    S1 = HIGH;
114    S2 = HIGH;
115  }
116  else
117  {
118    if (digitalRead(8)  == LOW)
119    {
120      lcd.clear();
121      lcd.print("Piec nr 1 i nr 2");
122      lcd.setCursor (4, 1);
123      lcd.print("WLACZONY");
124      S1 = LOW;
125      S2 = LOW;
126    }
127    else
128    {
129      lcd.clear();
130      lcd.print("    Piec nr 1");
131      lcd.setCursor (4, 1);
132      lcd.print("WLACZONY");
133      S1 = LOW;
134      S2 = HIGH;
135    }
136  }
137  delay(4000);
138  wdt_reset();
139  CzytT1T2();
140  LCDprint();                           // wywietlenie T1, T2 i  Tu
141  Taryfa2 = digitalRead(A2);       // czyta stan taryfy 2
142}
143
144
145
146void  loop()
147{
148  wdt_reset();
149  CzytT1T2();                                       //czyta  T1 i T2. Kontrola zakuce, zaokrglenie (zajmuje ok. 1 s.)
150
151  if (S2 == HIGH  && TempError1 == LOW && TempError2 == LOW)    //wyczony 2 piec i nie ma ErrorTemp
152  {
153    lcd.setCursor (8, 0);
154  }
155  else
156  {
157    lcd.setCursor (3,  0); // set cursor to 3,0      //wywietlenie T1, T2
158    if (TempError2 == HIGH)
159    {
160      lcd.print(int(T2));
161    }
162    else
163    {
164      lcd.print(T2,  1);                               //
165    }
166    lcd.setCursor (12, 0); // set  cursor to 12,0    //
167  }
168  if (TempError1 == HIGH)
169  {
170    lcd.print(int(T1));
171  }
172  else
173  {
174    lcd.print(T1, 1);                                 //
175  }
176
177  if ( G1 == LOW && G2 == LOW)                      // czy piece nie  grzej ?
178  {
179    digitalWrite(9, HIGH);                          // zmniejszenie  owietlenia LCD.
180  }
181  else
182  {
183    digitalWrite(9, LOW);                           //  zwikszenie owietlenia LCD gdy ktry piec grzeje.
184  }
185
186
187  if (W1 == HIGH  || W2 == HIGH)
188  {
189    digitalWrite(A3, HIGH);          // wczenie beep
190    lcd.setCursor (0, 1);           // set cursor to 0,1
191    lcd.print("Blad  temperatury ");
192  }
193  for (i = 0; i < 350; i++)            //         czeka  3.5 s.
194  {
195    SW1 = digitalRead(7);              // czyta stan zezwolenie  grzania 1 pieca
196    SW2 = digitalRead(8);              // czyta stan zezwolenie  grzania 2 pieca
197    if (digitalRead (4) == HIGH && S1 == SW1 && S2 == SW2 &&  Taryfa2 == digitalRead(A2))
198    {
199      delay(10);
200    }
201    else                              //  przerywa czekanie
202    {
203      break;
204    }
205    wdt_reset();
206  }
207  if (W1 == HIGH || W2 == HIGH)
208  {
209    digitalWrite(A3, LOW);               //  wyczwnie beep
210    lcd.setCursor (0, 1); // set cursor to 0,1      //
211    lcd.print("  T zadana = ");                      //
212    lcd.print(Tu);                                  //
213    lcd.print(" C");                                //
214  }
215  for (i = 0;  i < 500; i++)            //         czeka 5 s.
216  {
217    SW1 = digitalRead(7);              // czyta stan zezwolenie grzania 1 pieca
218    SW2 = digitalRead(8);              // czyta stan zezwolenie grzania 2 pieca
219    if (digitalRead (4)  == HIGH && S1 == SW1 && S2 == SW2 && Taryfa2 == digitalRead(A2))
220    {
221      delay(10);
222    }
223    else                              // przerywa czekanie
224    {
225      if (Taryfa2 == digitalRead(A2))
226      {
227        W1 = LOW;
228        W2  = LOW;
229      }
230      Taryfa2 = digitalRead(A2);       // czyta stan taryfy  2
231      break;
232    }
233    wdt_reset();
234  }
235
236
237  if ( S1 != SW1  )                    // zmiana stanu wcznika 1 pieca
238  {
239    digitalWrite(9,  LOW);
240    lcd.clear();
241    if ( SW1 == HIGH )
242    {
243      S1 = HIGH;
244      lcd.print( "   Wylaczono");
245      lcd.setCursor (0, 1);
246      lcd.print("piec  nr 1 i nr 2");
247    }
248    else
249    {
250      S1 = LOW;
251      lcd.print(  "   Wlaczono");
252      if ( SW2 == HIGH)
253      {
254        lcd.setCursor  (3, 1);
255        lcd.print( "piec nr 1");
256      }
257      else
258      {
259        lcd.setCursor (0, 1);
260        lcd.print("piec nr 1 i nr 2");
261      }
262    }
263    delay(4000);
264    wdt_reset();
265    LCDprint();                           //  wywietlenie T1, T2 i Tu
266  }
267
268  if ( S2 != SW2 )                       //  zmiana stanu wcznika 2 pieca
269  {
270    digitalWrite(9, LOW);
271    lcd.clear();
272    if ( SW2 == HIGH )
273    {
274      S2 = HIGH;
275      lcd.print( "   Wylaczono");
276      lcd.setCursor (3, 1);
277      lcd.print("piec nr 2");
278      wdt_reset();
279      delay(3000);
280      lcd.clear();
281      lcd.print("    ZAMKNIJ");
282      lcd.setCursor (1, 1);
283      lcd.print("zawor pieca 2");
284      for  (i = 0; i < 6 ; i++)
285      {
286        lcd.noDisplay();
287        delay(300);
288        lcd.display();
289        delay(700);
290        wdt_reset();
291      }
292    }
293    else
294    {
295      S2 = LOW;
296      if ( SW1 == LOW )
297      {
298        lcd.print( "   Wlaczono");
299        lcd.setCursor (3, 1);
300        lcd.print(  "piec nr 2");
301        wdt_reset();
302        delay(3000);
303        lcd.clear();
304        lcd.print("    OTWORZ");
305        lcd.setCursor (1, 1);
306        lcd.print("zawor  pieca 2");
307        for (i = 0; i < 6 ; i++)
308        {
309          lcd.noDisplay();
310          delay(300);
311          lcd.display();
312          delay(700);
313          wdt_reset();
314        }
315      }
316      else
317      {
318        lcd.print("   Blokada");
319        lcd.setCursor (2, 1);
320        lcd.print( "pieca nr 2");
321        wdt_reset();
322        delay(4000);
323      }
324    }
325
326    LCDprint();                           //  wywietlenie T1, T2 i Tu
327  }
328
329
330  if (digitalRead(4) == LOW)                    //  czy nacinieto "SET"
331  { // nacisnieto "SET"
332    digitalWrite(9, LOW);
333    lcd.clear();                                //wywietlenie
334    lcd.setCursor  (0, 0); // set cursor to 0,0  //"Ustaw tem. pieca"
335    lcd.print("Ustaw tem.  pieca");
336    lcd.setCursor (5, 1);
337    lcd.print("T = ");
338    lcd.print(Tu);
339    lcd.print(" C");
340    PullSW3();                                  // czeka  na puszczenie "SET"
341    start = millis();                       // zaadowanie  licznika czasu
342    while (digitalRead(4) == HIGH)          //wykonuj dopuki nie  nacinito "SET"
343    {
344      if (digitalRead(5) == LOW)       // czy nacinieto  "-"
345      {
346        start = millis();
347        Tu = Tu - 1;
348        Tu  = constrain (Tu, 20 , 60 );    // ograniczenie Tmin do 20 C
349        lcd.setCursor  (9, 1);
350        lcd.print(Tu);
351        delay (300);
352      }
353      if  (digitalRead(6) == LOW)       // czy nacinieto "+"
354      {
355        start  = millis();
356        Tu = Tu + 1;
357        Tu = constrain (Tu, 20 , 60 );  //  ograniczenie Tmax do 60 C
358        lcd.setCursor (9, 1);
359        lcd.print(Tu);
360        delay (300);
361      }
362      koniec = millis();
363      if (koniec  - start >= 30000 )   // jeeli nic si nie dziao przez 30 s. to RETURN.
364      {
365        LCDprint();
366        return;
367      }
368      wdt_reset();
369    }
370
371    EEPROM.update (0, Tu);        // zapis do EEPROMU ustawionej tem. Tu (update:  jeeli nie zmany - nie zapisuje)
372    lcd.clear();                                      //  wywietlenie  "Ustaw delty pieca"
373    lcd.setCursor (0, 0); // set cursor to  0,0
374    lcd.print("Ustaw del. pieca");
375    lcd.setCursor (2, 1);
376    lcd.print("delta  = ");
377    lcd.print(delta, 1);
378    lcd.print(" C");
379    PullSW3();                    //  czeka na puszczenie "SET"
380    deltaOld = delta;
381    start = millis();
382    while (digitalRead(4) == HIGH)          //wykonuj dopuki nie nacinito "SET"
383    {
384      if (digitalRead(5) == LOW)       // czy nacinieto "-"
385      {
386        start = millis();
387        delta = delta - 0.1;
388        delta = constrain  (delta, 0.3 , 5 );  // ograniczenie delty do 0.3 C
389        lcd.setCursor (10,  1);
390        lcd.print(delta, 1);
391        lcd.print(" C ");
392        delay  (300);
393      }
394      if (digitalRead(6) == LOW)       // czy nacinieto "+"
395      {
396        start = millis();
397        delta = delta + 0.1;
398        delta  = constrain (delta, 0.3 , 5 );  // ograniczenie delty do 5 C
399        lcd.setCursor  (10, 1);
400        lcd.print(delta, 1);
401        lcd.print(" C ");
402        delay  (300);
403      }
404      koniec = millis();
405      if (koniec - start >= 30000  )
406      {
407        LCDprint();
408        return;
409      }
410      wdt_reset();
411    }
412    if (deltaOld != delta )
413    {
414      EEPROM.put(1, delta);        //  zapis do EEPROMU ustawionej delty .
415    }
416    lcd.clear();                                      //  wywietlenie  "Ustaw Offset pieca 2"
417    lcd.setCursor (0, 0); // set cursor  to 0,0
418    lcd.print("Offset pieca 2:");
419    lcd.setCursor (1, 1);
420    lcd.print("offset  = ");
421    lcd.print(Offset2, 1);
422    lcd.print(" C");
423    PullSW3();                    // czeka na puszczenie "SET"
424    Offset2Old = Offset2;
425    start = millis();
426    while (digitalRead(4) == HIGH)          //wykonuj dopuki  nie nacinito "SET"
427    {
428      if (digitalRead(5) == LOW)       // czy nacinieto  "-"
429      {
430        start = millis();
431        Offset2 = Offset2 - 0.1;
432        Offset2 = constrain (Offset2, -3 , 3 );  // ograniczenie Offset2 do -3 C
433        lcd.setCursor (10, 1);
434        lcd.print(Offset2, 1);
435        lcd.print("  C ");
436        delay (300);
437      }
438      if (digitalRead(6) == LOW)       //  czy nacinieto "+"
439      {
440        start = millis();
441        Offset2 =  Offset2 + 0.1;
442        Offset2 = constrain (Offset2, -3 , 3 );  // ograniczenie  Offset2 do 3 C
443        lcd.setCursor (10, 1);
444        lcd.print(Offset2, 1);
445        lcd.print(" C ");
446        delay (300);
447      }
448      koniec =  millis();
449      if (koniec - start >= 30000 )
450      {
451        LCDprint();
452        return;
453      }
454      wdt_reset();
455    }
456    if (Offset2 !=  Offset2Old)
457    {
458      EEPROM.put(5, Offset2);        // zapis do EEPROMU  ustawiony Offset2 .
459    }
460    //////////////////////////////////////////////////////////////////////////////////////////
461    lcd.clear();                                      // wywietlenie  "Ustaw Tx"
462    lcd.setCursor (2, 0); // set cursor to 2,0
463    lcd.print("Tx pieca 1 :");
464    lcd.setCursor (2, 1);
465    lcd.print("Tx = ");
466    lcd.print(Tx, 1);
467    lcd.print(" C ");
468    PullSW3();                    // czeka na puszczenie  "SET"
469    TxOld = Tx;
470    start = millis();
471    while (digitalRead(4)  == HIGH)          //wykonuj dopuki nie nacinito "SET"
472    {
473      if (digitalRead(5)  == LOW)       // czy nacinieto "-"
474      {
475        start = millis();
476        Tx = Tx - 0.2;
477        Tx = constrain (Tx, 3 , 30 ); // ograniczenie  Tx do 3 C
478        lcd.setCursor (7, 1);
479        lcd.print(Tx, 1);
480        lcd.print("  C ");
481        delay (300);
482      }
483      if (digitalRead(6) == LOW)       //  czy nacinieto "+"
484      {
485        start = millis();
486        Tx = Tx +  0.2;
487        Tx = constrain (Tx, 3 , 30 );  // ograniczenie Tx do 30 C
488        lcd.setCursor  (7, 1);
489        lcd.print(Tx, 1);
490        lcd.print(" C ");
491        delay  (300);
492      }
493      koniec = millis();
494      if (koniec - start >= 30000  )
495      {
496        LCDprint();
497        return;
498      }
499      wdt_reset();
500    }
501    if (Tx != TxOld)
502    {
503      EEPROM.put(9, Tx);        // zapis  do EEPROMU ustawiony Tx .
504    }
505    LCDprint();                  // wywietlenie  T1, T2 i Tu
506    PullSW3();                   // czeka na puszczenie "SET"
507    //////////////////////////////////////////////////////////////////////////////////////////
508  }
509
510
511  if (SW1 == HIGH)              // czy brak zezwolenia na grzanie  1 pieca
512  {
513    G1 = LOW;
514    G2 = LOW;
515    digitalWrite(10, LOW);
516    digitalWrite(11, HIGH);
517    digitalWrite(12, HIGH);
518    digitalWrite(13,  LOW);
519    K = 0;
520    K2 = 0;
521    return;
522  }
523  if (SW2 == HIGH)                          //  czy brak zezwolenia na grzanie 2 pieca
524  {
525    G2 = LOW;
526    digitalWrite(12,  HIGH);
527    digitalWrite(13, LOW);
528    digitalWrite(10, LOW);
529    if (TempError1  == HIGH)
530    { // wyczenie 1 pieca.
531      G1 = LOW;
532      digitalWrite(11,  HIGH);
533      K = 0;
534      return;
535    }
536    if (G1 == HIGH)                         //  1 piec grzeje.
537    {
538      if (T1 >= Tu)
539      { // nagrza si 1 piec.
540        K = K + 1;
541        if ( K >= 3 )
542        { // wyczenie 1 pieca.
543          G1 = LOW;
544          digitalWrite(11, HIGH);
545          K = 0;
546        }
547        return;
548      }
549      K = 0;
550      return;
551    }
552    if (Taryfa2 == LOW)
553    { // WSTAWKA !!!!!!
554      if (T1 <= Tu - Tx)                //  czy nadmierne schodzenie pieca?
555      {
556        G1 = HIGH;
557        digitalWrite(11,  LOW);   // wczenie 1 pieca.
558        K = 0;
559      }
560      // koniec wstawki
561      return;
562    }
563    if (T1 <= Tu - delta)     // czy chce grza 1 piec  ?
564    {
565      K = K + 1;
566      if ( K >= 4 )
567      {
568        G1 =  HIGH;
569        digitalWrite(11, LOW);   // wczenie 1 pieca.
570        K = 0;
571      }
572      return;
573    }
574    K = 0;
575    return;
576  }
577  // oba  piece mog grza.
578
579  if (G1 == HIGH)                     // grzeje 1 piec.
580  {
581    if (TempError1 == HIGH)
582    { // wyczenie 1 pieca.
583      G1 = LOW;
584      digitalWrite(11, HIGH);
585      K = 0;
586    }
587    else
588    {
589      if (T2 <= Tu - delta && Taryfa2 == HIGH) // czy jest 2 taryfa i 2 piec chce  grza ?
590      {
591        digitalWrite(13, HIGH);
592      }
593      else
594      {
595        digitalWrite(13, LOW);
596      }
597      if (T1 < Tu)               //  czy nie nagrza si 1 piec ?
598      {
599        K = 0;
600        return;
601      }
602      K = K + 1;
603      if (K < 3 )
604      {
605        return;
606      }
607      G1 = LOW;                 // wyczenie 1 pieca.
608      digitalWrite(11, HIGH);
609      K = 0;
610    }
611    if (T2 <= Tu - delta )         //  2 piec chce grza  ?
612    {
613      if (TempError2 == LOW)
614      {
615        digitalWrite(12,  LOW);   // wczenie 2 pieca.
616        digitalWrite(13, LOW);
617        G2 = HIGH;                // wczenie flagi "2 piec grzeje".
618      }
619    }
620    return;
621  }
622
623  if (G2 == HIGH)             // czy grzeje 2 piec ?
624  {
625    if  (TempError2 == HIGH)
626    {
627      G2 = LOW;                 // wyczenie 2 pieca.
628      digitalWrite(12, HIGH);
629      K = 0;
630    }
631    if (T1 <= Tu - delta  && Taryfa2 == HIGH)  // czy jest 2 taryfa i 1 piec chce grza ?
632    {
633      digitalWrite(10,  HIGH);
634    }
635    else
636    {
637      digitalWrite(10, LOW);
638    }
639
640    if (T2 < Tu)              // czy 2 piec nienagrzany ?
641    {
642      K =  0;
643      return;
644    }
645    K = K + 1;
646    if (K < 3 )
647    {
648      return;
649    }
650    G2 = LOW;                 // wyczenie 2 pieca.
651    digitalWrite(12,  HIGH);
652    K = 0;
653
654    if (T1 <= Tu - delta && Taryfa2 == HIGH)  // czy  jest 2 taryfa i 1 piec chce grza ?
655    {
656      if (TempError1 == LOW)
657      {
658        digitalWrite(11, LOW);   // wczenie 1 pieca.
659        digitalWrite(10,  LOW);
660        G1 = HIGH;                // wczenie flagi "1 piec grzeje".
661      }
662    }
663    return;
664  }
665  if (Taryfa2 == LOW)         // czy nie  ma 2 taryfy ?
666  {
667    // WSTAWKA !!!!!!
668    if (TempError1 == LOW )
669    {
670      if (T1 <= Tu - Tx)                // czy nadmierne schodzenie pieca?
671      {
672        G1 = HIGH;
673        digitalWrite(11, LOW);   // wczenie 1 pieca.
674        K = 0;
675      }
676    }                                                         //  koniec wstawki
677
678    digitalWrite(10, LOW);
679    digitalWrite(13, LOW);
680    return;
681  }
682
683  if (TempError1 == LOW)
684  {
685    if (T1 <= Tu -  delta)     // czy chce grza 1 piec ?
686    {
687      K = K + 1;
688      if (  K >= 4 )
689      {
690        G1 = HIGH;
691        digitalWrite(11, LOW);   //  wczenie 1 pieca.
692        digitalWrite(10, LOW);
693        K = 0;
694      }
695      return;
696    }
697  }
698  K = 0;
699  digitalWrite(10, LOW);
700  if (  TempError2 == LOW)
701  {
702    if (T2 <= Tu - delta)       // czy chce grza 2  piec ?
703    {
704      K2 = K2 + 1;
705      if ( K2 >= 4 )
706      {
707        digitalWrite(12,  LOW);   // wczenie 2 pieca.
708        digitalWrite(13, LOW);
709        G2 = HIGH;                // wczenie flagi "2 piec grzeje".
710        K2 = 0;
711      }
712      return;
713    }
714  }
715  K2 = 0;
716  digitalWrite(13, LOW);
717}
718
719//  KONIEC programu LOOP.
720
721
722// PROCEDURY.
723
724void PullSW3()                //  Czeka na puszczenie "SET"
725{
726  while (digitalRead(4) == LOW)
727  {
728    delay(50);
729    wdt_reset();
730  }
731  delay(50);
732}
733
734void LCDprint()
735{
736  lcd.clear();
737  if (S2 == HIGH && TempError1 == LOW && TempError2 == LOW)        //wyczony 2 piec  i nie ma TempError
738  {
739    lcd.setCursor (3, 0);                           //  wywietlenie T1, Tu
740    lcd.print("T1 = ");
741    lcd.print(T1, 1);
742    lcd.print("  C");
743  }
744  else
745  {
746    lcd.setCursor (0, 0); // set cursor to 0,0    //wywietlenie T1, T2, Tu
747    lcd.print("T2=");                             //
748    if (TempError2 == HIGH)
749    {
750      lcd.print(int(T2));
751    }
752    else
753    {
754      lcd.print(T2, 1);
755    }
756    lcd.print("  T1=");
757    if  (TempError1 == HIGH)
758    {
759      lcd.print(int(T1));
760    }
761    else
762    {
763      lcd.print(T1, 1);
764    }
765  }                                               //
766  lcd.setCursor (1, 1); // set cursor to 0,1      //
767  lcd.print("T zadana =  ");                       //
768  lcd.print(Tu);                                  //
769  lcd.print(" C");                                //
770}
771
772float CzytT1T2()
773{
774  float T11 = 0;
775  float T21 = 0;
776  for (i = 0 ; i < 7 ; i++)                   //  oblicza redni z 7 pomiarw
777  {
778    sensor_1.setWaitForConversion(false);  //  makes it async
779    sensor_2.setWaitForConversion(false);  // makes it async
780    sensor_1.requestTemperatures();
781    sensor_2.requestTemperatures();
782    delay(150);
783    T11 = T11 + sensor_1.getTempCByIndex(0);
784    T21 = T21 + sensor_2.getTempCByIndex(0);
785  }
786  wdt_reset();
787  T11 = T11 / 7;
788  T21 = T21 / 7;
789
790  if (T11 <  10 || T11 > 65)
791  {
792    G1 = LOW;                 // wyczenie 1 pieca.
793    digitalWrite(11, HIGH);
794    digitalWrite(10, LOW);
795    if (TempError1  == LOW)
796    {
797      TempError1 = HIGH;
798      W1 = HIGH;
799      lcd.setCursor  (0, 0); // set cursor to 0,0    // wywietlenie T1, T2, Tu
800      lcd.print("T2=");                             //
801      lcd.print(T21, 1);                            //
802      lcd.setCursor(7, 0);
803      lcd.print("  T1=");                           //
804      lcd.print(int(T11));                          //
805    }
806  }
807  else
808  {
809    if (TempError1 == HIGH)
810    {
811      TempError1 = LOW;
812      W1  = LOW;
813      T1 = T11;
814      LCDprint();
815    }
816  }
817
818  if (T21  < 10 || T21 > 65)
819  {
820    G2 = LOW;                 // wyczenie 2 pieca.
821    digitalWrite(12, HIGH);
822    digitalWrite(13, LOW);
823    if (TempError2  == LOW)
824    {
825      TempError2 = HIGH;
826      W2 = HIGH;
827      lcd.setCursor  (0, 0); // set cursor to 0,0    //wywietlenie T1, T2, Tu
828      lcd.print("T2=");                             //
829      lcd.print(int (T21));                         //
830      lcd.setCursor(7, 0);
831      lcd.print("  T1=");                           //
832      lcd.print(T11, 1);                            //
833    }
834  }
835  else
836  {
837    if (TempError2 == HIGH)
838    {
839
840      TempError2 = LOW;
841      W2  = LOW;
842      T2 = T21;
843      LCDprint();
844    }
845  }
846
847  T11 = T11  * 10;                   // zaokrglenie Temp. do jednego miejsca po przecinku.
848  T1 = int( T11 );
849  if (T11 - T1 > 0.5)
850  {
851    T1 = T1 + 1;
852  }
853  T1 = T1 / 10;
854
855  T21 = T21 * 10;
856  T2 = int( T21 );
857  if (T21 - T2  > 0.5)
858  {
859    T2 = T2 + 1;
860  }
861  T2 = T2 / 10 + Offset2 + 0.2;   //  korekta o offset oraz uchyb.
862  return (T1, T2);
863}
864

/*
    ARDUINO NANO ATMEGA328 AVR 5V 16 MHz z wywietlaczem LCD 1602  2x16 i HD44780.
   Sterowanie grzaniem dwch piecy.
   Pomiar temperatury na  2 czujnikach DS18B20.
   Wywietlenie T1 i T2 oraz temperatury zadanej, programowanie  temperatury zadanej
   , delty grzania pieca oraz korekty ( Offset2 ) czujnika  temperatury pieca 2.
   Zastosowano filtr bdnych odczytw temperatury,
   Autor  Andrzej Coojew.
*/

#include <avr/wdt.h>
#include <OneWire.h>
#include  <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <DallasTemperature.h>

#define  ONE_WIRE_BUS_1 2                    //nr PIN = D2 dla sensora T1
#define ONE_WIRE_BUS_2  3                    //nr PIN = D3 dla sensora T2

OneWire oneWire_1(ONE_WIRE_BUS_1);
OneWire  oneWire_2(ONE_WIRE_BUS_2);
DallasTemperature sensor_1(&oneWire_1);
DallasTemperature  sensor_2(&oneWire_2);

LiquidCrystal_I2C  lcd(0x27, 2, 1, 0, 4, 5, 6, 7);  // 0x27 is the I2C bus address
float T1 ;
float T2 ;
byte Tu ;
float  Tx ;
float TxOld;
byte Taryfa2;
byte G1 = LOW;
byte G2 = LOW;
byte  SW1 = HIGH;
byte SW2 = HIGH;
byte S1 = HIGH;
byte S2 = HIGH;
byte TempError1  = LOW;
byte TempError2 = LOW;
float delta = 3.0;        // zajmuje 4 bajty
float  deltaOld;
float Offset2 = 0.0;
float Offset2Old;
byte K = 0;
byte K2  = 0;
short i;
unsigned long start;
unsigned long koniec;
byte W1 = LOW;
byte  W2 = LOW;

void setup()
{
  cli();                      //wyczenie WDT
  wdt_reset();                // wyzerowanie licznika WDT
  WDTCSR |= (1 << WDCE)  | (1 << WDE); // inicjacja setup'u WDT
  WDTCSR = (0 << WDIE) | (1 << WDE) |  (1 << WDP3) | (0 << WDP2) | (0 << WDP1) | (1 << WDP0); //zaprogramowanie WDT na  reset i czas 8 s.
  sei();                          // wczenie WDT


  // activate LCD module
  lcd.begin (16, 2);                // for 16 x 2 LCD  module
  lcd.setBacklightPin(3, POSITIVE);
  lcd.backlight();                  //  zaczenie podwietlenia
  sensor_1.begin();
  sensor_2.begin();
  pinMode(A2,  INPUT);               // Taryfa2
  pinMode(4, INPUT_PULLUP);
  pinMode(5,  INPUT_PULLUP);
  pinMode(6, INPUT_PULLUP);
  pinMode(7, INPUT_PULLUP);
  pinMode(8, INPUT_PULLUP);
  pinMode(9, OUTPUT);
  pinMode(A3, OUTPUT);            //  buzzer
  digitalWrite(9, LOW);
  pinMode(10, OUTPUT);
  digitalWrite(10,  LOW);
  pinMode(11, OUTPUT);
  digitalWrite(11, HIGH);
  pinMode(12, OUTPUT);
  digitalWrite(12, HIGH);
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
  Tu = EEPROM.read(0);
  EEPROM.get(9, Tx);
  if (Tu < 20 || Tu > 60)
  {
    Tu = 30;
    Tx = 25;
    EEPROM.write(0, Tu);
    EEPROM.put(1,  delta);                     // zapisuje zmienn uamkow "delta"
    EEPROM.put(5,  Offset2);                   // zapisuje zmienn uamkow "Offset2"
    EEPROM.put(9,  Tx);
  }
  else
  {
    EEPROM.get(1, delta);
    EEPROM.get(5, Offset2);
    EEPROM.get(9, Tx);
  }
  lcd.clear();
  lcd.print("STEROWNIK PIECOW");
  lcd.setCursor (2, 1);
  lcd.print("by A.Colojew");
  delay(4000);
  wdt_reset();
  lcd.clear();
  if (digitalRead(7) == HIGH)
  {
    lcd.print("Piec  nr 1 i nr 2");
    lcd.setCursor (4, 1);
    lcd.print("WYLACZONY");
    S1 = HIGH;
    S2 = HIGH;
  }
  else
  {
    if (digitalRead(8)  == LOW)
    {
      lcd.clear();
      lcd.print("Piec nr 1 i nr 2");
      lcd.setCursor (4, 1);
      lcd.print("WLACZONY");
      S1 = LOW;
      S2 = LOW;
    }
    else
    {
      lcd.clear();
      lcd.print("    Piec nr 1");
      lcd.setCursor (4, 1);
      lcd.print("WLACZONY");
      S1 = LOW;
      S2 = HIGH;
    }
  }
  delay(4000);
  wdt_reset();
  CzytT1T2();
  LCDprint();                           // wywietlenie T1, T2 i  Tu
  Taryfa2 = digitalRead(A2);       // czyta stan taryfy 2
}



void  loop()
{
  wdt_reset();
  CzytT1T2();                                       //czyta  T1 i T2. Kontrola zakuce, zaokrglenie (zajmuje ok. 1 s.)

  if (S2 == HIGH  && TempError1 == LOW && TempError2 == LOW)    //wyczony 2 piec i nie ma ErrorTemp
  {
    lcd.setCursor (8, 0);
  }
  else
  {
    lcd.setCursor (3,  0); // set cursor to 3,0      //wywietlenie T1, T2
    if (TempError2 == HIGH)
    {
      lcd.print(int(T2));
    }
    else
    {
      lcd.print(T2,  1);                               //
    }
    lcd.setCursor (12, 0); // set  cursor to 12,0    //
  }
  if (TempError1 == HIGH)
  {
    lcd.print(int(T1));
  }
  else
  {
    lcd.print(T1, 1);                                 //
  }

  if ( G1 == LOW && G2 == LOW)                      // czy piece nie  grzej ?
  {
    digitalWrite(9, HIGH);                          // zmniejszenie  owietlenia LCD.
  }
  else
  {
    digitalWrite(9, LOW);                           //  zwikszenie owietlenia LCD gdy ktry piec grzeje.
  }


  if (W1 == HIGH  || W2 == HIGH)
  {
    digitalWrite(A3, HIGH);          // wczenie beep
    lcd.setCursor (0, 1);           // set cursor to 0,1
    lcd.print("Blad  temperatury ");
  }
  for (i = 0; i < 350; i++)            //         czeka  3.5 s.
  {
    SW1 = digitalRead(7);              // czyta stan zezwolenie  grzania 1 pieca
    SW2 = digitalRead(8);              // czyta stan zezwolenie  grzania 2 pieca
    if (digitalRead (4) == HIGH && S1 == SW1 && S2 == SW2 &&  Taryfa2 == digitalRead(A2))
    {
      delay(10);
    }
    else                              //  przerywa czekanie
    {
      break;
    }
    wdt_reset();
  }
  if (W1 == HIGH || W2 == HIGH)
  {
    digitalWrite(A3, LOW);               //  wyczwnie beep
    lcd.setCursor (0, 1); // set cursor to 0,1      //
    lcd.print("  T zadana = ");                      //
    lcd.print(Tu);                                  //
    lcd.print(" C");                                //
  }
  for (i = 0;  i < 500; i++)            //         czeka 5 s.
  {
    SW1 = digitalRead(7);              // czyta stan zezwolenie grzania 1 pieca
    SW2 = digitalRead(8);              // czyta stan zezwolenie grzania 2 pieca
    if (digitalRead (4)  == HIGH && S1 == SW1 && S2 == SW2 && Taryfa2 == digitalRead(A2))
    {
      delay(10);
    }
    else                              // przerywa czekanie
    {
      if (Taryfa2 == digitalRead(A2))
      {
        W1 = LOW;
        W2  = LOW;
      }
      Taryfa2 = digitalRead(A2);       // czyta stan taryfy  2
      break;
    }
    wdt_reset();
  }


  if ( S1 != SW1  )                    // zmiana stanu wcznika 1 pieca
  {
    digitalWrite(9,  LOW);
    lcd.clear();
    if ( SW1 == HIGH )
    {
      S1 = HIGH;
      lcd.print( "   Wylaczono");
      lcd.setCursor (0, 1);
      lcd.print("piec  nr 1 i nr 2");
    }
    else
    {
      S1 = LOW;
      lcd.print(  "   Wlaczono");
      if ( SW2 == HIGH)
      {
        lcd.setCursor  (3, 1);
        lcd.print( "piec nr 1");
      }
      else
      {
        lcd.setCursor (0, 1);
        lcd.print("piec nr 1 i nr 2");
      }
    }
    delay(4000);
    wdt_reset();
    LCDprint();                           //  wywietlenie T1, T2 i Tu
  }

  if ( S2 != SW2 )                       //  zmiana stanu wcznika 2 pieca
  {
    digitalWrite(9, LOW);
    lcd.clear();
    if ( SW2 == HIGH )
    {
      S2 = HIGH;
      lcd.print( "   Wylaczono");
      lcd.setCursor (3, 1);
      lcd.print("piec nr 2");
      wdt_reset();
      delay(3000);
      lcd.clear();
      lcd.print("    ZAMKNIJ");
      lcd.setCursor (1, 1);
      lcd.print("zawor pieca 2");
      for  (i = 0; i < 6 ; i++)
      {
        lcd.noDisplay();
        delay(300);
        lcd.display();
        delay(700);
        wdt_reset();
      }
    }
    else
    {
      S2 = LOW;
      if ( SW1 == LOW )
      {
        lcd.print( "   Wlaczono");
        lcd.setCursor (3, 1);
        lcd.print(  "piec nr 2");
        wdt_reset();
        delay(3000);
        lcd.clear();
        lcd.print("    OTWORZ");
        lcd.setCursor (1, 1);
        lcd.print("zawor  pieca 2");
        for (i = 0; i < 6 ; i++)
        {
          lcd.noDisplay();
          delay(300);
          lcd.display();
          delay(700);
          wdt_reset();
        }
      }
      else
      {
        lcd.print("   Blokada");
        lcd.setCursor (2, 1);
        lcd.print( "pieca nr 2");
        wdt_reset();
        delay(4000);
      }
    }

    LCDprint();                           //  wywietlenie T1, T2 i Tu
  }


  if (digitalRead(4) == LOW)                    //  czy nacinieto "SET"
  { // nacisnieto "SET"
    digitalWrite(9, LOW);
    lcd.clear();                                //wywietlenie
    lcd.setCursor  (0, 0); // set cursor to 0,0  //"Ustaw tem. pieca"
    lcd.print("Ustaw tem.  pieca");
    lcd.setCursor (5, 1);
    lcd.print("T = ");
    lcd.print(Tu);
    lcd.print(" C");
    PullSW3();                                  // czeka  na puszczenie "SET"
    start = millis();                       // zaadowanie  licznika czasu
    while (digitalRead(4) == HIGH)          //wykonuj dopuki nie  nacinito "SET"
    {
      if (digitalRead(5) == LOW)       // czy nacinieto  "-"
      {
        start = millis();
        Tu = Tu - 1;
        Tu  = constrain (Tu, 20 , 60 );    // ograniczenie Tmin do 20 C
        lcd.setCursor  (9, 1);
        lcd.print(Tu);
        delay (300);
      }
      if  (digitalRead(6) == LOW)       // czy nacinieto "+"
      {
        start  = millis();
        Tu = Tu + 1;
        Tu = constrain (Tu, 20 , 60 );  //  ograniczenie Tmax do 60 C
        lcd.setCursor (9, 1);
        lcd.print(Tu);
        delay (300);
      }
      koniec = millis();
      if (koniec  - start >= 30000 )   // jeeli nic si nie dziao przez 30 s. to RETURN.
      {
        LCDprint();
        return;
      }
      wdt_reset();
    }

    EEPROM.update (0, Tu);        // zapis do EEPROMU ustawionej tem. Tu (update:  jeeli nie zmany - nie zapisuje)
    lcd.clear();                                      //  wywietlenie  "Ustaw delty pieca"
    lcd.setCursor (0, 0); // set cursor to  0,0
    lcd.print("Ustaw del. pieca");
    lcd.setCursor (2, 1);
    lcd.print("delta  = ");
    lcd.print(delta, 1);
    lcd.print(" C");
    PullSW3();                    //  czeka na puszczenie "SET"
    deltaOld = delta;
    start = millis();
    while (digitalRead(4) == HIGH)          //wykonuj dopuki nie nacinito "SET"
    {
      if (digitalRead(5) == LOW)       // czy nacinieto "-"
      {
        start = millis();
        delta = delta - 0.1;
        delta = constrain  (delta, 0.3 , 5 );  // ograniczenie delty do 0.3 C
        lcd.setCursor (10,  1);
        lcd.print(delta, 1);
        lcd.print(" C ");
        delay  (300);
      }
      if (digitalRead(6) == LOW)       // czy nacinieto "+"
      {
        start = millis();
        delta = delta + 0.1;
        delta  = constrain (delta, 0.3 , 5 );  // ograniczenie delty do 5 C
        lcd.setCursor  (10, 1);
        lcd.print(delta, 1);
        lcd.print(" C ");
        delay  (300);
      }
      koniec = millis();
      if (koniec - start >= 30000  )
      {
        LCDprint();
        return;
      }
      wdt_reset();
    }
    if (deltaOld != delta )
    {
      EEPROM.put(1, delta);        //  zapis do EEPROMU ustawionej delty .
    }
    lcd.clear();                                      //  wywietlenie  "Ustaw Offset pieca 2"
    lcd.setCursor (0, 0); // set cursor  to 0,0
    lcd.print("Offset pieca 2:");
    lcd.setCursor (1, 1);
    lcd.print("offset  = ");
    lcd.print(Offset2, 1);
    lcd.print(" C");
    PullSW3();                    // czeka na puszczenie "SET"
    Offset2Old = Offset2;
    start = millis();
    while (digitalRead(4) == HIGH)          //wykonuj dopuki  nie nacinito "SET"
    {
      if (digitalRead(5) == LOW)       // czy nacinieto  "-"
      {
        start = millis();
        Offset2 = Offset2 - 0.1;
        Offset2 = constrain (Offset2, -3 , 3 );  // ograniczenie Offset2 do -3 C
        lcd.setCursor (10, 1);
        lcd.print(Offset2, 1);
        lcd.print("  C ");
        delay (300);
      }
      if (digitalRead(6) == LOW)       //  czy nacinieto "+"
      {
        start = millis();
        Offset2 =  Offset2 + 0.1;
        Offset2 = constrain (Offset2, -3 , 3 );  // ograniczenie  Offset2 do 3 C
        lcd.setCursor (10, 1);
        lcd.print(Offset2, 1);
        lcd.print(" C ");
        delay (300);
      }
      koniec =  millis();
      if (koniec - start >= 30000 )
      {
        LCDprint();
        return;
      }
      wdt_reset();
    }
    if (Offset2 !=  Offset2Old)
    {
      EEPROM.put(5, Offset2);        // zapis do EEPROMU  ustawiony Offset2 .
    }
    //////////////////////////////////////////////////////////////////////////////////////////
    lcd.clear();                                      // wywietlenie  "Ustaw Tx"
    lcd.setCursor (2, 0); // set cursor to 2,0
    lcd.print("Tx pieca 1 :");
    lcd.setCursor (2, 1);
    lcd.print("Tx = ");
    lcd.print(Tx, 1);
    lcd.print(" C ");
    PullSW3();                    // czeka na puszczenie  "SET"
    TxOld = Tx;
    start = millis();
    while (digitalRead(4)  == HIGH)          //wykonuj dopuki nie nacinito "SET"
    {
      if (digitalRead(5)  == LOW)       // czy nacinieto "-"
      {
        start = millis();
        Tx = Tx - 0.2;
        Tx = constrain (Tx, 3 , 30 ); // ograniczenie  Tx do 3 C
        lcd.setCursor (7, 1);
        lcd.print(Tx, 1);
        lcd.print("  C ");
        delay (300);
      }
      if (digitalRead(6) == LOW)       //  czy nacinieto "+"
      {
        start = millis();
        Tx = Tx +  0.2;
        Tx = constrain (Tx, 3 , 30 );  // ograniczenie Tx do 30 C
        lcd.setCursor  (7, 1);
        lcd.print(Tx, 1);
        lcd.print(" C ");
        delay  (300);
      }
      koniec = millis();
      if (koniec - start >= 30000  )
      {
        LCDprint();
        return;
      }
      wdt_reset();
    }
    if (Tx != TxOld)
    {
      EEPROM.put(9, Tx);        // zapis  do EEPROMU ustawiony Tx .
    }
    LCDprint();                  // wywietlenie  T1, T2 i Tu
    PullSW3();                   // czeka na puszczenie "SET"
    //////////////////////////////////////////////////////////////////////////////////////////
  }


  if (SW1 == HIGH)              // czy brak zezwolenia na grzanie  1 pieca
  {
    G1 = LOW;
    G2 = LOW;
    digitalWrite(10, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(12, HIGH);
    digitalWrite(13,  LOW);
    K = 0;
    K2 = 0;
    return;
  }
  if (SW2 == HIGH)                          //  czy brak zezwolenia na grzanie 2 pieca
  {
    G2 = LOW;
    digitalWrite(12,  HIGH);
    digitalWrite(13, LOW);
    digitalWrite(10, LOW);
    if (TempError1  == HIGH)
    { // wyczenie 1 pieca.
      G1 = LOW;
      digitalWrite(11,  HIGH);
      K = 0;
      return;
    }
    if (G1 == HIGH)                         //  1 piec grzeje.
    {
      if (T1 >= Tu)
      { // nagrza si 1 piec.
        K = K + 1;
        if ( K >= 3 )
        { // wyczenie 1 pieca.
          G1 = LOW;
          digitalWrite(11, HIGH);
          K = 0;
        }
        return;
      }
      K = 0;
      return;
    }
    if (Taryfa2 == LOW)
    { // WSTAWKA !!!!!!
      if (T1 <= Tu - Tx)                //  czy nadmierne schodzenie pieca?
      {
        G1 = HIGH;
        digitalWrite(11,  LOW);   // wczenie 1 pieca.
        K = 0;
      }
      // koniec wstawki
      return;
    }
    if (T1 <= Tu - delta)     // czy chce grza 1 piec  ?
    {
      K = K + 1;
      if ( K >= 4 )
      {
        G1 =  HIGH;
        digitalWrite(11, LOW);   // wczenie 1 pieca.
        K = 0;
      }
      return;
    }
    K = 0;
    return;
  }
  // oba  piece mog grza.

  if (G1 == HIGH)                     // grzeje 1 piec.
  {
    if (TempError1 == HIGH)
    { // wyczenie 1 pieca.
      G1 = LOW;
      digitalWrite(11, HIGH);
      K = 0;
    }
    else
    {
      if (T2 <= Tu - delta && Taryfa2 == HIGH) // czy jest 2 taryfa i 2 piec chce  grza ?
      {
        digitalWrite(13, HIGH);
      }
      else
      {
        digitalWrite(13, LOW);
      }
      if (T1 < Tu)               //  czy nie nagrza si 1 piec ?
      {
        K = 0;
        return;
      }
      K = K + 1;
      if (K < 3 )
      {
        return;
      }
      G1 = LOW;                 // wyczenie 1 pieca.
      digitalWrite(11, HIGH);
      K = 0;
    }
    if (T2 <= Tu - delta )         //  2 piec chce grza  ?
    {
      if (TempError2 == LOW)
      {
        digitalWrite(12,  LOW);   // wczenie 2 pieca.
        digitalWrite(13, LOW);
        G2 = HIGH;                // wczenie flagi "2 piec grzeje".
      }
    }
    return;
  }

  if (G2 == HIGH)             // czy grzeje 2 piec ?
  {
    if  (TempError2 == HIGH)
    {
      G2 = LOW;                 // wyczenie 2 pieca.
      digitalWrite(12, HIGH);
      K = 0;
    }
    if (T1 <= Tu - delta  && Taryfa2 == HIGH)  // czy jest 2 taryfa i 1 piec chce grza ?
    {
      digitalWrite(10,  HIGH);
    }
    else
    {
      digitalWrite(10, LOW);
    }

    if (T2 < Tu)              // czy 2 piec nienagrzany ?
    {
      K =  0;
      return;
    }
    K = K + 1;
    if (K < 3 )
    {
      return;
    }
    G2 = LOW;                 // wyczenie 2 pieca.
    digitalWrite(12,  HIGH);
    K = 0;

    if (T1 <= Tu - delta && Taryfa2 == HIGH)  // czy  jest 2 taryfa i 1 piec chce grza ?
    {
      if (TempError1 == LOW)
      {
        digitalWrite(11, LOW);   // wczenie 1 pieca.
        digitalWrite(10,  LOW);
        G1 = HIGH;                // wczenie flagi "1 piec grzeje".
      }
    }
    return;
  }
  if (Taryfa2 == LOW)         // czy nie  ma 2 taryfy ?
  {
    // WSTAWKA !!!!!!
    if (TempError1 == LOW )
    {
      if (T1 <= Tu - Tx)                // czy nadmierne schodzenie pieca?
      {
        G1 = HIGH;
        digitalWrite(11, LOW);   // wczenie 1 pieca.
        K = 0;
      }
    }                                                         //  koniec wstawki

    digitalWrite(10, LOW);
    digitalWrite(13, LOW);
    return;
  }

  if (TempError1 == LOW)
  {
    if (T1 <= Tu -  delta)     // czy chce grza 1 piec ?
    {
      K = K + 1;
      if (  K >= 4 )
      {
        G1 = HIGH;
        digitalWrite(11, LOW);   //  wczenie 1 pieca.
        digitalWrite(10, LOW);
        K = 0;
      }
      return;
    }
  }
  K = 0;
  digitalWrite(10, LOW);
  if (  TempError2 == LOW)
  {
    if (T2 <= Tu - delta)       // czy chce grza 2  piec ?
    {
      K2 = K2 + 1;
      if ( K2 >= 4 )
      {
        digitalWrite(12,  LOW);   // wczenie 2 pieca.
        digitalWrite(13, LOW);
        G2 = HIGH;                // wczenie flagi "2 piec grzeje".
        K2 = 0;
      }
      return;
    }
  }
  K2 = 0;
  digitalWrite(13, LOW);
}

//  KONIEC programu LOOP.


// PROCEDURY.

void PullSW3()                //  Czeka na puszczenie "SET"
{
  while (digitalRead(4) == LOW)
  {
    delay(50);
    wdt_reset();
  }
  delay(50);
}

void LCDprint()
{
  lcd.clear();
  if (S2 == HIGH && TempError1 == LOW && TempError2 == LOW)        //wyczony 2 piec  i nie ma TempError
  {
    lcd.setCursor (3, 0);                           //  wywietlenie T1, Tu
    lcd.print("T1 = ");
    lcd.print(T1, 1);
    lcd.print("  C");
  }
  else
  {
    lcd.setCursor (0, 0); // set cursor to 0,0    //wywietlenie T1, T2, Tu
    lcd.print("T2=");                             //
    if (TempError2 == HIGH)
    {
      lcd.print(int(T2));
    }
    else
    {
      lcd.print(T2, 1);
    }
    lcd.print("  T1=");
    if  (TempError1 == HIGH)
    {
      lcd.print(int(T1));
    }
    else
    {
      lcd.print(T1, 1);
    }
  }                                               //
  lcd.setCursor (1, 1); // set cursor to 0,1      //
  lcd.print("T zadana =  ");                       //
  lcd.print(Tu);                                  //
  lcd.print(" C");                                //
}

float CzytT1T2()
{
  float T11 = 0;
  float T21 = 0;
  for (i = 0 ; i < 7 ; i++)                   //  oblicza redni z 7 pomiarw
  {
    sensor_1.setWaitForConversion(false);  //  makes it async
    sensor_2.setWaitForConversion(false);  // makes it async
    sensor_1.requestTemperatures();
    sensor_2.requestTemperatures();
    delay(150);
    T11 = T11 + sensor_1.getTempCByIndex(0);
    T21 = T21 + sensor_2.getTempCByIndex(0);
  }
  wdt_reset();
  T11 = T11 / 7;
  T21 = T21 / 7;

  if (T11 <  10 || T11 > 65)
  {
    G1 = LOW;                 // wyczenie 1 pieca.
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    if (TempError1  == LOW)
    {
      TempError1 = HIGH;
      W1 = HIGH;
      lcd.setCursor  (0, 0); // set cursor to 0,0    // wywietlenie T1, T2, Tu
      lcd.print("T2=");                             //
      lcd.print(T21, 1);                            //
      lcd.setCursor(7, 0);
      lcd.print("  T1=");                           //
      lcd.print(int(T11));                          //
    }
  }
  else
  {
    if (TempError1 == HIGH)
    {
      TempError1 = LOW;
      W1  = LOW;
      T1 = T11;
      LCDprint();
    }
  }

  if (T21  < 10 || T21 > 65)
  {
    G2 = LOW;                 // wyczenie 2 pieca.
    digitalWrite(12, HIGH);
    digitalWrite(13, LOW);
    if (TempError2  == LOW)
    {
      TempError2 = HIGH;
      W2 = HIGH;
      lcd.setCursor  (0, 0); // set cursor to 0,0    //wywietlenie T1, T2, Tu
      lcd.print("T2=");                             //
      lcd.print(int (T21));                         //
      lcd.setCursor(7, 0);
      lcd.print("  T1=");                           //
      lcd.print(T11, 1);                            //
    }
  }
  else
  {
    if (TempError2 == HIGH)
    {

      TempError2 = LOW;
      W2  = LOW;
      T2 = T21;
      LCDprint();
    }
  }

  T11 = T11  * 10;                   // zaokrglenie Temp. do jednego miejsca po przecinku.
  T1 = int( T11 );
  if (T11 - T1 > 0.5)
  {
    T1 = T1 + 1;
  }
  T1 = T1 / 10;

  T21 = T21 * 10;
  T2 = int( T21 );
  if (T21 - T2  > 0.5)
  {
    T2 = T2 + 1;
  }
  T2 = T2 / 10 + Offset2 + 0.2;   //  korekta o offset oraz uchyb.
  return (T1, T2);
}

Downloadable files

Heat pump controller

Comments

Only logged in users can leave comments

andrzejco

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content