Thermostat with Relative Humidity Control

Temperature and humidity control to achieve the ideal confort conditions. The system work in a automatic way without a manual control.

May 3, 2018

•

7274 views

•

6 respects

environmental sensing

energy efficiency

monitoring

Components and supplies

LCD 20x4 Display - IIC/I2C 2004

DS3231MPMB1 Peripheral Module

DHT11 Temperature & Humidity Sensor (4 pins)

LED (generic)

Resistor 221 ohm

Solderless Breadboard Full Size

Arduino Mega 2560

Apps and platforms

Arduino IDE

Project description

Code

termostato_fsm_19.04.2018

arduino

Finite state machine

1//  Autoria do projeto: Vasco Correia
2//  Data de execuo: Abril de   2018 - verso 00
3//  Controlo de humidade e temperatura de um espao a climatizar
4//   Garantir os nveis ideais de humidade e temperatura no ar
5//  Sistemas autnomos   de controlo das cargas sensveis e latentes do ar
6//  Projeto baseado em mquinas   de estado finitas
7
8// Bibliotecas
9#include <DS3231.h> // biblioteca para   o relgio em tempo real
10#include <LiquidCrystal_I2C.h>  // biblioteca para comunicao   I2C com o display de 20x4
11#include<dht.h> // biblioteca relativa ao sensor DHT11   - sensor de T e HR do ar
12dht DHT;
13
14#define DHT11_PIN 7    // Definido o   pino n 7 para o sensor de HR e Temperatura ambiente do espao a climatizar
15#define   HoldTime 10000   // Aguardar 10 segundos antes de ir para o estado inicial
16#define   HoldTime2 5000   // Aguardar 5 segundos antes de ir para o estado inicial
17#define   FSM1_L_pin 6        // Luz intermitente aquando o aquecimento ou o arrefecimento   do espao a climatizar - FSM1
18#define Vent_pin 5          // Ventilao ON - led   verde
19#define Aquec_pin 2         // Aquecimento ON - led vermelho
20#define   Arref_pin 3         // Arrefecimento ON - led azul
21#define FSM3_L_pin 4        //   Luz Amarelo torrado intermitente aquando a desumidificao ou humidificao do espao   a climatizar - FSM3
22#define Desum_pin 8         // Desumidificao ON - led azul
23#define   Humid_pin 9         // Desumidificao ON - led brilhante incolor
24
25//  Comunicao   IC2 utilizando o display LCD 4x20
26LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5,   6, 7, 3, POSITIVE);
27//  Clock externo
28DS3231  rtc(SDA, SCL);
29
30//Declarao   dos OUTPUTS como variveis globais das mquinas de estados
31static int FSM0_state   = 1;   // estado incial - controlo da climatizao do espao - afeta a carga sensvel
32static   int FSM1_state = 1;   // estado incial - led amarelo a piscar aquando o aquecimento   ou arrefecimento do espao a climatizar
33static int FSM2_state = 1;   // estado   inicial - controlo da carga latente no espao a climatizar
34static int FSM3_state   = 1;   // estado incial - led brilhante a piscar aquando a desumidificao e humidificao   do espao a climatizar
35static int FSM0_L = 0;  // estmulo da mquina de estados   do led amarelo a piscar FSM1
36static int FSM2_L = 0;  // estmulo da mquina de   estados do led laranja a piscar FSM3
37
38static  int Taquec;   // estmulo para   acionar o aquecimento
39static  int Tarref;   // estmulo para acionar o arrefecimento
40static   int T;   // estmulo para as temperaturas intermdias para o estado 2 e 3 da FSM0
41
42static   int Hhum;   // estmulo para acionar a humidificao
43static int Hdesum;   // estmulo   para acionar a desumidificao
44static int H;   // estmulo para a HR  nos estados   2 e 3 da FSM2
45
46static unsigned long FSM0_ts; // guarda o tempo atual para   a FSM0
47static unsigned long FSM1_ts; // guarda o tempo atual para a FSM1
48static   unsigned long FSM2_ts; // guarda o tempo atual para a FSM2
49static unsigned long   FSM3_ts; // guarda o tempo atual para a FSM3
50
51void setup()
52{
53  pinMode(Vent_pin,   OUTPUT);
54  pinMode(Aquec_pin, OUTPUT);
55  pinMode(Arref_pin, OUTPUT);
56  pinMode(DHT11_PIN,   INPUT);
57  pinMode(FSM1_L_pin, OUTPUT);
58  pinMode(Desum_pin, OUTPUT);
59  pinMode(Humid_pin,   OUTPUT);
60  pinMode(FSM3_L_pin, OUTPUT);
61
62  Serial.begin(9600);
63  lcd.begin(20,   4);
64  lcd.setCursor(0, 0);
65  rtc.begin();
66
67  //Descomente as linhas   para configurar o horrio atual (upload), aps o processo comente e faa o upload novamente   para o Arduino
68  //rtc.setDOW(TUESDAY);     // Set Day-of-Week to SUNDAY
69   //rtc.setTime(21,18, 0);     // Set the time to 12:00:00 (24hr format)
70  //rtc.setDate(10,04,2018);
71
72}
73
74void   loop()
75{
76  int chk = DHT.read11(DHT11_PIN);
77  int FSM0_E_time;
78  int   FSM1_E_time;
79  int FSM2_E_time;
80  int FSM3_E_time;
81  int Vent;
82  int   Aquec;
83  int Arref;
84  int Desum;
85  int Humid;
86  int FMS1_L;
87  int   FSM3_L;
88
89
90  Vent = digitalRead(Vent_pin);
91  Aquec = digitalRead(Aquec_pin);
92   Arref = digitalRead(Arref_pin);
93  Desum = digitalRead(Desum_pin);
94  Humid   = digitalRead(Humid_pin);
95
96  if (millis() - FSM0_ts > HoldTime)
97  {
98     FSM0_E_time = 1;
99  } else {
100    FSM0_E_time = 0;
101  }
102
103
104  if   (DHT.temperature <= 20) {
105    Taquec = 1;
106  }
107  else
108  {
109    Taquec   = 0;
110  }
111
112
113  if (DHT.temperature >= 24) {
114    Tarref = 1;
115  }
116   else
117  {
118    Tarref = 0;
119  }
120
121  if (DHT.temperature > 22) {
122     T = 1;
123  }
124  else
125  {
126    T = 0;
127  }
128  FSM0(FSM0_E_time, Taquec,   Tarref, T);
129
130
131  int LedOnOffTime = 750;
132  if (millis() - FSM1_ts > LedOnOffTime)   {
133    FSM1_E_time = 1;
134  } else {
135    FSM1_E_time = 0;
136  }
137  FSM1(FSM1_E_time,   FSM0_L);
138
139  if (millis() - FSM2_ts > HoldTime2)
140  {
141    FSM2_E_time   = 1;
142  } else {
143    FSM2_E_time = 0;
144  }
145
146  if (DHT.humidity <= 40)   {
147    Hhum = 1;
148  }
149  else
150  {
151    Hhum = 0;
152  }
153
154
155  if   (DHT.humidity >= 60) {
156    Hdesum = 1;
157  }
158  else
159  {
160    Hdesum   = 0;
161  }
162
163  if (DHT.humidity > 50) {
164    H = 1;
165  }
166  else
167   {
168    H = 0;
169  }
170  FSM2(FSM2_E_time, Hhum, Hdesum, H);
171
172
173  int   LedOnOffTime3 = 500;
174  if (millis() - FSM3_ts > LedOnOffTime3) {
175    FSM3_E_time   = 1;
176  } else {
177    FSM3_E_time = 0;
178  }
179  FSM3(FSM3_E_time, FSM2_L);
180
181
182
183
184}
185
186//   FSM0 sub arquitetura
187void FSM0(int FSM0_E_time, int Taquec, int Tarref, int T)
188{
189   FSM0_next_state(FSM0_E_time, Taquec, Tarref, T);
190  FSM0_output();
191}
192
193//   FSM1 sub arquitetura
194void FSM1(int FSM1_E_time, int FSM0_L)
195{
196  FSM1_next_state(FSM1_E_time,   FSM0_L);
197  FSM1_output();
198}
199
200// FSM2 sub arquitetura
201void FSM2(int   FSM2_E_time, int Hhum, int Hdesum, int H)
202{
203  FSM2_next_state(FSM2_E_time,   Hhum, Hdesum, H);
204  FSM2_output();
205}
206
207// FSM3 sub arquitetura
208void   FSM3(int FSM3_E_time, int FSM2_L)
209{
210  FSM3_next_state(FSM3_E_time, FSM2_L);
211   FSM3_output();
212}
213
214
215void FSM0_next_state(int FSM0_E_time, int Taquec,   int Tarref, int T)
216{
217  switch (FSM0_state)
218  {
219    case 1:
220      if   (Taquec == 1) {
221        FSM0_state = 3;
222      }
223      else if (Tarref ==   1) {
224        FSM0_state = 2;
225      }
226      else
227        FSM0_state =   1;
228      break;
229
230    case 2:
231      if (T == 0)
232      {
233        FSM0_state   = 4;
234      }
235      else
236        FSM0_state = 2;
237      break;
238
239     case 3:
240      if (T == 1)
241      {
242        FSM0_state = 5;
243      }
244       else
245        FSM0_state = 3;
246      break;
247
248    case 4:
249      if   (FSM0_E_time == 1) {
250        FSM0_state = 1;
251      }
252      break;
253
254     case 5:
255      if (FSM0_E_time == 1) {
256        FSM0_state = 1;
257      }
258       break;
259
260    default:
261      break;
262
263  }
264  Serial.print("Temperatura   = ");
265  Serial.print(DHT.temperature);
266  Serial.print(" C");
267  Serial.println("   ");
268  Serial.print("FSM0_state: ");
269  Serial.println(FSM0_state);
270  Serial.print("FSM1_state:   ");
271  Serial.println(FSM1_state);
272  Serial.print("FSM2_state: ");
273  Serial.println(FSM2_state);
274   Serial.print("FSM3_state: ");
275  Serial.println(FSM3_state);
276  Serial.print("HR   = ");
277  Serial.print(DHT.humidity);
278  Serial.println(" %");
279  Serial.println("   ");
280
281  lcd.setCursor(0, 1);
282  lcd.print(rtc.getTimeStr());
283  lcd.setCursor(10,   1);
284  lcd.print(rtc.getDOWStr());
285  lcd.setCursor(10, 0);
286  lcd.print(rtc.getDateStr());
287   lcd.setCursor(0, 4);
288  lcd.print("T=");
289  lcd.setCursor(2, 4);
290  lcd.print(DHT.temperature);
291   lcd.setCursor(6, 4);
292  lcd.print(" C");
293  lcd.setCursor(13, 4);
294  lcd.print("HR=");
295   lcd.setCursor(16, 4);
296  lcd.print(DHT.humidity);
297  lcd.setCursor(18, 4);
298   lcd.print(" %");
299  lcd.setCursor(0, 0);
300  lcd.print("UALG-EEE");
301   //lcd.setCursor(0,0);
302  //lcd.print("  ");
303
304  delay(500);
305}
306
307void   FSM0_output()
308{
309  switch (FSM0_state)
310  {
311    case 1:
312      digitalWrite(Vent_pin,   HIGH);
313      digitalWrite(Aquec_pin, LOW);
314      digitalWrite(Arref_pin, LOW);
315       break;
316
317    case 2:
318      digitalWrite(Vent_pin, HIGH);
319      digitalWrite(Aquec_pin,   LOW);
320      digitalWrite(Arref_pin, HIGH);
321      FSM0_L = 1;
322      FSM0_ts   = millis();
323      break;
324
325    case 3:
326      digitalWrite(Vent_pin, HIGH);
327       digitalWrite(Aquec_pin, HIGH);
328      digitalWrite(Arref_pin, LOW);
329       FSM0_L = 1;
330      FSM0_ts = millis();
331      break;
332
333    case 4:
334       digitalWrite(Vent_pin, HIGH);
335      digitalWrite(Aquec_pin, LOW);
336      digitalWrite(Arref_pin,   LOW);
337      FSM0_L = 0;
338      break;
339
340    case 5:
341      digitalWrite(Vent_pin,   HIGH);
342      digitalWrite(Aquec_pin, LOW);
343      digitalWrite(Arref_pin, LOW);
344       FSM0_L = 0;
345      break;
346
347    default:
348      break;
349  }
350}
351
352void   FSM1_next_state(int FSM1_E_time, int FSM0_L)
353{
354  switch (FSM1_state)
355  {
356     case 1:
357      if (FSM0_L == 1) {
358        FSM1_state = 2;
359      }
360       break;
361
362    case 2:
363      FSM1_state = 3;
364      if (FSM0_L ==   0) {
365        FSM1_state = 6;
366      }
367
368    case 3:
369      if (FSM1_E_time   == 1) {
370        FSM1_state = 4;
371      }
372      if (FSM0_L == 0) {
373        FSM1_state   = 6;
374      }
375      break;
376
377    case 4:
378      FSM1_state = 5;
379       if (FSM0_L == 0) {
380        FSM1_state = 6;
381      }
382      break;
383
384     case 5:
385      if (FSM1_E_time == 1) {
386        FSM1_state = 2;
387      }
388       if (FSM0_L == 0) {
389        FSM1_state = 6;
390      }
391      break;
392
393     case 6:
394      FSM1_state = 1;
395      break;
396
397    default:
398      FSM1_state   = 1;
399      break;
400  }
401}
402
403void FSM1_output()
404{
405
406  switch   (FSM1_state)
407  {
408    case 1:
409      break;
410
411    case 2:
412      digitalWrite(FSM1_L_pin,   HIGH);
413      FSM1_ts = millis();
414      break;
415
416    case 3:
417      break;
418
419     case 4:
420      digitalWrite(FSM1_L_pin, LOW);
421      FSM1_ts = millis();
422       break;
423
424    case 5:
425      break;
426
427    case 6:
428      digitalWrite(FSM1_L_pin,   LOW);
429      break;
430
431    default:
432      break;
433
434  }
435}
436
437void   FSM2_next_state(int FSM2_E_time, int Hhum, int Hdesum, int H)
438{
439  switch (FSM2_state)
440   {
441    case 1:
442      if (Hhum == 1) {
443        FSM2_state = 3;
444      }
445       else if (Hdesum == 1) {
446        FSM2_state = 2;
447      }
448      else
449         FSM2_state = 1;
450      break;
451
452    case 2:
453      if (H==0)
454       {
455        FSM2_state = 4;
456      }
457      break;
458
459    case 3:
460       if (H==1) {
461        FSM2_state = 5;
462      }
463      break;
464
465     case 4:
466      if (FSM2_E_time == 1) {
467        FSM2_state = 1;
468      }
469       break;
470
471    case 5:
472      if (FSM2_E_time == 1) {
473        FSM2_state   = 1;
474      }
475      break;
476
477    default:
478      break;
479  }
480}
481void   FSM2_output()
482{
483  switch (FSM2_state)
484  {
485    case 1:
486      digitalWrite(Desum_pin,   LOW);
487      digitalWrite(Humid_pin, LOW);
488      break;
489
490    case 2:
491       digitalWrite(Desum_pin, HIGH);
492      digitalWrite(Humid_pin, LOW);
493       FSM2_L = 1;
494      FSM2_ts = millis();
495      break;
496
497    case 3:
498       digitalWrite(Desum_pin, LOW);
499      digitalWrite(Humid_pin, HIGH);
500       FSM2_L = 1;
501      FSM2_ts = millis();
502      break;
503
504    case 4:
505       digitalWrite(Desum_pin, LOW);
506      digitalWrite(Humid_pin, LOW);
507      FSM2_L   = 0;
508      break;
509
510    case 5:
511      digitalWrite(Desum_pin, LOW);
512       digitalWrite(Humid_pin, LOW);
513      FSM2_L = 0;
514      break;
515
516     default:
517      break;
518  }
519}
520
521void FSM3_next_state(int FSM3_E_time,   int FSM2_L)
522{
523  switch (FSM3_state)
524  {
525    case 1:
526      if (FSM2_L   == 1) {
527        FSM3_state = 2;
528      }
529      break;
530
531    case 2:
532       FSM3_state = 3;
533      if (FSM2_L == 0) {
534        FSM3_state = 6;
535       }
536
537    case 3:
538      if (FSM3_E_time == 1) {
539        FSM3_state   = 4;
540      }
541      if (FSM2_L == 0) {
542        FSM3_state = 6;
543      }
544       break;
545
546    case 4:
547      FSM3_state = 5;
548      if (FSM2_L ==   0) {
549        FSM3_state = 6;
550      }
551      break;
552
553    case 5:
554       if (FSM3_E_time == 1) {
555        FSM3_state = 2;
556      }
557      if   (FSM2_L == 0) {
558        FSM3_state = 6;
559      }
560      break;
561
562    case   6:
563      FSM3_state = 1;
564      break;
565
566    default:
567      FSM3_state   = 1;
568      break;
569  }
570}
571
572void FSM3_output()
573{
574
575  switch   (FSM3_state)
576  {
577    case 1:
578      break;
579
580    case 2:
581      digitalWrite(FSM3_L_pin,   HIGH);
582      FSM3_ts = millis();
583      break;
584
585    case 3:
586      break;
587
588     case 4:
589      digitalWrite(FSM3_L_pin, LOW);
590      FSM3_ts = millis();
591       break;
592
593    case 5:
594      break;
595
596    case 6:
597      digitalWrite(FSM3_L_pin,   LOW);
598      break;
599
600    default:
601      break;
602
603  }
604}
605

