API tools faq
paste
Advertisement
PowerTGS440

DEMO_matrixh

PowerTGS440
Feb 13th, 2021 (edited)
299
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 106.55 KB | None | 0 0
raw download clone embed print report
  1. // matrix.h
  2. // taką nazwę ma mieć ten plik w katalogu z twoim projektem
  3. //
  4. // ------------------------------------------------------------------------------------------------------------------------ //
  5. // W A ż N E ! ! ! P R Z E C Z Y T A J ! ! ! //
  6. // ------------------------------------------------------------------------------------------------------------------------ //
  7. // //
  8. // z klasą TMatrix należy się zapoznać !!! posiada nie-konwencjonalne rozwiązania w celu bardzo szybkiego działania //
  9. // i nie dołączania zbędnych funkji i zmiennych do kodu - została tak napisana by 10-latek ją zrozumiał. Jest prosta //
  10. // i przejrzysta. Skoro mój 11-letni syn ją ogarnia, sam modyfikuje, dodaje i przerabia to poświęć 10min i mała //
  11. // analiza kodu źródłowego oraz komentarzy da obraz jej działania. //
  12. // //
  13. // ------------------------------------------------------------------------------------------------------------------------ //
  14. // //
  15. // T M A T R I X C L A S S B Y M A R C I N //
  16. // S. C. P. Version for Matrix PAROLA Dynamic Library //
  17. // //
  18. // Animation speed adapted to 16Mhz, 8-bit processors ATmega328 //
  19. // //
  20. // ------------------------------------------------------------------------------------------------------------------------ //
  21. // MADE by MARCIN (POLISH / ENGLISH MAKRO SWITCH) //
  22. // MAKRO JĘZYKA :-) 0 = POLSKI (dni tygodnia / miesiące) -- in POLISH (day of weeks / month) //
  23. // MAKRO JĘZYKA :-) 1 = ENGLISH (dni tygodnia / miesiące) -- in ENGLISH (day of weeks / month ) //
  24. // //
  25. #define LANGUAGE 0
  26. // //
  27. // Polski lub angielski - nie zużywa pamięci programu //
  28. // Polish or English - does not consume program memory //
  29. // ------------------------------------------------------------------------------------------------------------------------ //
  30. // M E T O D Y P U B L I C Z N E D O U Ż Y C I A / P U B L I C M E T H O D S F O R Y O U //
  31. // //
  32. // P. ShowAllValue(); -- isnieje jeśli TERMINAL jest TRUE //
  33. // P. ShowEffectDemo(); -- demo efektów klasy TMatrix //
  34. // P. ShowSpriteDemo(); -- demo duszków klasy TMatrix //
  35. // P. ShowRandomDemo(); -- demo efektów i dzusków klasy TMatrix //
  36. // P. ShowDayName(uint8_t nr_day); -- pokaż dzień tygodnia - na wejściu nr. dnia (1-7), jeśli 0 wyświetli ERROR //
  37. // P. ShowMonthName(uint8_t nr_month); -- pokaż nazwę miesiąca - na wejśćiu nr. mies (1-12),jeśłi 0 wyświetli ERORR //
  38. // ------------------------------------------------------------------------------------------------------------------------ //
  39. // //
  40. // build for 8-bit Arduino-MEGA256 (start buid: 11.02.2021) version.SCP //
  41. // this version works only with UNO, NANO and MEGA //
  42. // PROGMEM MEMORY is optimized for these devices !!! //
  43. // you must remove all PROGMEM makro and replace memory copy function strcpy_P to string copy strcpy //
  44. // and replace function strlen_P to strlen. All function pgm_read_word you delete from code. //
  45. // //
  46. // ta wersja pracuje tylko z UNO, NANO i MEGA //
  47. // wykorzystuje alokację stałych zmiennych za pomocą PROGMEM //
  48. // nie będzie działać z Arduino DUE gdzie nie ma podziału //
  49. // na szynę pamięci programu i szynę pamięci RAM //
  50. // kompatybilny z 32-bitowym DUE, ESP2886, ESP32 - musisz usunąć wszędzie makro PROGMEM i zamienić funkcję kopiowania //
  51. // z pamięci PROG (strcpy_P) na funkcję kopiowania string (strcpy) oraz funkcję obliczania rozmiaru (strlen_P) zastąpić //
  52. // zwykłą funkcją dla pobierania rozmiaru tablicy (strlen). //
  53. // Wszystkie funkcje pgm_read_word sięgające do pamięci spoza RAM muszą zostać skasowane //
  54. // //
  55. // ------------------------------------------------------------------------------------------------------------------------ //
  56. // //
  57. // language : english (code) & poland (comments) //
  58. // code : C and C++ in Arduino Pro IDE - Alpha 0.1.2 - nightly.20201110 //
  59. // e-mail : [email protected] //
  60. // blogger : https://arudino-code.blogspot.com/ //
  61. // //
  62. // ------------------------------------------------------------------------------------------------------------------------ //
  63. // //
  64. // S.C.P. Matrix PAROLA Class version history logger //
  65. // //
  66. // v0.052 Memory Test --- 13. 02. 2021 --- DAY ON, MONTH ON, DEMO ON -> Memory Size: 23030b PROG & 511b RAM //
  67. // v0.051 Rebuild --- 13. 02. 2021 --- modyfikacja, wykryto błędy nakładania bufora 22238b PROG 503b RAM //
  68. // v0.050 Show of Month --- 13. 02. 2021 --- dodano : pokaż nazwę miesiąca --- LOSOWY EFEKT DUSZKA ------------ //
  69. // v0.049 Random Sprite --- 13. 02. 2021 --- dodano : void ShowMsgRandomSprite(char *buf); (wyjęcie z ShowDay) //
  70. // --- 13. 02. 2021 --- odzyskano pamięć dynamiczną - stan : 22684b PROG & 511b RAM //
  71. // v0.048 Show of Day --- 13. 02. 2021 --- dodano : pokaż nazwę dnia --- LOSOWY EFEKT DUSZKA ---------------- //
  72. // v0.047 Language Switch --- 13. 02. 2021 --- dodano : MAKRO - przełącznik języków - 22404b PROG & 511b RAM :-) //
  73. // v0.046 English Month --- 13. 02. 2021 --- dodano : miesiące po angielsku //
  74. // v0.045 English Day --- 13. 02. 2021 --- dodano : dni po angielsku //
  75. // v0.044 Makro Time --- 13. 02. 2021 --- wyłączono makrem stare metody DAY & MONTH - 22404b PROG & 511b RAM //
  76. // v0.043 Define Terminal --- 13. 02. 2021 --- makro terminal połączenia z PC przeniesiony do klasy //
  77. // v0.042 Fake Terminal --- 13. 02. 2021 --- wyłączenie Terminala PC -> 22414b PROG & 541b RAM - HAPPY :-) //
  78. // v0.043 MACRO TEST --- 13. 02. 2021 --- test MATRIX MAKRO wszystkie na FALSE -> 23438b PROG & 716b RAM //
  79. // v0.042 MACRO save RAM --- 13. 02. 2021 --- makro wyłączające metodę MSG2Bufor -> 24768b PROG & 720b RAM //
  80. // --- na razie korzystamy z metod zwracających CHAR * ale metoda zostaje //
  81. // --- makro zdefiniowane w częśći prywatnej zmiennych klasy jako FALSE //
  82. // v0.041 new idea 3 --- 13. 02. 2021 --- wykorzystano char * MSG2Bufor w EFFECT -> 24768b PROG & 735b RAM //
  83. // v0.040 new idea 2 --- 13. 02. 2021 --- wykorzystano char * MSG2Bufor w SPRITE -> 24828b PROG & 735b RAM //
  84. // v0.039 new idea 1 --- 13. 02. 2021 --- dodano metodę do klasy : char * MSG2Bufor(nr_msg, buf, size_buf); //
  85. // v0.038 math random --- 13. 02. 2021 --- modyfikacja: random zamiast IF -> 24732b PROG & 735b RAM :-) //
  86. // v0.037 time for demo --- 13. 02. 2021 --- dodano: Przełącznik Demo -> 24513b PROG & 734b RAM //
  87. // v0.036 math day 2 --- 13. 02. 2021 --- modyfikacja ShowSpriteDemo -> 23606b PROG & 665b RAM //
  88. // v0.035 math day 1 --- 13. 02. 2021 --- modyfikacja ShowSpriteDemo -> 24128b PROG & 729b RAM //
  89. // v0.034 sprite day --- 13. 02. 2021 --- dodano sprite : G H O S T //
  90. // v0.033 sprite day --- 13. 02. 2021 --- dodano sprite : P A C M A N //
  91. // v0.032 sprite day --- 13. 02. 2021 --- dodano sprite : W AL K I N G M A N //
  92. // v0.031 sprite day --- 13. 02. 2021 --- dodano sprite : C H E V R O N //
  93. // v0.030 sprite day --- 13. 02. 2021 --- dodano sprite : F I R E B A L L //
  94. // v0.029 sprite day --- 13. 02. 2021 --- dodano sprite : R O C K E T //
  95. // v0.028 sprite day --- 13. 02. 2021 --- dodano sprite : S P A C E I N V A D E R S //
  96. // v0.027 sprite day --- 13. 02. 2021 --- dodano sprite : H E A R T F O R M Y M O M //
  97. // v0.026 sprire day --- 13. 02. 2021 --- dodano sprite : T I T A N I C S T E A M B O A T //
  98. // v0.025 sprite day --- 13. 02. 2021 --- dodano sprite : S A I L I N G B O A T //
  99. // v0.024 sprite day --- 13. 02. 2021 --- dodano sprite : A R R O W F A D I N G 2 O U T S I D E //
  100. // v0.023 sprite day --- 13. 02. 2021 --- dodano sprite : A R R O W F A D I N G 2 C E N T E R //
  101. // v0.022 sprite day --- 13. 02. 2021 --- dodano sprite : S P A C E D L I N E S //
  102. // v0.021 sprite day --- 13. 02. 2021 --- dodano sprite : R O L L I N G O C T A G O N //
  103. // v0.020 sprite day --- 12. 02. 2021 --- dodano sprite : R O L L I N G S Q U A R E //
  104. // v0.019 sprite day --- 12. 02. 2021 --- dodano sprite : W A V E W O R M //
  105. // v0.018 extractor time --- 12. 02. 2021 --- char * month - zwraca bufor z nazwą miesiąća //
  106. // v0.017 extractor time --- 12. 02. 2021 --- char * day of week - zwraca bufor z dniem tygodnia //
  107. // v0.016 debug rebuild --- 12. 02. 2021 --- przebudowowa DEBUG'ów ---- ALL OFF - use 22366b PROG & 663b RAM //
  108. // v0.015 catch month error --- 12. 02. 2021 --- złap błąd jeśli miesiąc poza zakresem :-) //
  109. // v0.015 catch day error --- 12. 02. 2021 --- złap błąd jeśli dzień tygodnia poza zakresem :-) //
  110. // v0.014 extract month --- 12. 02. 2021 --- wyciągnij MIESIAC z PROGMEM - używam: 23486b PROG & 667b RAM //
  111. // v0.013 optimization time --- 12. 02. 2021 --- redukcja zbędnego balastu --- reduction of unnecessary ballast //
  112. // v0.012 extract day --- 12. 02. 2021 --- wyciągnij DZIEN z PROGMEM - używam: 23486b PROG & 667b RAM //
  113. // v0.011 month of year --- 12. 02. 2021 --- MIESIĄCE do PROGMEM :-) 23008 bytes PROG and 635 bytes RAM //
  114. // v0.010 pacman & ghost --- 12. 02. 2021 --- animacja pacman & ghost //
  115. // v0.009 day of week --- 12. 02. 2021 --- DNI TYGODNIA do PROGMEM :-) 23008 bytes PROG & 635 bytes RAM //
  116. // v0.008 saving RAM --- 12. 02. 2021 --- MOJE WIADOMOSCI do PROGMEM :-) 22974 bytes PROG & 635 bytes RAM //
  117. // v0.007 frosty morning --- 12. 02. 2021 --- dodano wiadomości do wyświetlenia //
  118. // v0.006 visual effects --- 12. 02. 2021 --- dodano obsługę efektów wizualnych //
  119. // v0.005 moment of truth --- 11. 02. 2021 --- 22746 bytes program space & 525 bytes dynamic memory //
  120. // v0.004 truth flags --- 11. 02. 2021 --- flags and features of their return //
  121. // v0.003 save the memory --- 11. 02. 2021 --- constants to program memory //
  122. // v0.002 debug night --- 11. 02. 2021 --- building debugs //
  123. // v0.001 night mary --- 11. 02. 2021 --- start of class building //
  124. // //
  125. // ------------------------------------------------------------------------------------------------------------------------ //
  126. // INCLUDE PAROLA LIBRARY //
  127. // //
  128. #include <MD_Parola.h> //
  129. #include <MD_MAX72xx.h> //
  130. #include <SPI.h> //
  131. // ------------------------------------------------------------------------------------------------------------------------ //
  132. // DEFINE TERMINAL MAKRO -------------------------------------------------------------------------------------------------- //
  133. // ------------------------------------------------------------------------------------------------------------------------ //
  134. // włącza / wyłącza połączenie z Terminalem USB-Serial na PC (UNIX / DOS / WINDOWS) //
  135. // jeśli 0 - wyłącz TERMINAL i nie załącząj do pliku binarnego komunikacja przez USB-Serial z PC //
  136. // jeśli 1 - włącz TERMINAL z prędkością 57600boud i dołącz do pliku binarnego komunikację przez USB-Serial z PC //
  137. // //
  138. #define TERMINAL 0
  139.  
  140. #if TERMINAL
  141. #define TERMINAL_PC_SPEED 57600
  142. #endif
  143. //
  144. // ------------------------------------------------------------------------------------------------------------------------ //
  145. // DEFINE MAKRO --- M_DEBUG = all info for SERIAL --- F_DEBUG = 1 -- info for SERIAL ------------------------------------- //
  146. // dołączaj do pliku binarnego jeśli true --------------------------------------------------------------------------------- //
  147. #if TERMINAL
  148. #define M_DEBUG 1
  149. #else
  150. #define M_DEBUG 0
  151. #endif
  152. //
  153. // ------------------------------------------------------------------------------------------------------------------------ //
  154. // DEFINE MAKRO --- V_DEBUG = all variable for SERIAL --- V_DEBUG = 1 --- state for SERIAL -------------------------------- //
  155. // dołączaj do pliku binarnego jeśli true --------------------------------------------------------------------------------- //
  156. #if TERMINAL
  157. #define V_DEBUG 1
  158. #else
  159. #define V_DEBUG 0
  160. #endif
  161. //
  162. // ------------------------------------------------------------------------------------------------------------------------ //
  163. // DEFINE MAKRO --- LANGUAGE --- PL = 0, EN = 1 //
  164. // ------------------------------------------------------------------------------------------------------------------------ //
  165. #if LANGUAGE
  166. #define POLISH 0
  167. #define ENGLISH 1
  168. #else
  169. #define POLISH 1
  170. #define ENGLISH 0
  171. #endif
  172. // //
  173. // ------------------------------------------------------------------------------------------------------------------------ //
  174. // ALL SERIAL message to PROGMEM MEMORY !!! ------------------------------------------------------------------------------- //
  175. // ------------------------------------------------------------------------------------------------------------------------ //
  176. // include to binary files when M_DEBUG is TRUE !!! --- memory is FREE when M_DEBUG is false ------------------------------ //
  177. // dołączany do pliku binarnego wtedy gdy M_DEBUG ma wartość prawdziwą : 1, kiedy jest 0 wszystko jest pomijane !!! ------- //
  178. // nie jest sprawdzany czy SERIAL.BEGIN był inicjowany, całkowite wykluczenie z kodu wsadowego do ARDUINO MEGA 256 !!! ---- //
  179. //
  180. #if M_DEBUG
  181. const char SERIAL_MSG_00 [] PROGMEM = " TMatrix -> ERROR MSG -> Nie ma takiego komunikatu do wyswietlenia ";
  182. const char SERIAL_MSG_01 [] PROGMEM = " TMatrix -> Uruchomiono -> konstruktor klasy TMatrix ";
  183. const char SERIAL_MSG_02 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_ON() -> zmieniono stan flag ";
  184. const char SERIAL_MSG_03 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_OFF() -> zmieniono stan flag ";
  185. const char SERIAL_MSG_04 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_BUSY() -> zwrocono flage ";
  186. const char SERIAL_MSG_05 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_FREE() -> zwrocono flage ";
  187. const char SERIAL_MSG_06 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_isON() -> zwrocono flage ";
  188. const char SERIAL_MSG_07 [] PROGMEM = " TMatrix -> Uruchomiono -> TMatrix_isOFF() -> zwrocono flage ";
  189. const char SERIAL_MSG_08 [] PROGMEM = " TMatrix -> Nieudana ekstrakcja dnia tygodnia, poza zakresem -> skopiowano E R R O R ";
  190. const char SERIAL_MSG_09 [] PROGMEM = " TMatrix -> Nieudana ekstrakcja miesiaca, poza zakresem -> skopiowano E R R O R ";
  191. const char SERIAL_MSG_10 [] PROGMEM = " TMatrix -> DEMOMODE -> Utworzono napis : ";
  192.  
  193. const char * const SERIAL_MSG [] PROGMEM = {
  194. SERIAL_MSG_00 , SERIAL_MSG_01 , SERIAL_MSG_02 , SERIAL_MSG_03 , SERIAL_MSG_04 ,
  195. SERIAL_MSG_05 , SERIAL_MSG_06 , SERIAL_MSG_07 , SERIAL_MSG_08 , SERIAL_MSG_09 ,
  196. SERIAL_MSG_10
  197. };
  198. #endif
  199. //
  200. // ------------------------------------------------------------------------------------------------------------------------ //
  201. // ALL SERIAL VALUE message to PROGMEM MEMORY !!! ------------------------------------------------------------------------- //
  202. // ------------------------------------------------------------------------------------------------------------------------ //
  203. // include to binary files when V_DEBUG is TRUE !!! --- memory is FREE when V_DEBUG is false ------------------------------ //
  204. // dołączany do pliku binarnego wtedy gdy V_DEBUG ma wartość prawdziwą : 1, kiedy jest 0 wszystko jest pomijane !!! ------- //
  205. // nie jest sprawczyczy czy SERIAL.BEGIN był inicjowany, całkowite wykluczenie z kodu wsadowego do ARDUINO MEGA 256 ------- //
  206. //
  207. #if V_DEBUG
  208. const char VALUE_MSG_00 [] PROGMEM = " TMatrix -> ERROR MSG -> Nie ma takiego komunikatu do wyswietlenia ";
  209. const char VALUE_MSG_01 [] PROGMEM = " TMatrix -> Flaga : F_Matrix_Busy : ";
  210. const char VALUE_MSG_02 [] PROGMEM = " TMatrix -> Flaga : F_Matrix_Free : ";
  211. const char VALUE_MSG_03 [] PROGMEM = " TMatrix -> Flaga : F_Matrix_Off : ";
  212. const char VALUE_MSG_04 [] PROGMEM = " TMatrix -> Flaga : F_Matrix_On : ";
  213.  
  214. const char * const VALUE_MSG [] PROGMEM = {
  215. VALUE_MSG_00 , VALUE_MSG_01, VALUE_MSG_02, VALUE_MSG_03, VALUE_MSG_04
  216. };
  217. #endif
  218. //
  219. // ------------------------------------------------------------------------------------------------------------------------ //
  220. // ALL MATRIX message to PROGMEM MEMORY !!! ------------------------------------------------------------------------------- //
  221. // ------------------------------------------------------------------------------------------------------------------------ //
  222. //
  223. const char P_MSG_00 [] PROGMEM = "E R R O R";
  224. const char P_MSG_01 [] PROGMEM = "M A R C I N";
  225. const char P_MSG_02 [] PROGMEM = "MARCIN SCP!";
  226. const char P_MSG_03 [] PROGMEM = "S C P" ;
  227. const char P_MSG_04 [] PROGMEM = "M A R C I N";
  228. const char P_MSG_05 [] PROGMEM = "P O R T A L";
  229. const char P_MSG_06 [] PROGMEM = "KNIGHTS :3";
  230. const char P_MSG_07 [] PROGMEM = "HELLO MARCIN";
  231. const char P_MSG_08 [] PROGMEM = "I S L A N D";
  232. const char P_MSG_09 [] PROGMEM = "MINECRAFT";
  233.  
  234. // --- W A Ż N E --- Jeśli dodasz kolejną wiadomość ( napis ) do wyświetlenia, analogicznie jak powyżej - musisz nadać //
  235. // unikalna nazwę tej wiadomości wg. szablogu P_MSG_XX gdzie XX to kolejny numer. Następnie należy uzupełnić stałą tablicę //
  236. // wskaźników poniżej, po przecinku, ostatni wskaźnik do tablicy jest bez przecinka !!! Proste, przejrzyste --- Wielkość //
  237. // tablicy wskaźników cię nie interesuje, są obliczane dynamicznie w czasie kompilacji w funkcji INIT klasy TMatrix //
  238.  
  239. const char * const P_MSG [] PROGMEM = {
  240. P_MSG_00, P_MSG_01, P_MSG_02, P_MSG_03, P_MSG_04, P_MSG_05,
  241. P_MSG_06, P_MSG_07, P_MSG_08, P_MSG_09
  242.  
  243. };
  244. // ------------------------------------------------------------------------------------------------------------------------ //
  245. // ALL MATRIX DAY to PROGMEM MEMORY !!! ----------------------------------------------------------------------------------- //
  246. // ------------------------------------------------------------------------------------------------------------------------ //
  247. // jeśli POLISH jest true / if POLISH is true ----------------------------------------------------------------------------- //
  248. // //
  249. #if POLISH
  250. const char DAY_MSG_00 [] PROGMEM = "E R R O R";
  251. const char DAY_MSG_01 [] PROGMEM = "Poniedzialek";
  252. const char DAY_MSG_02 [] PROGMEM = "W T O R E K";
  253. const char DAY_MSG_03 [] PROGMEM = "S R O D A";
  254. const char DAY_MSG_04 [] PROGMEM = "CZWARTEK";
  255. const char DAY_MSG_05 [] PROGMEM = "P I A T E K";
  256. const char DAY_MSG_06 [] PROGMEM = "S O B O T A";
  257. const char DAY_MSG_07 [] PROGMEM = "NIEDZIELA";
  258. #endif
  259. // jeśli ENGLISH jest true / if ENGLISH is true -------------------------------------------------------------------------- //
  260. #if ENGLISH
  261. const char DAY_MSG_00 [] PROGMEM = "No day";
  262. const char DAY_MSG_01 [] PROGMEM = "Monday";
  263. const char DAY_MSG_02 [] PROGMEM = "Tuesday";
  264. const char DAY_MSG_03 [] PROGMEM = "Wednesday";
  265. const char DAY_MSG_04 [] PROGMEM = "Thursday";
  266. const char DAY_MSG_05 [] PROGMEM = "Friday";
  267. const char DAY_MSG_06 [] PROGMEM = "Saturday";
  268. const char DAY_MSG_07 [] PROGMEM = "Sunday";
  269. #endif
  270.  
  271. const char * const DAY_MSG [] PROGMEM = {
  272. DAY_MSG_00, DAY_MSG_01, DAY_MSG_02, DAY_MSG_03,
  273. DAY_MSG_04, DAY_MSG_05, DAY_MSG_06, DAY_MSG_07
  274. };
  275. // ------------------------------------------------------------------------------------------------------------------------ //
  276. // ALL MATRIX MONTH to PROGMEM MEMORY !!! --------------------------------------------------------------------------------- //
  277. // ------------------------------------------------------------------------------------------------------------------------ //
  278. // ------------------------------------------------------------------------------------------------------------------------ //
  279. // jeśli POLISH jest true / if POLISH is true ----------------------------------------------------------------------------- //
  280. // //
  281. #if POLISH
  282. const char MONTH_MSG_00 [] PROGMEM = "E R R O R";
  283. const char MONTH_MSG_01 [] PROGMEM = "STYCZEN";
  284. const char MONTH_MSG_02 [] PROGMEM = "L U T Y";
  285. const char MONTH_MSG_03 [] PROGMEM = "M A R Z E C";
  286. const char MONTH_MSG_04 [] PROGMEM = "KWIECIEN";
  287. const char MONTH_MSG_05 [] PROGMEM = "M A J";
  288. const char MONTH_MSG_06 [] PROGMEM = "CZERWIEC";
  289. const char MONTH_MSG_07 [] PROGMEM = "L I P I E C";
  290. const char MONTH_MSG_08 [] PROGMEM = "SIERPIEN";
  291. const char MONTH_MSG_09 [] PROGMEM = "WRZESIEN";
  292. const char MONTH_MSG_10 [] PROGMEM = "PAZDZIERNIK";
  293. const char MONTH_MSG_11 [] PROGMEM = "LISTOPAD";
  294. const char MONTH_MSG_12 [] PROGMEM = "GRUDZIEN";
  295. #endif
  296. // --- ENGLISH MONTH is LANGUAGE is true --- angielskie miesiące jeśli makro LANGUAGE jest TRUE -------------------------- //
  297. #if ENGLISH
  298. const char MONTH_MSG_00 [] PROGMEM = "No Month";
  299. const char MONTH_MSG_01 [] PROGMEM = "January";
  300. const char MONTH_MSG_02 [] PROGMEM = "February";
  301. const char MONTH_MSG_03 [] PROGMEM = "March";
  302. const char MONTH_MSG_04 [] PROGMEM = "April";
  303. const char MONTH_MSG_05 [] PROGMEM = "May";
  304. const char MONTH_MSG_06 [] PROGMEM = "June";
  305. const char MONTH_MSG_07 [] PROGMEM = "July";
  306. const char MONTH_MSG_08 [] PROGMEM = "August";
  307. const char MONTH_MSG_09 [] PROGMEM = "September";
  308. const char MONTH_MSG_10 [] PROGMEM = "October";
  309. const char MONTH_MSG_11 [] PROGMEM = "November";
  310. const char MONTH_MSG_12 [] PROGMEM = "December";
  311. #endif
  312.  
  313. const char * const MONTH_MSG [] PROGMEM = {
  314. MONTH_MSG_00, MONTH_MSG_01, MONTH_MSG_02, MONTH_MSG_03, MONTH_MSG_04,
  315. MONTH_MSG_05, MONTH_MSG_06, MONTH_MSG_07, MONTH_MSG_08, MONTH_MSG_09,
  316. MONTH_MSG_10, MONTH_MSG_11, MONTH_MSG_12
  317. };
  318. // ------------------------------------------------------------------------------------------------------------------------ //
  319. // S P R I T E D E F I N I T I O N -------------------------------------------------------------------------------------- //
  320. // ------------------------------------------------------------------------------------------------------------------------ //
  321. // P A C M A N D E F I N I T I O N -------------------------------------------------------------------------------------- //
  322. // ------------------------------------------------------------------------------------------------------------------------ //
  323. const uint8_t F_PMAN1 = 6; // rozmiar duszka PACMAN ----------------- //
  324. const uint8_t W_PMAN1 = 8; // rozmiar duszka PACMAN ----------------- //
  325. static const uint8_t pacman1[F_PMAN1 * W_PMAN1] PROGMEM = // definicja animacji PACMAN ------------- //
  326. {
  327. 0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c,
  328. 0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
  329. 0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  330. 0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  331. 0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  332. 0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
  333. };
  334. // ------------------------------------------------------------------------------------------------------------------------ //
  335. // S P R I T E : W A V E / W O R M D E F I N I T I O N ---------------------------------------------------------- //
  336. // ------------------------------------------------------------------------------------------------------------------------ //
  337. const uint8_t F_WAVE = 14;
  338. const uint8_t W_WAVE = 14;
  339. static const uint8_t wave [F_WAVE * W_WAVE] PROGMEM =
  340. {
  341. 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10,
  342. 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20,
  343. 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40,
  344. 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
  345. 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
  346. 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
  347. 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10,
  348. 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08,
  349. 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04,
  350. 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02,
  351. 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
  352. 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
  353. 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04,
  354. 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08,
  355. };
  356. // ------------------------------------------------------------------------------------------------------------------------ //
  357. // S P R I T E : G H O S T D E F I N I T I O N ---------------------------------------------------------------------- //
  358. // ------------------------------------------------------------------------------------------------------------------------ //
  359. const uint8_t F_PMAN2 = 6; // rozmiar duszka GHOST ----------------- //
  360. const uint8_t W_PMAN2 = 18; // rozmiar duszka GHOST ----------------- //
  361. static const uint8_t pacman2[F_PMAN2 * W_PMAN2] PROGMEM = // animacja DUCH goni PACMANA ----------- //
  362. {
  363. 0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  364. 0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  365. 0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  366. 0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
  367. 0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
  368. 0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
  369. }; //
  370. // ------------------------------------------------------------------------------------------------------------------------ //
  371. // S P R I T E : R O L L I N G 1 S Q U A R E D E F I N I T I O N -------------------------------------------- //
  372. // ------------------------------------------------------------------------------------------------------------------------ //
  373. const uint8_t F_ROLL1 = 4;
  374. const uint8_t W_ROLL1 = 8;
  375. static const uint8_t roll1[F_ROLL1 * W_ROLL1] PROGMEM =
  376. {
  377. 0xff, 0x8f, 0x8f, 0x8f, 0x81, 0x81, 0x81, 0xff,
  378. 0xff, 0xf1, 0xf1, 0xf1, 0x81, 0x81, 0x81, 0xff,
  379. 0xff, 0x81, 0x81, 0x81, 0xf1, 0xf1, 0xf1, 0xff,
  380. 0xff, 0x81, 0x81, 0x81, 0x8f, 0x8f, 0x8f, 0xff,
  381. };
  382. // ------------------------------------------------------------------------------------------------------------------------ //
  383. // S P R I T E : R O L L I N G 2 O C T A G O N D E F I N I T I O N -------------------------------------------- //
  384. // ------------------------------------------------------------------------------------------------------------------------ //
  385. const uint8_t F_ROLL2 = 4;
  386. const uint8_t W_ROLL2 = 8;
  387. static const uint8_t roll2 [F_ROLL2 * W_ROLL2] PROGMEM =
  388. {
  389. 0x3c, 0x4e, 0x8f, 0x8f, 0x81, 0x81, 0x42, 0x3c,
  390. 0x3c, 0x72, 0xf1, 0xf1, 0x81, 0x81, 0x42, 0x3c,
  391. 0x3c, 0x42, 0x81, 0x81, 0xf1, 0xf1, 0x72, 0x3c,
  392. 0x3c, 0x42, 0x81, 0x81, 0x8f, 0x8f, 0x4e, 0x3c,
  393. };
  394. // ------------------------------------------------------------------------------------------------------------------------ //
  395. // S P R I T E : S P A C E D L I N E S D E F I N I T I O N ---------------------------------------------------- //
  396. // ------------------------------------------------------------------------------------------------------------------------ //
  397. const uint8_t F_LINES = 3;
  398. const uint8_t W_LINES = 8;
  399. static const uint8_t lines [F_LINES * W_LINES] PROGMEM =
  400. {
  401. 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00,
  402. 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00,
  403. 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff,
  404. };
  405. // ------------------------------------------------------------------------------------------------------------------------ //
  406. // S P R I T E : A R R O W F A D I N G D E F I N I T I O N --------------------------------------------------- //
  407. // ------------------------------------------------------------------------------------------------------------------------ //
  408. const uint8_t F_ARROW1 = 3;
  409. const uint8_t W_ARROW1 = 10;
  410. static const uint8_t arrow1 [F_ARROW1 * W_ARROW1] PROGMEM =
  411. {
  412. 0x18, 0x3c, 0x7e, 0xff, 0x7e, 0x00, 0x00, 0x3c, 0x00, 0x00,
  413. 0x18, 0x3c, 0x7e, 0xff, 0x00, 0x7e, 0x00, 0x00, 0x18, 0x00,
  414. 0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x18,
  415. };
  416. // ------------------------------------------------------------------------------------------------------------------------ //
  417. // S P R I T E : A R R O W F A D I N G O U T S I D E D E F I N I T I O N ---------------------------------- //
  418. // ------------------------------------------------------------------------------------------------------------------------ //
  419. const uint8_t F_ARROW2 = 3;
  420. const uint8_t W_ARROW2 = 9;
  421. static const uint8_t arrow2 [F_ARROW2 * W_ARROW2] PROGMEM =
  422. {
  423. 0x18, 0x3c, 0x7e, 0xe7, 0x00, 0x00, 0xc3, 0x00, 0x00,
  424. 0x18, 0x3c, 0x7e, 0xe7, 0xe7, 0x00, 0x00, 0x81, 0x00,
  425. 0x18, 0x3c, 0x7e, 0xe7, 0x00, 0xc3, 0x00, 0x00, 0x81,
  426. };
  427. // ------------------------------------------------------------------------------------------------------------------------ //
  428. // S P R I T E : Ż A G L Ó W K A S H I P D E F I N I T I O N ------------------------------------------------- //
  429. // ------------------------------------------------------------------------------------------------------------------------ //
  430. const uint8_t F_SAILBOAT = 1;
  431. const uint8_t W_SAILBOAT = 11;
  432. static const uint8_t sailboat[F_SAILBOAT * W_SAILBOAT] PROGMEM =
  433. {
  434. 0x10, 0x30, 0x58, 0x94, 0x92, 0x9f, 0x92, 0x94, 0x98, 0x50, 0x30,
  435. };
  436. // ------------------------------------------------------------------------------------------------------------------------ //
  437. // S P R I T E : T I T A N I C S T E A M D E F I N I T I O N ------------------------------------------------- //
  438. // ------------------------------------------------------------------------------------------------------------------------ //
  439. const uint8_t F_STEAMBOAT = 2;
  440. const uint8_t W_STEAMBOAT = 11;
  441. const uint8_t steamboat[F_STEAMBOAT * W_STEAMBOAT] PROGMEM =
  442. {
  443. 0x10, 0x30, 0x50, 0x9c, 0x9e, 0x90, 0x91, 0x9c, 0x9d, 0x90, 0x71,
  444. 0x10, 0x30, 0x50, 0x9c, 0x9c, 0x91, 0x90, 0x9d, 0x9e, 0x91, 0x70,
  445. };
  446. // ------------------------------------------------------------------------------------------------------------------------ //
  447. // S P R I T E : H E A R T D E F I N I T I O N ------------------------------------------------------------------ //
  448. // ------------------------------------------------------------------------------------------------------------------------ //
  449. const uint8_t F_HEART = 5;
  450. const uint8_t W_HEART = 9;
  451. static const uint8_t heart[F_HEART * W_HEART] PROGMEM =
  452. {
  453. 0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
  454. 0x0e, 0x1f, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x1f, 0x0e,
  455. 0x0e, 0x1f, 0x3f, 0x7e, 0xfc, 0x7e, 0x3f, 0x1f, 0x0e,
  456. 0x0e, 0x1f, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x1f, 0x0e,
  457. 0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
  458. };
  459. // ------------------------------------------------------------------------------------------------------------------------ //
  460. // S P R I T E : N A J E Ż D Z C A Z K O S M O S U D E F I N I T I O N -------------------------------------- //
  461. // ------------------------------------------------------------------------------------------------------------------------ //
  462. const uint8_t F_INVADER = 2;
  463. const uint8_t W_INVADER = 10;
  464. static const uint8_t invader[F_INVADER * W_INVADER] PROGMEM =
  465. {
  466. 0x0e, 0x98, 0x7d, 0x36, 0x3c, 0x3c, 0x36, 0x7d, 0x98, 0x0e,
  467. 0x70, 0x18, 0x7d, 0xb6, 0x3c, 0x3c, 0xb6, 0x7d, 0x18, 0x70,
  468. };
  469. // ------------------------------------------------------------------------------------------------------------------------ //
  470. // S P R I T E : R A K I E T A Z K O S M O S U D E F I N I T I O N ------------------------------------------ //
  471. // ------------------------------------------------------------------------------------------------------------------------ //
  472. const uint8_t F_ROCKET = 2;
  473. const uint8_t W_ROCKET = 11;
  474. static const uint8_t rocket[F_ROCKET * W_ROCKET] PROGMEM =
  475. {
  476. 0x18, 0x24, 0x42, 0x81, 0x99, 0x18, 0x99, 0x18, 0xa5, 0x5a, 0x81,
  477. 0x18, 0x24, 0x42, 0x81, 0x18, 0x99, 0x18, 0x99, 0x24, 0x42, 0x99,
  478. };
  479. // ------------------------------------------------------------------------------------------------------------------------ //
  480. // S P R I T E : F I R E B A L L D E F I N I T I O N ------------------------------------------------------------ //
  481. // ------------------------------------------------------------------------------------------------------------------------ //
  482. const uint8_t F_FBALL = 2;
  483. const uint8_t W_FBALL = 11;
  484. static const uint8_t fireball[F_FBALL * W_FBALL] PROGMEM =
  485. {
  486. 0x7e, 0xab, 0x54, 0x28, 0x52, 0x24, 0x40, 0x18, 0x04, 0x10, 0x08,
  487. 0x7e, 0xd5, 0x2a, 0x14, 0x24, 0x0a, 0x30, 0x04, 0x28, 0x08, 0x10,
  488. };
  489. // ------------------------------------------------------------------------------------------------------------------------ //
  490. // S P R I T E : C H E V R O N D E F I N I T I O N -------------------------------------------------------------- //
  491. // ------------------------------------------------------------------------------------------------------------------------ //
  492. const uint8_t F_CHEVRON = 1;
  493. const uint8_t W_CHEVRON = 9;
  494. static const uint8_t chevron[F_CHEVRON * W_CHEVRON] PROGMEM =
  495. {
  496. 0x18, 0x3c, 0x66, 0xc3, 0x99, 0x3c, 0x66, 0xc3, 0x81,
  497. };
  498. // ------------------------------------------------------------------------------------------------------------------------ //
  499. // S P R I T E : I D Ą C Y L U D Z I K D E F I N I T I O N ---------------------------------------------------- //
  500. // ------------------------------------------------------------------------------------------------------------------------ //
  501. const uint8_t F_WALKER = 5;
  502. const uint8_t W_WALKER = 7;
  503. static const uint8_t walker[F_WALKER * W_WALKER] PROGMEM =
  504. {
  505. 0x00, 0x48, 0x77, 0x1f, 0x1c, 0x94, 0x68,
  506. 0x00, 0x90, 0xee, 0x3e, 0x38, 0x28, 0xd0,
  507. 0x00, 0x00, 0xae, 0xfe, 0x38, 0x28, 0x40,
  508. 0x00, 0x00, 0x2e, 0xbe, 0xf8, 0x00, 0x00,
  509. 0x00, 0x10, 0x6e, 0x3e, 0xb8, 0xe8, 0x00,
  510. };
  511. // ------------------------------------------------------------------------------------------------------------------------ //
  512. // S P R I T E : S T R U K T U R A A N I M A C J I d l a D U S Z K Ó W ----------------------------------------- //
  513. // ------------------------------------------------------------------------------------------------------------------------ //
  514. struct
  515. {
  516. const uint8_t *data;
  517. uint8_t width;
  518. uint8_t frames;
  519. }
  520.  
  521. sprite[] =
  522. {
  523. { walker, W_WALKER, F_WALKER },
  524. { invader, W_INVADER, F_INVADER },
  525. { chevron, W_CHEVRON, F_CHEVRON },
  526. { heart, W_HEART, F_HEART },
  527. { arrow1, W_ARROW1, F_ARROW1 },
  528. { steamboat, W_STEAMBOAT, F_STEAMBOAT },
  529. { fireball, W_FBALL, F_FBALL },
  530. { rocket, W_ROCKET, F_ROCKET },
  531. { roll2, W_ROLL2, F_ROLL2 },
  532. { pacman2, W_PMAN2, F_PMAN2 },
  533. { lines, W_LINES, F_LINES },
  534. { roll1, W_ROLL1, F_ROLL1 },
  535. { sailboat, W_SAILBOAT, F_SAILBOAT },
  536. { arrow2, W_ARROW2, F_ARROW2 },
  537. { wave, W_WAVE, F_WAVE },
  538. { pacman1, W_PMAN1, F_PMAN1 }
  539. };
  540. //
  541. // ------------------------------------------------------------------------------------------------------------------------ //
  542. // T M a t r i x P a r o l a C l a s s //
  543. // ------------------------------------------------------------------------------------------------------------------------ //
  544. // //
  545. class TMatrix // klasa TMatrix ................................ //
  546. { //
  547. // części prywatne klasy - private parts of the class ................................................................. //
  548. private : //
  549. MD_Parola & P; // adres obiektu klasy MD_Parola -> P ........... //
  550. //
  551. // Z M I E N N E P R Y W A T N E ................................................................................ //
  552. #define oldMethod false
  553. bool F_Matrix_Busy; // flaga wyświetlacza ... true = busy ........... //
  554. bool F_Matrix_Free; // flaga wyświetlacza ... true = free ........... //
  555. bool F_Matrix_Off; // flaga wyświetlacza ... true = OFF ............ //
  556. bool F_Matrix_On; // flaga wyświetlacza ... true = ON ............. //
  557. #define Bufor_Size 15 // definiowanie rozmiaru BUFORÓW ................ //
  558. //
  559. // bufor nie wykorzystany jeśli oldMethod jest false, wyłącza też zostaje funkcja MSG2Bufor z binarki ............. //
  560. // by używać metody i bufora należy przestawić wartość oldMethod na true .......................................... //
  561. #if oldMethod
  562. char P_Bufor[Bufor_Size]; // bufor napisów do wyświetlenia na P ........... //
  563. #endif
  564. //
  565. #if oldMethod
  566. char M_Bufor[Bufor_Size]; // bufor nazw miesiąca dla &P PAROLA MATRIX ..... //
  567. #endif
  568.  
  569. #if oldMethod
  570. char D_Bufor[Bufor_Size]; // bufor nazw tygodnia dla &P PAROLA MATRIX ..... //
  571. #endif
  572.  
  573. byte Day_Tab_Size = 0; // przechowuje rozmiar tablicy DAY_MSG[] ........ //
  574. byte Month_Tab_Size = 0; // przechowuje rozmiar tablucy MONTH_MSG[] ...... //
  575. // O N L Y F O R D E M O O N L Y ---------------------------------------------------------------------------- //
  576. // //
  577. //bool F_Effect_Demo = false;
  578. //bool F_Sprite_Demo = false;
  579. //
  580. // już nie używane, flagi zastąpiono funkcją matematyczną rand -> generator liczb losowych ------------------------ //
  581. // ---------------------------------------------------------------------------------------------------------------- //
  582. // K A T A L O G E F E K T Ó W --- S T R U K T U R A D L A E f e c t P A R O L A ........................ //
  583. struct pCatalog //
  584. { //
  585. textEffect_t effect; // effect do wyświetlenia ----------------------- //
  586. uint16_t speed; // speed multiplier of library default //
  587. uint16_t pause; // pause multiplier for library default //
  588. }; //
  589. // ---------------------------------------------------------------------------------------------------------------- //
  590. //
  591. int P_MSG_SIZE = 0; // zmienna przechowuje wielkość tablicy P_MSG [] //
  592. #define EFECT_SIZE 28 //
  593. //
  594. pCatalog Efect[EFECT_SIZE] =
  595. {
  596. { PA_PRINT, 1, 1 },
  597. { PA_SCROLL_UP, 5, 1 },
  598. { PA_SCROLL_DOWN, 5, 1 },
  599. { PA_SCROLL_LEFT, 5, 1 },
  600. { PA_SCROLL_RIGHT, 5, 1 },
  601. { PA_SPRITE, 5, 1 },
  602. { PA_SLICE, 1, 1 },
  603. { PA_MESH, 20, 1 },
  604. { PA_FADE, 20, 1 },
  605. { PA_DISSOLVE, 7, 1 },
  606. { PA_BLINDS, 7, 1 },
  607. { PA_RANDOM, 3, 1 },
  608. { PA_WIPE, 5, 1 },
  609. { PA_WIPE_CURSOR, 4, 1 },
  610. { PA_SCAN_HORIZ, 4, 1 },
  611. { PA_SCAN_HORIZX, 4, 1 },
  612. { PA_SCAN_VERT, 3, 1 },
  613. { PA_SCAN_VERTX, 3, 1 },
  614. { PA_OPENING, 3, 1 },
  615. { PA_OPENING_CURSOR, 4, 1 },
  616. { PA_CLOSING, 3, 1 },
  617. { PA_CLOSING_CURSOR, 4, 1 },
  618. { PA_SCROLL_UP_LEFT, 7, 1 },
  619. { PA_SCROLL_UP_RIGHT, 7, 1 },
  620. { PA_SCROLL_DOWN_LEFT, 7, 1 },
  621. { PA_SCROLL_DOWN_RIGHT, 7, 1 },
  622. { PA_GROW_UP, 7, 1 },
  623. { PA_GROW_DOWN, 7, 1 }
  624. };
  625. // HOT TO USE ? JAK UŻYWAĆ EFEKTY --------------------------------------------------------------------------------- //
  626. // P.displayText(Efect[i].psz, just, Efect[i].speed, Efect[i].pause, Efect[i].effect, Efect[i].effect);//
  627. // F U N K C J E P R Y W A T N E ................................................................................ //
  628. void SerialMSG(byte nr_msg); //
  629. void ValueMSG(byte nr_msg); //
  630. #if oldMethod
  631. void MSG2Bufor(byte nr_msg); // wyciąga z pamięci PROGMEM wiadomość do ....... //
  632. #endif
  633. // wyświetlenia i kopiuje do P_Bufor ............ //
  634. char * MSG2Bufor(byte nr_msg, char *buf, byte lenght); // a ta zwraca CHAR * bez kopiowania ............ //
  635. //
  636. #if oldMethod
  637. void DayExtract(byte nr_day); // wyciąga z pamięci PROGMEM dzien tygodnia ..... //
  638. #endif
  639. // i kopiuje łańcuch CHAR * do D_Bufor .......... //
  640. char * DayExtract(byte nr_day, char *buf, byte lenght); // a ta zwraca CHAR * bez kopiowania ........... //
  641. //
  642. #if oldMethod
  643. void MonthExtract(byte nr_month); // wyciąga z pamięci PROGMEM nazwę miesiąca ..... //
  644. #endif
  645. // i kopiuje łańcuch CHAR * do M_Bufor .......... //
  646. char * MonthExtract(byte nr_month, char *buf, byte lenght); // a ta zwraca CHAR * bez kopiowania //
  647. //
  648. void ShowMsgRandomSprite(char *buf);
  649. //
  650. void toON(); // włącz MATRIX - przestawia tylko flagi ........ //
  651. void toOFF(); // wyłącz MATRIX - przestawia tylko flagi ....... //
  652. inline bool isBUSY(); // czy matryca zajęta - dodatkowa flaga ......... //
  653. inline bool isFREE(); // czy matryca wolna - dodatkowa flaga .......... //
  654. inline bool isON(); // czy matryca włączona - główna flaga .......... //
  655. inline bool isOFF(); // czy matryca wyłączona - główna flaga ......... //
  656. //
  657. // częci publiczne klasy --- public parts of the class ---------------------------------------------------------------- //
  658. public: //
  659. TMatrix(MD_Parola & _P) : P ( _P ) { } // konstukor automatyczyny - auto. constructor .. //
  660. // ------------------------------------------------------------------------------------------------------------------ //
  661. void Init() //
  662. { //
  663. F_Matrix_Busy = false; // ustaw flagę na false - matryca wolna ......... //
  664. // flaga pomocnicza - additional flag ........... //
  665. F_Matrix_Free = true; // ustaw flagę na true - matryca wolna .......... //
  666. // flaga pomocnicza - additional flag ........... //
  667. F_Matrix_Off = true; // ustaw flagę na true - matryca wyłączona ...... //
  668. // matrix is OFF - value is TRUE ................ //
  669. F_Matrix_On = false; // ustaw flagę na false - matryca wyłączona ..... //
  670. // matrix is ON - value is TRUE ................. //
  671. P_MSG_SIZE = sizeof ( P_MSG ) / 2 ; // ustal ilość wiadomości do wyświetlenia ....... //
  672. Day_Tab_Size = sizeof ( DAY_MSG ) / 2 ; // przechowuje rozmiar tablicy DAY_MSG[] ........ //
  673. Month_Tab_Size = sizeof ( MONTH_MSG ) / 2 ; // przechowuje rozmiar tablicy MONTH_MSG[] ...... //
  674. // -------------------------------------------------------------------------------------------------------------- //
  675. //
  676. #if TERMINAL
  677. Serial.begin(TERMINAL_PC_SPEED);
  678. #endif
  679. //
  680. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB ------------------------------------------------------ //
  681. #if M_DEBUG
  682. SerialMSG(1);
  683. Serial.print(F(" ROZMIAR Day_Tab_Size : "));
  684. Serial.println(Day_Tab_Size);
  685. Serial.print(F(" Rozmiar Month_Tab_Size : "));
  686. Serial.println(Month_Tab_Size);
  687. #endif
  688. // tworzy SPRITE Pacman & Ghost --------------------------------------------------------------------------------- //
  689. #if ENA_SPRITE
  690. P.setSpriteData(pacman1, W_PMAN1, F_PMAN1, pacman2, W_PMAN2, F_PMAN2);
  691. #endif
  692. // --- ustaw prędkości efektów ---------------------------------------------------------------------------------- //
  693. for (uint8_t i=0; i<EFECT_SIZE; i++)
  694. {
  695. Efect[i].speed *= P.getSpeed();
  696. Efect[i].pause *= 500;
  697. }
  698. // koniec obsługi DEBUG ----------------------------------------------------------------------------------------- //
  699. } //
  700. // koniec konstruktora .............................................................................................. //
  701. //
  702. #if TERMINAL
  703. // albo jest albo nie ma :-) jeśli TERMINAL true //
  704. void ShowAllValue(); // pokaz ustawienie wszystkich flag ............. //
  705. // jeśli TERMINAL false funkcja nie istnieje .... //
  706. #endif
  707. void ShowEffectDemo(); // demo efektów PAROLA .......................... //
  708. void ShowSpriteDemo(); // demo duszków PAROLA .......................... //
  709. void ShowRandomDemo(); // mikser DEMO -> efekty / duszki ............... //
  710. void ShowDayName(uint8_t nr_day); // pokaż nazwę dnia - random sprite animation //
  711. void ShowMonthName(uint8_t nr_month); // pokaż nazwę miesiąca - random effect animation //
  712. //
  713. }; //
  714. // //
  715. // ------------------------------------------------------------------------------------------------------------------------ //
  716. // --- end of class declaracion --- koniec deklaracji klasy --------------------------------------------------------------- //
  717. // ------------------------------------------------------------------------------------------------------------------------ //
  718. // --- start private class definition function --- początek definicji funkcji prywatnych klasy TMatrix -------------------- //
  719. // ------------------------------------------------------------------------------------------------------------------------ //
  720. // --- SHOW Messege with Random Sprite Effect --- POKAZ napis z losową animację duszka ------------------------------------ //
  721. // ------------------------------------------------------------------------------------------------------------------------ //
  722. void TMatrix::ShowMsgRandomSprite(char *buf) //
  723. { //
  724. if(P.displayAnimate()) //
  725. { //
  726. int curEFX = random ( ARRAY_SIZE ( sprite ) ); //
  727. P.setSpriteData(sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames, // wejście SPRITE ----------- //
  728. sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames); // wyjśćie SPRITE ----------- //
  729. P.displayText(buf, PA_CENTER, 10, 1000, PA_SPRITE, PA_SPRITE); // wyświetl napis z bufora -- //
  730. } //
  731. } //
  732. //
  733. // ------------------------------------------------------------------------------------------------------------------------ //
  734. // P R I V A T E F U N C T I O N - D E B U G E R M S G S E R I A L I N F O //
  735. // ------------------------------------------------------------------------------------------------------------------------ //
  736. //
  737. void TMatrix::SerialMSG(byte nr_msg) //
  738. { //
  739. #if M_DEBUG
  740. if( nr_msg >= sizeof (SERIAL_MSG) / 2 ) // sprawdź czy istnieje ! ............... //
  741. { //
  742. char *bufor = new char [ strlen_P( pgm_read_word (& SERIAL_MSG[0] ) ) ]; // dynamiczny przydział pamięci bufora .. //
  743. strcpy_P ( bufor, (char*) pgm_read_word (& SERIAL_MSG[0] )); // kopiujemy z pamięci msg: error do bufor//
  744. Serial.println(bufor); //
  745. delete bufor; // kasujemy bufor z pam.ięci ............ //
  746. } //
  747. else //
  748. { //
  749. char *bufor = new char [ strlen_P( pgm_read_word (& SERIAL_MSG[nr_msg] ) ) ]; //
  750. strcpy_P ( bufor, (char*) pgm_read_word (& SERIAL_MSG[nr_msg] )); //
  751. Serial.println(bufor); //
  752. delete bufor; // kasujemy bufor z pamięci ............ //
  753. } //
  754. #endif
  755. } //
  756. //
  757. // ------------------------------------------------------------------------------------------------------------------------ //
  758. // P R I V A T E F U N C T I O N - D E B U G E R V A L U E O N L Y S E R I A L I N F O //
  759. // ------------------------------------------------------------------------------------------------------------------------ //
  760. void TMatrix::ValueMSG(byte nr_msg) //
  761. {
  762. #if V_DEBUG
  763. if( nr_msg >= sizeof (VALUE_MSG) / 2 ) // sprawdź czy istnieje ! ............... //
  764. { //
  765. char *bufor = new char [ strlen_P( pgm_read_word (& VALUE_MSG[0] ) ) ]; // dynamiczny przydział pamięci bufora .. //
  766. strcpy_P ( bufor, (char*) pgm_read_word (& VALUE_MSG[0] )); // kopiujemy z pamięci msg: error do bufor//
  767. Serial.println(bufor);
  768. delete bufor; // kasujemy bufor z pamięci ............ //
  769. } //
  770. else //
  771. { //
  772. char *bufor = new char [ strlen_P( pgm_read_word (& VALUE_MSG[nr_msg] ) ) ]; //
  773. strcpy_P ( bufor, (char*) pgm_read_word (& VALUE_MSG[nr_msg] )); //
  774. Serial.println(bufor);
  775. switch( nr_msg )
  776. {
  777. case 0 : break;
  778. case 1 : Serial.println ( F_Matrix_Busy ); break;
  779. case 2 : Serial.println ( F_Matrix_Free ); break;
  780. case 3 : Serial.println ( F_Matrix_Off ); break;
  781. case 4 : Serial.println ( F_Matrix_On ); break;
  782. default: break;
  783. }
  784. delete bufor; // kasujemy bufor z pamięci ............ //
  785. } //
  786. #endif
  787. }
  788. //
  789. // ------------------------------------------------------------------------------------------------------------------------ //
  790. // P R I V A T E F U N C T I O N - D E B U G E R V A L U E O N L Y S E R I A L I N F O //
  791. // ------------------------------------------------------------------------------------------------------------------------ //
  792. #if oldMethod
  793. void TMatrix::MSG2Bufor(byte nr_msg) //
  794. { //
  795. if( nr_msg > P_MSG_SIZE - 1) // sprawdź czy istnieje ! ............... //
  796. { //
  797. strcpy_P ( P_Bufor, (char*) pgm_read_word (& P_MSG[0] )); //
  798. } //
  799. else //
  800. { //
  801. strcpy_P ( P_Bufor, (char*) pgm_read_word (& P_MSG[nr_msg] )); //
  802. } //
  803. } //
  804. #endif
  805. //
  806. // ------------------------------------------------------------------------------------------------------------------------ //
  807. char * TMatrix::MSG2Bufor(byte nr_msg, char *buf, byte lenght) // metoda nie kopiuje do bufora, zwraca sklejony //
  808. { // napis jako char * ........................... //
  809. if( nr_msg > P_MSG_SIZE - 1) // wyłap błąd ---------------------------------- //
  810. { //
  811. #if M_DEBUG
  812. SerialMSG(8);
  813. buf = "MARCINEK";
  814. #endif
  815. } //
  816. else //
  817. { // brak błędu ---------------------------------- //
  818. strcpy_P (buf, (char*) pgm_read_word (& P_MSG[nr_msg])); // do wskaznika z PROGMEM ---------------------- //
  819. buf[lenght] = '\0'; // znak kónca do wskaźnika --------------------- //
  820. } //
  821. return buf; // zwzróć buf .................................. //
  822. // używać tak : MSG2Bufor(numer_msg, charBuf, sizeof(charBuf)-1) ................................................... //
  823. } //
  824. // ------------------------------------------------------------------------------------------------------------------------ //
  825. // P R I V A T E F U N C T I O N //
  826. // ------------------------------------------------------------------------------------------------------------------------ //
  827. // TMatrix_ON() - przełącz flagi --- wyświetlacz włączony ----------------------------------------------------------------- //
  828. void TMatrix::toON() //
  829. { //
  830. F_Matrix_On = true; // flaga T_Matrix_On = true - MATRIX jest ON ...... //
  831. F_Matrix_Off = false; // flaga T_Matrix_Off = false - MATRIX jest ON .... //
  832. F_Matrix_Busy = false; // flaga T_Matrix_Busy = false - MATRIX jest FREE . //
  833. F_Matrix_Free = true; // flaga T_Matrix_Free = true - MATRIX jest FREE .. //
  834. //
  835. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  836. #if M_DEBUG
  837. SerialMSG(2);
  838. #endif
  839. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  840. } //
  841. //
  842. // ------------------------------------------------------------------------------------------------------------------------ //
  843. // P R I V A T E F U N C T I O N //
  844. // ------------------------------------------------------------------------------------------------------------------------ //
  845. // //
  846. // TMatrix_OFF() - przełącz flagi --- wyświetlacz wyłączony --------------------------------------------------------------- //
  847. void TMatrix::toOFF() //
  848. { //
  849. F_Matrix_On = false; // flaga T_Matrix_On = false - MATRIX jest OFF .... //
  850. F_Matrix_Off = true; // flaga T_Matrix_Off = true - MATRIX jest OFF .... //
  851. //
  852. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  853. #if M_DEBUG
  854. SerialMSG(3);
  855. #endif
  856. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  857. } //
  858. // //
  859. // ------------------------------------------------------------------------------------------------------------------------ //
  860. // P R I V A T E F U N C T I O N //
  861. // ------------------------------------------------------------------------------------------------------------------------ //
  862. // //
  863. inline bool TMatrix:: isON() //
  864. { //
  865. //
  866. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  867. #if M_DEBUG
  868. SerialMSG(6);
  869. #endif
  870. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  871. return F_Matrix_On; // return matrix status - direct flag ............. //
  872. } //
  873. // ------------------------------------------------------------------------------------------------------------------------ //
  874. // P R I V A T E F U N C T I O N //
  875. // ------------------------------------------------------------------------------------------------------------------------ //
  876. // //
  877. inline bool TMatrix::isOFF() //
  878. { //
  879. //
  880. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  881. #if M_DEBUG
  882. SerialMSG(7);
  883. #endif
  884. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  885. return F_Matrix_Off; // return matrix status - direct flag ............. //
  886. } //
  887. // ------------------------------------------------------------------------------------------------------------------------ //
  888. // P R I V A T E F U N C T I O N - A D D B U S Y F L A G //
  889. // ------------------------------------------------------------------------------------------------------------------------ //
  890. // Czy matryca jest zajęta ? zwróć false lub true --- matrix is busy ? rerurn false or true ------------------------------- //
  891. inline bool TMatrix::isBUSY() //
  892. { //
  893. //
  894. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  895. #if M_DEBUG
  896. SerialMSG(4);
  897. Serial.println(F_Matrix_Busy);
  898. #endif
  899. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  900. return F_Matrix_Busy; // return matrix status - 3 auxiliary flag ........ //
  901. } //
  902. //
  903. // ------------------------------------------------------------------------------------------------------------------------ //
  904. // P R I V A T E F U N C T I O N - A D D F R E E F L A G //
  905. // ------------------------------------------------------------------------------------------------------------------------ //
  906. // Czy matryca jest wolna ? zwróć false lub true --- matrix is free ? rerurn false or true -------------------------------- //
  907. inline bool TMatrix::isFREE() //
  908. { //
  909. // jeśli DEBUG ma true wyświetl komunikat na monitorze USB -------------------------------------------------------- //
  910. #if M_DEBUG
  911. SerialMSG(5);
  912. Serial.println(F_Matrix_Free);
  913. #endif
  914. // koniec obsługi DEBUG ------------------------------------------------------------------------------------------- //
  915. //
  916. return F_Matrix_Free; // return matrix status - 4 auxiliary flag ........ //
  917. } //
  918. //
  919. // ------------------------------------------------------------------------------------------------------------------------ //
  920. // D A Y E X T R A C T O R F R O M P R O G M E M T O B U F O R //
  921. // ------------------------------------------------------------------------------------------------------------------------ //
  922. // funkcja wyciąga z pamięci PROGMEM dzień tygodnia i kopiuje do bufora D_Bufor[] ---------------------------------------- //
  923. // wyłączona makrem oldMethod -> korzystać ze zwracającej bufor char * //
  924. // //
  925. #if oldMethod
  926. void TMatrix::DayExtract(byte nr_day) //
  927. { //
  928. if( nr_day > Day_Tab_Size - 1 ) // OBSŁUGA BŁĘDU - WYŁAP !!! Catch ERROR !!! ... //
  929. { // jeżeli dzien tygodnia > 7 skopiuj ERROR //
  930. strcpy_P ( D_Bufor, (char*) pgm_read_word (& DAY_MSG[0] )); // do bufora i jeśli DEBUGER wyślij na Serial .. //
  931. #if M_DEBUG
  932. SerialMSG(8);
  933. #endif
  934. } //
  935. else // BRAK BŁĘDU !!! NO ERROR !!! skopiuj do Bufora //
  936. { //
  937. strcpy_P ( D_Bufor, (char*) pgm_read_word (& DAY_MSG[nr_day] )); //
  938. } //
  939. }
  940. #endif //
  941. // ------------------------------------------------------------------------------------------------------------------------ //
  942. char * TMatrix::DayExtract(byte nr_day, char *buf, byte lenght) // zwraca dzień tygodnia jako char * //
  943. { //
  944. * buf = '\0'; // do wskaźnika dołącz '\0' .................... //
  945. if( nr_day > Day_Tab_Size - 1) // wyłap błąd ---------------------------------- //
  946. { //
  947. #if M_DEBUG
  948. SerialMSG(8);
  949. #endif
  950. } //
  951. else //
  952. { // brak błędu ---------------------------------- //
  953. strcpy_P (buf, (char*) pgm_read_word (& DAY_MSG[nr_day])); // do wskaznika z PROGMEM ---------------------- //
  954. buf[lenght] = '\0'; // znak kónca do wskaźnika --------------------- //
  955. } //
  956. return buf; // zwzróć buf .................................. //
  957. // używać tak : DayExtract(RTC.day_of_month, dayBuf, sizeof(dayBuf)-1) gdzie dayBuf to tablica typu char[15] //
  958. } //
  959. // ------------------------------------------------------------------------------------------------------------------------ //
  960. // M O N T H E X T R A C T O R F R O M P R O G M E M T O B U F O R //
  961. // ------------------------------------------------------------------------------------------------------------------------ //
  962. // funkcja wyciąga z pamięci PROGMEM nazwe miesiąca i kopiuje do bufora M_Bufor[] --------------------------------------- //
  963. // wyłączona makrem oldMethod -> korzystać ze zwracającej bufor char * //
  964. // //
  965. #if oldMethod
  966. void TMatrix::MonthExtract(byte nr_month) //
  967. { //
  968. if( nr_month > Month_Tab_Size - 1 ) // OBSŁUGA BŁĘDU - WYŁAP !!! Catch ERROR !!! ... //
  969. { // jeżeli miesiac > 12 skopiuj ERROR //
  970. strcpy_P ( M_Bufor, (char*) pgm_read_word (& MONTH_MSG[0] )); // do bufora i jeśli DEBUGER wyślij na Serial .. //
  971. #if M_DEBUG
  972. SerialMSG(9);
  973. #endif
  974. } //
  975. else // BRAK BŁĘDU !!! NO ERROR !!! skopiuj do Bufora //
  976. { //
  977. strcpy_P ( M_Bufor, (char*) pgm_read_word (& MONTH_MSG[nr_month] )); //
  978. } //
  979. }
  980. #endif
  981. //
  982. // ------------------------------------------------------------------------------------------------------------------------ //
  983. char * TMatrix::MonthExtract(byte nr_month, char *buf, byte lenght) // zwraca miesiac jako char * //
  984. { //
  985. * buf = '\0'; // do wskaźnika dołącz '\0' .................... //
  986. if( nr_month > Month_Tab_Size - 1) // wyłap błąd ---------------------------------- //
  987. { //
  988. #if M_DEBUG
  989. SerialMSG(9);
  990. #endif
  991. } //
  992. else //
  993. { // brak błędu ---------------------------------- //
  994. strcpy_P (buf, (char*) pgm_read_word (& MONTH_MSG[nr_month])); // do wskaznika z PROGMEM ---------------------- //
  995. buf[lenght] = '\0'; // znak kónca do wskaźnika --------------------- //
  996. } //
  997. return buf; // zwzróć buf .................................. //
  998. // używać tak : MonthExtract(RTC.month, monthBuf, sizeof(monthBuf)-1) gdzie monthBuf to tablica typu char[15] //
  999. } //
  1000. // ------------------------------------------------------------------------------------------------------------------------ //
  1001. // --- end private class definition function --- koniec definicji prywatnych funkcji klasy TMatrix ------------------------ //
  1002. // ------------------------------------------------------------------------------------------------------------------------ //
  1003. // --- start public class definition function --- początek definicji funkcji publicznych klasy TMatrix -------------------- //
  1004. // ------------------------------------------------------------------------------------------------------------------------ //
  1005. // //
  1006. // M A G I C D E B U G E R F O R P R I V A T E A L L V A R I A B L E I N C L A S S ------------------------ //
  1007. // funkcja istnieje jeśli TERMINAL jest true, jeżeli false nie można jej wywołać - błąd kompilatora, przestaw na true ----- //
  1008. #if TERMINAL
  1009. void TMatrix::ShowAllValue() //
  1010. { //
  1011. ValueMSG(1); // pokaż wartość TRUE/FALSE na fladze : T_Matrix_Busy --------- //
  1012. ValueMSG(2); // pokaż wartość TRUE/FALSE na fladze : T_Matrix_Free --------- //
  1013. ValueMSG(3); // pokaż wartość TRUE/FALSE na fladze : T_Matrix_Off ---------- //
  1014. ValueMSG(4); // pokaż wartosć TRUE/FALSE na fladze : T_Matrix_On ----------- //
  1015. } //
  1016. #endif
  1017. // ------------------------------------------------------------------------------------------------------------------------ //
  1018. // D E M O A L L E F E C T //
  1019. // ------------------------------------------------------------------------------------------------------------------------ //
  1020. //
  1021. void TMatrix::ShowEffectDemo() //
  1022. { //
  1023. static uint8_t curEFX = 0; // statyczny licznik efektów ------------------- //
  1024. static uint8_t curMSG = 0; // statyczny licznik napisów ------------------- //
  1025. // --- GO GO GO ------------------------------------------------------------------------------------------------------- //
  1026. if(P.displayAnimate()) // jeśli animacja trwa ------------------------- //
  1027. { //
  1028. //MSG2Bufor(curMSG); // przygotuj bufor napisu dla m ---------------- //
  1029. char napis[15]; // bufor pomocniczy ---------------------------- //
  1030. MSG2Bufor(curMSG, napis, sizeof(napis)-1); // przygotuj bufor - nowa wersja .............. //
  1031. //strcpy(napis,P_Bufor); // kopiuj z bufora głównego do bufora pomocnicz. //
  1032. //
  1033. // M A T E M A T Y K A J E S T S P O K O - oszczędzamy pamięć i przyśpieszamy ------------------------- //
  1034. //
  1035. curEFX = ( curEFX + 1) % ARRAY_SIZE ( Efect ); // ustaw następnego duszka do kolejki ......... //
  1036. curMSG = ( curMSG + 1) % ARRAY_SIZE ( P_MSG ); // ustaw następną wiadomość do kolejki ........ //
  1037. //
  1038. P.displayText(napis, PA_CENTER, Efect[curEFX].speed, Efect[curEFX].pause,Efect[curEFX].effect, Efect[curEFX].effect);
  1039. //
  1040. // --- jesli M_DEBUG jest true --- pokaż informację o zawartości bufora ------------------------------------------- //
  1041. #if M_DEBUG
  1042. Serial.print(F("ShowEffectDemo -> Utworzono napis w buforze : "));
  1043. Serial.println(napis);
  1044. #endif
  1045. //F_Effect_Demo = true; // przestaw flagę - animacja trwa -------------- //
  1046. } // jeśli animacja się skończyła wypadamy z IF -- //
  1047. //else F_Effect_Demo = false; // przestaw flagę - demo się skończyło --------- //
  1048. // --- END END END ---------------------------------------------------------------------------------------------------- //
  1049. } //
  1050. //
  1051. // ------------------------------------------------------------------------------------------------------------------------ //
  1052. // D E M O S P R I T E A L L E F E C T //
  1053. // ------------------------------------------------------------------------------------------------------------------------ //
  1054. //
  1055. void TMatrix::ShowSpriteDemo() //
  1056. { //
  1057. static uint8_t curEFX = 0; // numer SPRITE -> aktualny duszek ........... //
  1058. static uint8_t curMSG = 0; // numer P_MSG -> aktualny napis ............. //
  1059. // --- jeśli trwa animacja nie wchodź ................................................................................... //
  1060. if (P.displayAnimate()) //
  1061. { //
  1062. //MSG2Bufor(curMSG); // przygotuj bufor - stara wersja jeszcze ..... //
  1063. char napis[15]; // bufor pomocniczy - działa, zostawiamy ...... //
  1064. MSG2Bufor(curMSG, napis, sizeof(napis)-1); // przygotuj bufor - nowa wersja .............. //
  1065. //strcpy(napis,P_Bufor); // kopiuj z bufora P_Bufor do bufora napis .... //
  1066. //
  1067. P.setSpriteData(sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames, // USTAW -> 1 przejście duszka .. //
  1068. sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames); // USTAW -> 2 przejście duszka .. //
  1069. //
  1070. // --- T R O C H Ę Z A A W A N S O W A N E J M A T E M A T Y K I ------------------------------------------------ //
  1071. //
  1072. curEFX = ( curEFX + 1) % ARRAY_SIZE ( sprite ); // ustaw następnego duszka do kolejki ......... //
  1073. curMSG = ( curMSG + 1) % ARRAY_SIZE ( P_MSG ); // ustaw następną wiadomość do kolejki ........ //
  1074. //
  1075. P.displayText(napis, PA_CENTER, 10, 1000, PA_SPRITE, PA_SPRITE); // wyświetl animację .......................... //
  1076. #if M_DEBUG
  1077. Serial.print(F("ShowSpriteDemo -> Utworzono napis w buforze : "));
  1078. Serial.println(napis);
  1079. #endif
  1080. //F_Sprite_Demo = true; // przestaw flagę - demo trwa ................. //
  1081. } //
  1082. //else F_Sprite_Demo = false; // przestaw flagę - demo się skończyło ........ //
  1083. } //
  1084. // ------------------------------------------------------------------------------------------------------------------------ //
  1085. // D E M O R A N D O M - S P R I T E O R E F F E C T //
  1086. // ------------------------------------------------------------------------------------------------------------------------ //
  1087. //
  1088. void TMatrix::ShowRandomDemo() //
  1089. { //
  1090. switch ( rand() % 2 ) // wylosuj liczbę i sprawdź resztę z dzielenia ....... //
  1091. { //
  1092. case 0 : ShowSpriteDemo(); break; // jeśli reszta z dzielenia to : 0 uruchom SPRITE ... //
  1093. case 1 : ShowEffectDemo(); break; // jeśli reszta z dzielenia to : 1 uruchom EFFECT ... //
  1094. } //
  1095. } //
  1096. // ------------------------------------------------------------------------------------------------------------------------ //
  1097. // P O K A Z N A Z W Ę D N I A - E F E K T S P R I T E //
  1098. // ------------------------------------------------------------------------------------------------------------------------ //
  1099. void TMatrix::ShowDayName(uint8_t nr_day) //
  1100. { //
  1101. if( nr_day > 0 && nr_day < 8) // sprawdź czy dzień tygodnia 0 > nr_day < 8 --------- //
  1102. { //
  1103. if(P.displayAnimate()) //
  1104. { //
  1105. char bufor[15]; // bufor do pobrania nazwy dnia ------------------ //
  1106. DayExtract(nr_day, bufor, sizeof(bufor)-1); // pobierz nazwę dnia tygodnia PL lub ENG -------- //
  1107. int curEFX = random ( ARRAY_SIZE ( sprite ) ); //
  1108. P.setSpriteData(sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames, // wejście SPRITE --------- //
  1109. sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames); // wyjśćie SPRITE --------- //
  1110. P.displayText(bufor, PA_CENTER, 10, 1000, PA_SPRITE, PA_SPRITE); // wyświetl napis z bufora //
  1111. } //
  1112. } //
  1113. else // jeśli dzień poza zakresem (możliwe wartości 1-7) ! //
  1114. { //
  1115. #if M_DEBUG
  1116. SerialMSG(8); // wyświetl BŁĄD - dzień tygodnia poza zakresem ------ //
  1117. #endif
  1118. } //
  1119. } //
  1120. // ------------------------------------------------------------------------------------------------------------------------ //
  1121. // P O K A Z N A Z W Ę M I E S I Ą C A - E F E K T S P R I T E //
  1122. // ------------------------------------------------------------------------------------------------------------------------ //
  1123. void TMatrix::ShowMonthName(uint8_t nr_month) //
  1124. { //
  1125. if( nr_month > 0 && nr_month < 13) // sprawdź czy miesiąc > 0 i miesiąc < 13 ------------ //
  1126. { //
  1127. if(P.displayAnimate()) //
  1128. { //
  1129. char bufor[15]; // bufor do pobrania nazwy miesiąć --------------- //
  1130. MonthExtract(nr_month, bufor, sizeof(bufor)-1); // pobierz nazwę dnia tygodnia PL lub ENG -------- //
  1131. int curEFX = random ( ARRAY_SIZE ( sprite ) ); //
  1132. P.setSpriteData(sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames, // wejście SPRITE --------- //
  1133. sprite[curEFX].data,sprite[curEFX].width,sprite[curEFX].frames); // wyjśćie SPRITE --------- //
  1134. P.displayText(bufor, PA_CENTER, 10, 1000, PA_SPRITE, PA_SPRITE); // wyświetl napis z bufora // //
  1135. } //
  1136. } //
  1137. else // jeśli miesiąc poza zakresem (możliwe wartości 1-12) //
  1138. { //
  1139. #if M_DEBUG
  1140. SerialMSG(9); // wyświetl BŁĄD - dzień tygodnia poza zakresem ------ //
  1141. #endif
  1142. }
  1143. } //
  1144. // ------------------------------------------------------------------------------------------------------------------------ //
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!