Tankless Water Heater temperature limiter

Control to limit the temperature of a tankless WH to prevent triggering the limit switch

Sep 23, 2020

•

3403 views

•

0 respects

waterheater

temperature limiter

gas burner

Components and supplies

Arduino Leonardo

Wire, Hook Up

Apps and platforms

Arduino IDE

Project description

Code

Temperature limiter

c_cpp

It has the code for a lcd shield, you can remove that if you don’t use it. VtoC converts the voltage from the ADC to a temperature reading. I used the lcd on the Arduino to display the voltage and filmed the values with the temperature displayed by the heater. This is for T2, the output thermistor. Then I curve fitted the data into the function you see here. A fourth degree polynomial was enough for the temperature range I needed. The units should matter and you can use Rankine, Kelvin or Fahrenheit as yours, just adjust the constants throughout the program. You probably want to insure that the temperature is more accurate around the range it activates (max_temp to about max_temp -15°C Since the heater is supplied by solar panels, the input temperature ranged from cold to about 60°C. You can try to adjust the temperature of T1 (first few lines of the loop function) to match T1 better. However, if you can’t (because it doesn’t change much), you can remove T1 from the program. It basically is a feature for efficiency and safety. It prevents the heater from turning on when the input temperature is high. To improve measurements and reduce reading artifacts, the code averages the last half second voltages using a stack (the PushPop class template). Allows to only have the data from the last window long number of points (you can change the size using the window constant) The heater control is done by sending a pulse to the flow sensor input. The Arduino configures a PWM oscillator to send a signal. The pwm… functions set this up. A frequency of 22 Hz was chosen to insure the heater wouldn’t shut-off thinking there wasn’t enough flow. The Arduino starts or stops the signal to control the heater. There is a delay of 5s to give the time for the water from solar panels time to reach the water heater. If you don’t like this, you can remove it. It also gives time to check that the flow sensor didn’t glitch and send a spurious pulse. The Arduino won’t wake up if it doesn’t detect a flow of water. Either mine is defective or the water pipe caused it to pulse. The program tries to predict the trend of the temperature doing a curve fit on the data from the stack. It does this trying to get ahead of the heater’s time constant to prevent it from either overheating or get ahead of the time it takes to turn on. Not perfect, and you can still feel the heater turning on and off by the range of temperature in the water. You might want to adjust the heater’s temperature control to be good enough for most cases (mine is at 51°C) at full flow. With low flow the temperature can reach 60–70°C (depending on how fast the temperature changes, or how restricted is the flow). So don’t try to set the temperature on the heater too high, or it will be turning on and off too often. The sleepy code puts the Arduino into sleep mode, to save energy

1#include <avr/sleep.h>
2#include <Arduino.h>
3#include <curveFitting.h>
4#include  <hd44780.h>
5#include <hd44780ioClass/hd44780_pinIO.h> // Arduino pin i/o class  header
6
7PROGMEM const bool debug = false;
8
9PROGMEM const int min_flow  = 3;
10PROGMEM const int max_temp = 69;
11PROGMEM const int window = 23;
12PROGMEM  const int pred_w = 6;
13PROGMEM const int order = 2;
14const uint8_t flowsensor  = 2;
15const uint8_t t1_pin = A1;
16const uint8_t t2_pin = A2;
17
18// lcd values
19const  int rs = 8, en = 9, db4 = 4, db5 = 5, db6 = 6, db7 = 7; // for all other devices
20hd44780_pinIO  lcd(rs, en, db4, db5, db6, db7);
21const int BACKLIGHT_PIN = 10;
22const int OFF  = 0;
23const int ON = 1;
24
25#define SafeBLon() pinMode(BACKLIGHT_PIN, INPUT)
26
27void  SafeBLoff() {
28  digitalWrite(BACKLIGHT_PIN, LOW);
29  delay(500);
30  pinMode(BACKLIGHT_PIN,  OUTPUT);
31}
32
33
34#define PWM366 10   //    366 Hz
35#define PWM183 11   //    183 Hz
36#define PWM91  12   //     91 Hz
37#define PWM45  13   //     45  Hz
38#define PWM22  14   //     22 Hz
39#define PWM11  15   //     11 Hz
40
41//  Direct PWM change variables
42#define PWM13       OCR4A
43
44
45double coeffs[3];
46double  y[window];
47double x[window];
48
49byte adcsra_save = ADCSRA;
50byte prr0_save  = 0x00;
51
52int t1 = 0;
53int t2 = 0;
54int t1t = 0;
55int t2t = 0;
56int  t1sum = 0;
57int t2sum = 0;
58int t1avg = 0;
59int t2avg = 0;
60int t2last =  0;
61int last_zero = 0;
62double a = 0;
63double m = 0;
64double pred = 0;
65double  pred0 = 0;
66unsigned int n = 0;
67unsigned long currentTime = 0;
68unsigned  long cloopTime = 0;
69unsigned long lastPulse = 0;
70unsigned int seq = 0;
71volatile  unsigned int count = 0;
72unsigned int liters = 0;
73String str = "";
74
75char  format1[] = "F% 3d a% 4s m% 4s";
76char format2[] = "T% 3d P% 4s Q% 4s";
77
78
79void  toLCD (const char* format, int a, double b, double c, int line) {
80  static char  chr[16] = "";
81  static char outstr[6] = "";
82  static char outstr1[6] =  "";
83
84  dtostrf(b, 3, 1, outstr);
85  dtostrf(c, 3, 1, outstr1);
86
87  lcd.setCursor(0, line);
88
89  sprintf(chr, format, a, outstr, outstr1);
90  lcd.print(chr);
91}
92
93void putLCD (char* format, int line) {
94  if (line  == 0) {
95    format1[0] = format;
96    format2[0] = 'T';
97  } else {
98    format1[0]  = 'F';
99    format2[0] = format;
100  }
101
102}
103template <class DATATYPE,  unsigned char SIZE> class PushPop {
104  private:
105    const unsigned char m_Size  = SIZE - 1;
106    DATATYPE m_Array[SIZE];
107    int m_Index;
108  public:
109    PushPop() {
110      m_Index = -1;
111    }
112    void Zero() {
113      m_Index  = -1;
114      for (int i = 0; i < m_Size; i++) {
115        m_Array[i] = 210;
116      }
117    }
118    void Push(DATATYPE what) {
119      if (m_Index >= m_Size)  {
120        Pop();
121      }
122      m_Index = min(m_Size, m_Index++);
123      m_Array[m_Index]  = what;
124    }
125    DATATYPE Pop() {
126      for (int i = 0; i < m_Index; i++)  {
127        m_Array[i] = m_Array[i + 1];
128      }
129      m_Index--;
130      return  m_Array[m_Index];
131    }
132    DATATYPE Walk(int i) {
133      return m_Array[i];
134    }
135    DATATYPE Last() {
136      return m_Array[m_Index];
137    }
138    void  printpp() {
139      for (int i = 0; i <= m_Index; i++) {
140        Serial.print(m_Array[i]);
141        Serial.print('\	');
142      }
143      Serial.println();
144    }
145    DATATYPE avg(int n) {
146      DATATYPE sum = 0;
147      if (n == 0) {
148        n = m_Index;
149      }
150      int i;
151      for (i = m_Index - n ;  i <= m_Index; i++) {
152        sum = sum + m_Array[i];
153      }
154      return  sum / (n + 1);
155    }
156    void getmat(DATATYPE mat[]) {
157      for (int i  = 0; i <= m_Index; i++) {
158        mat[i] = m_Array[i];
159      }
160    }
161    int getsize() {
162      return m_Index;
163    }
164
165    double slope(int  n) {
166      if (n == 0) {
167        n = m_Index;
168      }
169      n = m_Index  - n;
170      return (  m_Array[m_Index] - m_Array[n] ) / m_Index;
171    }
172};
173
174//  Configure the PWM clock
175// The argument is one of the 7 previously defined modes
176void  pwm613configure()
177{
178  // TCCR4A configuration
179  TCCR4A = 0;
180
181  //  TCCR4B configuration
182  TCCR4B = 0;
183
184  // TCCR4C configuration
185  TCCR4C  = 0;
186
187  // TCCR4D configuration
188  TCCR4D = 0;
189
190  TCCR4E |= (1 <<  ENHC4);
191
192  // PLL Configuration
193  // Use 96MHz / 2 = 48MHz
194  PLLFRQ  = (PLLFRQ & 0xCF) | 0x30;
195  // PLLFRQ=(PLLFRQ&0xCF)|0x10; // Will double all  frequencies
196
197  // Terminal count for Timer 4 PWM
198  OCR4C = 255;
199}
200
201//  Set PWM to D13 (Timer4 A)
202// Argument is PWM between 0 and 255
203void pwmSet13()
204{
205  if (TCCR4B == 0) {
206    TCCR4B = PWM91;
207    OCR4A = 255; // Set PWM value
208    DDRC |= 1 << 7; // Set Output Mode C7
209    TCCR4A = 0x82; // Activate channel  A
210  }
211  delay(10);
212  if (debug) {
213    Serial.println("pwmset");
214  }
215}
216
217void pwmStop13()
218{
219  TCCR4B = 0;
220  digitalWrite(13, LOW);
221  delay(10);
222
223  if (liters < min_flow) {
224    seq = 0;
225  }
226}
227
228void  flow() {
229  count++;
230}
231
232void wake() {
233  sleep_disable();
234  detachInterrupt(digitalPinToInterrupt(flowsensor));
235}
236
237int  VtoC (int temp) {
238  double f = 1.81176e-10;
239  f = f * temp;
240  f = f - 5.03596e-7;
241  f = f * temp;
242  f = f + 0.0005340536;
243  f = f * temp;
244  f = f - 0.33203628;
245  f = f * temp;
246  f = f + 110.4503125;
247  if (f > 100 or f < 0 ) {
248    f  = 0;
249  }
250  return (int(f));
251}
252
253
254PushPop<double, window> t2s;
255
256void  setup() {
257  if (debug) {
258    Serial.begin(9600);
259    delay(3000);
260    Serial.println("Starting…");
261
262  }
263
264  analogReference((int)DEFAULT);
265
266  lcd.begin(16, 2);              //  Initialize LCD for 16 character x 2 line operation
267
268  lcd.clear();
269
270  pwm613configure();
271  pwmStop13();
272  pinMode(flowsensor, INPUT);
273  pinMode(t1_pin,  INPUT);
274  pinMode(t2_pin, INPUT);
275
276  delay(3000);
277
278  lcd.setCursor(0,  0);
279  lcd.print("Starting...");
280
281  SafeBLon();
282
283  attachInterrupt(digitalPinToInterrupt(flowsensor),  flow, RISING);
284  sei(); // Enable interrupts
285  currentTime = millis();
286  cloopTime = currentTime;
287  lastPulse = currentTime;
288  t1sum = 0;
289  t2sum  = 0;
290  n = 0;
291  t2last = 0;
292
293  for (int i = 0; i < window; i++) {
294    x[i] = i;
295  }
296
297}
298
299void loop() {
300
301new_cycle:
302  currentTime  = millis();
303
304  yield();
305
306  delay(15);
307  t1 = analogRead(t1_pin);
308  t1 = 1.11 * t1 - 120.2;
309
310  delay(25);
311  t2 = analogRead(t2_pin);
312
313  t1sum = t1sum + t1;
314  t2sum = t2sum + t2;
315  n++;
316
317  t1avg = t1sum  / n;
318  t2avg = t2sum / n;
319
320  t1t = VtoC(t1avg);
321  t2t = VtoC(t2avg);
322
323  if ((liters <= min_flow) or (t2t > max_temp)) {
324    if (debug) {
325      Serial.println("immediate  stop");
326    }
327
328    pwmStop13();
329  }
330
331  if (currentTime >= (cloopTime  + 500)) {
332
333  //  analogReference((int)DEFAULT);
334    
335    t2s.Push(t2t);
336
337    cloopTime = currentTime; // Updates cloopTime
338    // Pulse frequency (Hz)  = 7.5Q, Q is flow rate in L/min.
339    //     liters = (count / 7.5 ); // (Pulse  frequency ) / 7.5Q = flowrate in L
340    noInterrupts();
341    liters = count;
342    count = 0; // Reset Counter
343    interrupts();
344
345    //    liters = 12;
346
347    if (liters > min_flow) {
348      seq++;
349      lastPulse = currentTime;
350      last_zero = 0;
351    } else {
352      if (last_zero > 2) {
353        seq  = 0;
354      }
355      last_zero++;
356    }
357    if (debug) {
358      str  = "liters: " + String(liters) + " t1t: " + String(t1t) + " t2t: " + String(t2t)  + " seq: " + String(seq) + " n: " + String(n);
359      Serial.println(str);
360    }
361
362	  t1sum = 0;
363    t2sum = 0;
364    n = 0;
365
366    if ((liters  <= min_flow) or (t2t > max_temp + 2) or (t1t >= 48)) {
367      if (debug) {
368        Serial.println("stop");
369        Serial.println("seq " + String(seq));
370      }
371      pwmStop13();
372    } else if (seq >= 5) {
373      t2s.getmat(y);
374      if (fitCurve(order, t2s.getsize(), x, y, sizeof(coeffs) / sizeof(double),  coeffs) == 0 and !isnan(coeffs[0])) {
375        pred  = (coeffs[0] * (window +  pred_w) + coeffs[1]) * (window + pred_w) + coeffs[2];
376        pred0 = (coeffs[0]  * (window + 1) + coeffs[1]) * (window + 1) + coeffs[2];
377        a = t2s.avg(10);
378        m = t2s.slope(4) * 2;
379
380
381        if (max(a, t2t) > (max_temp)) {
382           if (debug) {
383              Serial.println("    +Powering off");
384            }
385            putLCD ('M', 1);
386            pwmStop13();
387        }  else if (min(a, t2t) < (max_temp - 12)) {
388          if (debug) {
389              Serial.println("    -Powering on");
390            }
391            putLCD ('m', 0);
392            pwmSet13();
393        } else if (m > 0.2) {
394          if (max(a, t2t) > (max_temp -10) and  pred > (max_temp -5) and t2t < (pred0 + 1) and (pred0 + 1) < pred and pred > (a  + 2)) {
395            if (debug) {
396              Serial.println("    Powering  off");
397            }
398            putLCD ('.', 1);
399            pwmStop13();
400          } else if (min(a, t2t) < (max_temp -3) and pred < (max_temp -8) and t2t  > pred0 and pred0 > (pred + 1) ) {
401            if (debug) {
402              Serial.println("    Powering on");
403            }
404            putLCD ('.', 0);
405            pwmSet13();
406          }
407        } else if  (m <= -0.1) {
408          if (max(a, t2t) > (max_temp  - 10) and pred > (max_temp -5) and t2t < (pred0 + 1) and (pred0 + 1) < pred) {
409            if (debug) {
410              Serial.println("    *Powering off");
411            }
412            putLCD (':', 1);
413            pwmStop13();
414          }  else if (max(a, t2t) >= (max_temp -10) and t2t <= max_temp and pred < (max_temp  -5) and a >= (pred + 6) and t2t > pred0 and pred0 > (pred + 1)) {
415            if  (debug) {
416              Serial.println("    *Powering on");
417            }
418            putLCD (':', 0);
419            pwmSet13();
420          } else if ((t2t  + 1) < a and t2t < max_temp and a >= (pred + 3) and t2t > pred0 and pred0 > (pred  + 1)) {
421            if (debug) {
422              Serial.println("    *Powering  on *");
423            }
424            putLCD ('-', 0);
425            pwmSet13();
426          }
427        } else {
428          if ((a <= t2t and t2t > (max_temp -4)  and pred >= (a + 2) and pred0 < pred) or (t2t > (max_temp - 2))) {
429            if  (debug) {
430              Serial.println("    **Powering off");
431            }
432            putLCD ('*', 1);
433            pwmStop13();
434          } else if  (t2t <= (max_temp -4) and t2t < a and (pred + 2) < a and pred0 >= pred) {
435            if  (debug) {
436              Serial.println("    **Powering on");
437            }
438            putLCD ('*', 0);
439            pwmSet13();
440          }
441        }
442      }
443    }
444
445	toLCD (format1, liters, a, m, 0);
446	toLCD (format2,  t2t, pred, pred0, 1);
447
448    if ((currentTime >= (lastPulse + 300000)) and (liters  < min_flow)) {
449sleepy:
450      if (debug) {
451        Serial.println("sleepy");
452      }
453      SafeBLoff();
454      delay(500);
455      noInterrupts();
456      detachInterrupt(digitalPinToInterrupt(flowsensor));
457      set_sleep_mode(SLEEP_MODE_PWR_DOWN);
458      sleep_enable();
459      attachInterrupt(digitalPinToInterrupt(flowsensor),  wake, RISING);
460      interrupts();
461
462      adcsra_save = ADCSRA;
463      prr0_save  = PRR0;
464
465      pwmStop13();
466
467      ADCSRA &= ~(1 << ADEN);    // Disable  ADC
468      PRR0 = 0xFF;   // Power down functions
469
470      sleep_mode();
471      sleep_disable();
472      PRR0 = 0x00; //modules on
473      ADCSRA |= (1  << ADEN); // adc on
474
475      ADCSRA = adcsra_save; // stop power reduction
476      PRR0 = prr0_save;
477
478
479      noInterrupts();
480      attachInterrupt(digitalPinToInterrupt(flowsensor),  flow, RISING);
481      interrupts();
482
483      currentTime = millis();
484      cloopTime  = currentTime;
485      int times = 0;
486      count = 0;
487      liters = 0;
488      int i = 0;
489      t2s.Zero();
490
491      for (i = 0; i < 6; i++) {
492        while (currentTime < (cloopTime + 1000)) {
493          yield();
494          t2s.Push(VtoC(analogRead(t2_pin)));
495          delay(25);
496          currentTime = millis();
497        }
498        if  (count > 0) {
499          noInterrupts();
500          liters = liters + count;
501          count = 0; // Reset Counter
502          interrupts();
503          times  = times + 1;
504        }
505        if ((liters > 50) and (times > 2)) {
506          break;
507        }
508        cloopTime = currentTime;
509      }
510
511      if ((times  < 5) and (liters < 30)) {
512        goto sleepy;
513      }
514
515      seq =  times;
516
517      currentTime = millis();
518      lastPulse = currentTime;
519
520      SafeBLon();
521      delay(100);
522      t1sum = 0;
523      t2sum = 0;
524      n = 0;
525
526    }
527  }
528}

#include <avr/sleep.h>
#include <Arduino.h>
#include <curveFitting.h>
#include  <hd44780.h>
#include <hd44780ioClass/hd44780_pinIO.h> // Arduino pin i/o class  header

PROGMEM const bool debug = false;

PROGMEM const int min_flow  = 3;
PROGMEM const int max_temp = 69;
PROGMEM const int window = 23;
PROGMEM  const int pred_w = 6;
PROGMEM const int order = 2;
const uint8_t flowsensor  = 2;
const uint8_t t1_pin = A1;
const uint8_t t2_pin = A2;

// lcd values
const  int rs = 8, en = 9, db4 = 4, db5 = 5, db6 = 6, db7 = 7; // for all other devices
hd44780_pinIO  lcd(rs, en, db4, db5, db6, db7);
const int BACKLIGHT_PIN = 10;
const int OFF  = 0;
const int ON = 1;

#define SafeBLon() pinMode(BACKLIGHT_PIN, INPUT)

void  SafeBLoff() {
  digitalWrite(BACKLIGHT_PIN, LOW);
  delay(500);
  pinMode(BACKLIGHT_PIN,  OUTPUT);
}


#define PWM366 10   //    366 Hz
#define PWM183 11   //    183 Hz
#define PWM91  12   //     91 Hz
#define PWM45  13   //     45  Hz
#define PWM22  14   //     22 Hz
#define PWM11  15   //     11 Hz

//  Direct PWM change variables
#define PWM13       OCR4A


double coeffs[3];
double  y[window];
double x[window];

byte adcsra_save = ADCSRA;
byte prr0_save  = 0x00;

int t1 = 0;
int t2 = 0;
int t1t = 0;
int t2t = 0;
int  t1sum = 0;
int t2sum = 0;
int t1avg = 0;
int t2avg = 0;
int t2last =  0;
int last_zero = 0;
double a = 0;
double m = 0;
double pred = 0;
double  pred0 = 0;
unsigned int n = 0;
unsigned long currentTime = 0;
unsigned  long cloopTime = 0;
unsigned long lastPulse = 0;
unsigned int seq = 0;
volatile  unsigned int count = 0;
unsigned int liters = 0;
String str = "";

char  format1[] = "F% 3d a% 4s m% 4s";
char format2[] = "T% 3d P% 4s Q% 4s";


void  toLCD (const char* format, int a, double b, double c, int line) {
  static char  chr[16] = "";
  static char outstr[6] = "";
  static char outstr1[6] =  "";

  dtostrf(b, 3, 1, outstr);
  dtostrf(c, 3, 1, outstr1);

  lcd.setCursor(0, line);

  sprintf(chr, format, a, outstr, outstr1);
  lcd.print(chr);
}

void putLCD (char* format, int line) {
  if (line  == 0) {
    format1[0] = format;
    format2[0] = 'T';
  } else {
    format1[0]  = 'F';
    format2[0] = format;
  }

}
template <class DATATYPE,  unsigned char SIZE> class PushPop {
  private:
    const unsigned char m_Size  = SIZE - 1;
    DATATYPE m_Array[SIZE];
    int m_Index;
  public:
    PushPop() {
      m_Index = -1;
    }
    void Zero() {
      m_Index  = -1;
      for (int i = 0; i < m_Size; i++) {
        m_Array[i] = 210;
      }
    }
    void Push(DATATYPE what) {
      if (m_Index >= m_Size)  {
        Pop();
      }
      m_Index = min(m_Size, m_Index++);
      m_Array[m_Index]  = what;
    }
    DATATYPE Pop() {
      for (int i = 0; i < m_Index; i++)  {
        m_Array[i] = m_Array[i + 1];
      }
      m_Index--;
      return  m_Array[m_Index];
    }
    DATATYPE Walk(int i) {
      return m_Array[i];
    }
    DATATYPE Last() {
      return m_Array[m_Index];
    }
    void  printpp() {
      for (int i = 0; i <= m_Index; i++) {
        Serial.print(m_Array[i]);
        Serial.print('\	');
      }
      Serial.println();
    }
    DATATYPE avg(int n) {
      DATATYPE sum = 0;
      if (n == 0) {
        n = m_Index;
      }
      int i;
      for (i = m_Index - n ;  i <= m_Index; i++) {
        sum = sum + m_Array[i];
      }
      return  sum / (n + 1);
    }
    void getmat(DATATYPE mat[]) {
      for (int i  = 0; i <= m_Index; i++) {
        mat[i] = m_Array[i];
      }
    }
    int getsize() {
      return m_Index;
    }

    double slope(int  n) {
      if (n == 0) {
        n = m_Index;
      }
      n = m_Index  - n;
      return (  m_Array[m_Index] - m_Array[n] ) / m_Index;
    }
};

//  Configure the PWM clock
// The argument is one of the 7 previously defined modes
void  pwm613configure()
{
  // TCCR4A configuration
  TCCR4A = 0;

  //  TCCR4B configuration
  TCCR4B = 0;

  // TCCR4C configuration
  TCCR4C  = 0;

  // TCCR4D configuration
  TCCR4D = 0;

  TCCR4E |= (1 <<  ENHC4);

  // PLL Configuration
  // Use 96MHz / 2 = 48MHz
  PLLFRQ  = (PLLFRQ & 0xCF) | 0x30;
  // PLLFRQ=(PLLFRQ&0xCF)|0x10; // Will double all  frequencies

  // Terminal count for Timer 4 PWM
  OCR4C = 255;
}

//  Set PWM to D13 (Timer4 A)
// Argument is PWM between 0 and 255
void pwmSet13()
{
  if (TCCR4B == 0) {
    TCCR4B = PWM91;
    OCR4A = 255; // Set PWM value
    DDRC |= 1 << 7; // Set Output Mode C7
    TCCR4A = 0x82; // Activate channel  A
  }
  delay(10);
  if (debug) {
    Serial.println("pwmset");
  }
}

void pwmStop13()
{
  TCCR4B = 0;
  digitalWrite(13, LOW);
  delay(10);

  if (liters < min_flow) {
    seq = 0;
  }
}

void  flow() {
  count++;
}

void wake() {
  sleep_disable();
  detachInterrupt(digitalPinToInterrupt(flowsensor));
}

int  VtoC (int temp) {
  double f = 1.81176e-10;
  f = f * temp;
  f = f - 5.03596e-7;
  f = f * temp;
  f = f + 0.0005340536;
  f = f * temp;
  f = f - 0.33203628;
  f = f * temp;
  f = f + 110.4503125;
  if (f > 100 or f < 0 ) {
    f  = 0;
  }
  return (int(f));
}


PushPop<double, window> t2s;

void  setup() {
  if (debug) {
    Serial.begin(9600);
    delay(3000);
    Serial.println("Starting…");

  }

  analogReference((int)DEFAULT);

  lcd.begin(16, 2);              //  Initialize LCD for 16 character x 2 line operation

  lcd.clear();

  pwm613configure();
  pwmStop13();
  pinMode(flowsensor, INPUT);
  pinMode(t1_pin,  INPUT);
  pinMode(t2_pin, INPUT);

  delay(3000);

  lcd.setCursor(0,  0);
  lcd.print("Starting...");

  SafeBLon();

  attachInterrupt(digitalPinToInterrupt(flowsensor),  flow, RISING);
  sei(); // Enable interrupts
  currentTime = millis();
  cloopTime = currentTime;
  lastPulse = currentTime;
  t1sum = 0;
  t2sum  = 0;
  n = 0;
  t2last = 0;

  for (int i = 0; i < window; i++) {
    x[i] = i;
  }

}

void loop() {

new_cycle:
  currentTime  = millis();

  yield();

  delay(15);
  t1 = analogRead(t1_pin);
  t1 = 1.11 * t1 - 120.2;

  delay(25);
  t2 = analogRead(t2_pin);

  t1sum = t1sum + t1;
  t2sum = t2sum + t2;
  n++;

  t1avg = t1sum  / n;
  t2avg = t2sum / n;

  t1t = VtoC(t1avg);
  t2t = VtoC(t2avg);

  if ((liters <= min_flow) or (t2t > max_temp)) {
    if (debug) {
      Serial.println("immediate  stop");
    }

    pwmStop13();
  }

  if (currentTime >= (cloopTime  + 500)) {

  //  analogReference((int)DEFAULT);
    
    t2s.Push(t2t);

    cloopTime = currentTime; // Updates cloopTime
    // Pulse frequency (Hz)  = 7.5Q, Q is flow rate in L/min.
    //     liters = (count / 7.5 ); // (Pulse  frequency ) / 7.5Q = flowrate in L
    noInterrupts();
    liters = count;
    count = 0; // Reset Counter
    interrupts();

    //    liters = 12;

    if (liters > min_flow) {
      seq++;
      lastPulse = currentTime;
      last_zero = 0;
    } else {
      if (last_zero > 2) {
        seq  = 0;
      }
      last_zero++;
    }
    if (debug) {
      str  = "liters: " + String(liters) + " t1t: " + String(t1t) + " t2t: " + String(t2t)  + " seq: " + String(seq) + " n: " + String(n);
      Serial.println(str);
    }

	  t1sum = 0;
    t2sum = 0;
    n = 0;

    if ((liters  <= min_flow) or (t2t > max_temp + 2) or (t1t >= 48)) {
      if (debug) {
        Serial.println("stop");
        Serial.println("seq " + String(seq));
      }
      pwmStop13();
    } else if (seq >= 5) {
      t2s.getmat(y);
      if (fitCurve(order, t2s.getsize(), x, y, sizeof(coeffs) / sizeof(double),  coeffs) == 0 and !isnan(coeffs[0])) {
        pred  = (coeffs[0] * (window +  pred_w) + coeffs[1]) * (window + pred_w) + coeffs[2];
        pred0 = (coeffs[0]  * (window + 1) + coeffs[1]) * (window + 1) + coeffs[2];
        a = t2s.avg(10);
        m = t2s.slope(4) * 2;


        if (max(a, t2t) > (max_temp)) {
           if (debug) {
              Serial.println("    +Powering off");
            }
            putLCD ('M', 1);
            pwmStop13();
        }  else if (min(a, t2t) < (max_temp - 12)) {
          if (debug) {
              Serial.println("    -Powering on");
            }
            putLCD ('m', 0);
            pwmSet13();
        } else if (m > 0.2) {
          if (max(a, t2t) > (max_temp -10) and  pred > (max_temp -5) and t2t < (pred0 + 1) and (pred0 + 1) < pred and pred > (a  + 2)) {
            if (debug) {
              Serial.println("    Powering  off");
            }
            putLCD ('.', 1);
            pwmStop13();
          } else if (min(a, t2t) < (max_temp -3) and pred < (max_temp -8) and t2t  > pred0 and pred0 > (pred + 1) ) {
            if (debug) {
              Serial.println("    Powering on");
            }
            putLCD ('.', 0);
            pwmSet13();
          }
        } else if  (m <= -0.1) {
          if (max(a, t2t) > (max_temp  - 10) and pred > (max_temp -5) and t2t < (pred0 + 1) and (pred0 + 1) < pred) {
            if (debug) {
              Serial.println("    *Powering off");
            }
            putLCD (':', 1);
            pwmStop13();
          }  else if (max(a, t2t) >= (max_temp -10) and t2t <= max_temp and pred < (max_temp  -5) and a >= (pred + 6) and t2t > pred0 and pred0 > (pred + 1)) {
            if  (debug) {
              Serial.println("    *Powering on");
            }
            putLCD (':', 0);
            pwmSet13();
          } else if ((t2t  + 1) < a and t2t < max_temp and a >= (pred + 3) and t2t > pred0 and pred0 > (pred  + 1)) {
            if (debug) {
              Serial.println("    *Powering  on *");
            }
            putLCD ('-', 0);
            pwmSet13();
          }
        } else {
          if ((a <= t2t and t2t > (max_temp -4)  and pred >= (a + 2) and pred0 < pred) or (t2t > (max_temp - 2))) {
            if  (debug) {
              Serial.println("    **Powering off");
            }
            putLCD ('*', 1);
            pwmStop13();
          } else if  (t2t <= (max_temp -4) and t2t < a and (pred + 2) < a and pred0 >= pred) {
            if  (debug) {
              Serial.println("    **Powering on");
            }
            putLCD ('*', 0);
            pwmSet13();
          }
        }
      }
    }

	toLCD (format1, liters, a, m, 0);
	toLCD (format2,  t2t, pred, pred0, 1);

    if ((currentTime >= (lastPulse + 300000)) and (liters  < min_flow)) {
sleepy:
      if (debug) {
        Serial.println("sleepy");
      }
      SafeBLoff();
      delay(500);
      noInterrupts();
      detachInterrupt(digitalPinToInterrupt(flowsensor));
      set_sleep_mode(SLEEP_MODE_PWR_DOWN);
      sleep_enable();
      attachInterrupt(digitalPinToInterrupt(flowsensor),  wake, RISING);
      interrupts();

      adcsra_save = ADCSRA;
      prr0_save  = PRR0;

      pwmStop13();

      ADCSRA &= ~(1 << ADEN);    // Disable  ADC
      PRR0 = 0xFF;   // Power down functions

      sleep_mode();
      sleep_disable();
      PRR0 = 0x00; //modules on
      ADCSRA |= (1  << ADEN); // adc on

      ADCSRA = adcsra_save; // stop power reduction
      PRR0 = prr0_save;


      noInterrupts();
      attachInterrupt(digitalPinToInterrupt(flowsensor),  flow, RISING);
      interrupts();

      currentTime = millis();
      cloopTime  = currentTime;
      int times = 0;
      count = 0;
      liters = 0;
      int i = 0;
      t2s.Zero();

      for (i = 0; i < 6; i++) {
        while (currentTime < (cloopTime + 1000)) {
          yield();
          t2s.Push(VtoC(analogRead(t2_pin)));
          delay(25);
          currentTime = millis();
        }
        if  (count > 0) {
          noInterrupts();
          liters = liters + count;
          count = 0; // Reset Counter
          interrupts();
          times  = times + 1;
        }
        if ((liters > 50) and (times > 2)) {
          break;
        }
        cloopTime = currentTime;
      }

      if ((times  < 5) and (liters < 30)) {
        goto sleepy;
      }

      seq =  times;

      currentTime = millis();
      lastPulse = currentTime;

      SafeBLon();
      delay(100);
      t1sum = 0;
      t2sum = 0;
      n = 0;

    }
  }
}

Downloadable files

screen_shot_2020-09-22_at_19_57_28_6RQEY5fJHH.png

The output (led) should be pin 13 (not 3). Also you don't need the resistors, since the heater already has those in it's controller

screen_shot_2020-09-22_at_19_57_28_6RQEY5fJHH.png

The output (led) should be pin 13 (not 3). Also you don't need the resistors, since the heater already has those in it's controller

screen_shot_2020-09-22_at_19_57_28_6RQEY5fJHH.png

Comments

Only logged in users can leave comments

ugokanain

0 Followers

•

0 Projects

Intro