//  Autoria do projeto: Vasco Correia
//  Data de execuo: Abril de   2018 - verso 00
//  Controlo de humidade e temperatura de um espao a climatizar
//   Garantir os nveis ideais de humidade e temperatura no ar
//  Sistemas autnomos   de controlo das cargas sensveis e latentes do ar
//  Projeto baseado em mquinas   de estado finitas

// Bibliotecas
#include <DS3231.h> // biblioteca para   o relgio em tempo real
#include <LiquidCrystal_I2C.h>  // biblioteca para comunicao   I2C com o display de 20x4
#include<dht.h> // biblioteca relativa ao sensor DHT11   - sensor de T e HR do ar
dht DHT;

#define DHT11_PIN 7    // Definido o   pino n 7 para o sensor de HR e Temperatura ambiente do espao a climatizar
#define   HoldTime 10000   // Aguardar 10 segundos antes de ir para o estado inicial
#define   HoldTime2 5000   // Aguardar 5 segundos antes de ir para o estado inicial
#define   FSM1_L_pin 6        // Luz intermitente aquando o aquecimento ou o arrefecimento   do espao a climatizar - FSM1
#define Vent_pin 5          // Ventilao ON - led   verde
#define Aquec_pin 2         // Aquecimento ON - led vermelho
#define   Arref_pin 3         // Arrefecimento ON - led azul
#define FSM3_L_pin 4        //   Luz Amarelo torrado intermitente aquando a desumidificao ou humidificao do espao   a climatizar - FSM3
#define Desum_pin 8         // Desumidificao ON - led azul
#define   Humid_pin 9         // Desumidificao ON - led brilhante incolor

