API tools faq
paste
PowerTGS440

mp3_project_ino

PowerTGS440
Feb 17th, 2021
223
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 91.83 KB | None | 0 0
raw download clone embed print report
  1. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  2. // //
  3. // Wiki E-HOME project (2021) start buid : 24.01.2021 //
  4. // autor : Wiki i Marcin
  5. // e-mail: [email protected] //
  6. // //
  7. // v0.2.1 -> wyrzucona biblioteka Timers.h !!! stworzona wlasna obsluga watkow, pilot działa znow jak powinien //
  8. // v0.2 -> budowa programu i klasy obsługującej adresowalne diody RGB //
  9. // v0.1 -> budowa programu i klas obsługujących urządzenia : biblioteki wikiLCD.h, wikiMP3.h, panel.h //
  10. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  11.  
  12. // --- pliki nagłówkowe ---------------------------------------------------------------------------------------------- //
  13. #include <Adafruit_NeoPixel.h>
  14. #ifdef __AVR__
  15. #include <avr/power.h>
  16. #endif
  17.  
  18. #include <LiquidCrystal_I2C.h>
  19. #include <Wire.h>
  20. #include <TM1638.h>
  21. #include <TM1638QYF.h>
  22. #include "RichUNOIRremote.h";
  23. #include "DHT.h"
  24. #include "Arduino.h"
  25. #include "virtuabotixRTC.h"
  26. #include "wikilcd.h"
  27. #include "wikimp3.h"
  28. #include "panel.h"
  29. #include <SoftwareSerial.h>
  30. #include <MD_YX5300.h>
  31. #include <MD_UISwitch.h>
  32. #include "fire.h"
  33. #include "Przekaznik.h" // --- Relay --- klasa obsługi przekaźników -------------------------------------------- //
  34.  
  35. // --- DEFINICJE ----------------------------------------------------------------------------------------------------- //
  36. // --- PRZEKAZNIKI --------------------------------------------------------------------------------------------------- //
  37. #define RELAY1 30 // przekaznik 1 -> PIN 30 ------------------------ //
  38. #define RELAY2 31 // przekaznik 2 -> PIN 31 ------------------------ //
  39. #define RELAY3 32 // przekaznik 3 -> pin 32 ------------------------ //
  40. #define RELAY4 33 // przekaznik 4 -> pin 33 ------------------------ //
  41. #define RELAY5 34 // przekaznik 5 -> pin 34 ------------------------ //
  42. #define RELAY6 35 // przekaznik 6 -> pin 35 ------------------------ //
  43. #define RELAY7 36 // przekaznik 7 -> pin 36 ------------------------ //
  44. #define RELAY8 37 // przekaznik 8 -> pin 37 ------------------------ //
  45. //
  46. #define FOTOREZYSTOR1 A6 // fotorezystor 1 na pinie A6 -------------------- //
  47. #define FOTOREZYSTOR2 A7 // fotorezystor 2 na pinie A7 -------------------- //
  48. //
  49. #define LED1_PIN 4 // RGB na pinie DIGITAL 4 ------------------------ //
  50. #define LED2_PIN 5 // RGB na pinie DIGITAL 5 ------------------------ //
  51. #define LED3_PIN 6 // RGB na pinie DIGITAL 6 ------------------------ //
  52. #define LED4_PIN 7 // RGB na pinie DIGITAL 7 ------------------------ //
  53. //
  54. #define RGB_VU_METER 8 // --- ilość diód RGB dla VU --------------------- //
  55. #define RGB_RAINBOW 16 // --- ilość diód RGB dla RAINOW ----------------- //
  56. //
  57. // jeśli DEBUG_MODE jest TRUE włącza wszystkie debugery bibliotek, jeśli FALSE to je wyłącza ------------------------- //
  58. #define DEBUG_MODE false
  59. #define DEBUG_MAIN false
  60. // --- MP3 ----------------------------------------------------------------------------------------------------------- //
  61. const uint8_t ARDUINO_RX = 18; // connect to TX of MP3 Player module -------------------- //
  62. const uint8_t ARDUINO_TX = 19; // connect to RX of MP3 Player module -------------------- //
  63. SoftwareSerial MP3Stream(ARDUINO_RX, ARDUINO_TX); // MP3 player serial stream for comms -------------------- //
  64. MD_YX5300 mp3(MP3Stream); //
  65. // --- tworzenie obiektów -------------------------------------------------------------------------------------------- //
  66. Adafruit_NeoPixel rgb1P = Adafruit_NeoPixel(16, LED1_PIN, NEO_GRB + NEO_KHZ800);
  67. Adafruit_NeoPixel rgb1L = Adafruit_NeoPixel(16, LED2_PIN, NEO_GRB + NEO_KHZ800);
  68. Adafruit_NeoPixel rgb2L = Adafruit_NeoPixel( 8, LED3_PIN, NEO_GRB + NEO_KHZ800);
  69. Adafruit_NeoPixel rgb2P = Adafruit_NeoPixel( 8, LED4_PIN, NEO_GRB + NEO_KHZ800);
  70. NeoFire fire1(rgb2L);
  71. NeoFire fire2(rgb2P);
  72. NeoFire fire3(rgb1L);
  73. NeoFire fire4(rgb1P);
  74. LiquidCrystal_I2C LCD(0x27, 20, 4); // --- adres i rozmiar wyświetlacza LCD ---------------------------- //
  75. TLCD *lcd = new TLCD; // --- obiekt obsługujący wyświetlacz LCD -------------------------- //
  76. WIKIMP3 wikiMP3(mp3); // --- obiekt obsługujący odtwarzacz MP3 --------------------------- //
  77. virtuabotixRTC CLOCK(A2, A1, A0); // --- zegar - obiekt klasy virtuabotixRTC ------------------------- //
  78. TM1638QYF PANEL(50,51,52); // --- stwórz obiekt mod_KEY ( 16 x przycisków, 2x LCD ) ----------- //
  79. TPANEL *panel = new TPANEL; //
  80. DHT POGODA; // --- sensor pogody ----------------------------------------------- //
  81. IRrecv PILOT(11); // --- obiekt klasy IRrecv do obsługi pilota ----------------------- //
  82. Relay R [8] = { {RELAY1, 1}, {RELAY2, 1}, {RELAY3, 1}, {RELAY4, 1}, //
  83. {RELAY5, 1}, {RELAY6, 1}, {RELAY7, 1}, {RELAY8, 1} }; //
  84. // --- Z M I E N N E G L O B A L N E ------------------------------------------------------------------------------- //
  85. volatile uint_fast8_t czas[6] = { 0,0,0,0,0,0 }; // --- h,h,m,m,s,s -------------------------------------- //
  86. volatile uint_fast16_t data[4] = { 0,0,0,0 }; // --- dzien tygodnia, dzien, miesiac, rok -------------- //
  87. volatile uint_fast8_t godzina = 0; // --- przechowuj tu aktualną godzinę ------------------- //
  88. volatile uint_fast8_t minuta = 0; // --- przechowuj tu aktualną minutę -------------------- //
  89. volatile int_fast8_t temperatura = 0; // --- przechowuj tu temperaturę ------------------------ //
  90. volatile int_fast8_t wilgotnosc = 0; // --- przechowuj tu wilgotność ------------------------- //
  91. volatile int_fast8_t oswietlenie1 = 0; // --- przechowuj tu swiatlo ---------------------------- //
  92. volatile int_fast8_t oswietlenie2 = 0; // --- przechowuj tu swiatlo ---------------------------- //
  93. bool RelayStatus[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; // --- 0 -> OFF, 1 -> ON -------------------------------- //
  94. // --- F L A G I G L O B A L N E ----------------------------------------------------------------------------------- //
  95. bool F_reset_run = true; // --- synchronizacja wątku 5 do pełnej godziny --------- //
  96. // --- bool'e dla LCD ------------------------------------------------------------------------------------------------ //
  97. bool F_music_play = false; // --- tylko dla LCD --- gdy TRUE pokazuje progresBAR --- //
  98. bool F_music_start = false; // --- tylko dla LCD --- gdy TRUE wyświetla statusBAR --- //
  99. bool F_music_stop = false; // --- tylko dla LCD --- gdy TRUE czyści progresBAR ----- //
  100. // --- bool dla Continous MP3 Play ----------------------------------------------------------------------------------- //
  101. bool F_music_auto = false; // --- jeśli TRUE co 1 sekundę kontroluje MP3Playerem --- //
  102. bool F_timer_auto = false; // --- jeśli TRUE co 1 godzinę kontroluje TimeSpekar'em - //
  103. // --- bool dla Continous MP3 Play (paski LED) ----------------------------------------------------------------------- //
  104. bool F_NeoFire_stop = false; // --- jeśli TRUE to wygasza paski LED ------------------ //
  105. bool F_NeoFire_play = false; // --- jeśli TRUE to RGB LED są zajęte, nie można ich --- //
  106. bool step_fire = true; //
  107. // --- używać ------------------------------------------- //
  108. // ------------------------------------------------------------------------------------------------------------------- //
  109. bool F_dataShow = true; // wyswietl datę jeśli nie gra muzyka //
  110. char data_to_lcd[21]; // --- przechowuje tu string do wyswietlenia na LCD---- //
  111. //char msg_bufor [21]; // --- bufor msg -------------------------------------- //
  112. // --- MESSAGE ------- do pamięci PROGMEM ---------------------------------------------------------------------------- //
  113.  
  114. const char msg0[] PROGMEM = " Witaj Wiktoria :-) ";
  115. const char msg1[] PROGMEM = " Uruchomiono: Setup ";
  116. const char msg2[] PROGMEM = " Juz prawie gotowe! ";
  117. const char msg3[] PROGMEM = " .................. ";
  118. const char* const msg[] PROGMEM = {msg0, msg1, msg2, msg3};
  119.  
  120. //
  121. // --- MIESIACE ------- do pamięci PROGMEM --------------------------------------------------------------------------- //
  122. // const char *monthMap[12] = {"styczen","luty","marzec","kwiecien","maj","czerwiec",
  123. // "lipiec","sierpien","wrzesien","pazdziernik","listopad","grudzien"};
  124. // z 2018kbyts pamięci dynamiczne redukcja do 1898kbyts //
  125. // ------------------------------------------------------------------------------------------------------------------- //
  126. //
  127. const char dayMonth00[] PROGMEM = "NULL";
  128. const char dayMonth01[] PROGMEM = "styczen";
  129. const char dayMonth02[] PROGMEM = "luty";
  130. const char dayMonth03[] PROGMEM = "marzec";
  131. const char dayMonth04[] PROGMEM = "kwiecien";
  132. const char dayMonth05[] PROGMEM = "maj";
  133. const char dayMonth06[] PROGMEM = "czerwiec";
  134. const char dayMonth07[] PROGMEM = "lipiec";
  135. const char dayMonth08[] PROGMEM = "sierpien";
  136. const char dayMonth09[] PROGMEM = "wrzesien";
  137. const char dayMonth10[] PROGMEM = "pazdziernik";
  138. const char dayMonth11[] PROGMEM = "listopad";
  139. const char dayMonth12[] PROGMEM = "grudzien";
  140. const char* const month_table[] PROGMEM = {dayMonth00,dayMonth01,dayMonth02,dayMonth03,dayMonth04,dayMonth05,dayMonth06,
  141. dayMonth07,dayMonth08,dayMonth09,dayMonth10,dayMonth11,dayMonth12};
  142. //
  143. // --- DNI TYGODNIA --- do pamięci PROGMEM --------------------------------------------------------------------------- //
  144. //const char *dayMap[14] = {"poniedzialek","wtorek","sroda","czwartek","piatek","sobota","niedziela"}; --- old version
  145. // z 2106bytes pamięci dynamicznej redukcja do 2018 pamięci dynamicznej //
  146. // ------------------------------------------------------------------------------------------------------------------- //
  147. const char dayMap0[] PROGMEM = "NULL";
  148. const char dayMap1[] PROGMEM = "poniedzialek";
  149. const char dayMap2[] PROGMEM = "wtorek";
  150. const char dayMap3[] PROGMEM = "sroda";
  151. const char dayMap4[] PROGMEM = "czwartek";
  152. const char dayMap5[] PROGMEM = "piatek";
  153. const char dayMap6[] PROGMEM = "sobota";
  154. const char dayMap7[] PROGMEM = "niedziela";
  155. const char* const day_table[] PROGMEM = {dayMap0,dayMap1,dayMap2,dayMap3,dayMap4,dayMap5,dayMap6,dayMap7};
  156. //
  157. // -- T H R E A D S O L D S C H O O L : - ) M A D E B Y P O W E R T O M E K ------------------------------- //
  158. unsigned long czasZERO = 0; // --- czas ZERO dla funkcji MILLIS() --------------------------------------------- //
  159. unsigned long czas01SEC = 0; // --- czas01SEC dla sprawdzania co 1 sekundę ------------------------------------- //
  160. unsigned long czas50MSC = 0; // --- czas05SEC dla sprawdzania co 50 ms---- ------------------------------------- //
  161. unsigned long czas10SEC = 0; // --- czas30SEC dla sprawdzania co 30 sekund ------------------------------------- //
  162. unsigned long czas01MIN = 0; // --- czas01MIN dla sprawdzania co 1 minutę -------------------------------------- //
  163. unsigned long czas30SEC = 0; // --- czas05MIN dla sprawdzania co 5 minut --------------------------------------- //
  164. unsigned long czas30MIN = 0; // --- czas30MIN dla sprawdzania co 30 minut -------------------------------------- //
  165. unsigned long czas01HRS = 0; // --- czas01HRS dla sprawdzania co 1 godzine ------------------------------------- //
  166. unsigned long timeout01SEC = 0; // --- timeout dla 1 sekundy ------------------------------------------------------ //
  167. unsigned long timeout50MSC = 0; // --- timeout dla 50 msekundy ---------------------------------------------------- //
  168. unsigned long timeout10SEC = 0; // --- timeout dla 30sekundy ------------------------------------------------------ //
  169. unsigned long timeout01MIN = 0; // --- timeout dla 1 minuty ------------------------------------------------------ //
  170. unsigned long timeout30SEC = 0; // --- timeout dla 5 minuty ------------------------------------------------------ //
  171. unsigned long timeout30MIN = 0; // --- timeout dla 30 minut ------------------------------------------------------ //
  172. unsigned long timeout01HRS = 0; // --- timeout dla 1 godziny ------------------------------------------------------ //
  173. // ------------------------------------------------------------------------------------------------------------------- //
  174. // progressBAR dla wyswietlacza LCD. Czas trwania utworu jest mapowany, 0 to znak pusty, nie wyswietla sie nic, gdy //
  175. // jest jedynka na wyświetlaczu LCD pojawia się znak PEŁNY //
  176. // ------------------------------------------------------------------------------------------------------------------- //
  177. //
  178. volatile uint_fast8_t progressBar[17] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; // progress BAR 16 - segmentów --------- //
  179. //
  180. // --- SETUP & UPDATE CLOCK ---------------------------------------------------------------------------------------------
  181. void CLOCK_init() // --- ustaw godzinę i datę ------------------------------ //
  182. { //
  183. CLOCK.setDS1302Time(00, 17, 15, 7, 24, 01, 2021); // --- reczne ustawienie czasu ss:min:hh:dayw,day,mm,y --- //
  184. #if DEBUG_MAIN
  185. Serial.println(F("Inside: ClockInit(); Dokonano przestawienia czasu "));
  186. #endif
  187. } //
  188. // ------------------------------------------------------------------------------------------------------------------- //
  189. void ClockTimeUpdate() //
  190. { //
  191. CLOCK.updateTime(); // ... aktualizacja czasu rzeczywistego ................... //
  192. czas[0] = CLOCK.hours / 10; //
  193. czas[1] = CLOCK.hours % 10; //
  194. czas[2] = CLOCK.minutes / 10; //
  195. czas[3] = CLOCK.minutes % 10; //
  196. czas[4] = CLOCK.seconds / 10; //
  197. czas[5] = CLOCK.seconds % 10; //
  198. godzina = CLOCK.hours; //
  199. minuta = CLOCK.minutes; //
  200. } //
  201. // ------------------------------------------------------------------------------------------------------------------- //
  202. // zwraca ilość wolnej pamięci RAM ----------------------------------------------------------------------------------- //
  203. // ------------------------------------------------------------------------------------------------------------------- //
  204. unsigned int FreeRam()
  205. {
  206. extern int __heap_start, *__brkval;
  207. unsigned int v;
  208. return (unsigned int)&v - (__brkval == 0 ? (unsigned int)&__heap_start : (unsigned int)__brkval);
  209. }
  210. // ------------------------------------------------------------------------------------------------------------------- //
  211. void TypeWriter(const String & message, unsigned int wait, byte position)
  212. {
  213. LCD.setCursor(0,position);
  214. for (const char c: message)
  215. {
  216. LCD.print(c);
  217. delay(wait);
  218. }
  219. }
  220. //
  221. void LcdArrayCenter(char *text, byte max_size) //
  222. { //
  223. char bufor[24]; // mała rezerwa, bo nie obsługuje błedów :-) ---- //
  224. byte n = strlen(text); //
  225. byte l = (max_size - n) / 2; //
  226. //
  227. if(n<17) // jesli max 16 znakow to cos zrobimy ----------- //
  228. { //
  229. for(int i = 0; i < l - 1; i++ ) //
  230. { //
  231. if(!i) strcpy(bufor, "*"); // jesli krok 0 (i = 0) --- strcpy --- poczatek //
  232. else strcat(bufor, "*"); // jesli krok 1 (i = 1) --- strcat --- dalej //
  233. } //
  234. strcat(bufor, " "); //
  235. strcat(bufor,text); //
  236. strcat(bufor, " "); //
  237. for(int i = 0; i< l -1; i++ ) strcat(bufor,"*"); //
  238. if(n%2) strcat(bufor,"*"); // jesli zostala reszta z dzielenia jeden blok + //
  239. strcpy(data_to_lcd, bufor); // bufor zbudowany, przekopiuj do zmiennej ------ //
  240. } //
  241. else strcpy(data_to_lcd, text); // poza zakresem, tylko przekopiuj -------------- //
  242. } //
  243. // ------------------------------------------------------------------------------------------------------------------- //
  244. // --- D A Y L C D U P D A T E ---------------------------------------------------------------------------------- //
  245. // ------------------------------------------------------------------------------------------------------------------- //
  246. // żeby uniknąć ciągłych i zbędnych obliczeń funkcja została przeniesiona z klasy WIKILCD do programu głównego, jest //
  247. // tylko wywyływana przy starcie systemu i sprawdzana co godzinę czy zmienił się dzień, jeśli tak następuje wejście tu //
  248. // i wygenerowanie w tablilcy data_to_lcd nowego ciągu znaków dzien tygodnia, dzien miesiaca, miesiac, rok //
  249. // ------------------------------------------------------------------------------------------------------------------- //
  250. void DayLcdUpdate() //
  251. { //
  252. char bufor[22]; // bufor lancucha do zbudowania ciagu znakow do wyswietlenia //
  253. strcpy(bufor, "dzis: "); //
  254. strcat_P( bufor, (char*) pgm_read_word ( & (day_table[data[0]] ) ) ); // kopiuj z PROGMEM dzien tygodnia ---- //
  255. //strcat(bufor, dayMap[ data[0]-1] ); // kopiuj do bufora nazwe dnia (z tablicy dayMAP) //
  256. #if DEBUG_MAIN //
  257. Serial.println(F("Inside: DayLcdUpdate(); Zbudowano lancuch data_to_lcd dla wyswietlacza LCD."));
  258. #endif
  259. LcdArrayCenter(bufor, 20); //
  260. } //
  261. // ------------------------------------------------------------------------------------------------------------------- //
  262. void DataLcdUpdate() //
  263. { //
  264. char bufor[25]; // bufor lancucha do zbudowania ciagu znakow do wyswietlenia //
  265. char bufch[4]; // bufor dla sprinf //
  266. //
  267. sprintf(bufch, "%d", data[1] ); // konwersja do bufch //
  268. //
  269. if ( data[1] < 10 ) //
  270. { //
  271. strcpy(bufor, "0"); // jeśli dzien miesiaca mniejszy od 10 doklej liczbę 0 ---------- //
  272. strcat(bufor, bufch); //
  273. } //
  274. else strcpy(bufor, bufch); // na początek, bo więcej niż 9 dni ------------------------------ //
  275. //
  276. strcat(bufor, " ");
  277. strcat_P( bufor, (char*) pgm_read_word ( & (month_table[data[2]] ) ) ); //
  278. strcat(bufor, " "); //
  279. //
  280. sprintf(bufch, "%d", data[3] ); // rok ----------------------------------------------------------- //
  281. strcat(bufor, bufch); //
  282. //
  283. //strcat(bufor, "\0");
  284. #if DEBUG_MAIN
  285. Serial.println(F("Inside: DataLcdUpdate(); Zbudowano lancuch data_to_lcd dla wyswietlacza LCD."));
  286. #endif
  287. LcdArrayCenter(bufor, 20); //
  288. } //
  289. // ------------------------------------------------------------------------------------------------------------------- //
  290. // --- T E M P L C D U P D A T E --------------------------------------------------------------------------------- //
  291. // ------------------------------------------------------------------------------------------------------------------- //
  292. // aktualizator temperatury dla wyświetlacza LCD -> podwójnie buforowany - przechowywane w tej samej tablicy co DATA //
  293. // ------------------------------------------------------------------------------------------------------------------- //
  294. void TempLcdUpdate() //
  295. { //
  296. char bufor[25]; //
  297. char bufch[4]; //
  298. strcpy(bufor,"Temperatura: "); //
  299. sprintf(bufch, "%d", temperatura); //
  300. strcat(bufor, bufch); //
  301. strcat(bufor, " st.C"); //
  302. //strcat(bufor, "\0");
  303. #if DEBUG_MAIN
  304. Serial.println(F("Inside: TempLcdUpdate(); Zbudowano lancuch data_to_lcd dla wyswietlacza LCD."));
  305. #endif //
  306. LcdArrayCenter(bufor, 20); //
  307. } //
  308. // ------------------------------------------------------------------------------------------------------------------- //
  309. // --- H I G R L C D U P D A T E --------------------------------------------------------------------------------- //
  310. // ------------------------------------------------------------------------------------------------------------------- //
  311. // aktualizator wilgotnosci dla wyświetlacza LCD -> podwójnie buforowany - przechowywane w tej samej tablicy co DATA //
  312. // ------------------------------------------------------------------------------------------------------------------- //
  313. void HigrLcdUpdate() //
  314. { //
  315. char bufor[25]; //
  316. char bufch[4]; //
  317. strcpy(bufor,"Wilgotnosc : ");
  318. sprintf(bufch, "%d", wilgotnosc); //
  319. strcat(bufor, bufch); //
  320. strcat(bufor, " %"); //
  321. //strcat(bufor, "\0");
  322. #if DEBUG_MAIN
  323. Serial.println(F("Inside: HigrLcdUpdate(); Zbudowano lancuch data_to_lcd dla wyswietlacza LCD."));
  324. #endif
  325. LcdArrayCenter(bufor, 20); //
  326. } //
  327. // ------------------------------------------------------------------------------------------------------------------- //
  328. // --- L I G H T L C D U P D A T E ------------------------------------------------------------------------------- //
  329. // ------------------------------------------------------------------------------------------------------------------- //
  330. // aktualizator oswietlenia dla wyświetlacza LCD -> podwójnie buforowany - przechowywane w tej samej tablicy co DATA //
  331. // ------------------------------------------------------------------------------------------------------------------- //
  332. void LightLcdUpdate() //
  333. { //
  334. char bufor[25]; //
  335. char bufch[4]; //
  336. strcpy(bufor,"Oswietlenie : "); //
  337. sprintf(bufch, "%d", oswietlenie1); //
  338. strcat(bufor, bufch); //
  339. strcat(bufor, " %"); //
  340. //strcat(bufor, "\0");
  341. #if DEBUG_MAIN
  342. Serial.println(F("Inside: LightLcdUpdate(); Zbudowano lancuch data_to_lcd dla wyswietlacza LCD."));
  343. #endif //
  344. LcdArrayCenter(bufor, 20); //
  345. } //
  346. // ------------------------------------------------------------------------------------------------------------------- //
  347. void ClockDateUpdate() //
  348. { //
  349. CLOCK.updateTime(); // ... aktualizacja czasu rzeczywistego ................... //
  350. data[0] = CLOCK.dayofweek; //
  351. data[1] = CLOCK.dayofmonth; //
  352. data[2] = CLOCK.month; //
  353. data[3] = CLOCK.year; //
  354. #if DEBUG_MAIN
  355. Serial.println(F("Inside: ClockDateUpdate(); Dokonano aktualizacji daty z modulu zegara."));
  356. #endif //
  357. } //
  358. // --- SENSOR UPDATE ------------------------------------------------------------------------------------------------- //
  359. void SensorUpdate() //
  360. { //
  361. int_fast8_t w = POGODA.getHumidity(); // --- wilgotnosc ------------------------------ //
  362. int_fast8_t t = POGODA.getTemperature(); // --- temperatura ----------------------------- //
  363. oswietlenie1 = map(analogRead(FOTOREZYSTOR1), 0, 1023, 99, 0); // --- oswietlenie ----------------------------- //
  364. oswietlenie2 = map(analogRead(FOTOREZYSTOR2), 0, 1023, 99, 0); // --- oswietlenie ----------------------------- //
  365. if(w) wilgotnosc = w; // --- jeśli nie błąd odczytu ------------------ //
  366. if(t) temperatura = t; // --- jeśli nie błąd odczytu ------------------ //
  367. #if DEBUG_MAIN
  368. Serial.println(F("Inside: SensorUpdate(); Wykonano aktualizacje wartosci z sensorow. "));
  369. #endif //
  370. } //
  371. // --- SETUP & INIT NEOPIXEL ----------------------------------------------------------------------------------------- //
  372. void NeoPixelInit() //
  373. { //
  374. rgb1L.begin(); // start dla strip 1 --------------------------- //
  375. rgb1L.setBrightness(20); // set ----------------------------------------- //
  376. rgb1L.show(); // wszystkie pixele wyłącz --------------------- //
  377. //
  378. rgb1P.begin(); // start dla strip 2 --------------------------- //
  379. rgb1P.setBrightness(20); // set ----------------------------------------- //
  380. rgb1P.show(); // wszystkie pixele wyłącz --------------------- //
  381. //
  382. rgb2L.begin(); // start dla strip 3 --------------------------- //
  383. rgb2L.setBrightness(20); // set ----------------------------------------- //
  384. rgb2L.show(); // wszystkie pixele wyłącz --------------------- //
  385. //
  386. rgb2P.begin(); // start dla strip 4 --------------------------- //
  387. rgb2P.setBrightness(20); // set ----------------------------------------- //
  388. rgb2P.show(); // wszystkie pixele wyłącz --------------------- //
  389. // --- jeśli DEBUG_MAIN jest TRUE --- to pokaż na konsolę SERIALA komunikat -------------------------------------- //
  390. #if DEBUG_MAIN
  391. Serial.println(F("Inside: NeoPixelInit(); Wykonano inicjacje NeoPixel !!! "));
  392. #endif //
  393. } //
  394. // --- THREAD MY OLD SCHOOL :-) -------------------------------------------------------------------------------------- //
  395. void MyThread() //
  396. { //
  397. czasZERO = millis(); // --- zapamiętaj pod zmienną czasZERO z millis() -------- //
  398. czas01SEC = czasZERO - timeout01SEC; // --- przypisz nowy czas do warunków millis() ----------- //
  399. czas50MSC = czasZERO - timeout50MSC; // --- przypisz nowy czas do warunków millis() ----------- //
  400. czas10SEC = czasZERO - timeout10SEC; // --- przypisz nowy czas do warunków millis() ----------- //
  401. czas30SEC = czasZERO - timeout30SEC; // --- przypisz nowy czas do warunków millis() ----------- //
  402. czas01MIN = czasZERO - timeout01MIN; // --- przypisz nowy czas do warunków millis() ----------- //
  403. czas30MIN = czasZERO - timeout30MIN; // --- przypisz nowy czas do warunków millis() ----------- //
  404. czas01HRS = czasZERO - timeout01HRS; // --- przypisz nowy czas do warunkow millis() ----------- //
  405.  
  406. // --- wykonaj co 1 sekundę ---------------------------------------------------------------------------------------- //
  407. if(czas01SEC >= 1000UL) // --- wykonaj co sekundę -------------------------------- //
  408. { //
  409. Thread_01s();
  410. timeout01SEC = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  411. //Serial.println( FreeRam() );
  412. } //
  413. // --- wykonaj co 5 sekund ----------------------------------------------------------------------------------------- //
  414. if(czas50MSC >= 51UL) // --- wykonaj co 51 ms - ------------------------------ //
  415. { //
  416. Thread_50us(); // wątek nr. 1 -> wykonuj co 51 ms ---------------------- //
  417. timeout50MSC = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  418. } //
  419. // --- wykonaj co 10 sekund ---------------------------------------------------------------------------------------- //
  420. if(czas10SEC >= 10000UL) // --- wykonaj co 10 sekund ------------------------------ //
  421. { //
  422.  
  423. timeout10SEC = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  424. } //
  425. // --- wykonaj co 30 sekund----------------------------------------------------------------------------------------- //
  426. if(czas30SEC >= 30000UL) // --- wykonaj 30 sekund --------------------------------- //
  427. { //
  428.  
  429. timeout30SEC = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  430. } //
  431. // --- wykonaj co 1 minutę ----------------------------------------------------------------------------------------- //
  432. if(czas01MIN >= 60000UL) // --- wykonaj co 1 minutę ------------------------------- //
  433. {
  434. Thread_01m(); //
  435. timeout01MIN = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  436. } //
  437. // --- wykonaj co 30 minut ----------------------------------------------------------------------------------------- //
  438. if(czas30MIN >= 500UL) // --- wykonuj co 0.30 s --------------------------------- //
  439. { //
  440. if(!F_music_auto)
  441. {
  442. fire3.TicTac16(0);
  443. fire4.TicTac16(1);
  444. }
  445. timeout30MIN = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  446. } //
  447. // --- wykonaj co 60 minut ----------------------------------------------------------------------------------------- //
  448. if(czas01HRS >= 6000000UL) // --- wykonaj co 60 minut ------------------------------- //
  449. { //
  450. Thread_01h();
  451. timeout01HRS = czasZERO; // --- resetuj i ustaw 0UL ------------------------------- //
  452. } //
  453. // ----------------------------------------------------------------------------------------------------------------- //
  454. } //
  455. // --- RELAY SETUP & INIT -------------------------------------------------------------------------------------------- //
  456. void RelayInit() //
  457. { //
  458. for (uint_fast8_t i = 0; i < 8; i++) //
  459. { //
  460. R[i].begin(); //
  461. R[i].turnOff(); // do stanu niskiego ------------------------------------- //
  462. RelayStatus[i] = R[i].getState(); // zapisz status przekaznikow ---------------------------- //
  463. } //
  464. // -- jeśli DEBUG_MAIN jest TRUE --- to pokaż na konsolę SERIALA komunikat --------------------------------------- //
  465. #if DEBUG_MAIN
  466. Serial.println(F("Inside: RelayInit(); Wykonano instukcje ustawien !!! "));
  467. #endif
  468. }
  469. // --- S E T U P ----------------------------------------------------------------------------------------------------- //
  470. void setup() //
  471. { //
  472. //#if DEBUG_MODE
  473. Serial.begin(57600);
  474. //#endif
  475. POGODA.setup(2); //
  476. RelayInit(); //
  477. PANEL.setupDisplay(true, 1); // --- ustaw wyświetlacz na PANELU ------------------------- //
  478. PILOT.enableIRIn(); //
  479. lcd -> init(&LCD); // --- włącz LCD ------------------------------------------- //
  480. panel -> init(&PANEL); //
  481. panel -> showPanel(); //
  482. ClockTimeUpdate(); // --- aktualizuj czas ------------------------------------- //
  483. ClockDateUpdate(); // --- aktualizuj datę ------------------------------------- //
  484. NeoPixelInit(); // --- inicjuj NeoPixel ------------------------------------ //
  485. SensorUpdate(); // --- pobierz temperaturę, wilgotność, oświetlenie -------- //
  486. //
  487. MP3Stream.begin(MD_YX5300::SERIAL_BPS); //
  488. mp3.begin(); //
  489. mp3.setSynchronous(true); //
  490. //
  491. fire1.Init(8); // --- init fire1 ------------------------------------------ //
  492. fire2.Init(8); // --- init fire2 ------------------------------------------ //
  493. fire3.Init(16); // --- init fire3 ------------------------------------------ //
  494. fire4.Init(16); // --- init fire4 ------------------------------------------ //
  495. //
  496. char msg_bufor [21]; // --- bufor msg ------------------------------------ //
  497. strcpy_P(msg_bufor, (char*)pgm_read_word(&(msg[0]))); // --- skopiuj z pamięci PROGMEM do bufora ---------- //
  498. TypeWriter(msg_bufor, 100, 0); // --- wyświetl na LCD --- typewriter --------------- //
  499. fire1.RelayStrobe(); // --- pokaż efekt na fire1 ------------------------- //
  500. //
  501. strcpy_P(msg_bufor, (char*)pgm_read_word(&(msg[1]))); // --- skopiuj z pamięci PROGMEM do bufora ---------- //
  502. TypeWriter(msg_bufor, 100, 1); // --- wyświetl na LCD --- typewriter --------------- //
  503. fire2.RelayStrobe(); // --- pokaż efekt na fire2 ------------------------- //
  504. //
  505. strcpy_P(msg_bufor, (char*)pgm_read_word(&(msg[2]))); // --- skopiuj z pamięci PROGMEM do bufora ---------- //
  506. TypeWriter(msg_bufor, 100, 2); // --- wyświetl na LCD --- typewriter --------------- //
  507. fire3.RelayStrobe(); // --- pokaż efekt na fire3 ------------------------- //
  508. //
  509. strcpy_P(msg_bufor, (char*)pgm_read_word(&(msg[3]))); // --- skopiuj z pamięci PROGMEM do bufora ---------- //
  510. TypeWriter(msg_bufor, 100, 3); // 29934 - 1892 // --- wyświetl na LCD --- typewriter --------------- //
  511. fire4.RelayStrobe(); // --- pokaż efekt na fire 4 ------------------------ //
  512. //
  513. //
  514. wikiMP3.init(); // --- inicjuj odtwarzacz mp3 ------------------------------ //
  515. // --- jeśli DEBUG_MAIN jest TRUE --- to pokaż na konsolę SERIALA komunikat ---------------------------------------- //
  516. #if DEBUG_MAIN
  517. Serial.println(F("Inside: setup(); Wykonano instukcje ustawien !!! "));
  518. #endif //
  519. } //
  520. //
  521. // --- L O O P ------------------------------------------------------------------------------------------------------- //
  522. void loop() //
  523. { //
  524. PilotUpdate(); // --- sprawdź odczyty z pilota ---------------------------- // //
  525. PanelUpdate(); // --- sprawdź odczyty z panela ---------------------------- //
  526. MyThread();
  527. } //
  528. // --- W Ą T K I ----------------------------------------------------------------------------------------------------- //
  529. void Thread_01s() //
  530. { //
  531. ClockTimeUpdate(); // aktualizuj co 1 sekundę (CZAS) ------ //
  532. lcd -> WyswietlCzas(); //
  533. if(F_music_auto ) // jeśli muzyka jest włączona ---------- //
  534. { //
  535. wikiMP3.PlayerUpdate(0); // aktualizuj odtwarzanie -------------- //
  536. }
  537. else
  538. {
  539. fire1.TicTac();
  540. fire2.TicTac();
  541. }
  542. }
  543. // --- W Ą T K I ----------------------------------------------------------------------------------------------------- //
  544. void Thread_50us() //
  545. { //
  546. if( F_music_auto ) // jeśli muzyka gra --------------------------------------------- //
  547. { // i F_NeoFire_fake jest FALSE ---------------------------------- //
  548. if(step_fire)
  549. {
  550. fire1.Draw(); // fire1 -> zapalaj diody --------------------------------------- //
  551. fire3.Draw(); // fire3 -> zapalaj diody --------------------------------------- //
  552. step_fire = false; // koniec instrukcji w tym wątku, tylko Draw dla fire 1 i fire 3 //
  553. }
  554. else
  555. {
  556. fire2.Draw(); // fire2 -> zapalaj diody --------------------------------------- //
  557. fire4.Draw(); // fire4 -> zapalaj diody --------------------------------------- //
  558. step_fire = true; // koniec instrukcji w tym wątku, tylko Draw dla fire 2 i fire 4 //
  559. } //
  560. //
  561. F_NeoFire_play = true; // blokuj !!! --------------------------------------------------- //
  562. } // Flaga F_NeoFire jest ustawiana tylko z PILITA !!! ON/OFF ----- //
  563. //
  564. //
  565. // --- MUZYKA ZATRZYMANA ------------------------------------------------------------------------------------------- //
  566. if( F_NeoFire_stop ) // jeśli muzyka gra i F_NeoFire_fake jest FALSE ---------------- //
  567. { //
  568. fire1.StopDraw(); // fire1 -> zgas diody ----------------------------------------- //
  569. fire2.StopDraw(); // fire2 -> zgas diody ----------------------------------------- //
  570. fire3.StopDraw(); // fire3 -> zgas diody ----------------------------------------- //
  571. fire4.StopDraw(); // fire4 -> zgas diody ----------------------------------------- //
  572. F_NeoFire_stop = false; // zatrzymanie wykonani, przestaw flagę ------------------------ //
  573. F_NeoFire_play = false; // odblokuj !!! ------------------------------------------------ //
  574. } //
  575. } //
  576. // --- W Ą T K I ----------------------------------------------------------------------------------------------------- //
  577. void Thread_10s() //
  578. { //
  579. } //
  580. // --- W Ą T K I ----------------------------------------------------------------------------------------------------- //
  581. void Thread_01m() //
  582. { //
  583. SensorUpdate(); // aktualizuj co 1 minutę (SENSORY) ------------------------------------------------ //
  584. SystemAutoControl(); // AutoBOT !!! --------------------------------------------------------------------- //
  585. if(!F_music_auto)
  586. {
  587. LCDAutoControl(); // przełączaj informację na wyświetlaczu LCD --------------------- //
  588. //fire3.CyclonEffect();
  589. //fire4.CyclonEffect();
  590. }
  591. // --- synchronizacja wątku godzinnego --------------------------------------------------------------------------- //
  592. if(F_reset_run) //
  593. { //
  594. if(!minuta) // jeśli pełna godzina synchronizuj wątek ----------------------- //
  595. { //
  596. czasZERO = millis(); // --- zapamiętaj pod zmienną czasZERO z millis() -------- //
  597. timeout01HRS = czasZERO;
  598. F_reset_run = false; //
  599. // --- jeśli DEBUG_MAIN jest TRUE --- to pokaż na konsolę SERIALA komunikat ---------------------------------- //
  600. #if DEBUG_MAIN
  601. Serial.println(F("Inside: Thread_01m; Dokonano synchronizacji watku Thread_01h "));
  602. #endif
  603. } //
  604. } //
  605. // --- koniec synchronizacji ------------------------------------------------------------------------------------- //
  606. } //
  607. // ------------------------------------------------------------------------------------------------------------------- //
  608. // --- W Ą T E K 1 G O D Z I N A --------------------------------------------------------------------------------- //
  609. // ------------------------------------------------------------------------------------------------------------------- //
  610. // Wątek wykonywany co jedną godzinę, jest synchronizowany flagą F_reset_run, po uruchomieniu Arduino dopiero wtedy //
  611. // gdy minuta aktualnego czasu to 00 jest dołączony do wykonywania, interwał to 3.600.000 sekund //
  612. // ------------------------------------------------------------------------------------------------------------------- //
  613. void Thread_01h() //
  614. { //
  615. if( F_timer_auto ) wikiMP3.SpeakTime(); // jeśli muzyka nie gra (F_timer_auto) jest TRUE powiedz czas //
  616. if( data[0] != CLOCK.dayofweek ) // jeśli zmieniła się data //
  617. { //
  618. ClockDateUpdate(); // aktualizuj datę z zegara //
  619. } //
  620. } //
  621. // ------------------------------------------------------------------------------------------------------------------- //
  622. // --- S Y S T E M A U T O C O N T R O L ------------------------------------------------------------------------- //
  623. // ------------------------------------------------------------------------------------------------------------------- //
  624. // SystemAutoControl(); Funkcja automatycznego sterowanie całym systemem --- jesnym słowem AutoBOT wywyływany loopem //
  625. // ------------------------------------------------------------------------------------------------------------------- //
  626. void SystemAutoControl() //
  627. { //
  628. if(!F_music_auto) // jeśli muzyka nie gra -------------------------------------- //
  629. { //
  630. if(data[0] < 6) // jeśli mieści się w zakresie : poniedziałek - piątek ------- //
  631. { //
  632. if(godzina == 6 && 29 > minuta < 32) wikiMP3.PlayerUpdate(1); // włącz budzik o 6:30 ---------------- //
  633. } //
  634. else //
  635. if(data[0] == 6) // jeśli sobota --------------------------------------------- //
  636. { //
  637. if(godzina == 8 && 29 > minuta < 32 ) wikiMP3.PlayerUpdate(1); // włącz budzik o 8:30 ---------------- //
  638. } //
  639. else //
  640. if(data[0] > 6) // jeśli niedziela ------------------------------------------ //
  641. { //
  642. if(godzina == 9 && 00 > minuta < 03 ) wikiMP3.PlayerUpdate(1); // włącz budzik o 9:01 ---------------- //
  643. } //
  644. } // koniec !F_music_auto --- //
  645. // --------------------------------------------------------------------------------------------------------------- //
  646. } //
  647. // ------------------------------------------------------------------------------------------------------------------- //
  648. // --- L C D A U T O C O N T R O L ------------------------------------------------------------------------------- //
  649. // ------------------------------------------------------------------------------------------------------------------- //
  650. // Funkcja na podstawie statycznego licznika buduje tablicę znaków data_to_lcd do wyświetlenia na LCD. Nie ma zatem //
  651. // potrzeby ingerować w funkcję obsługi w klasie wikiLCD gdyż korzysta ona z extern tablicy która tu zostanie stworzona//
  652. // ------------------------------------------------------------------------------------------------------------------- //
  653. void LCDAutoControl() //
  654. { //
  655. static byte licznik = 0; // licznik przełącznika do budowania komunikatow //
  656. //
  657. //
  658. switch (licznik) // przełącznik na podstawie statycznego licznika //
  659. {
  660. case 0 : // jeśli 0 ------------------------------------- //
  661. { //
  662. DayLcdUpdate(); // zbuduj łańcuch z bieżące daty i dnia tygodnia //
  663. licznik ++; // inkrementuj o 1 ----------------------------- //
  664. }
  665. break; //
  666. case 1 : // jeśli 1 ------------------------------------- //
  667. { //
  668. DataLcdUpdate(); // zbuduj łańcuch z bieżące daty i dnia tygodnia //
  669. licznik ++; // inkrementuj o 1 ----------------------------- //
  670. } //
  671. break; //
  672. case 2: // jeśli 2 ------------------------------------- //
  673. { //
  674. TempLcdUpdate(); // zbuduj łańcuch z aktualnej temp w pokoju ---- //
  675. licznik ++; // inkrementuj o 1 ----------------------------- //
  676. } //
  677. break; //
  678. case 3: // jeśli 3 ------------------------------------- //
  679. { //
  680. HigrLcdUpdate(); // zbuduj łańcuch z aktualnej wilgotnosci ------ //
  681. licznik ++; // inkrementuj o 1 ----------------------------- //
  682. } //
  683. break; //
  684. case 4: // jeśli 4 ------------------------------------- //
  685. { //
  686. LightLcdUpdate(); // zbuduj łańcuch z aktualnego swiatla --------- //
  687. licznik ++; // inkrementuj o 1 ----------------------------- //
  688. } //
  689. break; //
  690. default : //
  691. { //
  692. licznik = 0; //
  693. } //
  694. break; // auto-zerowanie ------------------------------ //
  695. } //
  696. F_dataShow = true; // pozwól na zmianę na wyświetlaczu LCD -------- //
  697. } //
  698. // ------------------------------------------------------------------------------------------------------------------- //
  699. // --- P I L O T ----------------------------------------------------------------------------------------------------- //
  700. // ------------------------------------------------------------------------------------------------------------------- //
  701. // Funkcja PilotUpdate -> odczytuje dane z pilota, wykorzystana do tego jest biblioteka RichUNOIRRemote //
  702. // Biblioteka jest spora, ale oddaje kody w czytelnej postaci, nie trzeba interprerować kodów //
  703. // bo dostajemy tylko liczby całkowite, które łatwo ogarnąć. //
  704. // ------------------------------------------------------------------------------------------------------------------- //
  705. void PilotUpdate() //
  706. { //
  707. if (PILOT.decode()) // jeśli przycisk zdekodowany ------------------------------------ //
  708. { //
  709. if(PILOT.isReleased()) //
  710. { //
  711. #if DEBUG_MAIN
  712. Serial.print(F("Inside: PilotUpdate(); Odczyt z pilota !!! Kod to : "));
  713. Serial.println(PILOT.keycode);
  714. #endif
  715.  
  716. switch (PILOT.keycode) // sprawdz jaki przycisk ------------------------------ //
  717. { //
  718. case 7: wikiMP3.PlayerUpdate(2); // utwór poprzedni --- klawisz PREV //
  719. break; //
  720. case 8: RelaySwitch(3); break; // 8 to klawisz 4 ------------------------------------ //
  721. case 9: wikiMP3.PlayerUpdate(3); // utwór nastepny --- klawisz NEXT //
  722. break; //
  723. case 12: RelaySwitch(0); break; // 12 to klawisz 1 ------------------------------------ //
  724. case 13: break; // 13 to klawisz C ------------------------------------ //
  725. case 21: wikiMP3.PlayerUpdate(1); // 21 to klawisz PLAY --------------------------------- //
  726. case 22: break; // 22 to klawisz 0 ------------------------------------ //
  727. case 24: RelaySwitch(1); break; // 24 to klawisz 2 ------------------------------------ //
  728. case 25: if(F_music_auto) wikiMP3.PlayerUpdate(5); // volume DOWN --- klawisz MINUS --- //
  729. break; //
  730. case 28: RelaySwitch(4); break; // 28 to klawisz 5 ------------------------------------ //
  731. case 66: RelaySwitch(6); break; // 66 to klawisz 7 ------------------------------------ //
  732. case 64: if(F_music_auto) wikiMP3.PlayerUpdate(4); // volume UP --- klawisz PLUS ------ //
  733. break; //
  734. case 67: if(F_music_auto) wikiMP3.PlayerUpdate(3); // utwór poprzedni ---------------- //
  735. break; // 67 to klawisz BACK ------------- //
  736. case 68: if(F_music_auto) wikiMP3.PlayerUpdate(2); // utwór poprzedni --- klawisz TEST //
  737. break;
  738. case 69: break; // 69 to klawisz ON/OFF ------------------------------- //
  739. case 71: break; // 71 to klawisz MENU --------------------------------- //
  740. case 74: break; // 74 to klawisz 9 ------------------------------------ //
  741. case 82: RelaySwitch(7); break; // 82 to klawisz 8 ------------------------------------ //
  742. case 90: RelaySwitch(5); break; // 90 to klawisz 6 ------------------------------------ //
  743. case 94: RelaySwitch(2); break; // 94 to klawisz 3 ------------------------------------ //
  744. default : break; // DOMYŚLNIE ------------------------------------------ //
  745. } //
  746. delay(100); //
  747. } //
  748. PILOT.resume(); //
  749. } //
  750. //
  751. } //
  752. // ------------------------------------------------------------------------------------------------------------------- //
  753. // --- P A N E L U P D A T E --------------------------------------------------------------------------------------- //
  754. // ------------------------------------------------------------------------------------------------------------------- //
  755. // Funkcja wywoływana z pętli LOOP, sprawdza czy został wciśnięty klawisz na PANELU. Przyciski od 1 do 8 sterują //
  756. // przekażnikami. Jeśli przekaźnij jest włączony to go wyłącza, jeśli wyłączony to go włącza - nie po za tym //
  757. // Przyciski nr. 9,10,11,12 - sterują zmianą koloru adresowalnych diód RGB, wszystko odbywa się w klasie fire która //
  758. // znajduje się w pliku fire.h Przyciski aktywne dla klasy pod warunkiem, że flaga F_music_auto jest TRUE czyli //
  759. // muzyka gra, jeśli nie jest odwarzany żaden plik MP3 nie ma podmiany kolorów. //
  760. // Przyciski 13,14,15,16 - sterują odwarzaczem MP3, 13 - przycisk włącza PLAY, jego ponowne wciśniecie powoduje STOP //
  761. // przycisk 14 włącza STOP, jego ponowne wciśnięcie powoduje PLAY. Przycisk 15 to przełącznik odtwarzanego utworu //
  762. // na poprzedni pod warunkiem, że gra muzyka -> flaga F_music_auto jest TRUE, inaczej nic nie robi narazie. //
  763. // Przycisk 16 to przełącznik odwarzanego utworu na następny pod warunkiem, że gra muzyka, inaczej nic nie robi //
  764. // ------------------------------------------------------------------------------------------------------------------- //
  765. void PanelUpdate() // funkcja MOD_KEY do obsługi przycisków ----------------- //
  766. { //
  767. word keys = PANEL.getButtons(); // zapisz do keys kod przycisku -------------------------- //
  768. if(keys>0 && keys<17) //
  769. { //
  770. delay(100); // jeśli odczytano kod klawiatury z PANEL poczekaj 150ms - //
  771. #if DEBUG_MAIN
  772. Serial.print(F("Inside: PanelUpdate(); Odczyt z PANEL !!! Kod to : "));
  773. Serial.println(keys);
  774. #endif //
  775. } //
  776. // --- S W I T C H ------------------------------------------------------------------------------------------------- //
  777. switch(keys) //
  778. { //
  779. case 1: RelaySwitch(0); break; // przełącz przekaźnik nr. 1 ----------------------------- //
  780. case 2: RelaySwitch(1); break; // przełącz przekaźnik nr. 2 ----------------------------- //
  781. case 3: RelaySwitch(2); break; // przełącz przekaźnik nr. 3 ----------------------------- //
  782. case 4: RelaySwitch(3); break; // przełącz przekaźnik nr. 4 ----------------------------- //
  783. case 5: RelaySwitch(4); break; // przełącz przekaźnik nr. 5 ----------------------------- //
  784. case 6: RelaySwitch(5); break; // przełącz przekaźnik nr. 6 ----------------------------- //
  785. case 7: RelaySwitch(6); break; // przełącz przekaźnik nr. 7 ----------------------------- //
  786. case 8: RelaySwitch(7); break; // przełącz przekaźnik nr. 8 ----------------------------- //
  787. case 9: // przycisk nr. 9 ---------------------------------------- //
  788. { //
  789. if( F_music_auto ) fire1.SwapColor(); // jeśli gra muzyka, zmień kolory dla fire1 --- //
  790. }
  791. break; // o ile LEDY są włączone - F_NeoFire is FALSE //
  792. case 10: // przycisk nr. 10 --------------------------------------- //
  793. { //
  794. if( F_music_auto ) fire2.SwapColor(); // jeśli gra muzyka, zmień kolory dla fire2 --- //
  795. }
  796. break; // o ile LEDY są włączone - F_NeoFire is FALSE //
  797. case 11: // przycisk nr. 11 --------------------------------------- //
  798. { //
  799. if( F_music_auto ) fire3.SwapColor(); // jeśli gra muzyka, zmień kolory dla fire3 --- //
  800. }
  801. break; // o ile LEDY są włączone - F_NeoFire is FALSE //
  802. case 12: // przycisk nr. 12 --------------------------------------- //
  803. { //
  804. if( F_music_auto ) fire4.SwapColor(); // jeśli gra muzyka, zmień kolory dla fire4 --- //
  805. }
  806. break; // o ile LEDY są włączone - F_NeoFire is FALSE //
  807. case 13: // przycisk nr. 13 --------------------------------------- //
  808. { //
  809. if(!F_music_auto) wikiMP3.PlayerUpdate(1); // jeśli nie gra muzyka czyli flaga jest FALSE //
  810. }
  811. break; // jeśli przycisk nr. 13 włącz PLAY MP3 ------------------ //
  812. case 14: // przycisk nr. 14 --------------------------------------- //
  813. { //
  814. if( F_music_auto) wikiMP3.PlayerUpdate(1); // jeśli przycisk nr. 14 włącz STOP MP3 ------------------ //
  815. }
  816. break; //
  817. case 15: //
  818. { // jeśli gra muzyka czyli flaga jest TRUE //
  819. if( F_music_auto) wikiMP3.PlayerUpdate(2); // jeśli przycisk nr. 15 włącz PREV MP3 FILE ------------- //
  820. }
  821. break; //
  822. case 16: //
  823. { // jeśli gra muzyka czyli flaga jest TRUE //
  824. if (F_music_auto) wikiMP3.PlayerUpdate(3); // jeśli przycisk nr. 16 włącz NEXT MP3 FILE ------------- //
  825. }
  826. break; //
  827. default: break; //
  828. } //
  829. } //
  830. // ------------------------------------------------------------------------------------------------------------------- //
  831. // R E L A Y S W I T C H ------------------------------------------------------------------------------------------- //
  832. // ------------------------------------------------------------------------------------------------------------------- //
  833. // przełącznik stanów przekaźników, jeśli przekaźnik włączony getState() jest TRUE to wyłącza i zapisuje 0 w tablicy //
  834. // Jeśli przekaźnik wyłączony getState() jest FALSE to włącza przekaźnik i zapisuje 1 w tablicy. Tablica w któej //
  835. // przechowywane są stany RelayStatus[nr_przekaznika] jest pomocnicza, korzysta z nie funkcja która wyświetla stany //
  836. // ma panelu TM1638 //
  837. // ------------------------------------------------------------------------------------------------------------------- //
  838. void RelaySwitch(int keys) // funkcja RelaySwitch() na wejsciu nr. przekaznika -- //
  839. { //
  840. if(R[keys].getState()) // sprawdz czy przekaznik wlaczony -------------------- //
  841. { //
  842. RelayStatus[keys] = 0; // ustaw status przekaznika na 0 ---------------------- //
  843. R[keys].turnOff(); // wyłącz przekaźnik ---------------------------------- //
  844. if(!F_music_play)
  845. {
  846. fire3.RelayEffect();
  847. }
  848. } //
  849. else // jeśli przekaźnik wyłączony ------------------------- //
  850. { //
  851. RelayStatus[keys] = 1; // ustaw status przekaźnika na 1 ---------------------- //
  852. R[keys].turnOn(); // włącz przekaźnik ----------------------------------- //
  853. if(!F_music_play)
  854. {
  855. fire4.RelayEffect();
  856. }
  857. } //
  858.  
  859. panel -> showPanel(); // zmieniły się stany, więc wyświetl to na PANEL ------ //
  860. } //
  861. // ------------------------------------------------------------------------------------------------------------------- //
  862.  
  863.  
  864.  
  865.  
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!