API tools faq
paste
PowerTGS440

TMatrix v0.055

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