//  Comunicao   IC2 utilizando o display LCD 4x20
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5,   6, 7, 3, POSITIVE);
//  Clock externo
DS3231  rtc(SDA, SCL);

//Declarao   dos OUTPUTS como variveis globais das mquinas de estados
static int FSM0_state   = 1;   // estado incial - controlo da climatizao do espao - afeta a carga sensvel
static   int FSM1_state = 1;   // estado incial - led amarelo a piscar aquando o aquecimento   ou arrefecimento do espao a climatizar
static int FSM2_state = 1;   // estado   inicial - controlo da carga latente no espao a climatizar
static int FSM3_state   = 1;   // estado incial - led brilhante a piscar aquando a desumidificao e humidificao   do espao a climatizar
static int FSM0_L = 0;  // estmulo da mquina de estados   do led amarelo a piscar FSM1
static int FSM2_L = 0;  // estmulo da mquina de   estados do led laranja a piscar FSM3

static  int Taquec;   // estmulo para   acionar o aquecimento
static  int Tarref;   // estmulo para acionar o arrefecimento
static   int T;   // estmulo para as temperaturas intermdias para o estado 2 e 3 da FSM0

static   int Hhum;   // estmulo para acionar a humidificao
static int Hdesum;   // estmulo   para acionar a desumidificao
static int H;   // estmulo para a HR  nos estados   2 e 3 da FSM2

static unsigned long FSM0_ts; // guarda o tempo atual para   a FSM0
static unsigned long FSM1_ts; // guarda o tempo atual para a FSM1
static   unsigned long FSM2_ts; // guarda o tempo atual para a FSM2
static unsigned long   FSM3_ts; // guarda o tempo atual para a FSM3

void setup()
{
  pinMode(Vent_pin,   OUTPUT);
  pinMode(Aquec_pin, OUTPUT);
  pinMode(Arref_pin, OUTPUT);
  pinMode(DHT11_PIN,   INPUT);
  pinMode(FSM1_L_pin, OUTPUT);
  pinMode(Desum_pin, OUTPUT);
  pinMode(Humid_pin,   OUTPUT);
  pinMode(FSM3_L_pin, OUTPUT);

  Serial.begin(9600);
  lcd.begin(20,   4);
  lcd.setCursor(0, 0);
  rtc.begin();

  //Descomente as linhas   para configurar o horrio atual (upload), aps o processo comente e faa o upload novamente   para o Arduino
  //rtc.setDOW(TUESDAY);     // Set Day-of-Week to SUNDAY
   //rtc.setTime(21,18, 0);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(10,04,2018);

}

void   loop()
{
  int chk = DHT.read11(DHT11_PIN);
  int FSM0_E_time;
  int   FSM1_E_time;
  int FSM2_E_time;
  int FSM3_E_time;
  int Vent;
  int   Aquec;
  int Arref;
  int Desum;
  int Humid;
  int FMS1_L;
  int   FSM3_L;


  Vent = digitalRead(Vent_pin);
  Aquec = digitalRead(Aquec_pin);
   Arref = digitalRead(Arref_pin);
  Desum = digitalRead(Desum_pin);
  Humid   = digitalRead(Humid_pin);

  if (millis() - FSM0_ts > HoldTime)
  {
     FSM0_E_time = 1;
  } else {
    FSM0_E_time = 0;
  }


  if   (DHT.temperature <= 20) {
    Taquec = 1;
  }
  else
  {
    Taquec   = 0;
  }


  if (DHT.temperature >= 24) {
    Tarref = 1;
  }
   else
  {
    Tarref = 0;
  }

  if (DHT.temperature > 22) {
     T = 1;
  }
  else
  {
    T = 0;
  }
  FSM0(FSM0_E_time, Taquec,   Tarref, T);


  int LedOnOffTime = 750;
  if (millis() - FSM1_ts > LedOnOffTime)   {
    FSM1_E_time = 1;
  } else {
    FSM1_E_time = 0;
  }
  FSM1(FSM1_E_time,   FSM0_L);

  if (millis() - FSM2_ts > HoldTime2)
  {
    FSM2_E_time   = 1;
  } else {
    FSM2_E_time = 0;
  }

  if (DHT.humidity <= 40)   {
    Hhum = 1;
  }
  else
  {
    Hhum = 0;
  }


  if   (DHT.humidity >= 60) {
    Hdesum = 1;
  }
  else
  {
    Hdesum   = 0;
  }

  if (DHT.humidity > 50) {
    H = 1;
  }
  else
   {
    H = 0;
  }
  FSM2(FSM2_E_time, Hhum, Hdesum, H);


  int   LedOnOffTime3 = 500;
  if (millis() - FSM3_ts > LedOnOffTime3) {
    FSM3_E_time   = 1;
  } else {
    FSM3_E_time = 0;
  }
  FSM3(FSM3_E_time, FSM2_L);




}

//   FSM0 sub arquitetura
void FSM0(int FSM0_E_time, int Taquec, int Tarref, int T)
{
   FSM0_next_state(FSM0_E_time, Taquec, Tarref, T);
  FSM0_output();
}

//   FSM1 sub arquitetura
void FSM1(int FSM1_E_time, int FSM0_L)
{
  FSM1_next_state(FSM1_E_time,   FSM0_L);
  FSM1_output();
}

