API tools faq
paste
PowerTGS440

TMatrix v0.057

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