API tools faq
paste
PowerTGS440

Project_Dzialka_v1.6

PowerTGS440
May 23rd, 2021
266
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 40.46 KB | None | 0 0
raw download clone embed print report
  1. // --------------------------------------------------------------------------------------------------------------------------------- //
  2. //
  3. // Projekt   :   Działka Project 1 - Zegar NANO :-) coś z tym badziewiem w szufladzie trzeba zrobić...
  4. // Autor     :   Tomasz Majcher
  5. //
  6. //
  7. // --------------------------------------------------------------------------------------------------------------------------------- //
  8. //
  9. //  wersja 1.6    :   IR - pilot (dla EXPANDER 1)
  10. //  wersja 1.5    :   przepięto DHT-AI, LDR-AI, PIR-AI pod moduly na EXPANDER 2
  11. //  wersja 1.4    :   podpięto moduł 4 przekaźników pod EXPANDER 2
  12. //  wersja 1.3    :   DHT - AI
  13. //  wersja 1.2    :   DHT
  14. //  wersja 1.1    :   LDR - AI
  15. //  wersja 1.0    :   LDR
  16. //  wersja 0.9    :   DIODY (RED,ORANGE,GREEN) dla czujnika PIR
  17. //  wersja 0.8    :   PIR - AI
  18. //  wersja 0.7    :   PIR
  19. //  wersja 0.6    :   zmiana biblioteki PCF8574
  20. //  wersja 0.5    :   relay test ( O.K. ) power 5V 1A
  21. //  wersja 0.4    :   relay test ( fail ) no more power :-)
  22. //  wersja 0.3    :   led & key
  23. //  wersja 0.2    :   wyświetlacz TM1637
  24. //  wersja 0.1    :   zegar RTC
  25. //
  26. // --------------------------------------------------------------------------------------------------------------------------------- //
  27.  
  28.  
  29. #include <virtuabotixRTC.h>             // biblioteka zegar RTC  
  30. #include <TM1637Display.h>              // wyświetlacz TM1637
  31. #include "wiring_shift_mod.h"           // wiring
  32. #include "PCF8574.h"                    // expander'y
  33. #include "DHT.h"
  34. #include "RichUNOIRremote.h"
  35.  
  36. #define SerialSpeed 9600                // serial prędkość
  37. #define SERIAL      false               // serial wyświetl tak (true) / nie (false) (12020/10756Flash, 686/672Ram)
  38. #define RTC_SET     false               // aktualizacja manualna zegara RTC
  39.  
  40. // ----------------- expander'y ------------------------------- //
  41.  
  42. #define exp1_adres    0x20
  43. #define exp2_adres    0x27
  44.  
  45. // ------------------------------------------------------------ //
  46. // ----------------- P I R ------------------------------------ //
  47. // ------------------------------------------------------------ //
  48. //        !!! NANO piny A6 i A7 są tylko analogowe !!!          //
  49. // ------------------------------------------------------------ //
  50. //
  51. //   pirAI_Time   ---> czas auto wyłączenie przekaźnika
  52. //   pirAI_Relay  ---> numer przekaznika podpiętego pod PIR
  53. //   pirPin       ---> pin I/O gdzie wpięty jest czujnik PIR
  54. //
  55.  
  56. #define pirPin A3  
  57. #define pirAI_Time  180000UL
  58. #define pirAI_Relay 0
  59.  
  60. // ------------------------------------------------------------ //
  61. // ----------------- wyswietlacz TM1637 ----------------------- //
  62. //                       Z E G A R                              //
  63. // ------------------------------------------------------------ //
  64.  
  65. #define CLK 2
  66. #define DIO 3
  67.  
  68. // ------------------------------------------------------------ //
  69. // ----------------- wyswietlacz TM1637 ----------------------- //
  70. //                 T E M P E R A T U R A                        //
  71. // ------------------------------------------------------------ //
  72.  
  73. #define CLK_T 12
  74. #define DIO_T 13
  75.  
  76. // ------------------------------------------------------------ //
  77. // ----------------- P I L O T   I R -------------------------- //
  78. // ------------------------------------------------------------ //
  79.  
  80. #define PILOT_PIN 11
  81.  
  82. // ------------------------------------------------------------ //
  83. // ------------ Z N A K I    S P E C J A L N E ---------------- //
  84. // ------------------------------------------------------------ //
  85.  
  86. const uint8_t celsius[] =
  87. {
  88.     SEG_A | SEG_B | SEG_F | SEG_G,  // Stopien
  89.     SEG_A | SEG_D | SEG_E | SEG_F   // C
  90. };
  91.  
  92. const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};  // wszystkie segmenty ON
  93. const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00}; // wszystkie segmenty OFF
  94.  
  95. // ----------------- CZUJNIK LDR ----------------------------- //
  96.  
  97. #define LDR A5
  98. #define ldrAI1_Relay 1
  99. #define ldrAI2_Relay 2
  100. #define ldrAI_Time  300000UL
  101. #define minLight 35
  102. int Oswietlenie;
  103.  
  104. // ----------------- CZUJNIK DHT ----------------------------- //
  105.  
  106. #define DHTTYPE DHT11
  107. #define DHTPIN 7
  108. #define dhtAI_Time 600000UL
  109. #define dhtAI_Relay 3
  110. #define maxTemp 23
  111.  
  112. float temperatura = 0;     // temperatura
  113. float wilgotnosc = 0;      // wilgotnosc
  114.  
  115. // ----------------- SYGNALIZATOR ---------------------------- //
  116.  
  117. #define ORANGE 9
  118. #define GREEN  10
  119. #define RED    8
  120.  
  121. bool OrangeLed = true;    // stan logiczny diody ORANGE
  122.  
  123. // ----------------- panel LED & KEY -------------------------- //
  124.  
  125. #define str_pin   4
  126. #define clk_pin   5
  127. #define dat_pin   6
  128.  
  129. #define CLOCK_TYPE CLOCK_INVERT
  130. #define CLOCK_DELAY_US 1
  131.  
  132. uint8_t przycisk = 0;
  133.  
  134. const uint8_t LED_adres[] = { 0xC1, 0xC3, 0xC5, 0xC7, 0xC9, 0xCB, 0xCD, 0xCF};                   // adresy LED moduły LED & KEY
  135.  
  136. const uint8_t DIGIT_adres[] = { 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE};                 // adresy DIGIT moduły LED & KEY
  137.  
  138.                                 /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
  139. const uint8_t digits[] =      { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };    // cyfry bez kropki
  140.  
  141.                                 /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
  142. const uint8_t digits_dots[] = { 0xBF, 0x86, 0xdb, 0xcf, 0xe6, 0xed, 0xfd, 0x87, 0xff, 0xef };    // cyfry z kropką
  143.  
  144. // ----------------- PRZEKAZNIKI -------------------------- //
  145.  
  146. bool R_Status  [8];        // stan logiczny przekaźników (moduł 8)
  147. bool R_Status2 [4];        // stan logiczny przekaźników (moduł 4)
  148.  
  149. // --------------------------------------------------------------------------------------------------------------------------------- //
  150. // --- O B I E K T Y --------------------------------------------------------------------------------------------------------------- //
  151. // --------------------------------------------------------------------------------------------------------------------------------- //
  152.  
  153.  
  154. virtuabotixRTC myRTC(A0, A1, A2);                         // obiekt myRTC
  155. TM1637Display display  = TM1637Display(CLK, DIO);         // obiekt DISPLAY
  156. TM1637Display display2 = TM1637Display(CLK_T, DIO_T);     // obiekt DISPLAY
  157. PCF8574 expander1(exp1_adres);                            // expander 1                            
  158. PCF8574 expander2(exp2_adres);                            // expander 2
  159. DHT dht(DHTPIN, DHTTYPE);
  160. IRrecv IR(PILOT_PIN);
  161.  
  162. // --------------------------------------------------------------------------------------------------------------------------------- //
  163. // --- Zmienne globalne ------------------------------------------------------------------------------------------------------------ //
  164. // --------------------------------------------------------------------------------------------------------------------------------- //
  165.  
  166. struct RTC
  167. {
  168.     uint8_t   godzina = 0;
  169.     uint8_t   minuta  = 0;
  170.     uint8_t   sekunda = 0;
  171.     uint8_t   dzien_tygodnia = 0;
  172.     uint8_t   dzien = 0;
  173.     uint8_t   miesiac = 0;
  174.     uint16_t  rok = 0;
  175. }
  176. zegar;
  177.  
  178.  
  179. unsigned long aktualnyCzas = 0;    
  180.  
  181. unsigned long zapamietanyCzas1 = 0;    // dla millis
  182. unsigned long roznicaCzasu1 = 0;       // dla millis
  183.  
  184. unsigned long zapamietanyCzas2 = 0;    // dla millis
  185. unsigned long roznicaCzasu2 = 0;       // dla millis
  186.  
  187. unsigned long zapamietanyCzas3 = 0;    // dla millis
  188. unsigned long roznicaCzasu3 = 0;       // dla millis
  189.  
  190. unsigned long zapamietanyCzas4 = 0;    // dla millis
  191. unsigned long roznicaCzasu4 = 0;       // dla millis
  192.  
  193. unsigned long zapamietanyCzas5 = 0;    // dla millis
  194. unsigned long roznicaCzasu5 = 0;       // dla millis
  195.  
  196. bool F_sec = false;                    // sekundnik wyświetlacza TM1637 (:)
  197.  
  198. // --------------------------------------------------------------------------------------------------------------------------------- //
  199. // --- P I R ----------------------------------------------------------------------------------------------------------------------- //
  200. // --------------------------------------------------------------------------------------------------------------------------------- //
  201.  
  202. int                 calibrationTime = 30;
  203. long unsigned int   lowIn;
  204. long unsigned int   pause = 5000;
  205. boolean             lockLow = true;
  206. boolean             takeLowTime;
  207. int                 PIRValue = 0;
  208.  
  209. // --------------------------------------------------------------------------------------------------------------------------------- //
  210. // --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
  211. // --------------------------------------------------------------------------------------------------------------------------------- //
  212.  
  213. void AktualizujCzas()
  214. {
  215.     myRTC.updateTime();                               // pobierz czas z zegara
  216.  
  217.     zegar.godzina         =   myRTC.hours;            // pobierz i zapisz godzinę
  218.     zegar.minuta          =   myRTC.minutes;          // pobierz i zapisz minutę
  219.     zegar.sekunda         =   myRTC.seconds;          // pobierz i zapisz sekundę
  220.     zegar.dzien           =   myRTC.dayofmonth;       // pobierz i zapisz dzień miesiąca
  221.     zegar.dzien_tygodnia  =   myRTC.dayofweek;        // pobierz i zapisz dzień tygodnia
  222.     zegar.miesiac         =   myRTC.month;            // pobierz i zapisz miesiąc
  223.     zegar.rok             =   myRTC.year;             // pobierz i zapisz rok      
  224. }
  225. // --------------------------------------------------------------------------------------------------------------------------------- //
  226. // --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
  227. // --------------------------------------------------------------------------------------------------------------------------------- //
  228.  
  229. void WyswietlCzas()
  230. {
  231.     int clock;
  232.     byte bufor;
  233.  
  234.     bufor = zegar.godzina / 10;       // (HH / 10)    - podziel, wyznacz część całkowitą (dziesiątki) godziny
  235.     clock = 1000 * bufor;             // (Hh * 1000)  - zapisz Hx:xx
  236.  
  237.     bufor = zegar.godzina % 10;       // (HH % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) godziny
  238.     clock = clock + (bufor * 100);    // (hH * 100)   - zapisz xH:xx
  239.  
  240.     bufor = zegar.minuta / 10;        // (MM / 10)    - podziel, wyznacz część całkowitą (dziesiątki) minuty
  241.     clock = clock + (bufor * 10);     // (Mm * 10)    - zapisz xx:Mx
  242.  
  243.     bufor = zegar.minuta % 10;        // (MM % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) minuty
  244.     clock = clock + (bufor * 1);      // (mM * 1)     - zapisz xx:xM
  245.  
  246.     if (F_sec)                                                           // jeśli flaga jest prawdziwa (true)
  247.     {
  248.         display.showNumberDecEx(clock, 0b11100000, true, 4, 0);          // wyświetl dwukropek między godziną a minutą
  249.         F_sec = false;                                                   // przestaw flagę na fałszywą (false)
  250.         if (OrangeLed) digitalWrite(ORANGE, LOW);
  251.     }
  252.     else                                                                 // jeśli flaga jest fałszywa (false)
  253.     {
  254.         display.showNumberDecEx(clock, 0b00000000, true, 4, 0);          // nie wyświetlaj dwukropka między godziną a minutą      
  255.         F_sec = true;                                                    // przestaw flagę na prawdziwą (true)
  256.         if (OrangeLed) digitalWrite(ORANGE, HIGH);
  257.     }
  258. }
  259.  
  260. // --------------------------------------------------------------------------------------------------------------------------------- //
  261. // --- S E T    R T C -------------------------------------------------------------------------------------------------------------- //
  262. // --------------------------------------------------------------------------------------------------------------------------------- //
  263.  
  264. void setRTC()
  265. {
  266.     myRTC.setDS1302Time(0, 36, 9, 1, 17, 5, 2021);
  267. }
  268.  
  269. // --------------------------------------------------------------------------------------------------------------------------------- //
  270. // --- E X P A N D E R   I N I T    1 ---------------------------------------------------------------------------------------------- //
  271. // --------------------------------------------------------------------------------------------------------------------------------- //
  272.  
  273. void ExpanderInit_1()
  274. {
  275.     expander1.begin();
  276.     expander1.pinMode(P0, OUTPUT);
  277.     expander1.pinMode(P1, OUTPUT);
  278.     expander1.pinMode(P2, OUTPUT);
  279.     expander1.pinMode(P3, OUTPUT);
  280.     expander1.pinMode(P4, OUTPUT);
  281.     expander1.pinMode(P5, OUTPUT);
  282.     expander1.pinMode(P6, OUTPUT);
  283.     expander1.pinMode(P7, OUTPUT);    
  284. }
  285.  
  286. // --------------------------------------------------------------------------------------------------------------------------------- //
  287. // --- E X P A N D E R   I N I T    2 ---------------------------------------------------------------------------------------------- //
  288. // --------------------------------------------------------------------------------------------------------------------------------- //
  289.  
  290. void ExpanderInit_2()
  291. {
  292.     expander2.begin();    
  293.     expander2.pinMode(P0, OUTPUT);
  294.     expander2.pinMode(P1, OUTPUT);
  295.     expander2.pinMode(P2, OUTPUT);
  296.     expander2.pinMode(P3, OUTPUT);
  297.     expander2.pinMode(P4, OUTPUT);
  298.     expander2.pinMode(P5, OUTPUT);
  299.     expander2.pinMode(P6, OUTPUT);
  300.     expander2.pinMode(P7, OUTPUT);
  301. }
  302.  
  303. // --------------------------------------------------------------------------------------------------------------------------------- //
  304. // ---P I R   I N I T    ----------------------------------------------------------------------------------------------------------- //
  305. // --------------------------------------------------------------------------------------------------------------------------------- //
  306.  
  307. void PirInit()
  308. {
  309.     pinMode(pirPin, INPUT);        // czujnik ruchu
  310. }
  311.  
  312. // --------------------------------------------------------------------------------------------------------------------------------- //
  313. // --- S E T U P ------------------------------------------------------------------------------------------------------------------- //
  314. // --------------------------------------------------------------------------------------------------------------------------------- //
  315.  
  316. void setup()
  317. {
  318.     #if SERIAL
  319.         Serial.begin(SerialSpeed);
  320.         Serial.print(F("[SETUP] [SERIAL] Serial Speed : "));
  321.         Serial.print(SerialSpeed);
  322.     #endif
  323.  
  324.     pinMode(A0,OUTPUT);                   // RTC Clock -> pin CLK
  325.     pinMode(A1,OUTPUT);                   // RTC Clock -> pin DAT
  326.     pinMode(A2,OUTPUT);                   // RTC Clock -> pin RST
  327.    
  328.     display.clear();
  329.     display.setBrightness(7);  
  330.    
  331.     display2.clear();
  332.     display2.setBrightness(7);  
  333.     display2.setSegments(data);
  334.  
  335.     #if RTC_SET
  336.         setRTC();
  337.     #endif
  338.  
  339.     pinMode(str_pin, OUTPUT);              // digital 4 OUT dla strobe (LED & KEY)
  340.     pinMode(clk_pin, OUTPUT);              // digital 3 OUT dla clock (LED & KEY)
  341.     pinMode(dat_pin, OUTPUT);              // digital 2 OIT dla data (LED & KEY)
  342.        
  343.     sendCommand(0x8f);                     // activate LED & KEY
  344.     reset();                               // reset LED & KEY
  345.  
  346.     flash_LEDKEY();
  347.     flash_LEDKEY();
  348.     flash_LEDKEY();
  349.  
  350.     ExpanderInit_1();                      // inicjuj EXPANDER 1 (adres 0x20)        
  351.     ExpanderInit_2();                      // inicjuj EXPANDER 2 (adres 0x27)
  352.    
  353.     for(byte i = 0; i < 8; i++)
  354.     {
  355.         RelayTurnOff(i);                   // diody i wyświetlacz dla przekaźników OFF
  356.         R_Status[i] = false;               // status przekaźników FALSE ( OFF )
  357.     }
  358.  
  359.     for(byte i = 0; i < 4; i++)
  360.     {
  361.         RelayTurnOff2(i);                  // diody i wyświetlacz dla przekaźników OFF
  362.         R_Status2[i] = false;              // status przekaźników FALSE ( OFF )
  363.     }
  364.  
  365.    
  366.     PirInit();
  367.  
  368.     pinMode(RED, OUTPUT);  
  369.     pinMode(ORANGE, OUTPUT);  
  370.     pinMode(GREEN, OUTPUT);  
  371.  
  372.     dht.begin();                          // moduł DHT      
  373.  
  374.     IR.enableIRIn();                      // pilot IR  
  375.    
  376. }
  377.  
  378. // --------------------------------------------------------------------------------------------------------------------------------- //
  379. // --- L O O P --------------------------------------------------------------------------------------------------------------------- //
  380. // --------------------------------------------------------------------------------------------------------------------------------- //
  381.  
  382. void loop()
  383. {
  384.  
  385.     aktualnyCzas = millis();                                    
  386.  
  387.     roznicaCzasu1 = aktualnyCzas - zapamietanyCzas1;            
  388.     roznicaCzasu2 = aktualnyCzas - zapamietanyCzas2;    
  389.     roznicaCzasu3 = aktualnyCzas - zapamietanyCzas3;    // czujnik PIR
  390.     roznicaCzasu4 = aktualnyCzas - zapamietanyCzas4;    // czujnik LDR
  391.     roznicaCzasu5 = aktualnyCzas - zapamietanyCzas5;    // czujnik DHT
  392.  
  393.     PILOT_update();    
  394.  
  395.     // --- warunek wykonywany co 1 minutę ------------------------------------------------------- //
  396.  
  397.     if (roznicaCzasu2 >= 60000UL)                                 // wykonuj co minutę
  398.     {                                                            
  399.         AktualizujCzas();                                         // zapisz z zegara do struktury
  400.         LDRSensor();                                              // zrób pomiar oświetlenia
  401.         DHTSensor();                                              // zrób pomiar temperatury i wilgotnosci        
  402.         zapamietanyCzas2 = aktualnyCzas;                          // resetuj warunek                    
  403.     }          
  404.  
  405.     // --- warunek wykonywany co 1 sekundę ------------------------------------------------------ //
  406.  
  407.     if (roznicaCzasu1 >= 1000UL)                                 // wykonuj co 1 sekundę
  408.     {  
  409.         WyswietlCzas();                                           // wyświetl czas na TM1637        
  410.         PIRSensor();
  411.         zapamietanyCzas1 = aktualnyCzas;                          // resetuj warunek
  412.     }          
  413.  
  414.     // ------------------------------------------------------------------------------------------ //    
  415.  
  416.     if (roznicaCzasu3 >= pirAI_Time)                              // wejdz po 3 minutach
  417.     {  
  418.         RelayTurnOff2(pirAI_Relay);                                // wyłącz przekaźnik (PIR Time Out)
  419.         OrangeLed = true;
  420.         digitalWrite(RED, LOW);
  421.         digitalWrite(GREEN, LOW);
  422.         zapamietanyCzas3 = aktualnyCzas;                          // resetuj warunek
  423.     }          
  424.  
  425.     // ------------------------------------------------------------------------------------------ //    
  426.  
  427.     if (roznicaCzasu4 >= ldrAI_Time)                              // wejdz po 3 minutach
  428.     {  
  429.         RelayTurnOff2(ldrAI1_Relay);                              // wyłącz przekaźnik (LDR Time Out)        
  430.         RelayTurnOff2(ldrAI2_Relay);                              // wyłącz przekaźnik (LDR Time Out)        
  431.         zapamietanyCzas4 = aktualnyCzas;                          // resetuj warunek
  432.     }          
  433.  
  434.     // ------------------------------------------------------------------------------------------ //    
  435.  
  436.     if (roznicaCzasu5 >= dhtAI_Time)                              // wejdz po 5 minutach
  437.     {  
  438.         RelayTurnOff2(dhtAI_Relay);                               // wyłącz przekaźnik (DHT Time Out)        
  439.         zapamietanyCzas5 = aktualnyCzas;                          // resetuj warunek
  440.     }          
  441.  
  442.     // ------------------------------------------------------------------------------------------ //
  443.  
  444.     przycisk = readButtons();
  445.  
  446.     switch (przycisk)
  447.     {
  448.         case      1   :   RelaySwitch(0);   break;
  449.         case      2   :   RelaySwitch(1);   break;
  450.         case      4   :   RelaySwitch(2);   break;
  451.         case      8   :   RelaySwitch(3);   break;
  452.         case     16   :   RelaySwitch(4);   break;
  453.         case     32   :   RelaySwitch(5);   break;
  454.         case     64   :   RelaySwitch(6);   break;
  455.         case    128   :   RelaySwitch(7);   break;
  456.         default       : break;
  457.  
  458.     }
  459.    
  460.     // ------------------------------------------------------------------------------------------ //
  461. }
  462.  
  463. ///////////////////////////////////////////////////////////////////////////////////////////////
  464. //  RelaySwitch
  465. ///////////////////////////////////////////////////////////////////////////////////////////////
  466.  
  467. void RelaySwitch(byte nr)
  468. {
  469.     if ( R_Status[nr])
  470.     {
  471.         RelayTurnOff(nr);
  472.         R_Status[nr] = false;
  473.     }
  474.     else
  475.     if (!R_Status[nr])
  476.     {
  477.         RelayTurnOn(nr);
  478.         R_Status[nr] = true;
  479.     }
  480. }
  481.  
  482. ///////////////////////////////////////////////////////////////////////////////////////////////
  483. //  RelaySwitch
  484. ///////////////////////////////////////////////////////////////////////////////////////////////
  485.  
  486. void RelaySwitch2(byte nr)
  487. {
  488.     if ( R_Status2[nr])
  489.     {
  490.         RelayTurnOff2(nr);
  491.         R_Status2[nr] = false;
  492.     }
  493.     else
  494.     if (!R_Status2[nr])
  495.     {
  496.         RelayTurnOn2(nr);
  497.         R_Status2[nr] = true;
  498.     }
  499. }
  500.  
  501. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  502. //  *** L E D   &   K E Y   C O M M A N D ***                                                                              //
  503. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  504.  
  505. void sendCommand(uint8_t value)
  506. {
  507.     digitalWrite(str_pin, LOW);
  508.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, value);
  509.     digitalWrite(str_pin, HIGH);
  510. }
  511.  
  512.  
  513. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  514. //   *** R E S E T   L E D   &   K E Y ***                                                                                 //
  515. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  516.  
  517. void reset()
  518. {
  519.     sendCommand(0x40);
  520.     digitalWrite(str_pin, LOW);
  521.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0xc0);       // reset od adresu 0
  522.  
  523.     for (uint8_t i = 0; i < 16; i++)                                                 // petla 16x
  524.     {
  525.         shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x00);   // 8x LED + 8x DIGIT reset
  526.     }
  527.     digitalWrite(str_pin, HIGH);
  528. }
  529.  
  530. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  531. //   *** D E M O   N A   S T A R C I E   A R D U I N O ***                                                                 //
  532. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  533.  
  534. void flash_LEDKEY()          
  535. {
  536.     for (uint8_t i = 0; i < 16; i++)                                   // zapal diody 1-8 z przerwą 100ms
  537.     {
  538.         if (i < 8) setLed(1, i);                                       // zapal diodę na pozycji i jesli i<8
  539.         else setLed(0, i - 8);                                         // zgas diodę na pozycji i jeśli i>8
  540.         delay(100);
  541.     }
  542. }
  543.  
  544. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  545. //   *** Z A P A L   L U B   Z G A Ś   D I O D Ę   N A   L E D   &   K E Y ***                                             //
  546. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  547.  
  548. void setLed(uint8_t flaga, uint8_t adres)
  549. {
  550.     pinMode(dat_pin, OUTPUT);                                                              
  551.     sendCommand(0x44);
  552.     digitalWrite(str_pin, LOW);
  553.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, LED_adres[adres]);
  554.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, flaga);
  555.     digitalWrite(str_pin, HIGH);
  556. }
  557.  
  558. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  559. //  *** O D C Z Y T A J   P R Z Y C I S K   Z    L E D   &   K E Y ***                                                     //
  560. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  561.  
  562. uint8_t readButtons(void)
  563. {
  564.     uint8_t buttons = 0;
  565.     digitalWrite(str_pin, LOW);
  566.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x42);
  567.  
  568.     pinMode(dat_pin, INPUT);
  569.  
  570.     for (uint8_t i = 0; i < 4; i++)
  571.     {
  572.         uint8_t v = shiftInMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US) << i;
  573.         buttons |= v;
  574.     }
  575.  
  576.     pinMode(dat_pin, OUTPUT);
  577.     digitalWrite(str_pin, HIGH);  
  578.     delay(200);
  579.  
  580.     return buttons;                                               // zwróć kod przycisku
  581. }
  582.  
  583. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  584. // ***  W Y Ł Ą C Z   P R Z E K A Ź N I K  ***                                                                             //
  585. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  586.  
  587. void RelayTurnOff(byte adres)
  588. {
  589.     digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
  590.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
  591.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);                  // ustaw 0 (0x3f)
  592.     digitalWrite(str_pin, HIGH);                                                                // zapal OFF na wyświetlaczu
  593.     setLed(0, adres);                                                                           // wyłącz diodę dla przekaźnika
  594.     expander1.digitalWrite(adres, HIGH);                                                        // wyłącz przekaźnik na expander1
  595.     R_Status[adres] = false;                                                                    // ustaw status przekaźnika na OFF
  596. }
  597.  
  598. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  599. // ***  W Y Ł Ą C Z   W S Z Y S T K I E   P R Z E K A Ź N I K  ***                                                         //
  600. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  601.  
  602. void RelayAllOff()
  603. {
  604.     for (byte adres = 0; adres < 8; adres ++)
  605.     {
  606.         digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
  607.         shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
  608.         shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);                  // ustaw 0 (0x3f)
  609.         digitalWrite(str_pin, HIGH);                                                                // zapal OFF na wyświetlaczu
  610.         setLed(0, adres);                                                                           // wyłącz diodę dla przekaźnika
  611.         expander1.digitalWrite(adres, HIGH);                                                        // wyłącz przekaźnik na expander1
  612.         R_Status[adres] = false;                                                                    // ustaw status przekaźnika na OFF
  613.     }
  614. }
  615. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  616. // ***  W Y Ł Ą C Z   P R Z E K A Ź N I K  ***                                                                             //
  617. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  618.  
  619. void RelayTurnOff2(byte adres)
  620. {    
  621.     expander2.digitalWrite(adres, HIGH);                                                        // wyłącz przekaźnik na expander1
  622.     R_Status2[adres] = false;                                                                   // ustaw status przekaźnika na OFF
  623. }
  624.  
  625. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  626. //   *** W Ł Ą C Z   P R Z E K A Ź N I K ***                                                                               //
  627. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  628.  
  629. void RelayTurnOn(byte adres)
  630. {
  631.     digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
  632.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
  633.     shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);                  // ustaw 1 (0x3f)
  634.     digitalWrite(str_pin, HIGH);                                                                // zapal ON na wyświetlaczu
  635.     setLed(1, adres);                                                                           // włącz diodę dla przekaźnika
  636.     expander1.digitalWrite(adres, LOW);                                                         // włącz przekaźnik na expander1
  637.     R_Status[adres] = true;                                                                     // ustaw status przekaźnika na ON
  638. }
  639.  
  640. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  641. //   *** W Ł Ą C Z   P R Z E K A Ź N I K ***                                                                               //
  642. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  643.  
  644. void RelayAllOn()
  645. {
  646.     for(byte adres = 0; adres < 8; adres ++)
  647.     {
  648.         digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
  649.         shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
  650.         shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);                  // ustaw 1 (0x3f)
  651.         digitalWrite(str_pin, HIGH);                                                                // zapal ON na wyświetlaczu
  652.         setLed(1, adres);                                                                           // włącz diodę dla przekaźnika
  653.         expander1.digitalWrite(adres, LOW);                                                         // włącz przekaźnik na expander1
  654.         R_Status[adres] = true;                                                                     // ustaw status przekaźnika na ON
  655.     }
  656. }
  657.  
  658. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  659. //   *** W Ł Ą C Z   P R Z E K A Ź N I K ***                                                                               //
  660. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  661.  
  662. void RelayTurnOn2(byte adres)
  663. {    
  664.     expander2.digitalWrite(adres, LOW);                                                         // włącz przekaźnik na expander1
  665.     R_Status2[adres] = true;                                                                    // ustaw status przekaźnika na ON
  666. }
  667.  
  668. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  669. //   *** P I R   S E N S O R  ***                                                                                          //
  670. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  671.  
  672. void PIRSensor()
  673. {
  674.    if(digitalRead(pirPin) == HIGH)
  675.    {
  676.         if(lockLow)
  677.         {
  678.             PIRValue = 1;
  679.             lockLow = false;
  680.  
  681.             zapamietanyCzas3 = aktualnyCzas;
  682.             RelayTurnOn2(pirAI_Relay);
  683.  
  684.             #if SERIAL
  685.                 Serial.print(F("\n[PIR] Wykryto ruch..."));
  686.             #endif
  687.  
  688.             digitalWrite(RED,LOW);        // wyłącz diodę czerwoną
  689.             digitalWrite(GREEN,HIGH);     // włącz diodę zieloną
  690.             digitalWrite(ORANGE,LOW);     // zgas diode pomaranczowa
  691.  
  692.             OrangeLed = false;            // wylacz syngalizacje czuwania            
  693.          
  694.           delay(50);
  695.       }
  696.  
  697.       takeLowTime = true;
  698.    }
  699.    
  700.    if(digitalRead(pirPin) == LOW)
  701.    {
  702.         if(takeLowTime)
  703.         {
  704.             lowIn = millis();
  705.             takeLowTime = false;
  706.         }
  707.      
  708.         if(!lockLow && millis() - lowIn > pause)
  709.         {
  710.             PIRValue = 0;
  711.             lockLow = true;
  712.  
  713.             #if SERIAL
  714.                 Serial.print(F("\n[PIR} Brak ruchu..."));
  715.             #endif
  716.  
  717.             digitalWrite(RED,HIGH);       // zapal diodę czerwoną
  718.             digitalWrite(GREEN,LOW);      // zgaś diodę zieloną
  719.             digitalWrite(ORANGE,LOW);     // zgas diode pomaranczowa
  720.  
  721.             OrangeLed = false;            // wylacz syngalizacje czuwania
  722.  
  723.             delay(50);            
  724.         }
  725.     }
  726. }
  727.  
  728. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  729. // LDR
  730. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  731.  
  732. void LDRSensor()
  733. {              
  734.       int analog_value = analogRead(LDR);
  735.       Serial.print("\n[LDER] wartość analogowa : ");
  736.       Serial.print(analog_value);
  737.       Oswietlenie = map(analog_value, 0, 1025, 99, 0);         // mapuj odczyt do wartości (0-100) i odwróć wartości  
  738.  
  739.       #if SERIAL
  740.           Serial.print(F("\n[LDR] Oswietlenie [%] "));
  741.           Serial.print(Oswietlenie);
  742.       #endif  
  743.  
  744.       if (Oswietlenie < minLight)                              // jeśli oświetlenie < minLight włącz przekaźnik ldrAI_Relay
  745.       {
  746.             zapamietanyCzas4 = aktualnyCzas;
  747.             RelayTurnOn2(ldrAI1_Relay);                        // wyłącz przekaźnik ldrAI1
  748.             RelayTurnOn2(ldrAI2_Relay);                        // wyłącz przekaźnik ldrAI2
  749.       }
  750. }
  751.  
  752. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  753. // DHT 11
  754. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  755.  
  756. void DHTSensor()
  757. {              
  758.     wilgotnosc   = dht.readHumidity();
  759.     temperatura  = dht.readTemperature();
  760.  
  761.     if ( isnan(wilgotnosc) || isnan(temperatura) )
  762.     {
  763.         #if SERIAL
  764.             Serial.print(F("\n[DHT] Blad odczytu z czujnika DHT11 !"));
  765.         #endif
  766.  
  767.         return;
  768.     }
  769.     else
  770.     {
  771.         #if SERIAL
  772.             Serial.print(F("\n[DHT] Temperatura : "));
  773.             Serial.print(temperatura);
  774.             Serial.print(F(" st.C"));
  775.             Serial.print(F("\n[DHT] Wilgotnosc  : "));
  776.             Serial.print(wilgotnosc);
  777.             Serial.print(F(" %rH"));
  778.         #endif
  779.  
  780.         int temp = temperatura;                                 // zapisz do zmiennej temp (dla wyświetlacza 2)
  781.  
  782.         display2.clear();                                       // wyczysc mały wyświetlacz display2
  783.         display2.showNumberDec(temp, false, 2, 0);              // pokaz temperaturę (2 liczby)
  784.         display2.setSegments(celsius, 2, 2);                    // pokaż *C (2 znaki)
  785.  
  786.         if (temperatura > maxTemp)                              // jeśli temperatura > maxTemp włącz przekaźnik dhtAI_Relay
  787.         {
  788.             zapamietanyCzas5 = aktualnyCzas;                    // uruchom odliczanie
  789.             RelayTurnOn2(dhtAI_Relay);                          // włącz wentylator w altance
  790.         }
  791.     }
  792. }
  793.  
  794. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  795. // PILOT
  796. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  797.  
  798. void PILOT_update()                                        
  799. {                                                          
  800.     unsigned int kod = 99;                                  
  801.     int8_t key = 99;                                        
  802.  
  803.     if (IR.decode())                                        
  804.     {                                                        
  805.         if(IR.isReleased()) kod = IR.keycode;                  
  806.         IR.resume();      
  807.     }                                                                              
  808.  
  809.   // ----------------------------------------------------------------------------------------------------------------- //
  810.  
  811.   switch (kod)                                                
  812.   {                                                            
  813.         case  22:  key = 0; break;                             // 22 to klawisz 0
  814.         case  12:  key = 1; break;                             // 12 to klawisz 1
  815.         case  24:  key = 2; break;                             // 24 to klawisz 2
  816.         case  94:  key = 3; break;                             // 94 to klawisz 3
  817.         case   8:  key = 4; break;                             //  8 to klawisz 4
  818.         case  28:  key = 5; break;                             // 28 to klawisz 5
  819.         case  90:  key = 6; break;                             // 90 to klawisz 6
  820.         case  66:  key = 7; break;                             // 66 to klawisz 7
  821.         case  82:  key = 8; break;                             // 82 to klawisz 8
  822.         case  74:  key = 9; break;                             // 74 to klawisz 9
  823.         case  13:  break;                                      //Serial.println("Press  C");                          
  824.         case  25:  break;                                      //Serial.println("Press  -");
  825.         case  64:  break;                                      //Serial.println("Press  +");
  826.         case  21:  break;                                      //Serial.println("Press  OK");
  827.         case  68:  break;                                      //Serial.println("Press  TEST");
  828.         case  67:  break;                                      //Serial.println("Press  BACK");
  829.         case   7:  key = 20; break;                            // 7 to klawisz w lewo (poprzedni)
  830.         case   9:  key = 21; break;                            // 9 to klawisz w prawo (następny)
  831.         case  69:  break;                                      //Serial.println("Press  ON/OFF");
  832.         case  71:  break;                                      //Serial.println("Press  MENU");  
  833.   }                                                                                              
  834.  
  835.   switch (key)                                                                    
  836.   {                                                                              
  837.       case  0:     RelayAllOff();   break;                      // wyłącz wszystkie przekaźniki EXPANDER 1
  838.       case  1:     RelaySwitch(0);  break;                      // włącz / wyłącz przekaźnik nr. 0
  839.       case  2:     RelaySwitch(1);  break;                      // włącz / wyłącz przekaźnik nr. 1
  840.       case  3:     RelaySwitch(2);  break;                      // włącz / wyłącz przekaźnik nr. 2
  841.       case  4:     RelaySwitch(3);  break;                      // włącz / wyłącz przekaźnik nr. 3
  842.       case  5:     RelaySwitch(4);  break;                      // włącz / wyłącz przekaźnik nr. 4
  843.       case  6:     RelaySwitch(5);  break;                      // włącz / wyłącz przekaźnik nr. 5
  844.       case  7:     RelaySwitch(6);  break;                      // włącz / wyłącz przekaźnik nr. 6
  845.       case  8:     RelaySwitch(7);  break;                      // włącz / wyłącz przekaźnik nr. 7
  846.       case  9:     RelayAllOn();    break;                      // włącz wszystkie przekaźniki EXPANDER 1      
  847.       default:                      break;
  848.   }                                                                  
  849.  
  850. } // --- PILOT_update() KONIEC --------------------------------------------------------------------------------------- //
  851.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!