// FSM2 sub arquitetura
void FSM2(int   FSM2_E_time, int Hhum, int Hdesum, int H)
{
  FSM2_next_state(FSM2_E_time,   Hhum, Hdesum, H);
  FSM2_output();
}

// FSM3 sub arquitetura
void   FSM3(int FSM3_E_time, int FSM2_L)
{
  FSM3_next_state(FSM3_E_time, FSM2_L);
   FSM3_output();
}


void FSM0_next_state(int FSM0_E_time, int Taquec,   int Tarref, int T)
{
  switch (FSM0_state)
  {
    case 1:
      if   (Taquec == 1) {
        FSM0_state = 3;
      }
      else if (Tarref ==   1) {
        FSM0_state = 2;
      }
      else
        FSM0_state =   1;
      break;

    case 2:
      if (T == 0)
      {
        FSM0_state   = 4;
      }
      else
        FSM0_state = 2;
      break;

     case 3:
      if (T == 1)
      {
        FSM0_state = 5;
      }
       else
        FSM0_state = 3;
      break;

    case 4:
      if   (FSM0_E_time == 1) {
        FSM0_state = 1;
      }
      break;

     case 5:
      if (FSM0_E_time == 1) {
        FSM0_state = 1;
      }
       break;

    default:
      break;

  }
  Serial.print("Temperatura   = ");
  Serial.print(DHT.temperature);
  Serial.print(" C");
  Serial.println("   ");
  Serial.print("FSM0_state: ");
  Serial.println(FSM0_state);
  Serial.print("FSM1_state:   ");
  Serial.println(FSM1_state);
  Serial.print("FSM2_state: ");
  Serial.println(FSM2_state);
   Serial.print("FSM3_state: ");
  Serial.println(FSM3_state);
  Serial.print("HR   = ");
  Serial.print(DHT.humidity);
  Serial.println(" %");
  Serial.println("   ");

  lcd.setCursor(0, 1);
  lcd.print(rtc.getTimeStr());
  lcd.setCursor(10,   1);
  lcd.print(rtc.getDOWStr());
  lcd.setCursor(10, 0);
  lcd.print(rtc.getDateStr());
   lcd.setCursor(0, 4);
  lcd.print("T=");
  lcd.setCursor(2, 4);
  lcd.print(DHT.temperature);
   lcd.setCursor(6, 4);
  lcd.print(" C");
  lcd.setCursor(13, 4);
  lcd.print("HR=");
   lcd.setCursor(16, 4);
  lcd.print(DHT.humidity);
  lcd.setCursor(18, 4);
   lcd.print(" %");
  lcd.setCursor(0, 0);
  lcd.print("UALG-EEE");
   //lcd.setCursor(0,0);
  //lcd.print("  ");

  delay(500);
}

void   FSM0_output()
{
  switch (FSM0_state)
  {
    case 1:
      digitalWrite(Vent_pin,   HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin, LOW);
       break;

    case 2:
      digitalWrite(Vent_pin, HIGH);
      digitalWrite(Aquec_pin,   LOW);
      digitalWrite(Arref_pin, HIGH);
      FSM0_L = 1;
      FSM0_ts   = millis();
      break;

    case 3:
      digitalWrite(Vent_pin, HIGH);
       digitalWrite(Aquec_pin, HIGH);
      digitalWrite(Arref_pin, LOW);
       FSM0_L = 1;
      FSM0_ts = millis();
      break;

    case 4:
       digitalWrite(Vent_pin, HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin,   LOW);
      FSM0_L = 0;
      break;

    case 5:
      digitalWrite(Vent_pin,   HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin, LOW);
       FSM0_L = 0;
      break;

    default:
      break;
  }
}

void   FSM1_next_state(int FSM1_E_time, int FSM0_L)
{
  switch (FSM1_state)
  {
     case 1:
      if (FSM0_L == 1) {
        FSM1_state = 2;
      }
       break;

    case 2:
      FSM1_state = 3;
      if (FSM0_L ==   0) {
        FSM1_state = 6;
      }

    case 3:
      if (FSM1_E_time   == 1) {
        FSM1_state = 4;
      }
      if (FSM0_L == 0) {
        FSM1_state   = 6;
      }
      break;

    case 4:
      FSM1_state = 5;
       if (FSM0_L == 0) {
        FSM1_state = 6;
      }
      break;

     case 5:
      if (FSM1_E_time == 1) {
        FSM1_state = 2;
      }
       if (FSM0_L == 0) {
        FSM1_state = 6;
      }
      break;

     case 6:
      FSM1_state = 1;
      break;

    default:
      FSM1_state   = 1;
      break;
  }
}

void FSM1_output()
{

  switch   (FSM1_state)
  {
    case 1:
      break;

    case 2:
      digitalWrite(FSM1_L_pin,   HIGH);
      FSM1_ts = millis();
      break;

    case 3:
      break;

     case 4:
      digitalWrite(FSM1_L_pin, LOW);
      FSM1_ts = millis();
       break;

    case 5:
      break;

    case 6:
      digitalWrite(FSM1_L_pin,   LOW);
      break;

    default:
      break;

  }
}

void   FSM2_next_state(int FSM2_E_time, int Hhum, int Hdesum, int H)
{
  switch (FSM2_state)
   {
    case 1:
      if (Hhum == 1) {
        FSM2_state = 3;
      }
       else if (Hdesum == 1) {
        FSM2_state = 2;
      }
      else
         FSM2_state = 1;
      break;

    case 2:
      if (H==0)
       {
        FSM2_state = 4;
      }
      break;

    case 3:
       if (H==1) {
        FSM2_state = 5;
      }
      break;

     case 4:
      if (FSM2_E_time == 1) {
        FSM2_state = 1;
      }
       break;

    case 5:
      if (FSM2_E_time == 1) {
        FSM2_state   = 1;
      }
      break;

    default:
      break;
  }
}
void   FSM2_output()
{
  switch (FSM2_state)
  {
    case 1:
      digitalWrite(Desum_pin,   LOW);
      digitalWrite(Humid_pin, LOW);
      break;

    case 2:
       digitalWrite(Desum_pin, HIGH);
      digitalWrite(Humid_pin, LOW);
       FSM2_L = 1;
      FSM2_ts = millis();
      break;

    case 3:
       digitalWrite(Desum_pin, LOW);
      digitalWrite(Humid_pin, HIGH);
       FSM2_L = 1;
      FSM2_ts = millis();
      break;

    case 4:
       digitalWrite(Desum_pin, LOW);
      digitalWrite(Humid_pin, LOW);
      FSM2_L   = 0;
      break;

    case 5:
      digitalWrite(Desum_pin, LOW);
       digitalWrite(Humid_pin, LOW);
      FSM2_L = 0;
      break;

     default:
      break;
  }
}

void FSM3_next_state(int FSM3_E_time,   int FSM2_L)
{
  switch (FSM3_state)
  {
    case 1:
      if (FSM2_L   == 1) {
        FSM3_state = 2;
      }
      break;

    case 2:
       FSM3_state = 3;
      if (FSM2_L == 0) {
        FSM3_state = 6;
       }

    case 3:
      if (FSM3_E_time == 1) {
        FSM3_state   = 4;
      }
      if (FSM2_L == 0) {
        FSM3_state = 6;
      }
       break;

    case 4:
      FSM3_state = 5;
      if (FSM2_L ==   0) {
        FSM3_state = 6;
      }
      break;

    case 5:
       if (FSM3_E_time == 1) {
        FSM3_state = 2;
      }
      if   (FSM2_L == 0) {
        FSM3_state = 6;
      }
      break;

    case   6:
      FSM3_state = 1;
      break;

    default:
      FSM3_state   = 1;
      break;
  }
}

void FSM3_output()
{

  switch   (FSM3_state)
  {
    case 1:
      break;

    case 2:
      digitalWrite(FSM3_L_pin,   HIGH);
      FSM3_ts = millis();
      break;

    case 3:
      break;

     case 4:
      digitalWrite(FSM3_L_pin, LOW);
      FSM3_ts = millis();
       break;

    case 5:
      break;

    case 6:
      digitalWrite(FSM3_L_pin,   LOW);
      break;

    default:
      break;

  }
}

