Precise and programmable wireless thermostat

1/* Thermostat BLE receiver */
2
3/* If you want the heating system to stop
4   heating when not connected to the
5   thermostat, change the next line to false */
6const bool heatWhenNotConnected=true;
7
8bool heat;
9
10#include <ArduinoBLE.h>
11
12const int redLED=22;
13const int blueLED=23;
14
15/* If the LED is green when connected, replace
16   the previous line by the next one */
17// const int blueLED=24;
18
19const int heatPin=13;
20
21/* This address must be the same as in the 
22   thermostat software */
23BLEService heatService
24  ("707158fa-c794-4774-9d5c-790121b1be5d");
25
26BLEByteCharacteristic switchCharacteristic
27  ("707158fb-c794-4774-9d5c-790121b1be5d",
28  BLERead | BLEWrite);
29
30class chronometer
31{
32  unsigned long lastTime, actualTime;
33  public :
34  unsigned long elapsed;
35  void init(); // start the chronometer
36  void now();  // measure elapsed time since init
37  chronometer();
38};
39
40void chronometer::init()
41{
42  actualTime=millis();
43  lastTime=actualTime;
44}
45
46void chronometer::now()
47{
48  actualTime=millis();
49  if (actualTime<lastTime)
50  // Overflow of the millis counter
51    elapsed=(0xFFFFFFFFul-lastTime+
52             actualTime);
53  else
54    elapsed=(actualTime-lastTime);
55}
56
57chronometer::chronometer()
58{
59  actualTime=millis();
60  lastTime=actualTime;
61}
62
63void heatControl(void)
64{
65  static chronometer recChrono;
66
67  recChrono.now();
68  BLEDevice central=BLE.central();
69  if(central)
70  {
71    if(recChrono.elapsed<200)
72    {
73      digitalWrite(redLED, LOW);
74      digitalWrite(blueLED, HIGH);
75    }
76    else
77    {
78      digitalWrite(redLED, HIGH);
79      digitalWrite(blueLED, LOW);
80    }
81    if(switchCharacteristic.written())
82    {
83      heat=
84        switchCharacteristic.value()?
85          true:false;
86      recChrono.init();
87    }
88    if(recChrono.elapsed>120000)
89    heat=heatWhenNotConnected;
90  }
91  else
92  {
93    if(recChrono.elapsed<120000)
94    {
95      digitalWrite(blueLED, LOW);
96      digitalWrite(redLED, HIGH);
97    }
98    else
99    {
100      digitalWrite(redLED, HIGH);
101      digitalWrite(blueLED, HIGH);
102      heat=heatWhenNotConnected;     
103    }
104  }
105  if(heat)
106    digitalWrite(heatPin, HIGH);
107  else
108    digitalWrite(heatPin, LOW);
109}
110
111void setup()
112{
113  pinMode(redLED, OUTPUT);
114  pinMode(blueLED, OUTPUT);
115  pinMode(heatPin, OUTPUT);
116  digitalWrite(redLED,HIGH);
117  digitalWrite(blueLED,HIGH);
118  heat=heatWhenNotConnected;
119
120  BLE.begin();
121  BLE.setLocalName("remoteHeat");
122  BLE.setAdvertisedService(heatService);
123  heatService.addCharacteristic
124    (switchCharacteristic);
125  BLE.addService(heatService);
126  switchCharacteristic.writeValue(0);
127  BLE.advertise();
128}
129
130void loop()
131{
132  heatControl();
133}

