API tools faq
paste
PowerTGS440

project_00123

PowerTGS440
Nov 14th, 2020
208
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 58.31 KB | None | 0 0
raw download clone embed print report
  1. //  eHome MiniSystem v0.9.4 beta (14.11.2020)
  2. //  by Marcin M. Logic
  3. //  e-mail: [email protected]
  4. //
  5. // dodano w v0.9.3 beta:   poprawa dzialania zegara na 3xLED    
  6. // dodano w v0.9.2 beta:   dodano czujnuk ruchu i zegar                *** pamięć programu 21550 bajtów (70%) + pamięć dynamiczna  747 bajtów (36%) ***
  7. // dodano w v0.9.1 beta:   dostosowywanie LCD pod odliczanie czasu w doł
  8. // dodano w v0.9.0 beta:   modyfikacje odliczania z 4 przyciskow do 2 przyciskow (button1 start/stop, button2 -15min w pętli)
  9. // dodano w v0.8.9 beta:   moduł LED 128x64 + biblioteki ADAFRUIT      *** pamięć programu: 20784 bajtów (67%) + pamięć dynamiczna  673 bajtów (32%) ***      pociągło z biblioteki ADAFRUIT
  10. // dodano w v0.8.8 beta:   optymalizacja +  T-(minuty % 5) 3xLED       *** pamięć programu:  9068 bajtów (29%) + pamięć dynamiczna  443 bajtów (21%) ***      :-) WOOOW, pamięć oszczędzona na max !!!
  11. //
  12. // dodano w v0.8.7 beta:   zmiana INT na uint8_t                       *** pamięć programu: 10000 bajtów (32%) + pamięć dynamiczna  641 bajtów (31%) ***
  13. // dodano w v0.8.6 beta:   optymalizacja pamięci                       *** pamięć programu: 10370 bajtów (33%) + pamięć dynamiczna  646 bajtów (31%) ***
  14. // dodano w v0.8.5 beta:   dostosowywanie wyświetlacza 3x LED 8x8      *** pamięć programu: 11364 bajtów (36%) + pamieć dynamiczna 1002 bajtów (48%) ***
  15. //
  16. // dodano w v0.8.4 beta:   sterowanie countdown (90/75/60/45/30/15 min) stan pamięci (35% : 47%) dla NANO
  17. // dodano w v0.8.3 beta:   countdown gotowy (59.59 to 00.00) na 1 przycisku bez zerowania (32% : 28 %)
  18. // dodano w v0.8.2 beta:   optymalizacja (30% : 29%)
  19. // dodano w v0.8.1 beta:   modyfikacja ZEGARA pod LED&KEY
  20. // dodano w v0.8   beta:   działają ledy, przyciski i wyswietlacz (5,6,7,8) dla przekaznikow
  21. // dodano w v0.7   beta:   LED & KEY (definicje, deklaracje i setup)... dodane funkcje z demo. 32% pamięci programu (9874kb) + 40% pamięci dynamicznej (832 zajęte/1212 wolne)
  22. // dodano w v0.6   beta:   obsługa zegara
  23. // dodano w v0.5   beta:   napis (przekaznik ON/OFF na LED) sprinf + strcat
  24. // dodano w v0.4   beta:   re-deklaracja pinów pod touch (21.10.2020) (23% pamięci programu 7892 bajtów), (34% pamięci dynamicznej 699bajtów)
  25. // dodano w v0.3   beta:   8x8 led (21.10.2020)
  26. // dodano w v0.2   beta:   przekazniki
  27. // dodano w v0.1   beta:   zarys programu - przekazniki, diody na expander, przyciski
  28.  
  29.  
  30. # define WERSJA "v0.9.4 date: 14/11/2020"
  31.  
  32. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  33. // dołączone biblioteki do programu
  34.  
  35. #include "Arduino.h"
  36. //#include "Button.h"
  37. #include "PCF8574.h"
  38. #include "Relay.h"
  39. #include <Wire.h>
  40. #include "MaxMatrix.h"        // 8x8 Matrix
  41. #include <virtuabotixRTC.h>   // zegar
  42. #include "wiring_shift_mod.h"
  43. #include <SPI.h>
  44. #include <Adafruit_GFX.h>
  45. #include <Adafruit_SSD1306.h>
  46.  
  47. // deklaracje dla SSD1306 LED wyświetlacz I2C (SDA na pinie A4, SCL na pinie A5)
  48. #define OLED_RESET     4                  // pin resetu OLED
  49. #define SCREEN_WIDTH 128                  // OLED szerokość
  50. #define SCREEN_HEIGHT 64                  // OLED wysokość
  51. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
  52.  
  53. void LedKey_Czas(int flaga);
  54.  
  55. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  56.  
  57. PROGMEM const unsigned char CH[] = {
  58.   3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
  59.   1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
  60.   3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  61.   5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  62.   4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  63.   5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  64.   5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  65.   1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  66.   3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  67.   3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  68.   5, 8, B10000110, B01000110, B01010000, B01000110, B10000110, // *  smutny
  69.   5, 8, B01000110, B10000110, B10110000, B10000110, B01000110, // +  usmiech
  70.   2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  71.   4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  72.   2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  73.   1, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // / przerobiony na 1 linię dla zegara na 3xLED - pokazuje NIC
  74.   4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  75.   3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  76.   4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  77.   4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  78.   4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  79.   4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  80.   4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  81.   4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  82.   4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  83.   4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  84.   1, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // : przerobiony na 1 linię dla zegara na 3xLED - pokazuje :
  85.   1, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // ;
  86.   3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  87.   3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  88.   3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  89.   4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  90.   5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  91.   4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  92.   4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  93.   4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  94.   4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  95.   4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  96.   4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  97.   4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  98.   4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  99.   3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  100.   4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  101.   4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  102.   4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  103.   5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  104.   5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  105.   4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  106.   4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  107.   4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  108.   4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  109.   4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  110.   5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  111.   4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  112.   5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  113.   5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  114.   5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  115.   5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  116.   4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  117.   2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  118.   4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
  119.   2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  120.   3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
  121.   4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  122.   2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  123.   4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  124.   4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  125.   4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  126.   4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
  127.   4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
  128.   3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  129.   4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  130.   4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  131.   3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  132.   4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  133.   4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  134.   3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  135.   5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  136.   4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  137.   4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  138.   4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  139.   4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  140.   4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  141.   4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
  142.   3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
  143.   4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
  144.   5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
  145.   5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
  146.   5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
  147.   4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
  148.   3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
  149.   3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  150.   1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  151.   3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  152.   4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
  153. };
  154.  
  155. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  156. //
  157. // definicje pinów
  158. //
  159. // piny DIGIAL dla LED & KEY
  160. const uint8_t strobe_pin  = 4;
  161. const uint8_t clock_pin   = 3;
  162. const uint8_t data_pin    = 2;
  163. uint8_t przycisk = 0;
  164.  
  165. // Pin przekazniki
  166. #define RELAY4CH_1   5     // przekaznik 4ch kanał 1 na pin 4
  167. #define RELAY4CH_2   6     // przekaznik 4ch kanał 2 na pin 5
  168. #define RELAY4CH_3   7     // przekaznik 4ch kanał 3 na pin 6
  169. #define RELAY4CH_4   8     // przekaznik 4ch kanał 4 na pin 7
  170.  
  171. // Led & Key
  172. #define CLOCK_TYPE CLOCK_INVERT
  173. #define CLOCK_DELAY_US 1
  174.  
  175. #define czujnik_ruchu 9
  176.  
  177. // matryce LED 8x8 (3x)
  178. uint8_t data = 10;                  // DIN pin of MAX7219 module
  179. uint8_t load = 11;                  // CS pin of MAX7219 module
  180. uint8_t clock = 12;                // CLK pin of MAX7219 module
  181. uint8_t maxInUse = 3;              // how many MAX7219 are connected
  182.  
  183. ////////////////////////////////
  184. // FLAGI
  185. bool flaga_odliczanie = 0;      // flaga odliczanie 0 / nieaktywne - 1 / aktywne
  186.  
  187. MaxMatrix matryca(data, load, clock, maxInUse); // definicja obiektu matryca
  188.  
  189. //const unsigned int c_napisy = 4;          // ile naposów
  190. //char napisy[c_napisy][50] = { "pobawimy sie ?        ", "co robimy ?        ", "kliknij cos !        ","mam moc, wykorzystaj to !        " };
  191. //int ile_napisy = c_napisy;
  192. //int akt_napisy = 0;
  193.  
  194. // zegar
  195. virtuabotixRTC myRTC(A0, A1, A2);         // zegar
  196.  
  197. // inicjalizacja PRZYCISK i PRZEKAZNIK
  198. Relay  przekaznik[4] = { {RELAY4CH_1, true}, {RELAY4CH_2, true}, {RELAY4CH_3, true}, {RELAY4CH_4, true} };      // inicjalizacja 4 przekazników
  199.  
  200. uint8_t LED_adres[] = { 0xC1, 0xC3, 0xC5, 0xC7, 0xC9, 0xCB, 0xCD, 0xCF};                                        // adresy LED moduły LED & KEY
  201.  
  202. uint8_t DIGIT_adres[] = { 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE};                                      // adresy DIGIT moduły LED & KEY
  203.  
  204. /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
  205. uint8_t digits[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };                              // cyfry bez kropki
  206.  
  207. //    0.    1.   2.    3.    4.    5.    6.    7.    8.    9.
  208. uint8_t digits_dots[] = { 0xBF, 0x86, 0xdb, 0xcf, 0xe6, 0xed, 0xfd, 0x87, 0xff, 0xef };                         // cyfry z kropką
  209.  
  210.  
  211. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  212. // ustawienie MILLIS
  213. unsigned long aktualnyCzas = 0;
  214.  
  215. unsigned long zapamietanyCzas1 = 0;    // co 10 sekund - przerwanie millis() dla odświerzania LCD
  216. unsigned long roznicaCzasu1 = 0;       // co 10 sekund - przerwanie millis() dla odświerzania LCD
  217.  
  218. unsigned long zapamietanyCzas2 = 0;    // co 60 sekund - przerwanie millis() dla minutnika czasu rzeczywistego
  219. unsigned long roznicaCzasu2 = 0;       // co 60 sekund - przerwanie millis() dla minutnika czasu rzeczywistego
  220.  
  221. unsigned long zapamietanyCzas3 = 0;    // co 1 sekunde - przerwanie millis() dla sekundnika czasu odliczania (pełzająca dioda + kropka między segmentem 2: 3)
  222. unsigned long roznicaCzasu3 = 0;       // co 1 sekunde - przerwanie millis() dla sekundnika czasu odliczania (pełzająca dioda + kropka między segmentem 2: 3)
  223.  
  224. unsigned long zapamietanyCzas4 = 0;    // co 1 sekunde - przerwanie millis() dla sekundnika czasu rzeczywistego (pełzająca dioda + kropka między segmentem 2 : 3)
  225. unsigned long roznicaCzasu4 = 0;       // co 1 sekunde przerwanie millis() dla sekundnika czasu rzeczywistego (pełzająca dioda + kropka między segmentem 2 : 3)
  226.  
  227. unsigned long zapamietanyCzas5 = 0;    // dla przekaznika czasowego (co minute)
  228. unsigned long roznicaCzasu5 = 0;       // dla przekaznika czasowego (co minute)
  229. bool flaga_przekaznika = 0;            // dla przekaznika czasowego (co minute)
  230.  
  231.  
  232. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  233. // zmienne globalne domyślne (zamiast lokalnych) dla funkcji ODLICZANIE
  234. uint8_t digit_m1 = 9;   // aktywacja na starcie minuty (9x.xx)
  235. uint8_t digit_m2 = 0;   // aktywacja na starcie minuty (x0.xx)
  236. uint8_t digit_s1 = 0;   // aktywacja na starcie sekundy (xx.0x)
  237. uint8_t digit_s2 = 0;   // aktywacja na starcie sekundy (xx.x0)
  238.  
  239. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  240. //
  241. // setup programu
  242.  
  243. void
  244. setup()
  245. {
  246.   for (uint8_t i = 0; i < 4; i++)        // aktywacja przekaźników
  247.   {                                      // start FOR
  248.     przekaznik[i].begin();               // przekaznik[i] start
  249.     przekaznik[i].turnOff();             // przekaznik[i] wyłącz
  250.   }                                      // koniec FOR
  251.  
  252.   // LCD
  253.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);                          // inicjuj wyświetlacz LCD
  254.   display.display();                                                  // przygotuj wyświetlacz LCD
  255.   myRTC.updateTime();                                                 // aktualizacja: zegar RTC
  256.   LCD_pokaz_czas(1,"godz.");                                          // pokaz godzinę z napisem HelloMarcin
  257.   ////// matryce LED 8x8
  258.   matryca.init();                                                     // init: module MAX7219
  259.   matryca.setIntensity(5);                                            // MAX7219 intensywność wyświetlaczy
  260.   matryca.shiftLeft(false, true);                                     // ustaw scroll
  261.   printStringWithShift("+ hello Marcin, system gotowy +      ", 50);  // wyślij tekst na scroll
  262.  
  263.   // ustawienie pinów ANALOGOWYCH jako DIGITAL dla modułu zegar
  264.   pinMode(A0, OUTPUT);
  265.   pinMode(A1, OUTPUT);
  266.   pinMode(A2, OUTPUT);
  267.  
  268.   // ustawienie pinu 2 pod czujnik ruchu
  269.   pinMode(czujnik_ruchu, INPUT);                 //pin 2 jako wejście
  270.  
  271.   //myRTC.setDS1302Time(00, 52, 11, 6, 31, 10, 2020);  // reczne ustawienie czasu sec:minuta:godzina:dzień tygodnia:dzien:miesiac:rok
  272.  
  273.   ///// ustawienie pinów DIGITAL dla LED & KEY
  274.   pinMode(strobe_pin, OUTPUT);                   // digital 4 OUT dla strobe (LED & KEY)
  275.   pinMode(clock_pin, OUTPUT);                    // digital 3 OUT dla clock (LED & KEY)
  276.   pinMode(data_pin, OUTPUT);                     // digital 2 OIT dla data (LED & KEY)
  277.   sendCommand(0x8f);                             // activate LED & KEY
  278.   reset();                                       // reset LED & KEY
  279.   start_LEDKEY2();                               // aktywacja LED&KEY Digit moduł 2
  280.   flash_LEDKEY();                                // mrugnij flash 1-8 LED&KEY na starcie systemu
  281. }
  282. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  283. //
  284. // początek głównej petli sterującej LOOP
  285.  
  286. void loop()
  287. {
  288.   przycisk = readButtons();
  289.   switch (przycisk) {                                                                        // obługa przycisków LED&KEY
  290.   case 1:  {                                                                                 // jeśli zwrócono "1" to przycisk nr. 1
  291.            if (flaga_odliczanie == 1) odliczanie_zakoncz();                                  // jesli odliczanie aktywne przerwij i zeruj        
  292.            else if (flaga_odliczanie == 0) flaga_odliczanie = 1;                             // jesli odliczanie jest wylaczone wlacz odliczanie        
  293.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  294.   case 2:  {                                                                                 // jeśli zwrócona "2" to przycisk nr. 2
  295.            if (flaga_odliczanie == 1) odliczanie_przestaw();                                 // jesli tryb odliczanie jest wlaczony        
  296.            break; }                                                                          // przestawiaj czas o -15min w pętli bez końca
  297.   case 4:  {                                                                                 // jeśli zwrócona "4" to przycisk nr. 3
  298.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  299.   case 8:  {                                                                                 // jeśli zwrócona "8" to przycisk nr. 4
  300.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  301.   case 16: {                                                                                 // jeśli zwrócono "16" to przycisk nr. 5
  302.            RelaySwitch(0);                                                                   // przekaznik nr. 0 (pierwszy z czterech)        
  303.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  304.   case 32: {                                                                                 // jeśli zwrócono "32" to przycisk nr. 5
  305.            RelaySwitch(1);                                                                   // przekaznik nr. 1 (drugi z czterech)        
  306.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  307.   case 64: {                                                                                 // jeśli zwrócono "64" to przycisk nr. 7
  308.            RelaySwitch(2);                                                                   // przekaznik nr. 2 (trzeci z czterech)        
  309.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  310.   case 128:{                                                                                 // jeśli zwrócono "128 to przycisk nr. 8
  311.            RelaySwitch(3);                                                                   // przekaznik nr. 3 (czwarty z czterech)      
  312.            break; }                                                                          // przerwij bezwarunkowo i nie sprawdzaj dalej
  313.   }                                                                                          // KONIEC SWITCH
  314.  
  315.   delay(150);                                                  // małe opóźnienie 100ms
  316.   myRTC.updateTime();                                          // zegar RTC
  317.   aktualnyCzas = millis();                                     // millis() czas rzeczywisty
  318.   roznicaCzasu1 = aktualnyCzas - zapamietanyCzas1;             // dla LCD co 10 sekung
  319.   roznicaCzasu2 = aktualnyCzas - zapamietanyCzas2;             // dla ZEGAR co 1 minute
  320.   roznicaCzasu3 = aktualnyCzas - zapamietanyCzas3;             // dla ODLICZANIE co 1 sekunde
  321.   roznicaCzasu4 = aktualnyCzas - zapamietanyCzas4;             // dla ZEGAR co 1 sekunde
  322.   roznicaCzasu5 = aktualnyCzas - zapamietanyCzas5;             // dla przekaznika uruchamianego z czujnika ruchu
  323.  
  324.  
  325.  
  326.   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  327.   //
  328.   // sprawdzaj co sekundę jeśli flaga odliczanie nie aktywna
  329.   //
  330.   if (roznicaCzasu5 >= 20000UL && flaga_przekaznika == 1)              // jesli wlaczono przekaznik przy wykryciu ruchu
  331.   {
  332.       if(przekaznik[0].getState() == 1) wykryto_ruch(0,0);             // wylacz przekaznik 1 jesli wlaczony a minela minuta od właczenia    
  333.       printStringWithShift("+ AUTO-WYLACZANIE +      ", 10);                  
  334.   }
  335.   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  336.   //
  337.   // sprawdzaj co sekundę jeśli flaga odliczanie nie aktywna
  338.   //
  339.   if (roznicaCzasu4 >= 1000UL && flaga_odliczanie == 0)                 // wykonuj co 1 sekundę
  340.   {                                                                     // start IF
  341.     LedKey_Czas();                                                      // mrugaj kropką na 2 segmencie DIGIT 1
  342.     if (digitalRead(czujnik_ruchu) == HIGH && flaga_przekaznika == 0)   // jesli wykryto ruch a przekaznik wylaczony
  343.     {
  344.         if(przekaznik[0].getState() == 0) wykryto_ruch(1,0);              // jesli przekaznik 1 wyłączony wykonaj wykryto_ruch
  345.         printStringWithShift("+ WYKRYTO CZLOWIEKA +      ", 10);
  346.     }
  347.     zapamietanyCzas4 = aktualnyCzas;                             // resetuj czas na 0 dla sprawdzanie co sekunde
  348.   }                                                              // koniec IF dla time 1000UL
  349.   //
  350.   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  351.   //
  352.   // sprawdzaj co sekunę jeśli flaga odliczanie nie aktywna
  353.   //
  354.   if (roznicaCzasu3 >= 1000UL && flaga_odliczanie == 1)          // wykonuj co 1 sekundę jeśli odliczanie włączone
  355.   {                                                              // start IF
  356.     odliczanie();                                                // wykonaj podprogram odliczanie();    
  357.     zapamietanyCzas3 = aktualnyCzas;                             // resetuj czas na 0 dla sprawdzanie co sekundę
  358.   }                                                              // koniec IF dla time 1000UL
  359.   //
  360.   //
  361.   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  362.   //
  363.   // sprawdzaj co minutę jeśli flaga odliczanie nie aktywna
  364.   //
  365.   if (roznicaCzasu2 >= 60000UL && flaga_odliczanie == 0)        // wykonuj co minutę
  366.   {                                                             // start IF
  367.     LedKey_Czas();                                              // wyświetl czas na LED&KEY
  368.     godzina_sprawdz();                                          // sprawdz ktora godzina i wykonaj zadania wg. czasu
  369.     zapamietanyCzas2 = aktualnyCzas;                            // resetuj czas na 0 dla sprawdzania co minute    
  370.   }  
  371.   //
  372.   //
  373.   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  374.   //
  375.   // sprawdzaj co minutę jeśli flaga odliczanie nie aktywna
  376.   //
  377.   if (roznicaCzasu1 >= 30000UL && flaga_odliczanie == 0)        // wykonuj co 30 sekund
  378.   {                                                             // start IF
  379.     LCD_pokaz_czas(1,"godz.");                                  // LCD_pokaz_czas(1) flaga 1 = Hello Marcin    
  380.     zapamietanyCzas1 = aktualnyCzas;                            // resetuj czas na 0 dla sprawdzania co sekunde
  381.   }                                                             // koniec IF
  382.   // wrzucenie LCD_pokaz_czas co tego millis (co 5 sekund) wymuszone z brakiem synchronizacji (same wyświetlanie) między LCD a LED&KEY
  383.   //
  384.   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  385. }
  386.  
  387. // koniec głównej pętli sterującej LOOP
  388. //
  389. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  390. //
  391. //
  392. void
  393. odliczanie_przestaw()
  394. {
  395.     static uint8_t Tflaga = 0;
  396.  
  397.     switch (Tflaga)
  398.     {
  399.         case 0:
  400.           {
  401.             digit_m1 = 7;
  402.             digit_m2 = 5;  
  403.             Tflaga = 1;          
  404.             break;
  405.           }
  406.         case 1:
  407.           {
  408.             digit_m1 = 6;
  409.             digit_m2 = 0;
  410.             Tflaga = 2;
  411.             break;
  412.           }
  413.         case 2:
  414.           {
  415.             digit_m1 = 4;
  416.             digit_m2 = 5;
  417.             Tflaga = 3;
  418.             break;
  419.           }
  420.         case 3:
  421.           {
  422.             digit_m1 = 3;
  423.             digit_m2 = 0;
  424.             Tflaga = 4;
  425.             break;
  426.           }
  427.         case 4:
  428.           {
  429.             digit_m1 = 1;
  430.             digit_m2 = 5;
  431.             Tflaga = 5;
  432.             break;
  433.           }
  434.         case 5:
  435.           {
  436.             digit_m1 = 9;
  437.             digit_m2 = 0;
  438.             Tflaga = 0;
  439.             break;
  440.           }
  441.     }
  442.     digit_s1 = 0;                      // oszczędność 2 bajtów tu zamiast w IF (//) razem 4 bajty z digit_s2
  443.     digit_s2 = 0;                      // oszczędność 2 bajrów tu zamiast w IF (//) razem 4 bajty z digit_s1    
  444. }
  445.  
  446. void
  447. odliczanie_zakoncz()                                            // przerwij odliczanie i wyzeruj  na 90:00
  448. {
  449.   digit_m1 = 9;   // aktywacja na starcie minuty (5x.xx)
  450.   digit_m2 = 0;   // aktywacja na starcie minuty (x9.xx)
  451.   digit_s1 = 0;   // aktywacja na starcie sekundy (xx.5x)
  452.   digit_s2 = 0;   // aktywacja na starcie sekundy (xx.x9)
  453.   flaga_odliczanie = 0;                                              // flaga odliczanie = FALSE, przerwanie bezwarunkowe
  454. }
  455.  
  456. void odliczanie()
  457. {
  458.   static uint8_t flaga_kropki = 0;
  459.   LedKey_odliczanie(digit_m1, digit_m2, digit_s1, digit_s2);      // wyswietl przed operacjami matematycznymi na wyswietlacz
  460.  
  461.   if (digit_s2 == 0 && digit_s1 == 0 && (digit_m2 % 5) == 0)      // jeśli sekundu 0 i reszta z dzielenia jedności minut = 0
  462.   { // pokaz odliczanie T- co 5minut
  463.     char string_czas[20];                                       // zmienna char czas (wyświetlana na LED)
  464.     char string_minuta1[5];                                     // zmienna do pobranej godziny typu CHAR
  465.     char string_minuta2[5];                                     // zmienna do pobranej minuty typu CHAR
  466.     // sklejanie łańcuchów
  467.     sprintf(string_minuta1, "%d", digit_m1);                    // kopiuj liczbę do tablicy CHAR
  468.     sprintf(string_minuta2, "%d", digit_m2);                    // kopiuj liczbę do tablicy CHAR
  469.     strcpy(string_czas, "Time -");                              // kopiowanie "godzina" do zmiennej string_czas
  470.     strcat(string_czas, string_minuta1);                        // doklejenie godziny (liczby) do  string_czas
  471.     strcat(string_czas, string_minuta2);                        // doklejenie godziny (liczby) do  string_czas
  472.     strcat(string_czas, "                ");                    // doklejenie przestrzeni do string_czas
  473.     printStringWithShift(string_czas, 30);                      // godzina:minuta na LED
  474.   }                                                               // koniec IF
  475.  
  476.  
  477.   if (digit_m1 == 0 && digit_m2 == 0 && digit_s1 == 0 && digit_s2 == 0) // auto przywracanie na 90.00 po dojścia do końca odliczania
  478.   {
  479.     flaga_odliczanie = 0;
  480.     digit_m1 = 9;
  481.     digit_m2 = 0;
  482.     digit_s1 = 0;
  483.     digit_s2 = 0;
  484.   }
  485.  
  486.   if (digit_s2 > 0)                                                          // jesli jedności sekund większe niż 0
  487.   {
  488.     digit_s2--;                                                            // pomniejsz stan o jeden
  489.   }
  490.   else if (digit_s2 == 0 && digit_s1 != 0)                                   // jesli jedności sekund rowne 0
  491.   {
  492.     digit_s2 = 9;                                                          // nowy stan jednosci sekund
  493.     digit_s1 = digit_s1 - 1;                                               // pomniejsz dziesiatki sekund o jeden
  494.   }
  495.   else if (digit_s1 == 0 && digit_s2 == 0)                                   // gdy mamy mamy xx.00
  496.   {
  497.     if (digit_m2 > 0)
  498.     {
  499.       digit_s1 = 5;                                                        // z 0 na 5 dziesiatki sekund
  500.       digit_s2 = 9;                                                        // z 0 na 9 jednosci sekund
  501.       digit_m2 --;                                                         // jednosci minut - 1;
  502.     }
  503.     else if (digit_m2 == 0)
  504.     {
  505.       digit_s1 = 5;
  506.       digit_s2 = 9;
  507.       digit_m2 = 9;
  508.       digit_m1 --;
  509.     }
  510.   }
  511. }
  512. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  513. //
  514. void wykryto_ruch(uint8_t flaga, uint8_t nr_relay)                                             // jesli wykryto ruch lub minal czas
  515. {
  516.     if(flaga)                                                                                  // jesli flaga = 1 to wlacz przekaznik
  517.     {
  518.       if( przekaznik[1].getState() == 0 )                                                       // jesli przekaznik wylaczony
  519.       {
  520.         uint8_t DIGIT_ADDR = DIGIT_adres[4];                                                   // ustal adres
  521.         setLed(0, 4);                                                                          // włącz LED & KEY
  522.         przekaznik[nr_relay].turnOn();                                                         // włącz przekaznik
  523.         sendCommand(0x40);                                                                     // tryb LED&KEY
  524.         digitalWrite(strobe_pin, LOW);                                                         // ustaw tryb na LOW
  525.         shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_ADDR);    // ustaw adres
  526.         shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);          // wyswietl 1 (0x06)
  527.         digitalWrite(strobe_pin, HIGH);                                                        // zapal symbol ON
  528.         flaga_przekaznika = 1;                                                                 // przekaznik wlaczony na fladze
  529.         zapamietanyCzas5 = aktualnyCzas;                                                       // start działania
  530.       }
  531.     }
  532.     else if(flaga==0)                                                                          // jesli flaga = 0 to wylacz przekaznik
  533.     {
  534.         uint8_t DIGIT_ADDR = DIGIT_adres[4];                                                   // ustal adres
  535.         setLed(0, 4);                                                                          // wyłącz LED & KEY
  536.         przekaznik[nr_relay].turnOff();                                                               // wyłącz przekaznik
  537.         sendCommand(0x40);                                                                     // tryb LED&KEY
  538.         digitalWrite(strobe_pin, LOW);                                                         // ustaw tryb na LOW
  539.         shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_ADDR);    // ustaw adres
  540.         shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);          // wyswietl 1 (0x06)
  541.         digitalWrite(strobe_pin, HIGH);                                                        // zapal symbol ON
  542.         flaga_przekaznika = 0;                                                                 // przekaznik wlaczony na fladze
  543.         zapamietanyCzas5 = aktualnyCzas;                                                       // start działania  
  544.     }
  545. }
  546. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  547. void RelaySwitch(uint8_t i)
  548. {
  549.   char string_super[50];                                                                     // bufor dla super napis
  550.   uint8_t DIGIT_ADDR = DIGIT_adres[i + 4];                                                   // ustal adres
  551.   sprintf(string_super, "Przekaznik nr. %d", i + 1);                                         // napis na 3xLED
  552.  
  553.   if (przekaznik[i].getState())                                                              // jeśli przekaznik wlaczony to go wylacz
  554.   { // początek warunku
  555.     setLed(0, i + 4);                                                                      // wyłącz LED & KEY
  556.     przekaznik[i].turnOff();                                                               // wyłącz przekaznik
  557.     strcat(string_super, " OFF       ");                                                   // napis na 3xLED
  558.     sendCommand(0x40);                                                                     // obsługa LED&KEY
  559.     digitalWrite(strobe_pin, LOW);                                                         // pin strobe na OFF
  560.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_ADDR);    // ustaw adres
  561.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);          // ustaw 0 (0x3f)
  562.     digitalWrite(strobe_pin, HIGH);                                                        // wyswietl 0
  563.   }                                                                                          // koniec warunku
  564.   else                                                                                       // jeśli przekaznik wyłączony to go włącz
  565.   { // poczatek warunku
  566.     setLed(1, i + 4);                                                                      // wyłącz LED & KEY
  567.     przekaznik[i].turnOn();                                                                // włącz przekaznik
  568.     strcat(string_super, " ON       ");                                                    // jak wyzej
  569.     sendCommand(0x40);                                                                     // tryb LED&KEY
  570.     digitalWrite(strobe_pin, LOW);                                                         // ustaw tryb na LOW
  571.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_ADDR);    // ustaw adres
  572.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);          // wyswietl 1 (0x06)
  573.     digitalWrite(strobe_pin, HIGH);                                                        // wyswietl 1
  574.   }
  575.  
  576.   printStringWithShift( string_super, 30);                                               // wyślij tekst na scroll
  577. }
  578. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  579. // wyswietl godzine:minute (LED & KEY)
  580. void
  581. LedKey_Czas()
  582. {                                                      // START: LedKey_Czas
  583.   wyswietl_kropke(1, myRTC.hours % 10);                // wyswietl godzinę xH.xx z kropką lub bez kropki (sprawdź statyczną zmienna)
  584.   wyswietl_liczbe(0, myRTC.hours / 10);                // wyswietl godzine Hx.xx      tutaj zamiast w IF (//) 9 bajtów / 26 bajty
  585.   wyswietl_liczbe(2, myRTC.minutes / 10);              // wyswietl minutę  xx.Mx      tutaj zamiast w IF (//) 9 bajtów / 26 bajty
  586.   wyswietl_liczbe(3, myRTC.minutes % 10);              // wyswietl minutę  xx.xM      tutaj zamiast w IF (//) 8 bajtów / 26 bajty  
  587.   sec_LEDKEY();                                        // przesun diodę w prawo (co sekudnę)
  588. }                                                      // KONIEC: LedKey_Czas(int flaga)
  589. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  590. // wyswietl godzine:minute (LED & KEY)
  591. void
  592. LedKey_odliczanie(uint8_t h1, uint8_t h2, uint8_t m1, uint8_t m2) // LED&KEY odliczanie
  593. { // start podprogtamu
  594.   wyswietl_liczbe(0, h1);                   // wyswietl liczbe bez kropki GODZINA (Dx.xx)
  595.   wyswietl_kropke(1, h2);                   // wyswietl liczbe z kropka GODZINA (xD.xx)
  596.   wyswietl_liczbe(2, m1);                   // wyswietl liczbę bez kropki MINUTA (xx.Mx)
  597.   wyswietl_liczbe(3, m2);                   // wyswietl liczbę bez kropki MINUTA (xx.xM)
  598.   sec_LEDKEY();                             // przesun diodę w prawo co sekunę
  599.   LCD_odliczanie(h1,h2,m1,m2);              // wyświetl odliczanie na LCD
  600. }
  601. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  602. // czytaj przycisk, zwrót wartość (LED & KEY)
  603. uint8_t
  604. readButtons(void)
  605. {
  606.   uint8_t buttons = 0;
  607.   digitalWrite(strobe_pin, LOW);
  608.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x42);
  609.  
  610.   pinMode(data_pin, INPUT);
  611.  
  612.   for (uint8_t i = 0; i < 4; i++)
  613.   {
  614.     uint8_t v = shiftInMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US) << i;
  615.     buttons |= v;
  616.   }
  617.  
  618.   pinMode(data_pin, OUTPUT);
  619.   digitalWrite(strobe_pin, HIGH);
  620.   return buttons;
  621. }
  622. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  623. // zapal diodę lub zgaś (LED & KEY)
  624. void
  625. setLed(uint8_t flaga, uint8_t adres)
  626. {
  627.   pinMode(data_pin, OUTPUT);                                                                  // yy nie wiem czemu znow
  628.   sendCommand(0x44);
  629.   digitalWrite(strobe_pin, LOW);
  630.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, LED_adres[adres]);
  631.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, flaga);
  632.   digitalWrite(strobe_pin, HIGH);
  633. }
  634. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  635. void printString(char* s)
  636. {
  637.   int col = 0;
  638.   byte buffer[10];
  639.   while (*s != 0)
  640.   {
  641.     if (*s < 32) continue;
  642.     char c = *s - 32;
  643.     memcpy_P(buffer, CH + 7*c, 7);
  644.     matryca.writeSprite(col, 0, buffer);
  645.     matryca.setColumn(col + buffer[0], 0);
  646.     col += buffer[0] + 1;
  647.     s++;
  648.   }
  649. }
  650. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  651. // printCharWithShift(char c, int shift_speed)
  652. void
  653. printCharWithShift(char c, int shift_speed) {
  654.   byte buffer[10];
  655.   if (c < 32) return;
  656.   c -= 32;
  657.   memcpy_P(buffer, CH + 7 * c, 7);
  658.   matryca.writeSprite(maxInUse * 8, 0, buffer);
  659.   matryca.setColumn(maxInUse * 8 + buffer[0], 0);
  660.  
  661.   for (int i = 0; i < buffer[0] + 1; i++)
  662.   {
  663.     delay(shift_speed);
  664.     matryca.shiftLeft(false, false);
  665.   }
  666. }
  667. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  668. //
  669. // printStringWithShift(char* s, int shift_speed)
  670. //
  671. void
  672. printStringWithShift(char* s, int shift_speed)
  673. {
  674.   while (*s != 0)
  675.   {
  676.     printCharWithShift(*s, shift_speed);
  677.     s++;
  678.   }
  679. }
  680. // KONIEC: printStringWithShift(char* s, int shift_speed)
  681. //
  682. //
  683. //////////////////////////////////////////////////////////////////////////////////////////
  684. //
  685. // funkcja void sprawdz_godzina()
  686. //
  687. void godzina_sprawdz()
  688. {
  689.     uint8_t godzina = (myRTC.hours / 10) + (myRTC.hours % 10);
  690.  
  691. }
  692. //
  693. /////////////////////////////////////////////////////////////////////////////////////////////
  694. //
  695. //
  696. void
  697. wyswietl_kropke(int pozycja, int liczba)
  698. {
  699.   static uint8_t flaga = 0;   // flaga stanu kropka / bez kropki
  700.  
  701.   char string_czas[15];                                       // zmienna char czas (wyświetlana na LED)
  702.   char string_godzina[4];                                     // zmienna do pobranej godziny typu CHAR
  703.   char string_minuta[4];                                      // zmienna do pobranej minuty typu CHAR
  704.  
  705.   sprintf(string_godzina, "%d", myRTC.hours);                 // kopiuj liczbę do tablicy CHAR
  706.   sprintf(string_minuta, "%d", myRTC.minutes);                // kopiuj liczbę do tablicy CHAR
  707.   strcpy(string_czas, ";");
  708.  
  709.   sendCommand(0x40);      // wyślij komendę
  710.   digitalWrite(strobe_pin, LOW);
  711.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[1]);
  712.  
  713.   if (flaga) // flaga == 1 (liczba bez kropki na segmencie nr. 2
  714.   {
  715.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, digits[liczba]);         // liczba bez kropki
  716.     if(myRTC.hours < 10) strcat(string_czas,"0");               // jesli dzodzina mniejsza niz 10 doklej "0"
  717.     strcat(string_czas, string_godzina);                        // doklejenie godziny (liczby) do  string_czas
  718.     strcat(string_czas, "/");                                   // doklejenie : do string_czas
  719.     if(myRTC.minutes < 10) strcat(string_czas,"0");             // jesli minuty mniejsze niz 10 doklej "0"
  720.     strcat(string_czas, string_minuta);                         // doklejenie godziny (liczby) do  string_czas
  721.     flaga = 0;
  722.   }
  723.   else  // flaga ==0 (liczba z kropka na segmencie nr.2 )
  724.   {
  725.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, digits_dots[liczba]);    // liczba z kropka
  726.     if(myRTC.hours < 10) strcat(string_czas,"0");               // jesli dzodzina mniejsza niz 10 doklej "0"
  727.     strcat(string_czas, string_godzina);                        // doklejenie godziny (liczby) do  string_czas
  728.     strcat(string_czas, ":");                                   // doklejenie : do string_czas
  729.     if(myRTC.minutes < 10) strcat(string_czas,"0");             // jesli minuty mniejsze niz 10 doklej "0"
  730.     strcat(string_czas, string_minuta);                         // doklejenie godziny (liczby) do  string_czas
  731.     flaga = 1;
  732.   }
  733.  
  734.   digitalWrite(strobe_pin, HIGH);
  735.   printString(string_czas);
  736. }
  737. //
  738. //
  739. //
  740. /////////////////////////////////////////////////////////////////////////////////////////////
  741. // wyswietla liczbę na DIGIT (pozycja, liczba)
  742. void
  743. wyswietl_liczbe(uint8_t pozycja, uint8_t liczba)
  744. {
  745.   sendCommand(0x40);
  746.   digitalWrite(strobe_pin, LOW);
  747.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[pozycja]);
  748.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, digits[liczba]);
  749.   digitalWrite(strobe_pin, HIGH);
  750. }
  751. /////////////////////////////////////////////////////////////////////////////////////////////
  752. //
  753. // LED flash motyw
  754. //
  755. void
  756. flash_LEDKEY()                                                     // funkcja Flash LED&KEY
  757. { // start
  758.   for (uint8_t i = 0; i < 16; i++)                                   // zapal diody 1-8 z przerwą 100ms
  759.   { // FOR
  760.     if (i < 8) setLed(1, i);                                   // zapal diodę na pozycji i jesli i<8
  761.     else setLed(0, i - 8);                                     // zgas diodę na pozycji i jeśli i>8
  762.     delay(100);
  763.   }
  764. }
  765. //
  766. //
  767. /////////////////////////////////////////////////////////////////////////////////////////////
  768. //
  769. //
  770. //
  771. void
  772. sec_LEDKEY()                                           // step by step 0,1,2,3 diody
  773. {
  774.   static byte flaga = 0;
  775.   static byte nrled = 0;
  776.  
  777.   if (nrled == 0)         // jesli pierwsza dioda
  778.   {
  779.     setLed(1, nrled);     // zapal diode nr. 1
  780.     nrled++;
  781.     setLed(0, 3);
  782.   }
  783.   else if (nrled > 0 && nrled < 4)
  784.   {
  785.     setLed(0, nrled - 1);
  786.     setLed(1, nrled);
  787.     nrled++;
  788.   }
  789.   else if (nrled == 4) // jesli 4 dioda
  790.   {
  791.     setLed(0, 3);      // zgas 4 diode
  792.     nrled = 0;         // ustaw na diode 1
  793.     setLed(1, nrled);  // zapal diode 1
  794.     nrled++;
  795.   }
  796. }
  797. /////////////////////////////////////////////////////////////////////////////////////////////
  798. // LEDKEY1 LEDKEY2 - uruchamiane przy rozruchu
  799.  
  800. void start_LEDKEY1()                                                                     // pokaz czas na segmencie 1
  801. {
  802.  
  803.  
  804. }
  805. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  806. //
  807. //
  808. //
  809. void
  810. start_LEDKEY2()                                                                                   // mrugaj diodami na starcie tylko BAJER
  811. {                                                                                                 // START
  812.   for(uint8_t adr_tab = 4; adr_tab < 8; adr_tab++)                                                // FOR
  813.   {                                                                                               //
  814.     sendCommand(0x40);                                                                            // obsługa LED&KEY
  815.     digitalWrite(strobe_pin, LOW);                                                                // pin strobe na OFF
  816.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adr_tab]); // 0xc8 - wyswietlacz adr_tab
  817.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);                 // ustaw 0 (0x3f)
  818.     digitalWrite(strobe_pin, HIGH);                                                               // pin strobe na ON
  819.   }                                                                                               // KONIEC FOR
  820. }                                                                                                 // koniec LEDKEY2
  821. //
  822. //
  823. /////////////////////////////////////////////////////////////////////////////////////////////
  824. //
  825. //  LED & KEY funckje startu
  826. //
  827. void
  828. sendCommand(uint8_t value)
  829. {
  830.   digitalWrite(strobe_pin, LOW);
  831.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, value);
  832.   digitalWrite(strobe_pin, HIGH);
  833. }
  834. //
  835. //
  836. /////////////////////////////////////////////////////////////////////////////////////////////
  837. //
  838. //
  839. void
  840. reset()
  841. {
  842.   sendCommand(0x40);
  843.   digitalWrite(strobe_pin, LOW);
  844.   shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0xc0);     // reset od adresu 0
  845.   for (uint8_t i = 0; i < 16; i++)                                                  // petla 16x
  846.   {
  847.     shiftOutMod(data_pin, clock_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x00);   // 8x LED + 8x DIGIT reset
  848.   }
  849.   digitalWrite(strobe_pin, HIGH);
  850. }
  851. //
  852. //
  853. /////////////////////////////////////////////////////////////////////////////////////////////
  854. // wyświetla HELLO MARCIN na LCD
  855. void
  856. nakarm_rybke()                                 // definicja funkcji hello_marcin()
  857. {                                              // START
  858.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  859.   display.setCursor(28, 28);                   // ustaw kursor na x=40 y=28
  860.   display.println(F("NAKARM"));                // przygotuj na x,y napis "HELLO"
  861.   display.setCursor(38,48);                    // ustaw kursor na x=33 y=48
  862.   display.println(F("RYBKE"));                 // przygotuj na x,y napis "MARIN"
  863. }        
  864. /////////////////////////////////////////////////////////////////////////////////////////////
  865. // wyświetla HELLO MARCIN na LCD
  866. void
  867. nakarm_kroliki()                               // definicja funkcji hello_marcin()
  868. {                                              // START
  869.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  870.   display.setCursor(30, 28);                   // ustaw kursor na x=40 y=28
  871.   display.println(F("NAKARM"));                // przygotuj na x,y napis "HELLO"
  872.   display.setCursor(25,48);                    // ustaw kursor na x=33 y=48
  873.   display.println(F("KROLIKI"));               // przygotuj na x,y napis "MARIN"
  874. }        
  875. /////////////////////////////////////////////////////////////////////////////////////////////
  876. // wyświetla HELLO MARCIN na LCD
  877. void
  878. secret_laboratory()                            // definicja funkcji hello_marcin()
  879. {                                              // START
  880.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  881.   display.setCursor(28, 28);                   // ustaw kursor na x=40 y=28
  882.   display.println(F("SECRET"));                // przygotuj na x,y napis "HELLO"
  883.   display.setCursor(5, 48);                    // ustaw kursor na x=33 y=48
  884.   display.println(F("LABORATORY"));            // przygotuj na x,y napis "MARIN"
  885. }        
  886. /////////////////////////////////////////////////////////////////////////////////////////////
  887. // wyświetla HELLO MARCIN na LCD
  888. void
  889. hello_marcin()                                 // definicja funkcji hello_marcin()
  890. {                                              // START
  891.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  892.   display.setCursor(40, 28);                   // ustaw kursor na x=40 y=28
  893.   display.println(F("HELLO"));                 // przygotuj na x,y napis "HELLO"
  894.   display.setCursor(33, 48);                   // ustaw kursor na x=33 y=48
  895.   display.println(F("MARCIN"));                // przygotuj na x,y napis "MARIN"
  896. }                                              // KONIEC
  897. /////////////////////////////////////////////////////////////////////////////////////////////
  898. // wyświetla HELLO MARCIN na LCD
  899. void
  900. male_co_nieco()                                // definicja funkcji hello_marcin()
  901. {                                              // START
  902.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  903.   display.setCursor(40, 28);                   // ustaw kursor na x=40 y=28
  904.   display.println(F("HELLO"));                 // przygotuj na x,y napis "HELLO"
  905.   display.setCursor(33, 48);                   // ustaw kursor na x=33 y=48
  906.   display.println(F("MARCIN"));                // przygotuj na x,y napis "MARIN"
  907. }                                      
  908. /////////////////////////////////////////////////////////////////////////////////////////////
  909. // wyświetla czas na LCD
  910. void
  911. LCD_odliczanie(uint8_t &h1, uint8_t &h2, uint8_t &m1, uint8_t &m2)       // definicja funkcji LCD_odliczanie (na wejściu tylko adresy)
  912. {
  913.   char string_czas[12];                        // tu do sklejania godziny:minuty z pojedynczych wynikow h h m m
  914.   char bufor[4];                               // bufor char
  915.  
  916.   strcpy(string_czas, "time-");                // kopiuj na początek łańcucha string_czas napis "time-"
  917.   sprintf(bufor, "%d",h1);                     // do bufora z h1 (mx.xx)
  918.   strcat(string_czas, bufor);                  // doklej z bufora (h1) do string czas
  919.   sprintf(bufor, "%d",h2);                     // do bufora z h2 (xm.xx)
  920.   strcat(string_czas,bufor);                   // doklej z bufora (h2) do string czas
  921.   strcat(string_czas,":");                     // doklej napis ":"
  922.   sprintf(bufor, "%d",m1);                     // do bufora z m1 (xx.sx)
  923.   strcat(string_czas,bufor);                   // doklej z bufora (m1) do string czas
  924.   sprintf(bufor, "%d",m2);                     // do bufora z m2 (xx.xs)
  925.   strcat(string_czas,bufor);                   // doklej z bufora (m2) do string czas
  926.   display.clearDisplay();                      // wyczyść wyświetlacz
  927.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  928.   display.setTextColor(SSD1306_WHITE);         // ustaw kolor
  929.   display.setCursor(5, 0);                     // ustaw kursor
  930.   display.println(string_czas);                // ustaw czas na zółtym module
  931.  
  932.   switch (h1)                                  // switch do odliczania
  933.   {                                            // SWITCH START
  934.   case 9: {                                    // jeśli 90 min wyświetl NULL
  935.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE
  936.           }
  937.  
  938.   case 8: {                                    // jeśli 80 min wyswietl
  939.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  940.           else                                 // żeby było szybciej
  941.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  942.           break;
  943.           }  
  944.  
  945.   case 7: {                                    // jesli 70 min wyswietl
  946.           if(h2>5) nakarm_kroliki();           // NAKARM KROLIKI
  947.           else                                 // żeby było szybciej
  948.           if(h2<=5) nakarm_rybke();            // NAKARM RYBKĘ        
  949.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  950.           }
  951.  
  952.   case 6: {                                    // jeśli 60 min wyswietl
  953.           if(h2>5) nakarm_kroliki();           // NAKARM KROLIKI
  954.           else                                 // żeby było szybciej
  955.           if(h2<=5) nakarm_rybke();            // NAKARM RYBKĘ        
  956.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  957.           }
  958.  
  959.   case 5: {
  960.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  961.           else                                 // żeby było szybciej
  962.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  963.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  964.           }
  965.  
  966.   case 4: {
  967.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  968.           else                                 // żeby było szybciej
  969.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  970.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  971.           }
  972.  
  973.   case 3: {
  974.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  975.           else                                 // żeby było szybciej
  976.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  977.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  978.           }
  979.  
  980.   case 2: {
  981.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  982.           else                                 // żeby było szybciej
  983.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  984.           break;
  985.           }
  986.  
  987.   case 1: {
  988.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  989.           else                                 // żeby było szybciej
  990.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  991.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  992.           }
  993.  
  994.   case 0: {
  995.           if(h2>5) secret_laboratory();        // SECRET LABORATORY przy większe niz 85 min
  996.           else                                 // żeby było szybciej
  997.           if(h2<=5) hello_marcin();            // HELLO MARCIN przy mniejsze niz 85min
  998.           break;                               // przerwij sprawdzanie dalej SWITCH - CASE      
  999.           }
  1000.   }
  1001.   display.display();                           // pokaz na ekranie    
  1002. }
  1003. /////////////////////////////////////////////////////////////////////////////////////////////
  1004. // wyświetla czas na LCD
  1005. void
  1006. LCD_pokaz_czas(uint8_t flaga, char* str)       // definicja funkcji LCD_pokaz_czas(uint8_t)
  1007. {                                              // START
  1008.   char string_czas[12];                        // tu do sklejania godziny:minuty z pojedynczych wynikow h h m m
  1009.   char bufor[4];                               // bufor char
  1010.   uint8_t dtemp;                               // bufor int  
  1011.  
  1012.   strcpy(string_czas,"");                      // kopiuj na początek łańcucha napis "Time. "
  1013.   strcat(string_czas,str);                     // kopiuj na początek łańcucha napis "Time. "
  1014.  
  1015.   dtemp = myRTC.hours / 10;                    // bez reszty z dzielenia z hours  
  1016.   sprintf(bufor, "%d",dtemp);                  // załaduj do bufora bierzącą godzine Hx.
  1017.   strcat(string_czas,bufor);                   // doklej z bufor do string czas  
  1018.  
  1019.   dtemp = myRTC.hours % 10;                    // reszta z dzielenia z hours  
  1020.   sprintf(bufor, "%d",dtemp);                  // załaduj do bufora bierzącą godzine xH.
  1021.   strcat(string_czas,bufor);                   // doklej z bufor do string czas  
  1022.  
  1023.   strcat(string_czas,":");                     // doklej znak ":" do string czas
  1024.  
  1025.   dtemp = myRTC.minutes / 10;                  // bez reszty z dzielenia z hours  
  1026.   sprintf(bufor, "%d",dtemp);                  // załaduj do bufora bierzącą godzine Hx.
  1027.   strcat(string_czas,bufor);                   // doklej z bufor do string czas  
  1028.  
  1029.   dtemp = myRTC.minutes % 10;                  // reszta z dzielenia z hours  
  1030.   sprintf(bufor, "%d",dtemp);                  // załaduj do bufora bierzącą godzine xH.
  1031.   strcat(string_czas,bufor);                   // doklej z bufor do string czas  
  1032.    
  1033.   display.clearDisplay();                      // wyczyść wyświetlacz
  1034.   display.setTextSize(2);                      // ustaw czcionkę 2x skalowanie domyślnej
  1035.   display.setTextColor(SSD1306_WHITE);         // ustaw kolor
  1036.   display.setCursor(5, 0);                     // ustaw kursor
  1037.   display.println(string_czas);                // ustaw czas na zółtym module
  1038.  
  1039.   switch (flaga)                               // napisy niebieskie w zależności od flagi wejściowej
  1040.   {                                            // start SWITCH
  1041.     case 1 :                                   // jeśli flaga == 1
  1042.               hello_marcin();                  // ustaw hello marcin na niebieskim mudule
  1043.               break;                           // przerwij sprawdzanie flag
  1044.     default:                                   // jeśli flaga domyślna
  1045.               break;                           // przerwij sprawdzanie flag
  1046.   }                                            // koniec SWITCH
  1047.  
  1048.   display.display();                           // pokaz na ekranie
  1049. }
  1050. /////////////////////////////////////////////////////////////////////////////////////////////
  1051.  
  1052.  //display.startscrollright(0x00, 0x0F);
  1053.   //display.stopscroll();
  1054.   //delay(1000);
  1055.   //display.startscrollleft(0x00, 0x0F);
  1056.   //display.startscrolldiagright(0x00, 0x07);
  1057.   //delay(2000);
  1058.   //display.startscrolldiagleft(0x00, 0x07);  
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!