termostato_fsm_19.04.2018

arduino

Finite state machine

1//  Autoria do projeto: Vasco Correia
2//  Data de execuo: Abril de  2018 - verso 00
3//  Controlo de humidade e temperatura de um espao a climatizar
4//  Garantir os nveis ideais de humidade e temperatura no ar
5//  Sistemas autnomos  de controlo das cargas sensveis e latentes do ar
6//  Projeto baseado em mquinas  de estado finitas
7
8// Bibliotecas
9#include <DS3231.h> // biblioteca para  o relgio em tempo real
10#include <LiquidCrystal_I2C.h>  // biblioteca para comunicao  I2C com o display de 20x4
11#include<dht.h> // biblioteca relativa ao sensor DHT11  - sensor de T e HR do ar
12dht DHT;
13
14#define DHT11_PIN 7    // Definido o  pino n 7 para o sensor de HR e Temperatura ambiente do espao a climatizar
15#define  HoldTime 10000   // Aguardar 10 segundos antes de ir para o estado inicial
16#define  HoldTime2 5000   // Aguardar 5 segundos antes de ir para o estado inicial
17#define  FSM1_L_pin 6        // Luz intermitente aquando o aquecimento ou o arrefecimento  do espao a climatizar - FSM1
18#define Vent_pin 5          // Ventilao ON - led  verde
19#define Aquec_pin 2         // Aquecimento ON - led vermelho
20#define  Arref_pin 3         // Arrefecimento ON - led azul
21#define FSM3_L_pin 4        //  Luz Amarelo torrado intermitente aquando a desumidificao ou humidificao do espao  a climatizar - FSM3
22#define Desum_pin 8         // Desumidificao ON - led azul
23#define  Humid_pin 9         // Desumidificao ON - led brilhante incolor
24
25//  Comunicao  IC2 utilizando o display LCD 4x20
26LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5,  6, 7, 3, POSITIVE);
27//  Clock externo
28DS3231  rtc(SDA, SCL);
29
30//Declarao  dos OUTPUTS como variveis globais das mquinas de estados
31static int FSM0_state  = 1;   // estado incial - controlo da climatizao do espao - afeta a carga sensvel
32static  int FSM1_state = 1;   // estado incial - led amarelo a piscar aquando o aquecimento  ou arrefecimento do espao a climatizar
33static int FSM2_state = 1;   // estado  inicial - controlo da carga latente no espao a climatizar
34static int FSM3_state  = 1;   // estado incial - led brilhante a piscar aquando a desumidificao e humidificao  do espao a climatizar
35static int FSM0_L = 0;  // estmulo da mquina de estados  do led amarelo a piscar FSM1
36static int FSM2_L = 0;  // estmulo da mquina de  estados do led laranja a piscar FSM3
37
38static  int Taquec;   // estmulo para  acionar o aquecimento
39static  int Tarref;   // estmulo para acionar o arrefecimento
40static  int T;   // estmulo para as temperaturas intermdias para o estado 2 e 3 da FSM0
41
42static  int Hhum;   // estmulo para acionar a humidificao
43static int Hdesum;   // estmulo  para acionar a desumidificao
44static int H;   // estmulo para a HR  nos estados  2 e 3 da FSM2
45
46static unsigned long FSM0_ts; // guarda o tempo atual para  a FSM0
47static unsigned long FSM1_ts; // guarda o tempo atual para a FSM1
48static  unsigned long FSM2_ts; // guarda o tempo atual para a FSM2
49static unsigned long  FSM3_ts; // guarda o tempo atual para a FSM3
50
51void setup()
52{
53  pinMode(Vent_pin,  OUTPUT);
54  pinMode(Aquec_pin, OUTPUT);
55  pinMode(Arref_pin, OUTPUT);
56  pinMode(DHT11_PIN,  INPUT);
57  pinMode(FSM1_L_pin, OUTPUT);
58  pinMode(Desum_pin, OUTPUT);
59  pinMode(Humid_pin,  OUTPUT);
60  pinMode(FSM3_L_pin, OUTPUT);
61
62  Serial.begin(9600);
63  lcd.begin(20,  4);
64  lcd.setCursor(0, 0);
65  rtc.begin();
66
67  //Descomente as linhas  para configurar o horrio atual (upload), aps o processo comente e faa o upload novamente  para o Arduino
68  //rtc.setDOW(TUESDAY);     // Set Day-of-Week to SUNDAY
69  //rtc.setTime(21,18, 0);     // Set the time to 12:00:00 (24hr format)
70  //rtc.setDate(10,04,2018);
71
72}
73
74void  loop()
75{
76  int chk = DHT.read11(DHT11_PIN);
77  int FSM0_E_time;
78  int  FSM1_E_time;
79  int FSM2_E_time;
80  int FSM3_E_time;
81  int Vent;
82  int  Aquec;
83  int Arref;
84  int Desum;
85  int Humid;
86  int FMS1_L;
87  int  FSM3_L;
88
89
90  Vent = digitalRead(Vent_pin);
91  Aquec = digitalRead(Aquec_pin);
92  Arref = digitalRead(Arref_pin);
93  Desum = digitalRead(Desum_pin);
94  Humid  = digitalRead(Humid_pin);
95
96  if (millis() - FSM0_ts > HoldTime)
97  {
98    FSM0_E_time = 1;
99  } else {
100    FSM0_E_time = 0;
101  }
102
103
104  if  (DHT.temperature <= 20) {
105    Taquec = 1;
106  }
107  else
108  {
109    Taquec  = 0;
110  }
111
112
113  if (DHT.temperature >= 24) {
114    Tarref = 1;
115  }
116  else
117  {
118    Tarref = 0;
119  }
120
121  if (DHT.temperature > 22) {
122    T = 1;
123  }
124  else
125  {
126    T = 0;
127  }
128  FSM0(FSM0_E_time, Taquec,  Tarref, T);
129
130
131  int LedOnOffTime = 750;
132  if (millis() - FSM1_ts > LedOnOffTime)  {
133    FSM1_E_time = 1;
134  } else {
135    FSM1_E_time = 0;
136  }
137  FSM1(FSM1_E_time,  FSM0_L);
138
139  if (millis() - FSM2_ts > HoldTime2)
140  {
141    FSM2_E_time  = 1;
142  } else {
143    FSM2_E_time = 0;
144  }
145
146  if (DHT.humidity <= 40)  {
147    Hhum = 1;
148  }
149  else
150  {
151    Hhum = 0;
152  }
153
154
155  if  (DHT.humidity >= 60) {
156    Hdesum = 1;
157  }
158  else
159  {
160    Hdesum  = 0;
161  }
162
163  if (DHT.humidity > 50) {
164    H = 1;
165  }
166  else
167  {
168    H = 0;
169  }
170  FSM2(FSM2_E_time, Hhum, Hdesum, H);
171
172
173  int  LedOnOffTime3 = 500;
174  if (millis() - FSM3_ts > LedOnOffTime3) {
175    FSM3_E_time  = 1;
176  } else {
177    FSM3_E_time = 0;
178  }
179  FSM3(FSM3_E_time, FSM2_L);
180
181
182
183
184}
185
186//  FSM0 sub arquitetura
187void FSM0(int FSM0_E_time, int Taquec, int Tarref, int T)
188{
189  FSM0_next_state(FSM0_E_time, Taquec, Tarref, T);
190  FSM0_output();
191}
192
193//  FSM1 sub arquitetura
194void FSM1(int FSM1_E_time, int FSM0_L)
195{
196  FSM1_next_state(FSM1_E_time,  FSM0_L);
197  FSM1_output();
198}
199
200// FSM2 sub arquitetura
201void FSM2(int  FSM2_E_time, int Hhum, int Hdesum, int H)
202{
203  FSM2_next_state(FSM2_E_time,  Hhum, Hdesum, H);
204  FSM2_output();
205}
206
207// FSM3 sub arquitetura
208void  FSM3(int FSM3_E_time, int FSM2_L)
209{
210  FSM3_next_state(FSM3_E_time, FSM2_L);
211  FSM3_output();
212}
213
214
215void FSM0_next_state(int FSM0_E_time, int Taquec,  int Tarref, int T)
216{
217  switch (FSM0_state)
218  {
219    case 1:
220      if  (Taquec == 1) {
221        FSM0_state = 3;
222      }
223      else if (Tarref ==  1) {
224        FSM0_state = 2;
225      }
226      else
227        FSM0_state =  1;
228      break;
229
230    case 2:
231      if (T == 0)
232      {
233        FSM0_state  = 4;
234      }
235      else
236        FSM0_state = 2;
237      break;
238
239    case 3:
240      if (T == 1)
241      {
242        FSM0_state = 5;
243      }
244      else
245        FSM0_state = 3;
246      break;
247
248    case 4:
249      if  (FSM0_E_time == 1) {
250        FSM0_state = 1;
251      }
252      break;
253
254    case 5:
255      if (FSM0_E_time == 1) {
256        FSM0_state = 1;
257      }
258      break;
259
260    default:
261      break;
262
263  }
264  Serial.print("Temperatura  = ");
265  Serial.print(DHT.temperature);
266  Serial.print(" C");
267  Serial.println("  ");
268  Serial.print("FSM0_state: ");
269  Serial.println(FSM0_state);
270  Serial.print("FSM1_state:  ");
271  Serial.println(FSM1_state);
272  Serial.print("FSM2_state: ");
273  Serial.println(FSM2_state);
274  Serial.print("FSM3_state: ");
275  Serial.println(FSM3_state);
276  Serial.print("HR  = ");
277  Serial.print(DHT.humidity);
278  Serial.println(" %");
279  Serial.println("  ");
280
281  lcd.setCursor(0, 1);
282  lcd.print(rtc.getTimeStr());
283  lcd.setCursor(10,  1);
284  lcd.print(rtc.getDOWStr());
285  lcd.setCursor(10, 0);
286  lcd.print(rtc.getDateStr());
287  lcd.setCursor(0, 4);
288  lcd.print("T=");
289  lcd.setCursor(2, 4);
290  lcd.print(DHT.temperature);
291  lcd.setCursor(6, 4);
292  lcd.print(" C");
293  lcd.setCursor(13, 4);
294  lcd.print("HR=");
295  lcd.setCursor(16, 4);
296  lcd.print(DHT.humidity);
297  lcd.setCursor(18, 4);
298  lcd.print(" %");
299  lcd.setCursor(0, 0);
300  lcd.print("UALG-EEE");
301  //lcd.setCursor(0,0);
302  //lcd.print("  ");
303
304  delay(500);
305}
306
307void  FSM0_output()
308{
309  switch (FSM0_state)
310  {
311    case 1:
312      digitalWrite(Vent_pin,  HIGH);
313      digitalWrite(Aquec_pin, LOW);
314      digitalWrite(Arref_pin, LOW);
315      break;
316
317    case 2:
318      digitalWrite(Vent_pin, HIGH);
319      digitalWrite(Aquec_pin,  LOW);
320      digitalWrite(Arref_pin, HIGH);
321      FSM0_L = 1;
322      FSM0_ts  = millis();
323      break;
324
325    case 3:
326      digitalWrite(Vent_pin, HIGH);
327      digitalWrite(Aquec_pin, HIGH);
328      digitalWrite(Arref_pin, LOW);
329      FSM0_L = 1;
330      FSM0_ts = millis();
331      break;
332
333    case 4:
334      digitalWrite(Vent_pin, HIGH);
335      digitalWrite(Aquec_pin, LOW);
336      digitalWrite(Arref_pin,  LOW);
337      FSM0_L = 0;
338      break;
339
340    case 5:
341      digitalWrite(Vent_pin,  HIGH);
342      digitalWrite(Aquec_pin, LOW);
343      digitalWrite(Arref_pin, LOW);
344      FSM0_L = 0;
345      break;
346
347    default:
348      break;
349  }
350}
351
352void  FSM1_next_state(int FSM1_E_time, int FSM0_L)
353{
354  switch (FSM1_state)
355  {
356    case 1:
357      if (FSM0_L == 1) {
358        FSM1_state = 2;
359      }
360      break;
361
362    case 2:
363      FSM1_state = 3;
364      if (FSM0_L ==  0) {
365        FSM1_state = 6;
366      }
367
368    case 3:
369      if (FSM1_E_time  == 1) {
370        FSM1_state = 4;
371      }
372      if (FSM0_L == 0) {
373        FSM1_state  = 6;
374      }
375      break;
376
377    case 4:
378      FSM1_state = 5;
379      if (FSM0_L == 0) {
380        FSM1_state = 6;
381      }
382      break;
383
384    case 5:
385      if (FSM1_E_time == 1) {
386        FSM1_state = 2;
387      }
388      if (FSM0_L == 0) {
389        FSM1_state = 6;
390      }
391      break;
392
393    case 6:
394      FSM1_state = 1;
395      break;
396
397    default:
398      FSM1_state  = 1;
399      break;
400  }
401}
402
403void FSM1_output()
404{
405
406  switch  (FSM1_state)
407  {
408    case 1:
409      break;
410
411    case 2:
412      digitalWrite(FSM1_L_pin,  HIGH);
413      FSM1_ts = millis();
414      break;
415
416    case 3:
417      break;
418
419    case 4:
420      digitalWrite(FSM1_L_pin, LOW);
421      FSM1_ts = millis();
422      break;
423
424    case 5:
425      break;
426
427    case 6:
428      digitalWrite(FSM1_L_pin,  LOW);
429      break;
430
431    default:
432      break;
433
434  }
435}
436
437void  FSM2_next_state(int FSM2_E_time, int Hhum, int Hdesum, int H)
438{
439  switch (FSM2_state)
440  {
441    case 1:
442      if (Hhum == 1) {
443        FSM2_state = 3;
444      }
445      else if (Hdesum == 1) {
446        FSM2_state = 2;
447      }
448      else
449        FSM2_state = 1;
450      break;
451
452    case 2:
453      if (H==0)
454      {
455        FSM2_state = 4;
456      }
457      break;
458
459    case 3:
460      if (H==1) {
461        FSM2_state = 5;
462      }
463      break;
464
465    case 4:
466      if (FSM2_E_time == 1) {
467        FSM2_state = 1;
468      }
469      break;
470
471    case 5:
472      if (FSM2_E_time == 1) {
473        FSM2_state  = 1;
474      }
475      break;
476
477    default:
478      break;
479  }
480}
481void  FSM2_output()
482{
483  switch (FSM2_state)
484  {
485    case 1:
486      digitalWrite(Desum_pin,  LOW);
487      digitalWrite(Humid_pin, LOW);
488      break;
489
490    case 2:
491      digitalWrite(Desum_pin, HIGH);
492      digitalWrite(Humid_pin, LOW);
493      FSM2_L = 1;
494      FSM2_ts = millis();
495      break;
496
497    case 3:
498      digitalWrite(Desum_pin, LOW);
499      digitalWrite(Humid_pin, HIGH);
500      FSM2_L = 1;
501      FSM2_ts = millis();
502      break;
503
504    case 4:
505      digitalWrite(Desum_pin, LOW);
506      digitalWrite(Humid_pin, LOW);
507      FSM2_L  = 0;
508      break;
509
510    case 5:
511      digitalWrite(Desum_pin, LOW);
512      digitalWrite(Humid_pin, LOW);
513      FSM2_L = 0;
514      break;
515
516    default:
517      break;
518  }
519}
520
521void FSM3_next_state(int FSM3_E_time,  int FSM2_L)
522{
523  switch (FSM3_state)
524  {
525    case 1:
526      if (FSM2_L  == 1) {
527        FSM3_state = 2;
528      }
529      break;
530
531    case 2:
532      FSM3_state = 3;
533      if (FSM2_L == 0) {
534        FSM3_state = 6;
535      }
536
537    case 3:
538      if (FSM3_E_time == 1) {
539        FSM3_state  = 4;
540      }
541      if (FSM2_L == 0) {
542        FSM3_state = 6;
543      }
544      break;
545
546    case 4:
547      FSM3_state = 5;
548      if (FSM2_L ==  0) {
549        FSM3_state = 6;
550      }
551      break;
552
553    case 5:
554      if (FSM3_E_time == 1) {
555        FSM3_state = 2;
556      }
557      if  (FSM2_L == 0) {
558        FSM3_state = 6;
559      }
560      break;
561
562    case  6:
563      FSM3_state = 1;
564      break;
565
566    default:
567      FSM3_state  = 1;
568      break;
569  }
570}
571
572void FSM3_output()
573{
574
575  switch  (FSM3_state)
576  {
577    case 1:
578      break;
579
580    case 2:
581      digitalWrite(FSM3_L_pin,  HIGH);
582      FSM3_ts = millis();
583      break;
584
585    case 3:
586      break;
587
588    case 4:
589      digitalWrite(FSM3_L_pin, LOW);
590      FSM3_ts = millis();
591      break;
592
593    case 5:
594      break;
595
596    case 6:
597      digitalWrite(FSM3_L_pin,  LOW);
598      break;
599
600    default:
601      break;
602
603  }
604}
605