1/* Thermostat BLE */
2
3/* This address must be the same as in the
4   receiver software */
5String deviceAddress
6  ("707158fa-c794-4774-9d5c-790121b1be5d");
7
8#include <Wire.h>
9#include <MaximWire.h>
10#include <U8g2lib.h>
11#include <RTClib.h>
12#include <ArduinoBLE.h>
13#include "SourceFsm.h"
14
15#define rotaryAPin 6
16#define rotaryBPin 7
17#define rotarySwitchPin 8
18#define RTC_CLK A1
19#define RTC_DAT A2
20#define RTC_RST A3
21#define DS18B20Pin 2
22#define battPin A7
23
24/* Adapt the next line to the controller of
25   your OLED display */
26   
27U8G2_SH1106_128X64_NONAME_F_HW_I2C
28  u8g2(U8G2_R0);
29
30//U8G2_SSD1306_128X64_NONAME_F_HW_I2C
31//  u8g2(U8G2_R0);
32
33DS1302 rtc(RTC_RST, RTC_CLK, RTC_DAT);
34MaximWire::Bus bus(DS18B20Pin);
35MaximWire::DS18B20 device;
36BLEDevice peripheral;
37BLECharacteristic heatCharacteristic;
38
39float tempIncr;
40float temp=19.0, tempDS18B20;
41float corrDS18B20;
42bool tempOK=false;
43float minTemp, maxTemp;
44int percent=50;
45float setPoint, fixSetPoint;
46bool changeSetPoint=false;
47
48bool heat=true;
49bool connected=false;
50
51int mode;
52#define stop 0
53#define fixed 1
54#define prog 2
55bool changeMode=false;
56
57int sleepDelay;
58bool displayActive=true;
59
60int tempUnit;
61#define Celsius 0
62#define Fahrenheit 1
63
64int language;
65#define english 0
66#define french 1
67
68enum {noSet,  setSleepDelay, setTempUnit,
69      setDS18B20Corr, setLanguage}
70       settingsSet=noSet;
71
72float deltaT; /* When the difference
73   between the set point and the temperature
74   is larger than this value, the heating is
75   complete, else it is partial */
76int minHeatPercent;
77int maxHeatPercent;
78int cycleTime; /* seconds */
79float hysteresis;
80enum {noParam, setDeltaT, setMinHeat,
81      setMaxHeat, setCycleTime,
82      setHysteresis} paramSetting=noParam; 
83
84/* Program mode global data */
85
86int hourLimit[3][4];
87int minuteLimit[3][4];
88float progTemp[3][4];
89int progNum;
90enum {noProg, setProg0, setProg1, setProg2,
91      setWeek} progSetting=noProg;
92bool setHourLimit[4]=
93  {false, false, false, false};
94bool setProgTemp[4]=
95  {false, false, false, false};
96int setDayProg=0;
97int dayProg[7];
98
99/* Time & date global data */
100enum {none, setYear, setMonth, setDayOfMonth,
101      setHours, setMinutes, setSeconds}
102        timeSetting=none;
103DateTime current;
104int hour, minute, second;
105int year, month, dayOfMonth;
106
107enum
108{
109  EEPROMId0,
110  EEPROMId1,
111  EEPROMId2,
112  EEPROMMode,
113  EEPROMSetPointMSB,
114  EEPROMSetPointLSB,
115  EEPROMFixSetPointMSB,
116  EEPROMFixSetPointLSB,
117  EEPROMDeltaTMSB,
118  EEPROMDeltaTLSB,
119  EEPROMMinHeatPercent,
120  EEPROMMaxHeatPercent,
121  EEPROMCycleTime,
122  EEPROMHysteresisMSB,
123  EEPROMHysteresisLSB,
124  EEPROMCorrDS18B20MSB,
125  EEPROMCorrDS18B20LSB,
126  EEPROMSleepDelay,
127  EEPROMTempUnit,
128  EEPROMLanguage,
129  EEPROMWeek
130};
131int EEPROMProg=50;
132
133/* Class made to use an external EEPROM
134   (AT24Cxx) through functions compatible
135   with the EEPROM library */
136   
137class EEPROMI2C
138{
139  byte i2cAddress;
140  int address;
141  byte data;
142  public :
143  byte read(unsigned int address);
144  void write(unsigned int address, 
145             byte data);
146  void update(unsigned int address,
147              byte data);
148  EEPROMI2C(byte i2cAddress);
149};
150
151byte EEPROMI2C::read(unsigned int address)
152{
153  Wire.beginTransmission(i2cAddress);
154  Wire.write(highByte(address));
155  Wire.write(lowByte(address));
156  Wire.endTransmission();
157  delay(10);
158  Wire.requestFrom(i2cAddress, 1);
159  delay(10);
160  data=Wire.read();
161  delay(10);
162  return data;
163}
164
165void EEPROMI2C::write(unsigned int address,
166                     byte data)
167{
168  Wire.beginTransmission(i2cAddress);
169  Wire.write(highByte(address));
170  Wire.write(lowByte(address));
171  Wire.write(data);
172  delay(10);
173  Wire.endTransmission();
174  delay(10);
175}
176
177void EEPROMI2C::update(unsigned int address,
178                       byte data)
179{
180  if(read(address)!=data)
181    write(address, data);
182}
183
184EEPROMI2C::EEPROMI2C(byte i2cAddress)
185{
186  this->i2cAddress=i2cAddress;  
187}
188
189EEPROMI2C EEPROM(0x50);
190
191class chronometer
192{
193  unsigned long lastTime, actualTime;
194  public :
195  unsigned long elapsed;
196  void init(); // start the chronometer
197  void now();  // measure elapsed time since
198               // init
199  chronometer();
200};
201
202void chronometer::init()
203{
204  actualTime=millis();
205  lastTime=actualTime;
206}
207
208void chronometer::now()
209{
210  actualTime=millis();
211  if (actualTime<lastTime)
212  // Overflow of the millis counter
213    elapsed=(0xFFFFFFFFul-lastTime+
214             actualTime);
215  else
216    elapsed=(actualTime-lastTime);
217}
218
219chronometer::chronometer()
220{
221  actualTime=millis();
222  lastTime=actualTime;
223}
224
225/* Functions to read rotary encoder and
226   generate events which feed the Finite
227   State Machine */
228
229enum potentialEvents {noEvent, cwRot, ccwRot,
230                      shortSwitchPress,
231                      longSwitchPress,
232                      longSwitchPressAndHeat,
233                      timeOut} event;
234volatile enum potentialEvents
235                interruptEvent=noEvent;
236
237#define maxTime 30000
238#define longPressTime 2000
239chronometer eventChrono;
240
241void interruptRoutineReadEncoder(void)
242{
243  noInterrupts();
244  interruptEvent=noEvent;
245  if(digitalRead(rotaryBPin)==LOW)
246    interruptEvent=ccwRot;
247  else
248    interruptEvent=cwRot;
249  delayMicroseconds(1000);
250  if(digitalRead(rotaryAPin)==HIGH)
251    interruptEvent=noEvent;
252  interrupts();
253}
254
255void rotaryEncoderRead(void)
256{
257  unsigned long pressedSwitchDelay=0;
258  unsigned long pressedSwitchTime=0;
259  static bool longPressTreated=false;
260
261  event=interruptEvent;
262  interruptEvent=noEvent;
263  if(event!=noEvent) eventChrono.init();
264
265  if(digitalRead(rotarySwitchPin)==LOW)
266  {
267    if (!longPressTreated)
268    {
269      pressedSwitchTime=millis();
270      while(digitalRead(rotarySwitchPin)==LOW
271            && (millis()-pressedSwitchTime)<
272             longPressTime)
273      eventChrono.init();
274      pressedSwitchDelay=millis()-
275                         pressedSwitchTime;
276      if(pressedSwitchDelay>=longPressTime)
277      {
278        event=longSwitchPress;
279        if(mode!=stop)
280          event=longSwitchPressAndHeat;
281        longPressTreated=true;
282      }
283      else if(pressedSwitchDelay>50)
284        event=shortSwitchPress;
285    }
286  }
287  else
288    longPressTreated=false;
289  eventChrono.now();
290  if(eventChrono.elapsed>maxTime)
291    event=timeOut;
292}
293
294/* Temperature measurement with DS18B20 */
295
296void measureTempDS18B20(void)
297{
298  if (device.IsValid())
299  {
300    tempDS18B20=device.
301                 GetTemperature<float>(bus);
302    if (!isnan(tempDS18B20))
303    {
304      device.Update(bus);
305      tempDS18B20+=corrDS18B20;
306      tempOK=true;
307    }
308    else
309    {
310      device.Reset();
311      tempOK=false;
312    }
313  }
314  else
315  {
316    if (bus.Discover().
317          FindNextDevice(device) && 
318          device.GetModelCode() ==
319          MaximWire::DS18B20::MODEL_CODE) 
320    {
321      device.Update(bus);
322    }
323    else
324    {
325          device.Reset();
326    }
327    tempOK=false;
328  }
329}
330
331void measureTemp(bool wait)
332{
333  static chronometer chronoTemp;
334
335  chronoTemp.now();
336  if((chronoTemp.elapsed>5000) || !wait)
337  {
338    chronoTemp.init();
339    measureTempDS18B20();
340    if(tempOK)
341    {
342      temp=tempDS18B20;
343      if(temp<minTemp) minTemp=temp;
344      if(temp>maxTemp) maxTemp=temp;
345    }
346  }
347}
348
349/* Calendar functions */
350
351int dayOfWeek(DateTime dt)
352{
353  /* 0= monday, 1=tuesday... */
354  return ((dt.unixtime()/86400L)+3)%7;
355}
356
357/******** Display functions *************/
358
359void drawHeatSymbol(int x, int y)
360{
361  for(int i=y; i<=y+10; i+=5)
362  {
363    u8g2.drawPixel(x, i);
364    u8g2.drawPixel(x+1, i+1);
365    u8g2.drawPixel(x+2, i+2);
366    u8g2.drawPixel(x+3, i+2);
367    u8g2.drawPixel(x+4, i+1);
368    u8g2.drawPixel(x+5, i);
369    u8g2.drawPixel(x+6, i);
370    u8g2.drawPixel(x+7, i+1);
371    u8g2.drawPixel(x+8, i+2);
372  }
373}
374
375void centerCursor(char * s, int y)
376{
377  #define screenWidth 128
378
379  u8g2.setCursor((screenWidth-
380                  u8g2.getStrWidth(s))/2, y);
381}
382
383float tempFormat(float temp)
384{
385  if(tempUnit==Celsius)
386    return temp;
387  else
388    return (temp*9./5.)+32.;
389}
390
391char * deg(void)
392{
393  if(tempUnit==Celsius)
394    return "\xb0""C";
395  else
396    return "\xb0""F";
397}
398
399void mainScreenEnglish()
400{
401  char line[100];
402
403  u8g2.setFont(u8g2_font_6x13_mf);
404  current=rtc.now();
405  sprintf(line, "%02d/%02d/%d  %2d:%02d:%02d",
406          current.month(), current.day(),
407          current.year(), current.hour(),
408          current.minute(), current.second());
409  centerCursor(line, 9);
410  u8g2.print(line);
411
412  u8g2.setFont(u8g2_font_9x15B_mf);
413  u8g2.setCursor(0, 28);
414  if(tempOK)
415      u8g2.print(tempFormat(temp), 1);
416  else
417    u8g2.print("--.-");
418  u8g2.print(deg());
419
420  u8g2.setFont(u8g2_font_6x13_mf);
421  u8g2.setCursor(76, 28);
422  u8g2.print(percent);
423  u8g2.print(" %");
424
425  sprintf(line, "Set point : --.--%cC",
426          char(176));
427  centerCursor(line, 46);
428  u8g2.print("Set point : ");
429  if (changeSetPoint) u8g2.setDrawColor(0);
430  if(mode==stop)
431    u8g2.print("--.-");
432  else
433  {
434    u8g2.setFont(u8g2_font_6x13B_mf);
435    u8g2.print(tempFormat(setPoint), 1);
436    u8g2.setFont(u8g2_font_6x13_mf);
437  }
438  u8g2.setDrawColor(1);
439  u8g2.print(deg());
440
441  switch(mode)
442  {
443    case stop :
444      sprintf(line, "Mode : stop");
445      break;
446    case fixed :
447      sprintf(line, "Mode : fixed");
448      break;
449    case prog :
450      sprintf(line, "Mode : program");
451      u8g2.setFont(u8g2_font_blipfest_07_tn);
452      u8g2.setCursor(118, 61);
453      u8g2.print(
454        dayProg[dayOfWeek(current)]+1);
455      u8g2.setFont(u8g2_font_6x13_mf);
456      break;
457  }
458  centerCursor(line, 61);
459  u8g2.print(line);
460  if(heat) drawHeatSymbol(115, 17);  
461}
462
463void mainScreenFrench()
464{
465  char line[100];
466
467  u8g2.setFont(u8g2_font_6x13_mf);
468  current=rtc.now();
469  sprintf(line, "%2d/%02d/%d  %2d:%02d:%02d",
470          current.day(), current.month(),
471          current.year(), current.hour(),
472          current.minute(), current.second());
473  centerCursor(line, 9);
474  u8g2.print(line);
475
476  u8g2.setFont(u8g2_font_9x15B_mf);
477  u8g2.setCursor(0, 28);
478  if(tempOK)
479      u8g2.print(tempFormat(temp), 1);
480  else
481    u8g2.print("--.-");
482  u8g2.print(deg());
483
484  u8g2.setFont(u8g2_font_6x13_mf);
485  u8g2.setCursor(76, 28);
486  u8g2.print(percent);
487  u8g2.print(" %");
488
489  sprintf(line, "Consigne : --.--%cC",
490          char(176));
491  centerCursor(line, 46);
492  u8g2.print("Consigne : ");
493  if (changeSetPoint) u8g2.setDrawColor(0);
494  if(mode==stop)
495    u8g2.print("--.-");
496  else
497  {
498    u8g2.setFont(u8g2_font_6x13B_mf);
499    u8g2.print(tempFormat(setPoint), 1);
500    u8g2.setFont(u8g2_font_6x13_mf);
501  }
502  u8g2.setDrawColor(1);
503  u8g2.print(deg());
504
505  switch(mode)
506  {
507    case stop :
508      sprintf(line, "Mode : arr%ct",
509              char(234));
510      break;
511    case fixed :
512      sprintf(line, "Mode : fixe");
513      break;
514    case prog :
515      sprintf(line, "Mode : programme");
516      u8g2.setFont(u8g2_font_blipfest_07_tn);
517      u8g2.setCursor(118, 61);
518      u8g2.print(
519        dayProg[dayOfWeek(current)]+1);
520      u8g2.setFont(u8g2_font_6x13_mf);
521      break;
522  }
523  centerCursor(line, 61);
524  u8g2.print(line);
525  if(heat) drawHeatSymbol(115, 17); 
526}
527
528void mainScreen()
529{
530  if(!displayActive) return;
531  u8g2.clearBuffer();
532  switch(language)
533  {
534    case english :
535      mainScreenEnglish();
536      break;
537    case french :
538      mainScreenFrench();
539      break;
540  }
541  u8g2.sendBuffer();
542}
543
544void modeScreenEnglish(void)
545{
546  char stringToDisplay[20];
547 
548  u8g2.setFont(u8g2_font_6x13_mf);
549  sprintf(stringToDisplay, "Mode");
550  centerCursor(stringToDisplay, 20);
551  u8g2.print(stringToDisplay);
552  u8g2.setFont(u8g2_font_9x15B_mf);
553
554  if(changeMode) u8g2.setDrawColor(0);
555  switch(mode)
556  {
557    case stop :
558      sprintf(stringToDisplay, "Stop");
559      break;
560    case fixed :
561      sprintf(stringToDisplay, "Fixed");
562      break;
563    case prog :
564      sprintf(stringToDisplay, "Program");
565      break;
566  }
567  centerCursor(stringToDisplay, 40);
568  u8g2.print(stringToDisplay);
569  u8g2.setDrawColor(1);
570}
571
572void modeScreenFrench(void)
573{
574  char stringToDisplay[20];
575  
576  u8g2.setFont(u8g2_font_6x13_mf);
577  sprintf(stringToDisplay, "Mode");
578  centerCursor(stringToDisplay, 20);
579  u8g2.print(stringToDisplay);
580  u8g2.setFont(u8g2_font_9x15B_mf);
581
582  if(changeMode) u8g2.setDrawColor(0);
583  switch(mode)
584  {
585    case stop :
586      sprintf(stringToDisplay, "Arr%ct",
587              char(234));
588      break;
589    case fixed :
590      sprintf(stringToDisplay, "Fixe");
591      break;
592    case prog :
593      sprintf(stringToDisplay, "Programme");
594      break;
595  }
596  centerCursor(stringToDisplay, 40);
597  u8g2.print(stringToDisplay);
598  u8g2.setDrawColor(1);
599}
600
601void modeScreen(void)
602{
603  if(!displayActive) return;
604  u8g2.clearBuffer();  
605  switch(language)
606  {
607    case english :
608      modeScreenEnglish();
609      break;
610    case french :
611      modeScreenFrench();
612      break;
613  }
614  u8g2.sendBuffer();
615}
616
617void progScreen(void)
618{
619  char line[20];
620
621  if(!displayActive) return;
622  u8g2.clearBuffer();
623  u8g2.setDrawColor(1);
624  u8g2.setFont(u8g2_font_6x13_mf);
625  switch(language)
626  {
627    case english :
628      strcpy(line, "Program");
629      break;
630    case french :
631      strcpy(line, "Programme");
632      break;
633  }
634  centerCursor(line, 11);
635  u8g2.print(line);
636
637  u8g2.setFont(u8g2_font_6x13B_mf);
638  u8g2.setCursor(10, 30);
639  if(progSetting==setProg0)
640    u8g2.setDrawColor(0);
641  u8g2.print("Prog 1");
642  u8g2.setDrawColor(1);
643  u8g2.setCursor(10, 50);
644  if(progSetting==setProg1)
645    u8g2.setDrawColor(0);
646  u8g2.print("Prog 2");
647  u8g2.setDrawColor(1);
648  u8g2.setCursor(70, 30);
649  if(progSetting==setProg2)
650    u8g2.setDrawColor(0);
651  u8g2.print("Prog 3");
652  u8g2.setDrawColor(1);
653  u8g2.setCursor(70, 50);
654  if(progSetting==setWeek)
655    u8g2.setDrawColor(0);
656  switch(language)
657  {
658    case english :
659      u8g2.print("Week");
660      break;
661    case french :
662      u8g2.print("Semaine");
663      break;
664  }
665
666  u8g2.setFont(u8g2_font_6x13_mf);
667  u8g2.setDrawColor(1);
668  u8g2.sendBuffer();
669}
670
671void dailyProgScreen(void)
672{
673  char line[20];
674
675  if(!displayActive) return;
676  u8g2.clearBuffer();
677  u8g2.setDrawColor(1);
678  u8g2.setFont(u8g2_font_6x13_mf);
679
680  switch(language)
681  {
682    case english :
683      sprintf(line, "Prog. %d", progNum+1);
684      break;
685    case french :
686      sprintf(line, "Prog. %d", progNum+1);
687      break;
688  }
689  centerCursor(line, 11);
690  u8g2.print(line);
691  for(int i=0; i<4; i++)
692  {
693    u8g2.setCursor(0, 12*(i+2)+1);
694    if(setHourLimit[i]) u8g2.setDrawColor(0);
695    u8g2.setFont(u8g2_font_6x13B_mf);
696    if(hourLimit[progNum][i]<10)
697      u8g2.print(" ");
698    u8g2.print(hourLimit[progNum][i]);
699    u8g2.print(":");
700    if(minuteLimit[progNum][i]<10)
701      u8g2.print("0");
702    u8g2.print(minuteLimit[progNum][i]);
703    u8g2.setFont(u8g2_font_6x13_mf);
704    u8g2.setDrawColor(1);
705    u8g2.print(" -> ");
706
707    if(setHourLimit[(i+1)%4])
708      u8g2.setDrawColor(0);
709    u8g2.setFont(u8g2_font_6x13B_mf);
710    if(hourLimit[progNum][(i+1)%4]<10)
711      u8g2.print(" ");
712    u8g2.print(hourLimit[progNum][(i+1)%4]);
713    u8g2.print(":");
714    if(minuteLimit[progNum][(i+1)%4]<10)
715      u8g2.print("0");
716    u8g2.print(minuteLimit[progNum][(i+1)%4]);
717    u8g2.setDrawColor(1);
718    u8g2.print(" ");
719
720    if(setProgTemp[i]) u8g2.setDrawColor(0);
721    u8g2.print(tempFormat
722                 (progTemp[progNum][i]), 1);
723    u8g2.setFont(u8g2_font_6x13_mf);
724    u8g2.setDrawColor(1);
725    u8g2.print(deg());
726  }
727  u8g2.sendBuffer();
728}
729
730void weekProgScreenEnglish(void)
731{
732  char line[20];
733
734  strcpy(line, "Week");
735  centerCursor(line, 11);
736  u8g2.print(line);
737
738  for(int i=0; i<7; i++)
739  {
740    u8g2.setCursor((i<4)? 0 : 80,
741                   (i&3)*12+25);
742    switch(i)
743    {
744      case 0:
745        u8g2.print("Mon: ");
746        break;
747      case 1:
748        u8g2.print("Tue: ");
749        break;
750      case 2:
751        u8g2.print("Wed: ");
752        break;
753      case 3:
754        u8g2.print("Thu: ");
755        break;
756      case 4:
757        u8g2.print("Fri: ");
758        break;
759      case 5:
760        u8g2.print("Sat: ");
761        break;
762      case 6:
763        u8g2.print("Sun: ");
764        break;
765    }
766    u8g2.setFont(u8g2_font_6x13B_mf);
767    if(i==setDayProg)
768      u8g2.setDrawColor(0);
769    u8g2.print(dayProg[i]+1);
770    u8g2.setDrawColor(1);
771    u8g2.setFont(u8g2_font_6x13_mf);
772  }
773}
774
775void weekProgScreenFrench(void)
776{
777  char line[20];
778
779  strcpy(line, "Semaine");
780  centerCursor(line, 11);
781  u8g2.print(line);
782
783  for(int i=0; i<7; i++)
784  {
785    u8g2.setCursor((i<4)? 0 : 80,
786                   (i&3)*12+25);
787    switch(i)
788    {
789      case 0:
790        u8g2.print("Lun : ");
791        break;
792      case 1:
793        u8g2.print("Mar : ");
794        break;
795      case 2:
796        u8g2.print("Mer : ");
797        break;
798      case 3:
799        u8g2.print("Jeu : ");
800        break;
801      case 4:
802        u8g2.print("Ven : ");
803        break;
804      case 5:
805        u8g2.print("Sam : ");
806        break;
807      case 6:
808        u8g2.print("Dim : ");
809        break;
810    }
811    u8g2.setFont(u8g2_font_6x13B_mf);
812    if(i==setDayProg)
813      u8g2.setDrawColor(0);
814    u8g2.print(dayProg[i]+1);
815    u8g2.setDrawColor(1);
816    u8g2.setFont(u8g2_font_6x13_mf);
817  }
818}
819
820void weekProgScreen(void)
821{
822  if(!displayActive) return;
823  u8g2.clearBuffer();
824  u8g2.setDrawColor(1);
825  u8g2.setFont(u8g2_font_6x13_mf);
826  switch(language)
827  {
828    case english :
829      weekProgScreenEnglish();
830      break;
831    case french :
832      weekProgScreenFrench();
833      break;
834  }
835  u8g2.sendBuffer();
836}
837
838void heatingBehaviourScreenEnglish(void)
839{
840  char line[30];
841  
842  u8g2.setFont(u8g2_font_6x13_mf);
843  strcpy(line, "Heating law");
844  centerCursor(line, 10);
845  u8g2.print(line);
846  u8g2.setCursor(0, 23);
847  u8g2.print("Hysteresis : ");
848  if(paramSetting==setHysteresis)
849    u8g2.setDrawColor(0);
850  u8g2.setFont(u8g2_font_6x13B_mf);
851  if(tempUnit==Celsius)
852    u8g2.print(hysteresis, 1);
853  else
854    u8g2.print(hysteresis*9.0/5.0, 1);
855  u8g2.setFont(u8g2_font_6x13_mf);
856  u8g2.setDrawColor(1);
857  u8g2.print(deg());
858  u8g2.setCursor(0, 36);
859  u8g2.print("Delta T : ");
860  if(paramSetting==setDeltaT)
861    u8g2.setDrawColor(0);
862  u8g2.setFont(u8g2_font_6x13B_mf);
863  if(tempUnit==Celsius)
864    u8g2.print(deltaT, 1);
865  else
866    u8g2.print(deltaT*9.0/5.0, 1);
867  u8g2.setFont(u8g2_font_6x13_mf);
868  u8g2.setDrawColor(1);
869  u8g2.print(deg());
870  u8g2.setCursor(0, 49);
871  u8g2.print("Min : ");
872  if(paramSetting==setMinHeat)
873    u8g2.setDrawColor(0);
874  u8g2.setFont(u8g2_font_6x13B_mf);
875  u8g2.print(minHeatPercent);
876  u8g2.setFont(u8g2_font_6x13_mf);
877  u8g2.setDrawColor(1);
878  u8g2.print(" % Max : ");
879  if(paramSetting==setMaxHeat)
880    u8g2.setDrawColor(0);
881  u8g2.setFont(u8g2_font_6x13B_mf);
882  u8g2.print(maxHeatPercent);
883  u8g2.setFont(u8g2_font_6x13_mf);
884  u8g2.setDrawColor(1);
885  u8g2.print(" %");
886  u8g2.setCursor(0, 62);
887  u8g2.print("Cycle : ");
888  if(paramSetting==setCycleTime)
889    u8g2.setDrawColor(0);
890  u8g2.setFont(u8g2_font_6x13B_mf);
891  u8g2.print(cycleTime);
892  u8g2.setFont(u8g2_font_6x13_mf);
893  u8g2.setDrawColor(1);
894  u8g2.print(" s");
895}
896
897void heatingBehaviourScreenFrench(void)
898{
899  char line[20];
900
901  u8g2.setFont(u8g2_font_6x13_mf);
902  strcpy(line, "Courbe de chauffe");
903  centerCursor(line, 10);
904  u8g2.print(line);
905  u8g2.setCursor(0, 23);
906  u8g2.print("Hysteresis : ");
907  if(paramSetting==setHysteresis)
908    u8g2.setDrawColor(0);
909  u8g2.setFont(u8g2_font_6x13B_mf);
910  if(tempUnit==Celsius)
911    u8g2.print(hysteresis, 1);
912  else
913    u8g2.print(hysteresis*9.0/5.0, 1);
914  u8g2.setFont(u8g2_font_6x13_mf);
915  u8g2.setDrawColor(1);
916  u8g2.print(deg());
917  u8g2.setCursor(0, 36);
918  u8g2.print("Delta T : ");
919  if(paramSetting==setDeltaT)
920    u8g2.setDrawColor(0);
921  u8g2.setFont(u8g2_font_6x13B_mf);
922  if(tempUnit==Celsius)
923    u8g2.print(deltaT, 1);
924  else
925    u8g2.print(deltaT*9.0/5.0, 1);
926  u8g2.setFont(u8g2_font_6x13_mf);
927  u8g2.setDrawColor(1);
928  u8g2.print(deg());
929  u8g2.setCursor(0, 49);
930  u8g2.print("Min : ");
931  if(paramSetting==setMinHeat)
932    u8g2.setDrawColor(0);
933  u8g2.setFont(u8g2_font_6x13B_mf);
934  u8g2.print(minHeatPercent);
935  u8g2.setFont(u8g2_font_6x13_mf);
936  u8g2.setDrawColor(1);
937  u8g2.print(" % Max : ");
938  if(paramSetting==setMaxHeat)
939    u8g2.setDrawColor(0);
940  u8g2.setFont(u8g2_font_6x13B_mf);
941  u8g2.print(maxHeatPercent);
942  u8g2.setFont(u8g2_font_6x13_mf);
943  u8g2.setDrawColor(1);
944  u8g2.print(" %");
945  u8g2.setCursor(0, 62);
946  u8g2.print("Cycle : ");
947  if(paramSetting==setCycleTime)
948    u8g2.setDrawColor(0);
949  u8g2.setFont(u8g2_font_6x13B_mf);
950  u8g2.print(cycleTime);
951  u8g2.setFont(u8g2_font_6x13_mf);
952  u8g2.setDrawColor(1);
953  u8g2.print(" s");
954}
955
956void heatingBehaviourScreen(void)
957{
958  if(!displayActive) return;
959  u8g2.clearBuffer();
960  switch(language)
961  {
962    case english :
963      heatingBehaviourScreenEnglish();
964      break;
965    case french :
966      heatingBehaviourScreenFrench();
967      break;
968  }
969  u8g2.sendBuffer();
970}
971
972void systemScreenEnglish(void)
973{
974  char line[20];
975  
976  u8g2.setFont(u8g2_font_7x13_mf);
977  strcpy(line, "System");
978  centerCursor(line, 10);
979  u8g2.print(line);
980
981  u8g2.setCursor(0, 25);
982  u8g2.print("Connected : ");
983  if(connected)
984    u8g2.print("yes");
985  else
986    u8g2.print("no");
987
988  u8g2.setCursor(0, 40);
989  u8g2.print("Battery : ");
990  u8g2.print((float)analogRead(battPin)*
991               3.3*(47+220)/47/1023, 1);
992  u8g2.print(" V");
993
994  u8g2.setCursor(0, 58);
995  u8g2.setFont(u8g2_font_7x13B_mf);
996  u8g2.print("Settings ");
997  u8g2.setFont(u8g2_font_6x13_mf);
998  u8g2.print("(press 3s)");
999  u8g2.setFont(u8g2_font_7x13_mf);
1000}
1001
1002void systemScreenFrench(void)
1003{
1004  char line[20];
1005  
1006  u8g2.setFont(u8g2_font_7x13_mf);
1007  strcpy(line, "Syst\xE8me");
1008  centerCursor(line, 10);
1009  u8g2.print(line);
1010
1011  u8g2.setCursor(0, 25);
1012  u8g2.print("Connect\xe9 : ");
1013  if(connected)
1014    u8g2.print("oui");
1015  else
1016    u8g2.print("non");
1017
1018  u8g2.setCursor(0, 40);
1019  u8g2.print("Pile : ");
1020  u8g2.print((float)analogRead(battPin)*
1021               3.3*(47+220)/47/1023, 1);
1022  u8g2.print(" V");
1023
1024  u8g2.setCursor(0, 58);
1025  u8g2.setFont(u8g2_font_7x13B_mf);
1026  u8g2.print("R\xe9glages ");
1027  u8g2.setFont(u8g2_font_6x13_mf);
1028  u8g2.print("(appui 3s)");
1029  u8g2.setFont(u8g2_font_7x13_mf);
1030}
1031
1032void systemScreen(void)
1033{
1034  if(!displayActive) return;
1035  u8g2.clearBuffer();
1036  switch(language)
1037  {
1038    case english :
1039      systemScreenEnglish();
1040      break;
1041    case french :
1042      systemScreenFrench();
1043      break;
1044  }
1045  u8g2.sendBuffer();
1046}
1047
1048void settingsScreenEnglish(void)
1049{
1050  char line[30];
1051
1052  u8g2.setFont(u8g2_font_7x13_mf);
1053  strcpy(line, "Settings");
1054  centerCursor(line, 10);
1055  u8g2.print(line);
1056
1057  u8g2.setCursor(0, 23);
1058  u8g2.print("Sleep : ");
1059  if(settingsSet==setSleepDelay)
1060    u8g2.setDrawColor(0);
1061  u8g2.setFont(u8g2_font_7x13B_mf);
1062  if(sleepDelay>0)
1063  {
1064    u8g2.print(sleepDelay);
1065    u8g2.setFont(u8g2_font_7x13_mf);
1066    u8g2.setDrawColor(1);
1067    u8g2.print(" s");
1068  }
1069  else
1070  {
1071    u8g2.print("no");
1072    u8g2.setFont(u8g2_font_7x13_mf);
1073    u8g2.setDrawColor(1);
1074  }
1075
1076  u8g2.setCursor(0, 36);
1077  u8g2.print("Temp. unit : ");
1078  if(settingsSet==setTempUnit)
1079    u8g2.setDrawColor(0);
1080  u8g2.setFont(u8g2_font_7x13B_mf);
1081  u8g2.print(deg());
1082  u8g2.setFont(u8g2_font_7x13_mf);
1083  u8g2.setDrawColor(1);
1084
1085  u8g2.setCursor(0, 49);
1086  u8g2.print("T\xb0 corr. : ");
1087  if(settingsSet==setDS18B20Corr)
1088    u8g2.setDrawColor(0);
1089  u8g2.setFont(u8g2_font_7x13B_mf);
1090  if(tempUnit==Celsius)
1091    u8g2.print(corrDS18B20, 1);
1092  else
1093    u8g2.print(corrDS18B20*9.0/5.0, 1);
1094  u8g2.setFont(u8g2_font_7x13_mf);
1095  u8g2.setDrawColor(1);
1096  u8g2.print(deg());
1097
1098  u8g2.setCursor(0, 62);
1099  u8g2.print("Lang. : ");
1100  if(settingsSet==setLanguage)
1101    u8g2.setDrawColor(0);
1102  u8g2.setFont(u8g2_font_7x13B_mf);
1103  u8g2.print("english");
1104  u8g2.setFont(u8g2_font_7x13_mf);
1105  u8g2.setDrawColor(1);
1106}
1107
1108void settingsScreenFrench(void)
1109{
1110  char line[30];
1111
1112  u8g2.setFont(u8g2_font_7x13_mf);
1113  strcpy(line, "R\xe9glages");
1114  centerCursor(line, 10);
1115  u8g2.print(line);
1116
1117  u8g2.setCursor(0, 23);
1118  u8g2.print("Veille : ");
1119  if(settingsSet==setSleepDelay)
1120    u8g2.setDrawColor(0);
1121  u8g2.setFont(u8g2_font_7x13B_mf);
1122  if(sleepDelay>0)
1123  {
1124    u8g2.print(sleepDelay);
1125    u8g2.setFont(u8g2_font_7x13_mf);
1126    u8g2.setDrawColor(1);
1127    u8g2.print(" s");
1128  }
1129  else
1130  {
1131    u8g2.print("non");
1132    u8g2.setFont(u8g2_font_7x13_mf);
1133    u8g2.setDrawColor(1);
1134  }
1135
1136  u8g2.setCursor(0, 36);
1137  u8g2.print("Unit\xe9 T : ");
1138  if(settingsSet==setTempUnit)
1139    u8g2.setDrawColor(0);
1140  u8g2.setFont(u8g2_font_7x13B_mf);
1141  u8g2.print(deg());
1142  u8g2.setFont(u8g2_font_7x13_mf);
1143  u8g2.setDrawColor(1);
1144
1145  u8g2.setCursor(0, 49);
1146  u8g2.print("Corr. T\xb0 : ");
1147  if(settingsSet==setDS18B20Corr)
1148    u8g2.setDrawColor(0);
1149  u8g2.setFont(u8g2_font_7x13B_mf);
1150  if(tempUnit==Celsius)
1151    u8g2.print(corrDS18B20, 1);
1152  else
1153    u8g2.print(corrDS18B20*9.0/5.0, 1);
1154  u8g2.setFont(u8g2_font_7x13_mf);
1155  u8g2.setDrawColor(1);
1156  u8g2.print(deg());
1157
1158  u8g2.setCursor(0, 62);
1159  u8g2.print("Langue : ");
1160  if(settingsSet==setLanguage)
1161    u8g2.setDrawColor(0);
1162  u8g2.setFont(u8g2_font_7x13B_mf);
1163  u8g2.print("fran\xe7""ais");
1164  u8g2.setFont(u8g2_font_7x13_mf);
1165  u8g2.setDrawColor(1);
1166}
1167
1168void settingsScreen(void)
1169{  
1170  if(!displayActive) return;
1171  u8g2.clearBuffer();
1172  switch(language)
1173  {
1174    case english :
1175      settingsScreenEnglish();
1176      break;
1177    case french :
1178      settingsScreenFrench();
1179      break;
1180  }
1181  u8g2.sendBuffer();
1182}
1183
1184void timeDateScreenEnglish(void)
1185{
1186  char stringToDisplay[25];
1187  char lengthString[25];
1188
1189  u8g2.setDrawColor(1);
1190  u8g2.setFont(u8g2_font_6x13_mf);
1191  switch(dayOfWeek(DateTime(year, month,
1192         dayOfMonth)))
1193  {
1194    case 0 :
1195      sprintf(stringToDisplay, "Monday");
1196      break;
1197    case 1 :
1198      sprintf(stringToDisplay, "Tuesday");
1199      break;
1200    case 2 :
1201      sprintf(stringToDisplay, "Wednesday");
1202      break;
1203    case 3 :
1204      sprintf(stringToDisplay, "Thursday");
1205      break;
1206    case 4 :
1207      sprintf(stringToDisplay, "Friday");
1208      break;
1209    case 5 :
1210      sprintf(stringToDisplay, "Saturday");
1211      break;
1212    case 6 :
1213      sprintf(stringToDisplay, "Sunday");
1214      break;
1215  }
1216  centerCursor(stringToDisplay, 45);
1217  u8g2.print(stringToDisplay);
1218
1219  u8g2.setFont(u8g2_font_9x15B_mf);
1220  sprintf(stringToDisplay, "%d", dayOfMonth);
1221  centerCursor(stringToDisplay, 29);
1222  if(timeSetting==setDayOfMonth)
1223    u8g2.setDrawColor(0);
1224  else u8g2.setDrawColor(1);
1225  u8g2.print(stringToDisplay);
1226
1227  u8g2.setFont(u8g2_font_6x13_mf);
1228  switch(month)
1229  {
1230    case 1 :
1231      sprintf(stringToDisplay, "January");
1232      break;
1233    case 2 :
1234      sprintf(stringToDisplay, "February");
1235      break;
1236    case 3 :
1237      sprintf(stringToDisplay, "March");
1238      break;
1239    case 4 :
1240      sprintf(stringToDisplay, "April");
1241      break;
1242    case 5 :
1243      sprintf(stringToDisplay, "May");
1244      break;
1245    case 6 :
1246      sprintf(stringToDisplay, "June");
1247      break;
1248    case 7 :
1249      sprintf(stringToDisplay, "July");
1250      break;
1251    case 8 :
1252      sprintf(stringToDisplay, "August");
1253      break;
1254    case 9 :
1255      sprintf(stringToDisplay, "September");
1256      break;
1257    case 10 :
1258      sprintf(stringToDisplay, "October");
1259      break;
1260    case 11 :
1261      sprintf(stringToDisplay, "November");
1262      break;
1263    case 12 :
1264      sprintf(stringToDisplay, "December");
1265      break;
1266  }
1267  strcpy(lengthString, stringToDisplay);
1268  strcat(lengthString, " 2022");
1269  centerCursor(lengthString, 10);
1270  if(timeSetting==setMonth)
1271    u8g2.setDrawColor(0);
1272  else u8g2.setDrawColor(1);
1273  u8g2.print(stringToDisplay);
1274  u8g2.setDrawColor(1);
1275  u8g2.print(" ");
1276  if(timeSetting==setYear)
1277    u8g2.setDrawColor(0);
1278  else u8g2.setDrawColor(1);
1279  u8g2.print(year);
1280
1281  u8g2.setFont(u8g2_font_9x15B_mf);
1282  sprintf(lengthString, "%d:%02d:%02d", hour,
1283          minute, second);
1284  centerCursor(lengthString, 63);
1285  if(timeSetting==setHours)
1286    u8g2.setDrawColor(0);
1287  else u8g2.setDrawColor(1);
1288  u8g2.print(hour);
1289  u8g2.setDrawColor(1);
1290  u8g2.print(":");
1291  sprintf(stringToDisplay, "%02d", minute);
1292  if(timeSetting==setMinutes)
1293    u8g2.setDrawColor(0);
1294  else u8g2.setDrawColor(1);
1295  u8g2.print(stringToDisplay);
1296  u8g2.setDrawColor(1);
1297  u8g2.print(":");
1298  sprintf(stringToDisplay, "%02d", second);
1299  if(timeSetting==setSeconds)
1300    u8g2.setDrawColor(0);
1301  else u8g2.setDrawColor(1);
1302  u8g2.print(stringToDisplay);
1303}
1304
1305void timeDateScreenFrench(void)
1306{
1307  char stringToDisplay[25];
1308  char lengthString[25];
1309
1310  u8g2.setDrawColor(1);
1311  u8g2.setFont(u8g2_font_6x13_mf);
1312  switch(dayOfWeek(DateTime(year, month,
1313         dayOfMonth)))
1314  {
1315    case 0 :
1316      sprintf(stringToDisplay, "Lundi");
1317      break;
1318    case 1 :
1319      sprintf(stringToDisplay, "Mardi");
1320      break;
1321    case 2 :
1322      sprintf(stringToDisplay, "Mercredi");
1323      break;
1324    case 3 :
1325      sprintf(stringToDisplay, "Jeudi");
1326      break;
1327    case 4 :
1328      sprintf(stringToDisplay, "Vendredi");
1329      break;
1330    case 5 :
1331      sprintf(stringToDisplay, "Samedi");
1332      break;
1333    case 6 :
1334      sprintf(stringToDisplay, "Dimanche");
1335      break;
1336  }
1337  centerCursor(stringToDisplay, 10);
1338  u8g2.print(stringToDisplay);
1339
1340  u8g2.setFont(u8g2_font_9x15B_mf);
1341  sprintf(stringToDisplay, "%d", dayOfMonth);
1342  centerCursor(stringToDisplay, 29);
1343  if(timeSetting==setDayOfMonth)
1344    u8g2.setDrawColor(0);
1345  else u8g2.setDrawColor(1);
1346  u8g2.print(stringToDisplay);
1347  u8g2.setFont(u8g2_font_6x13_mf);
1348  switch(month)
1349  {
1350    case 1 :
1351      sprintf(stringToDisplay, "janvier");
1352      break;
1353    case 2 :
1354      sprintf(stringToDisplay, "f%cvrier",
1355              char(233));
1356      break;
1357    case 3 :
1358      sprintf(stringToDisplay, "mars");
1359      break;
1360    case 4 :
1361      sprintf(stringToDisplay, "avril");
1362      break;
1363    case 5 :
1364      sprintf(stringToDisplay, "mai");
1365      break;
1366    case 6 :
1367      sprintf(stringToDisplay, "juin");
1368      break;
1369    case 7 :
1370      sprintf(stringToDisplay, "juillet");
1371      break;
1372    case 8 :
1373      sprintf(stringToDisplay, "ao%ct",
1374              char(251));
1375      break;
1376    case 9 :
1377      sprintf(stringToDisplay, "septembre");
1378      break;
1379    case 10 :
1380      sprintf(stringToDisplay, "octobre");
1381      break;
1382    case 11 :
1383      sprintf(stringToDisplay, "novembre");
1384      break;
1385    case 12 :
1386      sprintf(stringToDisplay, "d%ccembre",
1387              char(233));
1388      break;
1389  }
1390  strcpy(lengthString, stringToDisplay);
1391  strcat(lengthString, " 2022");
1392  centerCursor(lengthString, 45);
1393  if(timeSetting==setMonth)
1394    u8g2.setDrawColor(0);
1395  else u8g2.setDrawColor(1);
1396  u8g2.print(stringToDisplay);
1397  u8g2.setDrawColor(1);
1398  u8g2.print(" ");
1399  if(timeSetting==setYear)
1400    u8g2.setDrawColor(0);
1401  else u8g2.setDrawColor(1);
1402  u8g2.print(year);
1403
1404  u8g2.setFont(u8g2_font_9x15B_mf);
1405  sprintf(lengthString, "%d:%02d:%02d", hour,
1406          minute, second);
1407  centerCursor(lengthString, 63);
1408  if(timeSetting==setHours)
1409    u8g2.setDrawColor(0);
1410  else u8g2.setDrawColor(1);
1411  u8g2.print(hour);
1412  u8g2.setDrawColor(1);
1413  u8g2.print(":");
1414  sprintf(stringToDisplay, "%02d", minute);
1415  if(timeSetting==setMinutes)
1416    u8g2.setDrawColor(0);
1417  else u8g2.setDrawColor(1);
1418  u8g2.print(stringToDisplay);
1419  u8g2.setDrawColor(1);
1420  u8g2.print(":");
1421  sprintf(stringToDisplay, "%02d", second);
1422  if(timeSetting==setSeconds)
1423    u8g2.setDrawColor(0);
1424  else u8g2.setDrawColor(1);
1425  u8g2.print(stringToDisplay);
1426}
1427
1428void timeDateScreen(void)
1429{
1430  if(!displayActive) return;
1431  u8g2.clearBuffer();
1432  switch(language)
1433  {
1434    case english :
1435      timeDateScreenEnglish();
1436      break;
1437    case french :
1438      timeDateScreenFrench();
1439      break;
1440  }
1441  u8g2.sendBuffer();
1442}
1443
1444void temperatureScreen(void)
1445{
1446  char line[20];
1447  
1448  if(!displayActive) return;
1449  u8g2.clearBuffer();
1450  u8g2.setFont(u8g2_font_logisoso26_tf);
1451  strcpy(line, "19.0dC");
1452  centerCursor(line, 40);
1453  if(tempOK)
1454    u8g2.print(tempFormat(temp), 1);
1455  else
1456    u8g2.print("--.-");
1457  u8g2.print(deg());
1458  u8g2.setFont(u8g2_font_6x13_mf);
1459  u8g2.setCursor(0, 63);
1460  u8g2.print("Min : ");
1461  u8g2.print(tempFormat(minTemp), 1),
1462  u8g2.print(" Max : ");
1463  u8g2.print(tempFormat(maxTemp), 1);
1464  u8g2.sendBuffer();
1465}
1466
1467/* Wake detection function to spare
1468   battery when rotary encoder is not
1469   used */
1470
1471void wakeDetection(void)
1472{
1473  eventChrono.now();
1474  if((eventChrono.elapsed<
1475      (unsigned long)sleepDelay*1000) ||
1476     (sleepDelay==0))
1477  {
1478    u8g2.setPowerSave(0);
1479    displayActive=true;
1480  }
1481  else
1482  {
1483    u8g2.setPowerSave(1);
1484    displayActive=false;
1485  }  
1486}
1487
1488/* Heating control functions */
1489
1490void heatControl(void)
1491{
1492  static chronometer heatChrono;
1493
1494/* 
1495________________
1496                |
1497 MaxHeatPercent |
1498                .\
1499                . \
1500                .  \
1501                .   \
1502                .    \
1503                .     \
1504                .      \      hysteresis
1505 MinHeatPercent .       \________
1506                .        |XXXXXX|
1507                . deltaT |XXXXXX|
1508_________________________|XXXXXX|________\ t°
1509                     setPoint            /
1510 */
1511
1512  heatChrono.now();
1513  if(heatChrono.elapsed>=
1514     (unsigned long)cycleTime*1000)
1515    heatChrono.init();
1516  heat=false;
1517  if((mode==stop) || !tempOK) percent=0;
1518  else
1519  {
1520    if(temp>setPoint+hysteresis) percent=0;
1521    else if(temp <= setPoint-deltaT)
1522      percent=100;
1523    else if(temp<=setPoint)
1524    {
1525      percent=minHeatPercent+
1526       (maxHeatPercent-minHeatPercent) /
1527       deltaT * (setPoint-temp);
1528    }
1529    if(percent>maxHeatPercent) heat=true;
1530    else if(percent>=minHeatPercent)
1531      if(heatChrono.elapsed<
1532         (unsigned long)cycleTime * percent *
1533         10) /* percent of milliseconds */
1534         heat=true;
1535  }
1536}
1537
1538void setPointControl(void)
1539{
1540  int progNum;
1541  if(mode==prog)
1542  {
1543    current=rtc.now();
1544    if(current.second()==0)
1545    {
1546      progNum=dayProg[dayOfWeek(current)];
1547      for(int i=0; i<4; i++)
1548      {
1549        if(current.hour()==
1550          hourLimit[progNum][i] &&
1551           current.minute()==
1552           minuteLimit[progNum][i])
1553          setPoint=progTemp[progNum][i];
1554      }
1555    }
1556  }
1557}
1558
1559void setPointInit(void)
1560{
1561  int currentMinutes, progNum;
1562  
1563  current=rtc.now();;
1564  currentMinutes=current.hour()*60+
1565                 current.minute();
1566  progNum=dayProg[dayOfWeek(current)];
1567
1568  for(int i=0; i<=3; i++)
1569  {
1570/* Test if noon is between the two limits */
1571    if(hourLimit[progNum][i]*60+
1572       minuteLimit[progNum][i]<
1573       hourLimit[progNum][(i+1)%4]*60+
1574         minuteLimit[progNum][(i+1)%4])
1575    {
1576      if(currentMinutes>=
1577           hourLimit[progNum][i]*60+
1578           minuteLimit[progNum][i] &&
1579         currentMinutes<
1580           hourLimit[progNum][(i+1)%4]*60+
1581           minuteLimit[progNum][(i+1)%4])
1582        setPoint=progTemp[progNum][i];
1583    }
1584    else
1585    {
1586      if(currentMinutes>=
1587         hourLimit[progNum][i]*60+
1588           minuteLimit[progNum][i] ||
1589         currentMinutes<
1590         hourLimit[progNum][(i+1)%4]*60+
1591           minuteLimit[progNum][(i+1)%4])
1592        setPoint=progTemp[progNum][i];
1593    }
1594  }
1595}
1596
1597/* BLE connection functions */
1598
1599int connectRemoteHeat(void)
1600{
1601  unsigned long tOut=500;
1602  chronometer connectChrono;
1603
1604  connected=false;
1605  BLE.begin();
1606  connectChrono.init();
1607  do
1608  {
1609    connectChrono.now();
1610  }
1611  while((!BLE.scanForUuid
1612    (deviceAddress)) &&
1613         connectChrono.elapsed<tOut);
1614  if(connectChrono.elapsed>=tOut)
1615  {
1616    BLE.stopScan();
1617    return 1;
1618  }
1619
1620  connectChrono.init();
1621  do
1622  {
1623    connectChrono.now();
1624  }
1625  while((!(peripheral=BLE.available())) &&
1626         connectChrono.elapsed<tOut);
1627  BLE.stopScan();
1628  if(connectChrono.elapsed>=tOut)
1629    return 2;
1630
1631  connectChrono.init();
1632  do
1633  {
1634    connectChrono.now();
1635  }
1636  while((!peripheral.connect()) &&
1637         connectChrono.elapsed<tOut);
1638  if(connectChrono.elapsed>=tOut)
1639    return 3;
1640
1641  connectChrono.init();
1642  do
1643  {
1644    connectChrono.now();
1645  }
1646  while((!peripheral.discoverAttributes()) &&
1647         connectChrono.elapsed<tOut);
1648  if(connectChrono.elapsed>=tOut)
1649    return 4;
1650
1651  connectChrono.init();
1652  do
1653  {
1654    connectChrono.now();
1655  }
1656  while((!(heatCharacteristic=
1657      peripheral.characteristic
1658  ("707158fb-c794-4774-9d5c-790121b1be5d")))
1659    && connectChrono.elapsed<tOut);
1660  if(connectChrono.elapsed>=tOut)
1661    return 5;
1662
1663  connected=true;
1664  return 0;
1665}
1666
1667void remoteHeatControl(void)
1668{
1669  static chronometer remChrono;
1670  static bool oldHeat=!heat;
1671
1672  remChrono.now();
1673  if((heat!=oldHeat) ||
1674     (remChrono.elapsed>30000))
1675  {
1676    oldHeat=heat;
1677    remChrono.init();
1678    connectRemoteHeat();
1679    if(peripheral.connected())
1680    {
1681      heatCharacteristic.writeValue(heat?
1682        (byte)1:(byte)0);
1683      peripheral.disconnect();
1684    }
1685    BLE.end();
1686  }
1687}
1688
1689/* Initialization functions */
1690
1691void readEEPROM(void)
1692{
1693  if(EEPROM.read(EEPROMId0)==byte('t') &&
1694     EEPROM.read(EEPROMId1)==byte('h') &&
1695     EEPROM.read(EEPROMId2)==byte('e'))
1696  {
1697    mode=
1698      EEPROM.read(EEPROMMode);
1699    setPoint=(float)
1700      (EEPROM.read(EEPROMSetPointMSB)*256+
1701      EEPROM.read(EEPROMSetPointLSB))/10.0;
1702    fixSetPoint=(float)
1703      (EEPROM.read(EEPROMFixSetPointMSB)*256+
1704      EEPROM.read(EEPROMFixSetPointLSB))/10.0;
1705    deltaT=(float)
1706      (EEPROM.read(EEPROMDeltaTMSB)*256+
1707      EEPROM.read(EEPROMDeltaTLSB))/10.0;
1708    minHeatPercent=
1709      EEPROM.read(EEPROMMinHeatPercent);
1710    maxHeatPercent=
1711      EEPROM.read(EEPROMMaxHeatPercent);
1712    cycleTime=
1713      EEPROM.read(EEPROMCycleTime);
1714    hysteresis=(float)
1715      (EEPROM.read(EEPROMHysteresisMSB)*256+
1716      EEPROM.read(EEPROMHysteresisLSB))/10.0;
1717    corrDS18B20=(float)((short)
1718              ((short)(EEPROM.read
1719                (EEPROMCorrDS18B20MSB))<<8)+
1720      EEPROM.read(EEPROMCorrDS18B20LSB))/10.0;
1721    sleepDelay=
1722      EEPROM.read(EEPROMSleepDelay);
1723    tempUnit=
1724      EEPROM.read(EEPROMTempUnit);
1725    if(tempUnit==Celsius)
1726      tempIncr=0.1;
1727    else
1728      tempIncr=0.5/9.0;
1729    language=
1730      EEPROM.read(EEPROMLanguage);
1731    for(int i=0; i<7; i++)
1732      dayProg[i]=EEPROM.read(EEPROMWeek+i);
1733    for(int pr=0; pr<3; pr++)
1734      for(int i=0; i<4; i++)
1735      {
1736        hourLimit[pr][i]=
1737          EEPROM.read
1738            (EEPROMProg+16*pr+4*i);
1739        minuteLimit[pr][i]=
1740          EEPROM.read
1741            (EEPROMProg+16*pr+4*i+1);
1742        progTemp[pr][i]=(float)
1743          ((EEPROM.read
1744              (EEPROMProg+16*pr+4*i+2)*256+
1745            EEPROM.read
1746              (EEPROMProg+16*pr+4*i+3))/
1747                10.0);
1748      }
1749  }
1750  else
1751  {   
1752    EEPROM.update(EEPROMId0, 't');
1753    EEPROM.update(EEPROMId1, 'h');
1754    EEPROM.update(EEPROMId2, 'e');
1755    mode=stop;
1756    EEPROM.update(EEPROMMode, mode);
1757    setPoint=19.0;
1758    EEPROM.update(EEPROMSetPointMSB,
1759         (byte)((int)(setPoint*10.01)>>8));
1760    EEPROM.update(EEPROMSetPointLSB,
1761         (byte)((int)(setPoint*10.01)%256));
1762    fixSetPoint=19.0;
1763    EEPROM.update(EEPROMFixSetPointMSB,
1764        (byte)((int)(fixSetPoint*10.01)>>8));
1765    EEPROM.update(EEPROMFixSetPointLSB,
1766       (byte)((int)(fixSetPoint*10.01)%256));
1767    deltaT=0.0;
1768    EEPROM.update(EEPROMDeltaTMSB,
1769           (byte)((int)(deltaT*10.01)>>8));
1770    EEPROM.update(EEPROMDeltaTLSB,
1771           (byte)((int)(deltaT*10.01)%256));
1772    minHeatPercent=20;
1773    EEPROM.update(EEPROMMinHeatPercent,
1774                  minHeatPercent);
1775    maxHeatPercent=85;
1776    EEPROM.update(EEPROMMaxHeatPercent,
1777                  maxHeatPercent);
1778    cycleTime=120;
1779    EEPROM.update(EEPROMCycleTime, cycleTime);
1780    hysteresis=0.3;
1781    EEPROM.update(EEPROMHysteresisMSB,
1782         (byte)((int)(hysteresis*10.01)>>8));
1783    EEPROM.update(EEPROMHysteresisLSB,
1784        (byte)((int)(hysteresis*10.01)%256));
1785    corrDS18B20=0.0;
1786    EEPROM.update(EEPROMCorrDS18B20MSB,
1787        (byte)
1788          ((short)(corrDS18B20*10.01)>>8));
1789    EEPROM.update(EEPROMCorrDS18B20LSB,
1790        (byte)
1791          ((short)(corrDS18B20*10.01)%256));
1792    sleepDelay=15;
1793    EEPROM.update(EEPROMSleepDelay,
1794                   sleepDelay);
1795    tempUnit=Celsius;
1796    tempIncr=0.1;
1797    EEPROM.update(EEPROMTempUnit, tempUnit);
1798    language=english;
1799    EEPROM.update(EEPROMLanguage, language);
1800
1801    dayProg[0]=0;
1802    dayProg[1]=0;
1803    dayProg[2]=0;
1804    dayProg[3]=0;
1805    dayProg[4]=1;
1806    dayProg[5]=2;
1807    dayProg[6]=2;
1808    for(int i=0; i<7; i++)
1809      EEPROM.update(EEPROMWeek+i,
1810                    dayProg[i]);
1811
1812    hourLimit[0][0]=6;
1813    minuteLimit[0][0]=0;
1814    progTemp[0][0]=19.0;
1815    hourLimit[0][1]=8;
1816    minuteLimit[0][1]=30;
1817    progTemp[0][1]=17.5;
1818    hourLimit[0][2]=17;
1819    minuteLimit[0][2]=30;
1820    progTemp[0][2]=19.0;
1821    hourLimit[0][3]=23;
1822    minuteLimit[0][3]=00;
1823    progTemp[0][3]=16.0;
1824
1825    hourLimit[1][0]=6;
1826    minuteLimit[1][0]=0;
1827    progTemp[1][0]=19.0;
1828    hourLimit[1][1]=8;
1829    minuteLimit[1][1]=30;
1830    progTemp[1][1]=17.5;
1831    hourLimit[1][2]=12;
1832    minuteLimit[1][2]=00;
1833    progTemp[1][2]=19.0;
1834    hourLimit[1][3]=23;
1835    minuteLimit[1][3]=00;
1836    progTemp[1][3]=16.0;
1837
1838    hourLimit[2][0]=7;
1839    minuteLimit[2][0]=30;
1840    progTemp[2][0]=19.0;
1841    hourLimit[2][1]=12;
1842    minuteLimit[2][1]=00;
1843    progTemp[2][1]=19.0;
1844    hourLimit[2][2]=17;
1845    minuteLimit[2][2]=30;
1846    progTemp[2][2]=19.0;
1847    hourLimit[2][3]=23;
1848    minuteLimit[2][3]=00;
1849    progTemp[2][3]=16.0;
1850
1851    for(int pr=0; pr<3; pr++)
1852      for(int i=0; i<4; i++)
1853      {
1854        EEPROM.update
1855          (EEPROMProg+16*pr+4*i,
1856           hourLimit[pr][i]);
1857        EEPROM.update
1858          (EEPROMProg+16*pr+4*i+1,
1859           minuteLimit[pr][i]);
1860        EEPROM.update
1861          (EEPROMProg+16*pr+4*i+2,
1862           (byte)((int)
1863             (progTemp[pr][i]*10.01)>>8));
1864        EEPROM.update
1865           (EEPROMProg+16*pr+4*i+3,
1866            (byte)((int)
1867              (progTemp[pr][i]*10.01)%256));
1868      }
1869  }
1870  if(mode==prog) setPointInit();
1871  if(mode==fixed) setPoint=fixSetPoint;
1872}
1873
1874#include "Thermostat_state_functions.h"
1875
1876#include "Thermostat_fsm.h"
1877
1878void setup()
1879{
1880  pinMode(rotaryAPin, INPUT);
1881  pinMode(rotaryBPin, INPUT);
1882  pinMode(rotarySwitchPin, INPUT_PULLUP);
1883  digitalWrite(LED_PWR, LOW);
1884  Wire.begin();
1885  u8g2.begin();
1886  u8g2.setFont(u8g2_font_6x13_mf);
1887  u8g2.setFontDirection(0);
1888  u8g2.setDrawColor(1);
1889  rtc.begin();
1890  if (!rtc.isrunning())
1891    rtc.adjust(DateTime(__DATE__, __TIME__));
1892  current=rtc.now();
1893  if(current.hour()>24 ||
1894     current.minute()>60 ||
1895     current.month()>12)
1896    rtc.adjust(DateTime(__DATE__, __TIME__));
1897  attachInterrupt(digitalPinToInterrupt
1898                   (rotaryAPin),
1899              interruptRoutineReadEncoder,
1900              FALLING);
1901  if(digitalRead(rotarySwitchPin)==LOW)
1902  {
1903    EEPROM.update(EEPROMId0, 0xFF);
1904    EEPROM.update(EEPROMId1, 0xFF);
1905    EEPROM.update(EEPROMId2, 0xFF);
1906  }
1907  readEEPROM();
1908  measureTemp(false);
1909  minTemp=temp;
1910  maxTemp=temp;
1911  setTransitions();
1912}
1913
1914void loop()
1915{
1916  measureTemp(true);
1917  rotaryEncoderRead();
1918  myFsm.trigger(event);
1919  myFsm.run_machine();
1920  setPointControl();
1921  heatControl();
1922  if(!changeSetPoint && !changeMode)
1923    remoteHeatControl();
1924  wakeDetection();
1925  if(!displayActive)
1926    delay(500);
1927}