//  Autoria do projeto: Vasco Correia
//  Data de execuo: Abril de  2018 - verso 00
//  Controlo de humidade e temperatura de um espao a climatizar
//  Garantir os nveis ideais de humidade e temperatura no ar
//  Sistemas autnomos  de controlo das cargas sensveis e latentes do ar
//  Projeto baseado em mquinas  de estado finitas

// Bibliotecas
#include <DS3231.h> // biblioteca para  o relgio em tempo real
#include <LiquidCrystal_I2C.h>  // biblioteca para comunicao  I2C com o display de 20x4
#include<dht.h> // biblioteca relativa ao sensor DHT11  - sensor de T e HR do ar
dht DHT;

#define DHT11_PIN 7    // Definido o  pino n 7 para o sensor de HR e Temperatura ambiente do espao a climatizar
#define  HoldTime 10000   // Aguardar 10 segundos antes de ir para o estado inicial
#define  HoldTime2 5000   // Aguardar 5 segundos antes de ir para o estado inicial
#define  FSM1_L_pin 6        // Luz intermitente aquando o aquecimento ou o arrefecimento  do espao a climatizar - FSM1
#define Vent_pin 5          // Ventilao ON - led  verde
#define Aquec_pin 2         // Aquecimento ON - led vermelho
#define  Arref_pin 3         // Arrefecimento ON - led azul
#define FSM3_L_pin 4        //  Luz Amarelo torrado intermitente aquando a desumidificao ou humidificao do espao  a climatizar - FSM3
#define Desum_pin 8         // Desumidificao ON - led azul
#define  Humid_pin 9         // Desumidificao ON - led brilhante incolor

//  Comunicao  IC2 utilizando o display LCD 4x20
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5,  6, 7, 3, POSITIVE);
//  Clock externo
DS3231  rtc(SDA, SCL);

//Declarao  dos OUTPUTS como variveis globais das mquinas de estados
static int FSM0_state  = 1;   // estado incial - controlo da climatizao do espao - afeta a carga sensvel
static  int FSM1_state = 1;   // estado incial - led amarelo a piscar aquando o aquecimento  ou arrefecimento do espao a climatizar
static int FSM2_state = 1;   // estado  inicial - controlo da carga latente no espao a climatizar
static int FSM3_state  = 1;   // estado incial - led brilhante a piscar aquando a desumidificao e humidificao  do espao a climatizar
static int FSM0_L = 0;  // estmulo da mquina de estados  do led amarelo a piscar FSM1
static int FSM2_L = 0;  // estmulo da mquina de  estados do led laranja a piscar FSM3

static  int Taquec;   // estmulo para  acionar o aquecimento
static  int Tarref;   // estmulo para acionar o arrefecimento
static  int T;   // estmulo para as temperaturas intermdias para o estado 2 e 3 da FSM0

static  int Hhum;   // estmulo para acionar a humidificao
static int Hdesum;   // estmulo  para acionar a desumidificao
static int H;   // estmulo para a HR  nos estados  2 e 3 da FSM2

static unsigned long FSM0_ts; // guarda o tempo atual para  a FSM0
static unsigned long FSM1_ts; // guarda o tempo atual para a FSM1
static  unsigned long FSM2_ts; // guarda o tempo atual para a FSM2
static unsigned long  FSM3_ts; // guarda o tempo atual para a FSM3

void setup()
{
  pinMode(Vent_pin,  OUTPUT);
  pinMode(Aquec_pin, OUTPUT);
  pinMode(Arref_pin, OUTPUT);
  pinMode(DHT11_PIN,  INPUT);
  pinMode(FSM1_L_pin, OUTPUT);
  pinMode(Desum_pin, OUTPUT);
  pinMode(Humid_pin,  OUTPUT);
  pinMode(FSM3_L_pin, OUTPUT);

  Serial.begin(9600);
  lcd.begin(20,  4);
  lcd.setCursor(0, 0);
  rtc.begin();

  //Descomente as linhas  para configurar o horrio atual (upload), aps o processo comente e faa o upload novamente  para o Arduino
  //rtc.setDOW(TUESDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(21,18, 0);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(10,04,2018);

}

void  loop()
{
  int chk = DHT.read11(DHT11_PIN);
  int FSM0_E_time;
  int  FSM1_E_time;
  int FSM2_E_time;
  int FSM3_E_time;
  int Vent;
  int  Aquec;
  int Arref;
  int Desum;
  int Humid;
  int FMS1_L;
  int  FSM3_L;


  Vent = digitalRead(Vent_pin);
  Aquec = digitalRead(Aquec_pin);
  Arref = digitalRead(Arref_pin);
  Desum = digitalRead(Desum_pin);
  Humid  = digitalRead(Humid_pin);

  if (millis() - FSM0_ts > HoldTime)
  {
    FSM0_E_time = 1;
  } else {
    FSM0_E_time = 0;
  }


  if  (DHT.temperature <= 20) {
    Taquec = 1;
  }
  else
  {
    Taquec  = 0;
  }


  if (DHT.temperature >= 24) {
    Tarref = 1;
  }
  else
  {
    Tarref = 0;
  }

  if (DHT.temperature > 22) {
    T = 1;
  }
  else
  {
    T = 0;
  }
  FSM0(FSM0_E_time, Taquec,  Tarref, T);


  int LedOnOffTime = 750;
  if (millis() - FSM1_ts > LedOnOffTime)  {
    FSM1_E_time = 1;
  } else {
    FSM1_E_time = 0;
  }
  FSM1(FSM1_E_time,  FSM0_L);

  if (millis() - FSM2_ts > HoldTime2)
  {
    FSM2_E_time  = 1;
  } else {
    FSM2_E_time = 0;
  }

  if (DHT.humidity <= 40)  {
    Hhum = 1;
  }
  else
  {
    Hhum = 0;
  }


  if  (DHT.humidity >= 60) {
    Hdesum = 1;
  }
  else
  {
    Hdesum  = 0;
  }

  if (DHT.humidity > 50) {
    H = 1;
  }
  else
  {
    H = 0;
  }
  FSM2(FSM2_E_time, Hhum, Hdesum, H);


  int  LedOnOffTime3 = 500;
  if (millis() - FSM3_ts > LedOnOffTime3) {
    FSM3_E_time  = 1;
  } else {
    FSM3_E_time = 0;
  }
  FSM3(FSM3_E_time, FSM2_L);




}

//  FSM0 sub arquitetura
void FSM0(int FSM0_E_time, int Taquec, int Tarref, int T)
{
  FSM0_next_state(FSM0_E_time, Taquec, Tarref, T);
  FSM0_output();
}

//  FSM1 sub arquitetura
void FSM1(int FSM1_E_time, int FSM0_L)
{
  FSM1_next_state(FSM1_E_time,  FSM0_L);
  FSM1_output();
}

// FSM2 sub arquitetura
void FSM2(int  FSM2_E_time, int Hhum, int Hdesum, int H)
{
  FSM2_next_state(FSM2_E_time,  Hhum, Hdesum, H);
  FSM2_output();
}

// FSM3 sub arquitetura
void  FSM3(int FSM3_E_time, int FSM2_L)
{
  FSM3_next_state(FSM3_E_time, FSM2_L);
  FSM3_output();
}


void FSM0_next_state(int FSM0_E_time, int Taquec,  int Tarref, int T)
{
  switch (FSM0_state)
  {
    case 1:
      if  (Taquec == 1) {
        FSM0_state = 3;
      }
      else if (Tarref ==  1) {
        FSM0_state = 2;
      }
      else
        FSM0_state =  1;
      break;

    case 2:
      if (T == 0)
      {
        FSM0_state  = 4;
      }
      else
        FSM0_state = 2;
      break;

    case 3:
      if (T == 1)
      {
        FSM0_state = 5;
      }
      else
        FSM0_state = 3;
      break;

    case 4:
      if  (FSM0_E_time == 1) {
        FSM0_state = 1;
      }
      break;

    case 5:
      if (FSM0_E_time == 1) {
        FSM0_state = 1;
      }
      break;

    default:
      break;

  }
  Serial.print("Temperatura  = ");
  Serial.print(DHT.temperature);
  Serial.print(" C");
  Serial.println("  ");
  Serial.print("FSM0_state: ");
  Serial.println(FSM0_state);
  Serial.print("FSM1_state:  ");
  Serial.println(FSM1_state);
  Serial.print("FSM2_state: ");
  Serial.println(FSM2_state);
  Serial.print("FSM3_state: ");
  Serial.println(FSM3_state);
  Serial.print("HR  = ");
  Serial.print(DHT.humidity);
  Serial.println(" %");
  Serial.println("  ");

  lcd.setCursor(0, 1);
  lcd.print(rtc.getTimeStr());
  lcd.setCursor(10,  1);
  lcd.print(rtc.getDOWStr());
  lcd.setCursor(10, 0);
  lcd.print(rtc.getDateStr());
  lcd.setCursor(0, 4);
  lcd.print("T=");
  lcd.setCursor(2, 4);
  lcd.print(DHT.temperature);
  lcd.setCursor(6, 4);
  lcd.print(" C");
  lcd.setCursor(13, 4);
  lcd.print("HR=");
  lcd.setCursor(16, 4);
  lcd.print(DHT.humidity);
  lcd.setCursor(18, 4);
  lcd.print(" %");
  lcd.setCursor(0, 0);
  lcd.print("UALG-EEE");
  //lcd.setCursor(0,0);
  //lcd.print("  ");

  delay(500);
}

void  FSM0_output()
{
  switch (FSM0_state)
  {
    case 1:
      digitalWrite(Vent_pin,  HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin, LOW);
      break;

    case 2:
      digitalWrite(Vent_pin, HIGH);
      digitalWrite(Aquec_pin,  LOW);
      digitalWrite(Arref_pin, HIGH);
      FSM0_L = 1;
      FSM0_ts  = millis();
      break;

    case 3:
      digitalWrite(Vent_pin, HIGH);
      digitalWrite(Aquec_pin, HIGH);
      digitalWrite(Arref_pin, LOW);
      FSM0_L = 1;
      FSM0_ts = millis();
      break;

    case 4:
      digitalWrite(Vent_pin, HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin,  LOW);
      FSM0_L = 0;
      break;

    case 5:
      digitalWrite(Vent_pin,  HIGH);
      digitalWrite(Aquec_pin, LOW);
      digitalWrite(Arref_pin, LOW);
      FSM0_L = 0;
      break;

    default:
      break;
  }
}

void  FSM1_next_state(int FSM1_E_time, int FSM0_L)
{
  switch (FSM1_state)
  {
    case 1:
      if (FSM0_L == 1) {
        FSM1_state = 2;
      }
      break;

    case 2:
      FSM1_state = 3;
      if (FSM0_L ==  0) {
        FSM1_state = 6;
      }

    case 3:
      if (FSM1_E_time  == 1) {
        FSM1_state = 4;
      }
      if (FSM0_L == 0) {
        FSM1_state  = 6;
      }
      break;

    case 4:
      FSM1_state = 5;
      if (FSM0_L == 0) {
        FSM1_state = 6;
      }
      break;

    case 5:
      if (FSM1_E_time == 1) {
        FSM1_state = 2;
      }
      if (FSM0_L == 0) {
        FSM1_state = 6;
      }
      break;

    case 6:
      FSM1_state = 1;
      break;

    default:
      FSM1_state  = 1;
      break;
  }
}

void FSM1_output()
{

  switch  (FSM1_state)
  {
    case 1:
      break;

    case 2:
      digitalWrite(FSM1_L_pin,  HIGH);
      FSM1_ts = millis();
      break;

    case 3:
      break;

    case 4:
      digitalWrite(FSM1_L_pin, LOW);
      FSM1_ts = millis();
      break;

    case 5:
      break;

    case 6:
      digitalWrite(FSM1_L_pin,  LOW);
      break;

    default:
      break;

  }
}

void  FSM2_next_state(int FSM2_E_time, int Hhum, int Hdesum, int H)
{
  switch (FSM2_state)
  {
    case 1:
      if (Hhum == 1) {
        FSM2_state = 3;
      }
      else if (Hdesum == 1) {
        FSM2_state = 2;
      }
      else
        FSM2_state = 1;
      break;

    case 2:
      if (H==0)
      {
        FSM2_state = 4;
      }
      break;

    case 3:
      if (H==1) {
        FSM2_state = 5;
      }
      break;

    case 4:
      if (FSM2_E_time == 1) {
        FSM2_state = 1;
      }
      break;

    case 5:
      if (FSM2_E_time == 1) {
        FSM2_state  = 1;
      }
      break;

    default:
      break;
  }
}
void  FSM2_output()
{
  switch (FSM2_state)
  {
    case 1:
      digitalWrite(Desum_pin,  LOW);
      digitalWrite(Humid_pin, LOW);
      break;

    case 2:
      digitalWrite(Desum_pin, HIGH);
      digitalWrite(Humid_pin, LOW);
      FSM2_L = 1;
      FSM2_ts = millis();
      break;

    case 3:
      digitalWrite(Desum_pin, LOW);
      digitalWrite(Humid_pin, HIGH);
      FSM2_L = 1;
      FSM2_ts = millis();
      break;

    case 4:
      digitalWrite(Desum_pin, LOW);
      digitalWrite(Humid_pin, LOW);
      FSM2_L  = 0;
      break;

    case 5:
      digitalWrite(Desum_pin, LOW);
      digitalWrite(Humid_pin, LOW);
      FSM2_L = 0;
      break;

    default:
      break;
  }
}

void FSM3_next_state(int FSM3_E_time,  int FSM2_L)
{
  switch (FSM3_state)
  {
    case 1:
      if (FSM2_L  == 1) {
        FSM3_state = 2;
      }
      break;

    case 2:
      FSM3_state = 3;
      if (FSM2_L == 0) {
        FSM3_state = 6;
      }

    case 3:
      if (FSM3_E_time == 1) {
        FSM3_state  = 4;
      }
      if (FSM2_L == 0) {
        FSM3_state = 6;
      }
      break;

    case 4:
      FSM3_state = 5;
      if (FSM2_L ==  0) {
        FSM3_state = 6;
      }
      break;

    case 5:
      if (FSM3_E_time == 1) {
        FSM3_state = 2;
      }
      if  (FSM2_L == 0) {
        FSM3_state = 6;
      }
      break;

    case  6:
      FSM3_state = 1;
      break;

    default:
      FSM3_state  = 1;
      break;
  }
}

void FSM3_output()
{

  switch  (FSM3_state)
  {
    case 1:
      break;

    case 2:
      digitalWrite(FSM3_L_pin,  HIGH);
      FSM3_ts = millis();
      break;

    case 3:
      break;

    case 4:
      digitalWrite(FSM3_L_pin, LOW);
      FSM3_ts = millis();
      break;

    case 5:
      break;

    case 6:
      digitalWrite(FSM3_L_pin,  LOW);
      break;

    default:
      break;

  }
}

Downloadable files

Schematics

Connections sensors, led, display and clock on arduino ATMEGA 2560.

Schematics

schematics_fritzing_QEEiMQPjuv.pdf

Schematics

Connections sensors, led, display and clock on arduino ATMEGA 2560.

Schematics

Comments

Only logged in users can leave comments

Correia_VSM

0 Followers

•

0 Projects

Intro