Advertisement
Guest User

cube code

a guest
May 25th, 2017
110
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 48.79 KB | None | 0 0
  1. #include "SPI.h"
  2.  
  3. #define SPI_SCK 13 // SPI clock - must be pin 13
  4. #define SPI_MOSI 11 // SPI data out - must be pin 11
  5. #define SR_LATCH 3 // shift register latch - any non SPI pin
  6. #define SR_BLANK 2 // shift register output enable - any non SPI pin
  7. #define TD1 80 // time delay 1 - 100ms
  8. #define TD2 3000 // time delay 2 - 3 seconds
  9. #define TD3 1000 // time delay 3 - 1 second
  10. #define TD4 20 // time delay 4 - 20ms
  11. #define TD5 400 // time delay 5 - 400ms
  12. #define TD6 120 // time delay 5 - 400ms
  13. #define TD7 100 // time delay 5 - 400ms
  14. #define TD8 100
  15. #define TD9 20
  16. #define TD10 100
  17. #define TD11 3000
  18. #define TD12 50
  19. #define TD13 1000
  20. #define TD14 20
  21. #define TD15 100
  22. #define TD16 100
  23. #define TD17 50
  24. #define TD18 1000
  25.  
  26.  
  27. // =====================================================================================================
  28. // variables used by Inturrupt Service Routine (ISR), must be volatile
  29. // =====================================================================================================
  30. volatile byte shiftRegisterRed[64]; // red shift register data, 8 bytes, 1 byte per common anode
  31. volatile byte shiftRegisterGrn[64]; // green shift register data, 8 bytes, 1 byte per common anode
  32. volatile byte shiftRegisterBlu[64]; // blue shift register data, 8 bytes, 1 byte per common anode
  33. volatile byte anodeIndex = 0; // keeps track of which common anode is active
  34. volatile byte anodeLevel[] = { // used by 74HC595N shift register to control the anode multiplexing
  35. B11111110, // This is not an efficient use of variable memory, but what the heck!
  36. B11111101, // at least it shows how the anode multiplexing is done.
  37. B11111011,
  38. B11110111,
  39. B11101111,
  40. B11011111,
  41. B10111111,
  42. B01111111};
  43. byte colours[] = { 1, 2, 4, 3, 6, 5, 7 };
  44.  
  45. // =====================================================================================================
  46. // font definition
  47. // =====================================================================================================
  48. char font8x8_basic[95][8] = {
  49. {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii ( )
  50. {0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x00}, // Ascii (!)
  51. {0x14, 0x14, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (")
  52. {0x14, 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x14, 0x00}, // Ascii (#)
  53. {0x08, 0x3C, 0x0A, 0x1C, 0x28, 0x1E, 0x08, 0x00}, // Ascii ($)
  54. {0x06, 0x26, 0x10, 0x08, 0x04, 0x32, 0x30, 0x00}, // Ascii (%)
  55. {0x0C, 0x12, 0x0A, 0x04, 0x2A, 0x12, 0x2C, 0x00}, // Ascii (&)
  56. {0x0C, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (')
  57. {0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08, 0x00}, // Ascii (()
  58. {0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02, 0x00}, // Ascii ())
  59. {0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x00, 0x00}, // Ascii (*)
  60. {0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00}, // Ascii (+)
  61. {0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x02}, // Ascii (,)
  62. {0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00}, // Ascii (-)
  63. {0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00}, // Ascii (.)
  64. {0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00}, // Ascii (/)
  65. {0x1C, 0x22, 0x32, 0x2A, 0x26, 0x22, 0x1C, 0x00}, // Ascii (0)
  66. {0x08, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x1C, 0x00}, // Ascii (1)
  67. {0x1C, 0x22, 0x20, 0x18, 0x04, 0x02, 0x3E, 0x00}, // Ascii (2)
  68. {0x1C, 0x22, 0x20, 0x18, 0x20, 0x22, 0x1C, 0x00}, // Ascii (3)
  69. {0x10, 0x18, 0x14, 0x12, 0x3E, 0x10, 0x10, 0x00}, // Ascii (4)
  70. {0x3E, 0x02, 0x1E, 0x20, 0x20, 0x22, 0x1C, 0x00}, // Ascii (5)
  71. {0x18, 0x04, 0x02, 0x1E, 0x22, 0x22, 0x1C, 0x00}, // Ascii (6)
  72. {0x3E, 0x20, 0x10, 0x08, 0x04, 0x04, 0x04, 0x00}, // Ascii (7)
  73. {0x1C, 0x22, 0x22, 0x1C, 0x22, 0x22, 0x1C, 0x00}, // Ascii (8)
  74. {0x1C, 0x22, 0x22, 0x3C, 0x20, 0x10, 0x0C, 0x00}, // Ascii (9)
  75. {0x00, 0x0C, 0x0C, 0x00, 0x0C, 0x0C, 0x00, 0x00}, // Ascii (:)
  76. {0x00, 0x00, 0x0C, 0x0C, 0x00, 0x0C, 0x08, 0x04}, // Ascii (;)
  77. {0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00}, // Ascii (<)
  78. {0x00, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x00, 0x00}, // Ascii (=)
  79. {0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02, 0x00}, // Ascii (>)
  80. {0x1C, 0x22, 0x20, 0x10, 0x08, 0x00, 0x08, 0x00}, // Ascii (?)
  81. {0x1C, 0x22, 0x20, 0x2C, 0x2A, 0x2A, 0x1C, 0x00}, // Ascii (@)
  82. {0x1C, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x00}, // Ascii (A)
  83. {0x1E, 0x22, 0x22, 0x1E, 0x22, 0x22, 0x1E, 0x00}, // Ascii (B)
  84. {0x1C, 0x22, 0x02, 0x02, 0x02, 0x22, 0x1C, 0x00}, // Ascii (C)
  85. {0x0E, 0x12, 0x22, 0x22, 0x22, 0x12, 0x0E, 0x00}, // Ascii (D)
  86. {0x3E, 0x02, 0x02, 0x1E, 0x02, 0x02, 0x3E, 0x00}, // Ascii (E)
  87. {0x3E, 0x02, 0x02, 0x1E, 0x02, 0x02, 0x02, 0x00}, // Ascii (F)
  88. {0x1C, 0x22, 0x02, 0x02, 0x32, 0x22, 0x3C, 0x00}, // Ascii (G)
  89. {0x22, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x00}, // Ascii (H)
  90. {0x0E, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0E, 0x00}, // Ascii (I)
  91. {0x38, 0x10, 0x10, 0x10, 0x10, 0x12, 0x0C, 0x00}, // Ascii (J)
  92. {0x22, 0x12, 0x0A, 0x06, 0x0A, 0x12, 0x22, 0x00}, // Ascii (K)
  93. {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x3E, 0x00}, // Ascii (L)
  94. {0x22, 0x36, 0x2A, 0x2A, 0x22, 0x22, 0x22, 0x00}, // Ascii (M)
  95. {0x22, 0x22, 0x26, 0x2A, 0x32, 0x22, 0x22, 0x00}, // Ascii (N)
  96. {0x1C, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00}, // Ascii (O)
  97. {0x1E, 0x22, 0x22, 0x1E, 0x02, 0x02, 0x02, 0x00}, // Ascii (P)
  98. {0x1C, 0x22, 0x22, 0x22, 0x2A, 0x12, 0x2C, 0x00}, // Ascii (Q)
  99. {0x1E, 0x22, 0x22, 0x1E, 0x0A, 0x12, 0x22, 0x00}, // Ascii (R)
  100. {0x1C, 0x22, 0x02, 0x1C, 0x20, 0x22, 0x1C, 0x00}, // Ascii (S)
  101. {0x3E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00}, // Ascii (T)
  102. {0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00}, // Ascii (U)
  103. {0x22, 0x22, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00}, // Ascii (V)
  104. {0x22, 0x22, 0x22, 0x2A, 0x2A, 0x2A, 0x14, 0x00}, // Ascii (W)
  105. {0x22, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00}, // Ascii (X)
  106. {0x22, 0x22, 0x14, 0x08, 0x08, 0x08, 0x08, 0x00}, // Ascii (Y)
  107. {0x3E, 0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x00}, // Ascii (Z)
  108. {0x0E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0E, 0x00}, // Ascii ([)
  109. {0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00}, // Ascii (\)
  110. {0x0E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0E, 0x00}, // Ascii (])
  111. {0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (^)
  112. {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E}, // Ascii (_)
  113. {0x02, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (`)
  114. {0x00, 0x00, 0x1C, 0x20, 0x3C, 0x22, 0x3C, 0x00}, // Ascii (a)
  115. {0x02, 0x02, 0x1A, 0x26, 0x22, 0x22, 0x1E, 0x00}, // Ascii (b)
  116. {0x00, 0x00, 0x0C, 0x12, 0x02, 0x12, 0x0C, 0x00}, // Ascii (c)
  117. {0x20, 0x20, 0x2C, 0x32, 0x22, 0x22, 0x3C, 0x00}, // Ascii (d)
  118. {0x00, 0x00, 0x1C, 0x22, 0x3E, 0x02, 0x1C, 0x00}, // Ascii (e)
  119. {0x08, 0x14, 0x04, 0x0E, 0x04, 0x04, 0x04, 0x00}, // Ascii (f)
  120. {0x00, 0x00, 0x3C, 0x22, 0x22, 0x3C, 0x20, 0x1C}, // Ascii (g)
  121. {0x02, 0x02, 0x1A, 0x26, 0x22, 0x22, 0x22, 0x00}, // Ascii (h)
  122. {0x04, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00}, // Ascii (i)
  123. {0x08, 0x00, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x06}, // Ascii (j)
  124. {0x02, 0x02, 0x12, 0x0A, 0x06, 0x0A, 0x12, 0x00}, // Ascii (k)
  125. {0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0E, 0x00}, // Ascii (l)
  126. {0x00, 0x00, 0x16, 0x2A, 0x2A, 0x22, 0x22, 0x00}, // Ascii (m)
  127. {0x00, 0x00, 0x1A, 0x16, 0x12, 0x12, 0x12, 0x00}, // Ascii (n)
  128. {0x00, 0x00, 0x0C, 0x12, 0x12, 0x12, 0x0C, 0x00}, // Ascii (o)
  129. {0x00, 0x00, 0x0E, 0x12, 0x12, 0x0E, 0x02, 0x02}, // Ascii (p)
  130. {0x00, 0x00, 0x1C, 0x12, 0x12, 0x1C, 0x10, 0x10}, // Ascii (q)
  131. {0x00, 0x00, 0x14, 0x0C, 0x04, 0x04, 0x04, 0x00}, // Ascii (r)
  132. {0x00, 0x00, 0x1C, 0x02, 0x0C, 0x10, 0x0E, 0x00}, // Ascii (s)
  133. {0x04, 0x04, 0x0E, 0x04, 0x04, 0x04, 0x0C, 0x00}, // Ascii (t)
  134. {0x00, 0x00, 0x12, 0x12, 0x12, 0x12, 0x1C, 0x00}, // Ascii (u)
  135. {0x00, 0x00, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00}, // Ascii (v)
  136. {0x00, 0x00, 0x22, 0x22, 0x2A, 0x2A, 0x14, 0x00}, // Ascii (w)
  137. {0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x00}, // Ascii (x)
  138. {0x00, 0x00, 0x12, 0x12, 0x12, 0x1C, 0x10, 0x0C}, // Ascii (y)
  139. {0x00, 0x00, 0x3E, 0x10, 0x08, 0x04, 0x3E, 0x00}, // Ascii (z)
  140. {0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08, 0x00}, // Ascii ({)
  141. {0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00}, // Ascii (|)
  142. {0x02, 0x04, 0x04, 0x08, 0x04, 0x04, 0x02, 0x00}, // Ascii (})
  143. {0x2C, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; // Ascii (~)
  144.  
  145.  
  146.  
  147. // =====================================================================================================
  148. // ~~~ START of SETUP ~~~
  149. // =====================================================================================================
  150. void setup() {
  151.  
  152. // set up IO pins as outputs
  153. // -------------------------------------------------------------
  154. pinMode(SPI_SCK, OUTPUT);
  155. pinMode(SPI_MOSI, OUTPUT);
  156. pinMode(SR_LATCH, OUTPUT);
  157. pinMode(SR_BLANK, OUTPUT);
  158.  
  159. digitalWrite(SR_BLANK, HIGH); // temporarily disable all shift register outputs
  160. digitalWrite(SR_LATCH, LOW); // set shift register latch to initial state
  161.  
  162. // set up Timer 2 for 8KHz (125uS) interrupt
  163. // code example from Amanda Ghassaei
  164. // http://www.instructables.com/id/Arduino-Timer-Interrupts/?ALLSTEPS
  165. // ------------------------------------------------------------------
  166. cli(); // stop interrupts
  167. TCCR2A = 0; // set entire TCCR2A register to 0
  168. TCCR2B = 0; // same for TCCR2B
  169. TCNT2 = 0; // initialize counter value to 0
  170. OCR2A = 249; // Set compare match register for 16KHz. Increments calculated as follows:
  171. // Arduino clk frequency 16MHz / (required frequency * Prescaler of 8) - 1, Result must be < 256.
  172. // So for this instance we calculate 16,000,000 / (8,000 * 8) - 1 = 249
  173. TCCR2A |= (1 << WGM21); // turn on CTC mode
  174. TCCR2B |= (1 << CS21); // Set CS21 bit for 8 pre-scalar
  175. TIMSK2 |= (1 << OCIE2A); // enable timer compare interrupt
  176. sei(); // allow interrupts
  177. // end code example from Amanda Ghassaei
  178. // -------------------------------------------------------------
  179.  
  180. // initialise SPI
  181. // -------------------------------------------------------------
  182. SPI.setDataMode (SPI_MODE0 ); // mode 0 rising edge of data, keep clock low
  183. SPI.setBitOrder (MSBFIRST ); // most significant bit first
  184. SPI.setClockDivider(SPI_CLOCK_DIV2); // run the data in at 16MHz/2 - 8MHz (max speed)
  185. SPI.begin(); // start up SPI
  186.  
  187. // initialise Serial Port for de-bugging
  188. // -------------------------------------------------------------
  189. Serial.begin (115200 ); // set up serial port for 115200 baud rate
  190. Serial.println("Start"); // display Start in Terminal Window
  191.  
  192. randomSeed(analogRead(0)); // set random seed
  193.  
  194. // display some text, only runs once
  195. // -------------------------------------------------------------
  196. //displaySomeText("WELCOME TO THE 8x8 RGB LED PANEL TESTING... ", TD5);
  197. }
  198. // ====================
  199. // ~~~ END of SETUP ~~~
  200. // ====================
  201.  
  202.  
  203. byte colourIndex = 0;
  204.  
  205. // =====================================================================================================
  206. // ~~~ START of LOOP ~~~
  207. // =====================================================================================================
  208. void loop() {
  209.  
  210. animatieEen(TD8,TD9);
  211. animatieTwee(TD10,TD11);
  212. animatieDrie (TD12,TD13);
  213. animatieVier (TD14);
  214. animatieVijf(TD15);
  215. animatieZes(TD16,1,0,0);
  216. animatieZes(TD16,1,1,1);
  217. animatieZes(TD16,0,1,1);
  218. animatieZes(TD16,1,0,1);
  219. animatieZeven(TD17,TD18);
  220.  
  221. }
  222. // ===================
  223. // ~~~ END of LOOP ~~~
  224. // ===================
  225.  
  226. void animatieEen (int TD99, int TD98) {
  227.  
  228. ////////////////////////////////////////// nieuwe functie 1
  229. for (int j = 0; j < 8; j++) {
  230. for(int i = 0; i < 8; i++){
  231. setPixel(0,i,j,1,1,0);
  232. delay(TD99);
  233. }
  234. }
  235. /////////////////////////////////////////////////////////////////////////// 2
  236.  
  237. for (int i = 0; i < 8; i++) {
  238. setPixel(1,i,0,1,1,0);
  239. setPixel(0,i,7,0,0,0);
  240. }
  241. delay(TD98);
  242.  
  243. for (int i = 0; i < 8; i++) {
  244. setPixel(2,i,0,1,1,0);
  245. setPixel(0,i,6,0,0,0);
  246. }
  247. delay(TD98);
  248.  
  249. for (int i = 0; i < 8; i++) {
  250. setPixel(3,i,0,1,1,0);
  251. setPixel(0,i,5,0,0,0);
  252. }
  253. delay(TD98);
  254.  
  255. for (int i = 0; i < 8; i++) {
  256. setPixel(4,i,0,1,1,0);
  257. setPixel(0,i,4,0,0,0);
  258. }
  259. delay(TD98);
  260.  
  261. for (int i = 0; i < 8; i++) {
  262. setPixel(5,i,0,1,1,0);
  263. setPixel(0,i,3,0,0,0);
  264. }
  265. delay(TD98);
  266.  
  267. for (int i = 0; i < 8; i++) {
  268. setPixel(6,i,0,1,1,0);
  269. setPixel(0,i,2,0,0,0);
  270. }
  271. delay(TD98);
  272.  
  273. for (int i = 0; i < 8; i++) {
  274. setPixel(7,i,0,1,1,0);
  275. setPixel(0,i,1,0,0,0);
  276. }
  277. delay(TD98);
  278.  
  279. /////////////////////////////////////////////////////////////////////////////////////////// 3
  280.  
  281. for (int i = 0; i < 8; i++) {
  282. setPixel(7,i,1,1,1,0);
  283. setPixel(0,i,0,0,0,0);
  284. }
  285. delay(TD98);
  286.  
  287. for (int i = 0; i < 8; i++) {
  288. setPixel(7,i,2,1,1,0);
  289. setPixel(1,i,0,0,0,0);
  290. }
  291. delay(TD98);
  292.  
  293. for (int i = 0; i < 8; i++) {
  294. setPixel(7,i,3,1,1,0);
  295. setPixel(2,i,0,0,0,0);
  296. }
  297. delay(TD98);
  298.  
  299. for (int i = 0; i < 8; i++) {
  300. setPixel(7,i,4,1,1,0);
  301. setPixel(3,i,0,0,0,0);
  302. }
  303. delay(TD98);
  304.  
  305. for (int i = 0; i < 8; i++) {
  306. setPixel(7,i,5,1,1,0);
  307. setPixel(4,i,0,0,0,0);
  308. }
  309. delay(TD98);
  310.  
  311. for (int i = 0; i < 8; i++) {
  312. setPixel(7,i,6,1,1,0);
  313. setPixel(5,i,0,0,0,0);
  314. }
  315. delay(TD98);
  316.  
  317. for (int i = 0; i < 8; i++) {
  318. setPixel(7,i,7,1,1,0);
  319. setPixel(6,i,0,0,0,0);
  320. }
  321. delay(TD98);
  322.  
  323.  
  324. /////////////////////////////////////////////////////////////////////////////// 4
  325.  
  326.  
  327. for (int i = 0; i < 8; i++) {
  328. setPixel(6,i,7,1,1,0);
  329. setPixel(7,i,0,0,0,0);
  330. }
  331. delay(TD98);
  332.  
  333. for (int i = 0; i < 8; i++) {
  334. setPixel(5,i,7,1,1,0);
  335. setPixel(7,i,1,0,0,0);
  336. }
  337. delay(TD98);
  338.  
  339. for (int i = 0; i < 8; i++) {
  340. setPixel(4,i,7,1,1,0);
  341. setPixel(7,i,2,0,0,0);
  342. }
  343. delay(TD98);
  344.  
  345.  
  346. for (int i = 0; i < 8; i++) {
  347. setPixel(3,i,7,1,1,0);
  348. setPixel(7,i,3,0,0,0);
  349. }
  350. delay(TD98);
  351.  
  352. for (int i = 0; i < 8; i++) {
  353. setPixel(2,i,7,1,1,0);
  354. setPixel(7,i,4,0,0,0);
  355. }
  356. delay(TD98);
  357.  
  358. for (int i = 0; i < 8; i++) {
  359. setPixel(1,i,7,1,1,0);
  360. setPixel(7,i,5,0,0,0);
  361. }
  362. delay(TD98);
  363.  
  364. for (int i = 0; i < 8; i++) {
  365. setPixel(0,i,7,1,1,0);
  366. setPixel(7,i,6,0,0,0);
  367. }
  368. delay(TD98);
  369.  
  370.  
  371. ////////////////////////////////////////////////////////////////////////////// 5
  372.  
  373. for (int i = 0; i < 8; i++) {
  374. setPixel(0,i,6,1,1,0);
  375. setPixel(7,i,7,0,0,0);
  376. }
  377. delay(TD98);
  378.  
  379.  
  380. for (int i = 0; i < 8; i++) {
  381. setPixel(0,i,5,1,1,0);
  382. setPixel(6,i,7,0,0,0);
  383. }
  384. delay(TD98);
  385.  
  386. for (int i = 0; i < 8; i++) {
  387. setPixel(0,i,4,1,1,0);
  388. setPixel(5,i,7,0,0,0);
  389. }
  390. delay(TD98);
  391.  
  392.  
  393. for (int i = 0; i < 8; i++) {
  394. setPixel(0,i,3,1,1,0);
  395. setPixel(4,i,7,0,0,0);
  396. }
  397. delay(TD98);
  398.  
  399. for (int i = 0; i < 8; i++) {
  400. setPixel(0,i,2,1,1,0);
  401. setPixel(3,i,7,0,0,0);
  402. }
  403. delay(TD98);
  404.  
  405. for (int i = 0; i < 8; i++) {
  406. setPixel(0,i,1,1,1,0);
  407. setPixel(2,i,7,0,0,0);
  408. }
  409. delay(TD98);
  410.  
  411. for (int i = 0; i < 8; i++) {
  412. setPixel(0,i,0,1,1,0);
  413. setPixel(1,i,7,0,0,0);
  414. }
  415. delay(TD98);
  416.  
  417.  
  418. //////////////////////////////////////////////////////////////////////// 6
  419.  
  420. for (int i = 0; i < 8; i++) {
  421. setPixel(0,0,i,0,0,0);
  422. delay(TD99);
  423. }
  424.  
  425. for (int i = 0; i < 8; i++) {
  426. setPixel(0,1,i,0,0,0);
  427. delay(TD99);
  428. }
  429.  
  430. for (int i = 0; i < 8; i++) {
  431. setPixel(0,2,i,0,0,0);
  432. delay(TD99);
  433. }
  434.  
  435. for (int i = 0; i < 8; i++) {
  436. setPixel(0,3,i,0,0,0);
  437. delay(TD99);
  438. }
  439.  
  440. for (int i = 0; i < 8; i++) {
  441. setPixel(0,4,i,0,0,0);
  442. delay(TD99);
  443. }
  444.  
  445. for (int i = 0; i < 8; i++) {
  446. setPixel(0,5,i,0,0,0);
  447. delay(TD99);
  448. }
  449.  
  450. for (int i = 0; i < 8; i++) {
  451. setPixel(0,6,i,0,0,0);
  452. delay(TD99);
  453. }
  454.  
  455. for (int i = 0; i < 8; i++) {
  456. setPixel(0,7,i,0,0,0);
  457. delay(TD99);
  458. }
  459.  
  460. }
  461.  
  462. void animatieTwee(int TD97,int TD96) {
  463.  
  464. beginleds();
  465. een(1,8,1,8,TD97);
  466. vijf(0,7,1,8,TD97);
  467. drie(0,7,0,7,TD97);
  468. zes(0,7,0,7,TD97);
  469. twee(0,7,1,8,TD97);
  470. vier(1,8,1,8,TD97);
  471. vijf(1,8,1,8,TD97);
  472. een(1,8,0,7,TD97);
  473. drie(0,7,0,7,TD97);
  474. zes(0,7,0,7,TD97);
  475. vier(0,8,1,8,TD97);
  476. delay(TD96);
  477.  
  478. }
  479.  
  480. void beginleds () {
  481.  
  482. for (int a = 0; a < 8; a++) {
  483. for (int b = 0; b < 8; b++) {
  484. setPixel(0,a,b,1,1,0);
  485. }
  486. }
  487.  
  488. for (int a = 0; a < 8; a++) {
  489. for (int b = 0; b < 8; b++) {
  490. setPixel(b,a,0,1,1,0);
  491. }
  492. }
  493.  
  494. for (int a = 0; a < 8; a++) {
  495. for (int b = 0; b < 8; b++) {
  496. setPixel(a,0,b,1,1,0);
  497. }
  498. }
  499.  
  500. };
  501.  
  502. void een (int u, int v, int w, int x, int TD95) {
  503.  
  504. for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
  505.  
  506. for (int a = u; a < v; a++) {
  507. for (int b = w; b < x; b++) {
  508. setPixel(c,a,b,1,1,0); //1
  509. }
  510. }
  511.  
  512. for (int a = u; a < v; a++) {
  513. for (int b = w; b < x; b++) {
  514. setPixel(d,a,b,0,0,0); //0
  515. }
  516. }
  517. delay(TD95);
  518. }
  519.  
  520.  
  521. };
  522.  
  523. void twee (int u, int v, int w, int x, int TD95) {
  524.  
  525. for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
  526.  
  527. for (int a = u; a < v; a++) {
  528. for (int b = w; b < x; b++) {
  529. setPixel(c,a,b,1,1,0); //6
  530. }
  531. }
  532.  
  533. for (int a = u; a < v; a++) {
  534. for (int b = w; b < x; b++) {
  535. setPixel(d,a,b,0,0,0); //7
  536. }
  537. }
  538. delay(TD95);
  539. }
  540.  
  541.  
  542. };
  543.  
  544. void drie (int u, int v, int w, int x, int TD95) {
  545.  
  546. for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
  547.  
  548. for (int a = u; a < v; a++) {
  549. for (int b = w; b < x; b++) {
  550. setPixel(a,c,b,1,1,0);
  551. }
  552. }
  553.  
  554. for (int a = u; a < v; a++) {
  555. for (int b = w; b < x; b++) {
  556. setPixel(a,d,b,0,0,0);
  557. }
  558. }
  559. delay(TD95);
  560. }
  561.  
  562. };
  563.  
  564. void vier (int u, int v, int w, int x, int TD95) {
  565.  
  566. for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
  567.  
  568. for (int a = u; a < v; a++) {
  569. for (int b = w; b < x; b++) {
  570. setPixel(a,c,b,1,1,0);
  571. }
  572. }
  573.  
  574. for (int a = u; a < v; a++) {
  575. for (int b = w; b < x; b++) {
  576. setPixel(a,d,b,0,0,0);
  577. }
  578. }
  579. delay(TD95);
  580. }
  581.  
  582. };
  583.  
  584. void vijf (int u, int v, int w, int x, int TD95) {
  585.  
  586. for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
  587.  
  588. for (int a = u; a < v; a++) {
  589. for (int b = w; b < x; b++) {
  590. setPixel(a,b,c,1,1,0);
  591. }
  592. }
  593.  
  594. for (int a = u; a < v; a++) {
  595. for (int b = w; b < x; b++) {
  596. setPixel(a,b,d,0,0,0);
  597. }
  598. }
  599. delay(TD95);
  600. }
  601.  
  602. };
  603.  
  604. void zes (int u, int v, int w, int x, int TD95) {
  605.  
  606. for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
  607.  
  608. for (int a = u; a < v; a++) {
  609. for (int b = w; b < x; b++) {
  610. setPixel(a,b,c,1,1,0);
  611. }
  612. }
  613.  
  614. for (int a = u; a < v; a++) {
  615. for (int b = w; b < x; b++) {
  616. setPixel(a,b,d,0,0,0);
  617. }
  618. }
  619. delay(TD95);
  620. }
  621.  
  622. };
  623.  
  624. void animatieDrie (int TD94,int TD93) {
  625.  
  626. for (int i = 0; i < 8; i++) {
  627. setPixel(i,0,0,1,1,0);
  628. }
  629. delay (TD94);
  630.  
  631. for (int i = 0; i < 8; i++) {
  632. setPixel(i,1,0,1,1,0);
  633. setPixel(i,0,1,1,1,0);
  634. }
  635. delay (TD94);
  636.  
  637. for (int i = 0; i < 8; i++) {
  638. setPixel(i,2,0,1,1,0);
  639. setPixel(i,0,2,1,1,0);
  640. setPixel(i,1,1,1,1,0);
  641. }
  642. delay (TD94);
  643.  
  644. for (int i = 0; i < 8; i++) {
  645. setPixel(i,3,0,1,1,0);
  646. setPixel(i,0,3,1,1,0);
  647. setPixel(i,1,2,1,1,0);
  648. setPixel(i,2,1,1,1,0);
  649. }
  650. delay (TD94);
  651.  
  652. for (int i = 0; i < 8; i++) {
  653. setPixel(i,4,0,1,1,0);
  654. setPixel(i,3,1,1,1,0);
  655. setPixel(i,1,3,1,1,0);
  656. setPixel(i,2,2,1,1,0);
  657. setPixel(i,0,4,1,1,0);
  658. }
  659. delay (TD94);
  660.  
  661. for (int i = 0; i < 8; i++) {
  662. setPixel(i,5,0,0,1,0);
  663. setPixel(i,4,1,1,1,0);
  664. setPixel(i,3,2,1,1,0);
  665. setPixel(i,2,3,1,1,0);
  666. setPixel(i,1,4,1,1,0);
  667. setPixel(i,0,5,1,1,0);
  668. }
  669. delay (TD94);
  670.  
  671. for (int i = 0; i < 8; i++) {
  672. setPixel(i,6,0,1,1,0);
  673. setPixel(i,5,1,1,1,0);
  674. setPixel(i,4,2,1,1,0);
  675. setPixel(i,3,3,1,1,0);
  676. setPixel(i,2,4,1,1,0);
  677. setPixel(i,1,5,1,1,0);
  678. setPixel(i,0,6,1,1,0);
  679. }
  680. delay (TD94);
  681.  
  682. for (int i = 0; i < 8; i++) {
  683. setPixel(i,7,0,1,1,0);
  684. setPixel(i,6,1,1,1,0);
  685. setPixel(i,5,2,0,1,0);
  686. setPixel(i,4,3,1,1,0);
  687. setPixel(i,3,4,1,1,0);
  688. setPixel(i,2,5,1,1,0);
  689. setPixel(i,1,6,1,1,0);
  690. setPixel(i,0,7,1,1,0);
  691. }
  692. delay (TD94);
  693.  
  694. for (int i = 0; i < 8; i++) {
  695. setPixel(i,7,1,1,1,0);
  696. setPixel(i,6,2,1,1,0);
  697. setPixel(i,5,3,1,1,0);
  698. setPixel(i,4,4,1,1,0);
  699. setPixel(i,3,5,1,1,0);
  700. setPixel(i,2,6,1,1,0);
  701. setPixel(i,1,7,1,1,0);
  702. }
  703. delay (TD94);
  704.  
  705. for (int i = 0; i < 8; i++) {
  706. setPixel(i,7,2,1,1,0);
  707. setPixel(i,6,3,1,1,0);
  708. setPixel(i,5,4,1,1,0);
  709. setPixel(i,4,5,1,1,0);
  710. setPixel(i,3,6,1,1,0);
  711. setPixel(i,2,7,1,1,0);
  712. }
  713. delay (TD94);
  714.  
  715. for (int i = 0; i < 8; i++) {
  716. setPixel(i,7,3,1,1,0);
  717. setPixel(i,6,4,1,1,0);
  718. setPixel(i,5,5,1,1,0);
  719. setPixel(i,4,6,1,1,0);
  720. setPixel(i,3,7,1,1,0);
  721. }
  722. delay (TD94);
  723.  
  724. for (int i = 0; i < 8; i++) {
  725. setPixel(i,7,4,1,1,0);
  726. setPixel(i,6,5,1,1,0);
  727. setPixel(i,5,6,1,1,0);
  728. setPixel(i,4,7,1,1,0);
  729. }
  730. delay (TD94);
  731.  
  732. for (int i = 0; i < 8; i++) {
  733. setPixel(i,7,5,1,1,0);
  734. setPixel(i,6,6,1,1,0);
  735. setPixel(i,5,7,1,1,0);
  736. }
  737. delay (TD94);
  738.  
  739. for (int i = 0; i < 8; i++) {
  740. setPixel(i,7,6,1,1,0);
  741. setPixel(i,6,7,1,1,0);
  742. }
  743. delay (TD94);
  744.  
  745. for (int i = 0; i < 8; i++) {
  746. setPixel(i,7,7,1,1,0);
  747. }
  748. delay (TD94);
  749. delay (TD93);
  750. for (int i = 0; i < 8; i++) {
  751. for (int j = 0; j < 8; j++) {
  752. for (int k = 0; k < 8; k++) {
  753. setPixel(i,j,k,0,0,0);
  754. }
  755. }
  756. }
  757. ///////////////////////////////////////////////
  758.  
  759. for (int i = 0; i < 8; i++) {
  760. setPixel(i,7,7,0,1,0);
  761. }
  762. delay (TD94);
  763.  
  764. for (int i = 0; i < 8; i++) {
  765. setPixel(i,6,7,0,1,0);
  766. setPixel(i,7,6,0,1,0);
  767. }
  768. delay (TD94);
  769.  
  770. for (int i = 0; i < 8; i++) {
  771. setPixel(i,5,7,0,1,0);
  772. setPixel(i,6,6,0,1,0);
  773. setPixel(i,7,5,0,1,0);
  774. }
  775. delay (TD94);
  776.  
  777. for (int i = 0; i < 8; i++) {
  778. setPixel(i,4,7,0,1,0);
  779. setPixel(i,5,6,0,1,0);
  780. setPixel(i,6,5,0,1,0);
  781. setPixel(i,7,4,0,1,0);
  782. }
  783. delay (TD94);
  784.  
  785. for (int i = 0; i < 8; i++) {
  786. setPixel(i,3,7,0,1,0);
  787. setPixel(i,4,6,0,1,0);
  788. setPixel(i,5,5,0,1,0);
  789. setPixel(i,6,4,0,1,0);
  790. setPixel(i,7,3,0,1,0);
  791. }
  792. delay (TD94);
  793.  
  794. for (int i = 0; i < 8; i++) {
  795. setPixel(i,2,7,0,1,0);
  796. setPixel(i,3,6,0,1,0);
  797. setPixel(i,4,5,0,1,0);
  798. setPixel(i,5,4,0,1,0);
  799. setPixel(i,6,3,0,1,0);
  800. setPixel(i,7,2,0,1,0);
  801.  
  802. }
  803. delay (TD94);
  804.  
  805. for (int i = 0; i < 8; i++) {
  806. setPixel(i,1,7,0,1,0);
  807. setPixel(i,2,6,0,1,0);
  808. setPixel(i,3,5,0,1,0);
  809. setPixel(i,4,4,0,1,0);
  810. setPixel(i,5,3,0,1,0);
  811. setPixel(i,6,2,0,1,0);
  812. setPixel(i,7,1,0,1,0);
  813. }
  814. delay (TD94);
  815.  
  816. for (int i = 0; i < 8; i++) {
  817. setPixel(i,0,7,0,1,0);
  818. setPixel(i,1,6,0,1,0);
  819. setPixel(i,2,5,0,1,0);
  820. setPixel(i,3,4,0,1,0);
  821. setPixel(i,4,3,0,1,0);
  822. setPixel(i,5,2,0,1,0);
  823. setPixel(i,6,1,0,1,0);
  824. setPixel(i,7,0,0,1,0);
  825. }
  826. delay (TD94);
  827.  
  828. for (int i = 0; i < 8; i++) {
  829. setPixel(i,0,6,0,1,0);
  830. setPixel(i,1,5,0,1,0);
  831. setPixel(i,2,4,0,1,0);
  832. setPixel(i,3,3,0,1,0);
  833. setPixel(i,4,2,0,1,0);
  834. setPixel(i,5,1,0,1,0);
  835. setPixel(i,6,0,0,1,0);
  836. }
  837. delay (TD94);
  838.  
  839. for (int i = 0; i < 8; i++) {
  840. setPixel(i,0,5,0,1,0);
  841. setPixel(i,1,4,0,1,0);
  842. setPixel(i,2,3,0,1,0);
  843. setPixel(i,3,2,0,1,0);
  844. setPixel(i,4,1,0,1,0);
  845. setPixel(i,5,0,0,1,0);
  846. }
  847. delay (TD94);
  848.  
  849. for (int i = 0; i < 8; i++) {
  850. setPixel(i,0,4,0,1,0);
  851. setPixel(i,1,3,0,1,0);
  852. setPixel(i,2,2,0,1,0);
  853. setPixel(i,3,1,0,1,0);
  854. setPixel(i,4,0,0,1,0);
  855. }
  856. delay (TD94);
  857.  
  858. for (int i = 0; i < 8; i++) {
  859. setPixel(i,0,3,0,1,0);
  860. setPixel(i,1,2,0,1,0);
  861. setPixel(i,2,1,0,1,0);
  862. setPixel(i,3,0,0,1,0);
  863. }
  864. delay (TD94);
  865.  
  866. for (int i = 0; i < 8; i++) {
  867. setPixel(i,0,2,0,1,0);
  868. setPixel(i,1,1,0,1,0);
  869. setPixel(i,2,0,0,1,0);
  870. }
  871. delay (TD94);
  872.  
  873. for (int i = 0; i < 8; i++) {
  874. setPixel(i,0,1,0,1,0);
  875. setPixel(i,1,0,0,1,0);
  876. }
  877. delay (TD94);
  878.  
  879. for (int i = 0; i < 8; i++) {
  880. setPixel(i,0,0,0,1,0);
  881. }
  882. delay (TD94);
  883. delay (TD93);
  884. for (int i = 0; i < 8; i++) {
  885. for (int j = 0; j < 8; j++) {
  886. for (int k = 0; k < 8; k++) {
  887. setPixel(i,j,k,0,0,0);
  888. }
  889. }
  890. }
  891. ////////////////////////////////////////////////////////////
  892.  
  893. for (int i = 0; i < 8; i++) {
  894. setPixel(7,7,i,0,1,1);
  895. }
  896. delay (TD94);
  897.  
  898. for (int i = 0; i < 8; i++) {
  899. setPixel(7,6,i,0,1,1);
  900. setPixel(6,7,i,0,1,1);
  901. }
  902. delay (TD94);
  903.  
  904. for (int i = 0; i < 8; i++) {
  905. setPixel(7,5,i,0,1,1);
  906. setPixel(6,6,i,0,1,1);
  907. setPixel(5,7,i,0,1,1);
  908. }
  909. delay (TD94);
  910.  
  911. for (int i = 0; i < 8; i++) {
  912. setPixel(7,4,i,0,1,1);
  913. setPixel(6,5,i,0,1,1);
  914. setPixel(5,6,i,0,1,1);
  915. setPixel(4,7,i,0,1,1);
  916. }
  917. delay (TD94);
  918.  
  919. for (int i = 0; i < 8; i++) {
  920. setPixel(7,3,i,0,1,1);
  921. setPixel(6,4,i,0,1,1);
  922. setPixel(5,5,i,0,1,1);
  923. setPixel(4,6,i,0,1,1);
  924. setPixel(3,7,i,0,1,1);
  925. }
  926. delay (TD94);
  927.  
  928. for (int i = 0; i < 8; i++) {
  929. setPixel(7,2,i,0,1,1);
  930. setPixel(6,3,i,0,1,1);
  931. setPixel(5,4,i,0,1,1);
  932. setPixel(4,5,i,0,1,1);
  933. setPixel(3,6,i,0,1,1);
  934. setPixel(2,7,i,0,1,1);
  935. }
  936. delay (TD94);
  937.  
  938. for (int i = 0; i < 8; i++) {
  939. setPixel(7,1,i,0,1,1);
  940. setPixel(6,2,i,0,1,1);
  941. setPixel(5,3,i,0,1,1);
  942. setPixel(4,4,i,0,1,1);
  943. setPixel(3,5,i,0,1,1);
  944. setPixel(2,6,i,0,1,1);
  945. setPixel(1,7,i,0,1,1);
  946. }
  947. delay (TD94);
  948.  
  949. for (int i = 0; i < 8; i++) {
  950. setPixel(7,0,i,0,1,1);
  951. setPixel(6,1,i,0,1,1);
  952. setPixel(5,2,i,0,1,1);
  953. setPixel(4,3,i,0,1,1);
  954. setPixel(3,4,i,0,1,1);
  955. setPixel(2,5,i,0,1,1);
  956. setPixel(1,6,i,0,1,1);
  957. setPixel(0,7,i,0,1,1);
  958. }
  959. delay (TD94);
  960.  
  961. for (int i = 0; i < 8; i++) {
  962. setPixel(6,0,i,0,1,1);
  963. setPixel(5,1,i,0,1,1);
  964. setPixel(4,2,i,0,1,1);
  965. setPixel(3,3,i,0,1,1);
  966. setPixel(2,4,i,0,1,1);
  967. setPixel(1,5,i,0,1,1);
  968. setPixel(0,6,i,0,1,1);
  969. }
  970. delay (TD94);
  971.  
  972. for (int i = 0; i < 8; i++) {
  973. setPixel(5,0,i,0,1,1);
  974. setPixel(4,1,i,0,1,1);
  975. setPixel(3,2,i,0,1,1);
  976. setPixel(2,3,i,0,1,1);
  977. setPixel(1,4,i,0,1,1);
  978. setPixel(0,5,i,0,1,1);
  979. }
  980. delay (TD94);
  981.  
  982. for (int i = 0; i < 8; i++) {
  983. setPixel(4,0,i,0,1,1);
  984. setPixel(3,1,i,0,1,1);
  985. setPixel(2,2,i,0,1,1);
  986. setPixel(1,3,i,0,1,1);
  987. setPixel(0,4,i,0,1,1);
  988. }
  989. delay (TD94);
  990.  
  991. for (int i = 0; i < 8; i++) {
  992. setPixel(3,0,i,0,1,1);
  993. setPixel(2,1,i,0,1,1);
  994. setPixel(1,2,i,0,1,1);
  995. setPixel(0,3,i,0,1,1);
  996. }
  997. delay (TD94);
  998.  
  999. for (int i = 0; i < 8; i++) {
  1000. setPixel(2,0,i,0,1,1);
  1001. setPixel(1,1,i,0,1,1);
  1002. setPixel(0,2,i,0,1,1);
  1003. }
  1004. delay (TD94);
  1005.  
  1006. for (int i = 0; i < 8; i++) {
  1007. setPixel(1,0,i,0,1,1);
  1008. setPixel(0,1,i,0,1,1);
  1009. }
  1010. delay (TD94);
  1011.  
  1012. for (int i = 0; i < 8; i++) {
  1013. setPixel(0,0,i,0,1,1);
  1014. }
  1015. delay (TD94);
  1016. delay (TD93);
  1017. for (int i = 0; i < 8; i++) {
  1018. for (int j = 0; j < 8; j++) {
  1019. for (int k = 0; k < 8; k++) {
  1020. setPixel(i,j,k,0,0,0);
  1021. }
  1022. }
  1023. }
  1024. /////////////////////////////////////////////////////////
  1025. for (int i = 0; i < 8; i++) {
  1026. setPixel(7,0,i,1,1,1);
  1027. }
  1028. delay (TD94);
  1029.  
  1030. for (int i = 0; i < 8; i++) {
  1031. setPixel(7,1,i,1,1,1);
  1032. setPixel(6,0,i,1,1,1);
  1033. }
  1034. delay (TD94);
  1035.  
  1036. for (int i = 0; i < 8; i++) {
  1037. setPixel(7,2,i,1,1,1);
  1038. setPixel(6,1,i,1,1,1);
  1039. setPixel(5,0,i,1,1,1);
  1040. }
  1041. delay (TD94);
  1042.  
  1043. for (int i = 0; i < 8; i++) {
  1044. setPixel(7,3,i,1,1,1);
  1045. setPixel(6,2,i,1,1,1);
  1046. setPixel(5,1,i,1,1,1);
  1047. setPixel(4,0,i,1,1,1);
  1048. }
  1049. delay (TD94);
  1050.  
  1051. for (int i = 0; i < 8; i++) {
  1052. setPixel(7,4,i,1,1,1);
  1053. setPixel(6,3,i,1,1,1);
  1054. setPixel(5,2,i,1,1,1);
  1055. setPixel(4,1,i,1,1,1);
  1056. setPixel(3,0,i,1,1,1);
  1057. }
  1058. delay (TD94);
  1059.  
  1060. for (int i = 0; i < 8; i++) {
  1061. setPixel(7,5,i,1,1,1);
  1062. setPixel(6,4,i,1,1,1);
  1063. setPixel(5,3,i,1,1,1);
  1064. setPixel(4,2,i,1,1,1);
  1065. setPixel(3,1,i,1,1,1);
  1066. setPixel(2,0,i,1,1,1);
  1067. }
  1068. delay (TD94);
  1069.  
  1070. for (int i = 0; i < 8; i++) {
  1071. setPixel(7,6,i,1,1,1);
  1072. setPixel(6,5,i,1,1,1);
  1073. setPixel(5,4,i,1,1,1);
  1074. setPixel(4,3,i,1,1,1);
  1075. setPixel(3,2,i,1,1,1);
  1076. setPixel(2,1,i,1,1,1);
  1077. setPixel(1,0,i,1,1,1);
  1078. }
  1079. delay (TD94);
  1080.  
  1081. for (int i = 0; i < 8; i++) {
  1082. setPixel(7,7,i,1,1,1);
  1083. setPixel(6,6,i,1,1,1);
  1084. setPixel(5,5,i,1,1,1);
  1085. setPixel(4,4,i,1,1,1);
  1086. setPixel(3,3,i,1,1,1);
  1087. setPixel(2,2,i,1,1,1);
  1088. setPixel(1,1,i,1,1,1);
  1089. setPixel(0,0,i,1,1,1);
  1090. }
  1091. delay (TD94);
  1092.  
  1093. for (int i = 0; i < 8; i++) {
  1094. setPixel(6,7,i,1,1,1);
  1095. setPixel(5,6,i,1,1,1);
  1096. setPixel(4,5,i,1,1,1);
  1097. setPixel(3,4,i,1,1,1);
  1098. setPixel(2,3,i,1,1,1);
  1099. setPixel(1,2,i,1,1,1);
  1100. setPixel(0,1,i,1,1,1);
  1101. }
  1102. delay (TD94);
  1103.  
  1104. for (int i = 0; i < 8; i++) {
  1105. setPixel(5,7,i,1,1,1);
  1106. setPixel(4,6,i,1,1,1);
  1107. setPixel(3,5,i,1,1,1);
  1108. setPixel(2,4,i,1,1,1);
  1109. setPixel(1,3,i,1,1,1);
  1110. setPixel(0,2,i,1,1,1);
  1111. }
  1112. delay (TD94);
  1113.  
  1114. for (int i = 0; i < 8; i++) {
  1115. setPixel(4,7,i,1,1,1);
  1116. setPixel(3,6,i,1,1,1);
  1117. setPixel(2,5,i,1,1,1);
  1118. setPixel(1,4,i,1,1,1);
  1119. setPixel(0,3,i,1,1,1);
  1120. }
  1121. delay (TD94);
  1122.  
  1123. for (int i = 0; i < 8; i++) {
  1124. setPixel(3,7,i,1,1,1);
  1125. setPixel(2,6,i,1,1,1);
  1126. setPixel(1,5,i,1,1,1);
  1127. setPixel(0,4,i,1,1,1);
  1128. }
  1129. delay (TD94);
  1130.  
  1131. for (int i = 0; i < 8; i++) {
  1132. setPixel(2,7,i,1,1,1);
  1133. setPixel(1,6,i,1,1,1);
  1134. setPixel(0,5,i,1,1,1);
  1135. }
  1136. delay (TD94);
  1137.  
  1138. for (int i = 0; i < 8; i++) {
  1139. setPixel(1,7,i,1,1,1);
  1140. setPixel(0,6,i,1,1,1);
  1141. }
  1142. delay (TD94);
  1143.  
  1144. for (int i = 0; i < 8; i++) {
  1145. setPixel(0,7,i,1,1,1);
  1146. }
  1147. delay (TD94);
  1148. delay (TD93);
  1149. for (int i = 0; i < 8; i++) {
  1150. for (int j = 0; j < 8; j++) {
  1151. for (int k = 0; k < 8; k++) {
  1152. setPixel(i,j,k,0,0,0);
  1153. }
  1154. }
  1155. }
  1156.  
  1157. }
  1158.  
  1159. void zigZagFill (boolean red, boolean green, boolean blue, int TD92) {
  1160.  
  1161. for(int k = 0; k < 8; k=k+2){
  1162. for(int j = 0; j < 8; j++){
  1163. for(int i = 0; i < 8; i++){
  1164. setPixel(j,k,i,red,green,blue);
  1165. }
  1166. delay(TD92);
  1167. }
  1168.  
  1169. for(int j = 7; j > -1; j--){
  1170. for(int i = 0; i < 8; i++){
  1171. setPixel(j,k+1,i,red,green,blue);
  1172. }
  1173. delay(TD92);
  1174. }
  1175. }
  1176.  
  1177. }
  1178.  
  1179. void animatieVier (int TD91) {
  1180. zigZagFill(1, 0, 0, TD91);
  1181. zigZagFill(0, 1, 0, TD91);
  1182. zigZagFill(0, 0, 1, TD91);
  1183. zigZagFill(1, 1, 1, TD91);
  1184. zigZagFill(1, 0, 1, TD91);
  1185. zigZagFill(1, 1, 0, TD91);
  1186. zigZagFill(0, 1, 1, TD91);
  1187.  
  1188. }
  1189.  
  1190. void bovenonder (boolean red, boolean green, boolean blue, int TD90) {
  1191.  
  1192. for(int k = 0; k < 8; k++){
  1193. for(int i = 0; i < 8; i++){
  1194. for(int j= 0; j < 8; j++){
  1195. setPixel(i,k,j,red,green,blue);
  1196. }
  1197. }
  1198.  
  1199. delay(TD90);
  1200.  
  1201. for(int i = 0; i < 8; i++){
  1202. for(int j= 0; j < 8; j++){
  1203. setPixel(i,k,j,0,0,0);
  1204. }
  1205. }
  1206. }
  1207.  
  1208. }
  1209.  
  1210. void linksrechts (boolean red, boolean green, boolean blue, int TD90) {
  1211.  
  1212. for(int k = 0; k < 8; k++){
  1213. for(int i = 0; i < 8; i++){
  1214. for(int j= 0; j < 8; j++){
  1215. setPixel(k,i,j,red,green,blue);
  1216. }
  1217. }
  1218.  
  1219. delay(TD90);
  1220.  
  1221. for(int i = 0; i < 8; i++){
  1222. for(int j= 0; j < 8; j++){
  1223. setPixel(k,i,j,0,0,0);
  1224. }
  1225. }
  1226. }
  1227.  
  1228. }
  1229.  
  1230. void animatieVijf (int TD89) {
  1231.  
  1232. bovenonder(1,0,0,TD89);
  1233. bovenonder(0,1,0,TD89);
  1234. bovenonder(0,0,1,TD89);
  1235. bovenonder(1,1,1,TD89);
  1236. bovenonder(1,1,0,TD89);
  1237. bovenonder(0,1,1,TD89);
  1238.  
  1239. linksrechts(1,0,0,TD89);
  1240. linksrechts(0,1,0,TD89);
  1241. linksrechts(0,0,1,TD89);
  1242. linksrechts(1,1,1,TD89);
  1243. linksrechts(1,1,0,TD89);
  1244. linksrechts(0,1,1,TD89);
  1245.  
  1246. }
  1247.  
  1248. void animatieZes (int TD88, int red, int green, int blue) {
  1249.  
  1250. for(int z = 0; z < 14; z++ ){
  1251.  
  1252. int v = z - 2;
  1253. int w = z - 4;
  1254. int x = z - 6;
  1255.  
  1256.  
  1257. if (z < 8) {
  1258. for(int k = 0; k < 8; k++){
  1259. setPixel(0,k,z,red,green,blue);
  1260. }
  1261.  
  1262. for(int k = 0; k < 8; k++){
  1263. setPixel(k,0,z,red,green,blue);
  1264. }
  1265.  
  1266. for(int k = 0; k < 8; k++){
  1267. setPixel(7,k,z,red,green,blue);
  1268. }
  1269.  
  1270. for(int k = 0; k < 8; k++){
  1271. setPixel(k,7,z,red,green,blue);
  1272. }
  1273.  
  1274. }
  1275.  
  1276. if (v > -1 && v < 8) {
  1277. for(int k = 1; k < 7; k++){
  1278. setPixel(1,k,v,red,green,blue);
  1279. }
  1280.  
  1281. for(int k = 1; k < 7; k++){
  1282. setPixel(k,1,v,red,green,blue);
  1283. }
  1284.  
  1285. for(int k = 1; k < 7; k++){
  1286. setPixel(6,k,v,red,green,blue);
  1287. }
  1288.  
  1289. for(int k = 1; k < 7; k++){
  1290. setPixel(k,6,v,red,green,blue);
  1291. }
  1292. }
  1293.  
  1294. if (w > -1 && w < 8) {
  1295. for(int k = 2; k < 6; k++){
  1296. setPixel(2,k,w,red,green,blue);
  1297. }
  1298.  
  1299. for(int k = 2; k < 6; k++){
  1300. setPixel(k,2,w,red,green,blue);
  1301. }
  1302.  
  1303. for(int k = 2; k < 6; k++){
  1304. setPixel(5,k,w,red,green,blue);
  1305. }
  1306.  
  1307. for(int k = 2; k < 6; k++){
  1308. setPixel(k,5,w,red,green,blue);
  1309. }
  1310. }
  1311.  
  1312.  
  1313.  
  1314. if (x > -1 && x < 8) {
  1315. for(int k = 3; k < 5; k++){
  1316. setPixel(3,k,x,red,green,blue);
  1317. }
  1318.  
  1319. for(int k = 3; k < 5; k++){
  1320. setPixel(k,3,x,red,green,blue);
  1321. }
  1322.  
  1323. for(int k = 3; k < 5; k++){
  1324. setPixel(4,k,x,red,green,blue);
  1325. }
  1326.  
  1327. for(int k = 3; k < 5; k++){
  1328. setPixel(k,4,x,red,green,blue);
  1329. }
  1330. }
  1331.  
  1332. delay(TD88);
  1333.  
  1334. if (z < 8) {
  1335. for(int k = 0; k < 8; k++){
  1336. setPixel(0,k,z,0,0,0);
  1337. }
  1338.  
  1339. for(int k = 0; k < 8; k++){
  1340. setPixel(k,0,z,0,0,0);
  1341. }
  1342.  
  1343. for(int k = 0; k < 8; k++){
  1344. setPixel(7,k,z,0,0,0);
  1345. }
  1346.  
  1347. for(int k = 0; k < 8; k++){
  1348. setPixel(k,7,z,0,0,0);
  1349. }
  1350.  
  1351. }
  1352.  
  1353.  
  1354. if (v > -1 && v < 8) {
  1355. for(int k = 1; k < 7; k++){
  1356. setPixel(1,k,v,0,0,0);
  1357. }
  1358.  
  1359. for(int k = 1; k < 7; k++){
  1360. setPixel(k,1,v,0,0,0);
  1361. }
  1362.  
  1363. for(int k = 1; k < 7; k++){
  1364. setPixel(6,k,v,0,0,0);
  1365. }
  1366.  
  1367. for(int k = 1; k < 7; k++){
  1368. setPixel(k,6,v,0,0,0);
  1369. }
  1370. }
  1371.  
  1372.  
  1373.  
  1374. if (w > -1 && w < 8) {
  1375. for(int k = 2; k < 6; k++){
  1376. setPixel(2,k,w,0,0,0);
  1377. }
  1378.  
  1379. for(int k = 2; k < 6; k++){
  1380. setPixel(k,2,w,0,0,0);
  1381. }
  1382.  
  1383. for(int k = 2; k < 6; k++){
  1384. setPixel(5,k,w,0,0,0);
  1385. }
  1386.  
  1387. for(int k = 2; k < 6; k++){
  1388. setPixel(k,5,w,0,0,0);
  1389. }
  1390. }
  1391.  
  1392. if (x > -1 && x < 8) {
  1393. for(int k = 3; k < 5; k++){
  1394. setPixel(3,k,x,0,0,0);
  1395. }
  1396.  
  1397. for(int k = 3; k < 5; k++){
  1398. setPixel(k,3,x,0,0,0);
  1399. }
  1400.  
  1401. for(int k = 3; k < 5; k++){
  1402. setPixel(4,k,x,0,0,0);
  1403. }
  1404.  
  1405. for(int k = 3; k < 5; k++){
  1406. setPixel(k,4,x,0,0,0);
  1407. }
  1408. }
  1409.  
  1410. }
  1411.  
  1412. }
  1413.  
  1414. void animatieZeven (int TD87, int TD86) {
  1415. for (int i = 8; i > -1; i--) {
  1416. setPixel(0,i,0,1,0,0);
  1417. delay(TD87);
  1418. }
  1419.  
  1420. for (int i = 1; i < 8; i++) {
  1421. setPixel(i,0,0,1,0,0);
  1422. setPixel(0,0,i,1,0,0);
  1423. delay(TD87);
  1424. }
  1425.  
  1426. ///////////////////////////////
  1427.  
  1428. for (int i = 0; i < 8; i++) {
  1429. setPixel(7,i,0,1,1,0);
  1430. delay(TD87);
  1431. }
  1432.  
  1433. for (int i = 6, k = 1; (i > -1) && (k < 8); i--, k++) {
  1434. setPixel(i,7,0,1,1,0);
  1435. setPixel(7,7,k,1,1,0);
  1436. delay(TD87);
  1437. }
  1438.  
  1439. ///////////////////////////////////////////////////////////////////
  1440.  
  1441. for (int i = 8; i > -1; i--) {
  1442. setPixel(i,7,7,1,1,1);
  1443. delay(TD87);
  1444. }
  1445.  
  1446.  
  1447. for (int i = 6; i > -1; i--) {
  1448. setPixel(0,7,i,1,1,1);
  1449. setPixel(0,i,7,1,1,1);
  1450. delay(TD87);
  1451. }
  1452.  
  1453. ////////////////////////////////////////////////////////
  1454.  
  1455. for (int i = 0; i < 8 ; i++) {
  1456. setPixel(i,0,7,1,0,1);
  1457. delay(TD87);
  1458. }
  1459.  
  1460.  
  1461. for (int i = 6, k = 1; (i > -1) && (k < 8); i--, k++) {
  1462. setPixel(7,0,i,1,0,1); //i--
  1463. setPixel(7,k,7,1,0,1); //i++
  1464. delay(TD87);
  1465. }
  1466. delay(TD86);
  1467. //////////////////////////////////////////////////////////////////
  1468.  
  1469. for (int v = 0; v < 8; v++) {
  1470. for (int i = 0; i < 8; i++) {
  1471. for (int l = 0; l < 8; l++) {
  1472. setPixel(v,l,i,0,0,0);
  1473. }
  1474. }
  1475. }
  1476. }
  1477.  
  1478. // =====================================================================================================
  1479. // ~~~ START of DISPLAY SOME TEXT ~~~
  1480. // ----------------------------------
  1481. // takes a string of text and displays it one character at a time with each new word a random colour
  1482. // =====================================================================================================
  1483. void displaySomeText(String someText, int pauseTime) {
  1484. byte aChar; // grabs one character at a time from the message string
  1485. int stringLen; // length of text message
  1486. byte myColour; // random colour
  1487.  
  1488. uint16_t charScroll[8] = {0x0000, 0x0000, // 8 row 16 bit display buffer
  1489. 0x0000, 0x0000, // 8x8 panel maps to the 8 MSB's
  1490. 0x0000, 0x0000, // aChar loads into 8 LSB's
  1491. 0x0000, 0x0000}; // bit shifts to the left to scroll new char in and old char out
  1492.  
  1493. stringLen = someText.length(); // find length of text message
  1494. myColour = random(7) + 1; // select first random colour
  1495.  
  1496. for(int i = 0; i < stringLen; i++){ // loop for as many characters in text message
  1497. aChar = int(someText[i] - 0x20); // get ascii value for each character and remove offset
  1498.  
  1499. // load a character into buffers 8 Least Significant Bits
  1500. for(int j = 0; j < 8; j++){
  1501. charScroll[j] += font8x8_basic[aChar][7 - j] << 8;
  1502. }
  1503.  
  1504. // shift buffer left one bit then load shift registers with the buffers 8 Most Significant Bits
  1505. for(int j = 0; j < 7; j++){
  1506. for(int k = 0; k < 8; k++){
  1507. charScroll[k] = charScroll[k] >> 1;
  1508. if(myColour & 0x01) {shiftRegisterRed[k] = 0x00ff & charScroll[k];} else {shiftRegisterRed[k] = 0;}
  1509. if(myColour & 0x02) {shiftRegisterGrn[k] = 0x00ff & charScroll[k];} else {shiftRegisterGrn[k] = 0;}
  1510. if(myColour & 0x04) {shiftRegisterBlu[k] = 0x00ff & charScroll[k];} else {shiftRegisterBlu[k] = 0;}
  1511. }
  1512. delay(60);
  1513. }
  1514. // if a space is detected chose a new random colour for the next word
  1515. if(aChar == 0x00){ myColour = random(7) + 1; }
  1516. }
  1517. delay(1000);
  1518. }
  1519. // ================================
  1520. // ~~~ END of DISPLAY SOME TEXT ~~~
  1521. // ================================
  1522.  
  1523.  
  1524.  
  1525. // =====================================================================================================
  1526. // ~~~ START Draw Rectanle Outline ~~~
  1527. // -----------------------------------
  1528. // draw a 3d wireframe rectangle
  1529. // =====================================================================================================
  1530. void drawRectangleOutline(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
  1531.  
  1532. for (int x = xMin; x < xMax + 1; x++) {
  1533. setPixel( x, yMin, zMin, red, grn, blu);
  1534. setPixel( x, yMin, zMax, red, grn, blu);
  1535. setPixel( x, yMax, zMax, red, grn, blu);
  1536. setPixel( x, yMax, zMin, red, grn, blu);
  1537. }
  1538. for (int y = yMin; y < yMax + 1; y++) {
  1539. setPixel( xMin, y, zMin, red, grn, blu);
  1540. setPixel( xMin, y, zMax, red, grn, blu);
  1541. setPixel( xMax, y, zMax, red, grn, blu);
  1542. setPixel( xMax, y, zMin, red, grn, blu);
  1543. }
  1544. for (int z = zMin; z < zMax + 1; z++) {
  1545. setPixel( xMin, yMin, z, red, grn, blu);
  1546. setPixel( xMin, yMax, z, red, grn, blu);
  1547. setPixel( xMax, yMax, z, red, grn, blu);
  1548. setPixel( xMax, yMin, z, red, grn, blu);
  1549. }
  1550. }
  1551. // =================================
  1552. // ~~~ END Draw Rectanle Outline ~~~
  1553. // =================================
  1554.  
  1555.  
  1556.  
  1557. // =====================================================================================================
  1558. // ~~~ START Draw Rectanle Sides ~~~
  1559. // ---------------------------------
  1560. // draw a 3d rectangle filled sides
  1561. // =====================================================================================================
  1562. void drawRectangleSides(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
  1563.  
  1564. for (int x = xMin; x < xMax + 1; x++) {
  1565. for (int y = yMin; y < yMax + 1; y++) {
  1566. setPixel( x, y, zMin, red, grn, blu);
  1567. setPixel( x, y, zMax, red, grn, blu);
  1568. }
  1569. }
  1570. for (int y = yMin; y < yMax + 1; y++) {
  1571. for (int z = zMin; z < zMax + 1; z++) {
  1572. setPixel( xMin, y, z, red, grn, blu);
  1573. setPixel( xMax, y, z, red, grn, blu);
  1574. }
  1575. }
  1576. for (int x = xMin; x < xMax + 1; x++) {
  1577. for (int z = zMin; z < zMax + 1; z++) {
  1578. setPixel( x, yMin, z, red, grn, blu);
  1579. setPixel( x, yMax, z, red, grn, blu);
  1580. }
  1581. }
  1582. }
  1583. // ===============================
  1584. // ~~~ END Draw Rectanle Sides ~~~
  1585. // ===============================
  1586.  
  1587.  
  1588.  
  1589. // =====================================================================================================
  1590. // ~~~ START Draw Rectanle Filled ~~~
  1591. // ----------------------------------
  1592. // draw a 3d rectangle filled
  1593. // =====================================================================================================
  1594. void drawRectangleFilled(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
  1595.  
  1596. for (int x = xMin; x < xMax + 1; x++) {
  1597. for (int y = yMin; y < yMax + 1; y++) {
  1598. for (int z = zMin; z < zMax + 1; z++) {
  1599. setPixel(x, y, z, red, grn, blu);
  1600. }
  1601. }
  1602. }
  1603. }
  1604. // ================================
  1605. // ~~~ END Draw Rectanle Filled ~~~
  1606. // ================================
  1607.  
  1608.  
  1609.  
  1610. // =====================================================================================================
  1611. // ~~~ Start Flood Fill ~~~
  1612. // ------------------------
  1613. // fills entire panel with chosen colour via direct manipulation of the shift register arrays
  1614. // (much faster than setting individual pixels)
  1615. // =====================================================================================================
  1616. void floodFill(boolean red, boolean grn, boolean blu) {
  1617.  
  1618. for ( int indexY = 0; indexY < 8; indexY++ ) {
  1619. if(red == 1) {shiftRegisterRed[indexY] = B11111111;} else {shiftRegisterRed[indexY] = B00000000;}
  1620. if(grn == 1) {shiftRegisterGrn[indexY] = B11111111;} else {shiftRegisterGrn[indexY] = B00000000;}
  1621. if(blu == 1) {shiftRegisterBlu[indexY] = B11111111;} else {shiftRegisterBlu[indexY] = B00000000;}
  1622. }
  1623. }
  1624. // =========================
  1625. // ~~~ END of Flood Fill ~~~
  1626. // =========================
  1627.  
  1628.  
  1629.  
  1630. // =====================================================================================================
  1631. // ~~~ Start Fill YZ Axis Plane ~~~
  1632. // --------------------------------
  1633. //
  1634. //
  1635. // =====================================================================================================
  1636. void yzPlaneFill(byte xIndex, byte colour) {
  1637.  
  1638. boolean red = colour & B00000001;
  1639. boolean grn = colour & B00000010;
  1640. boolean blu = colour & B00000100;
  1641. Serial.print("red = ");
  1642. Serial.print(red);
  1643.  
  1644. // test column index is within boundary
  1645. if ( xIndex < 0) xIndex = 0;
  1646. if ( xIndex > 7) xIndex = 7;
  1647.  
  1648. // set the register arrays using bit manipulation
  1649. for ( int i = 0; i < 8; i++ ) {
  1650. for ( int j = 0; j < 8; j++ ) {
  1651. if ( red == 0 ) shiftRegisterRed[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterRed[i + (j * 8)] |= (1 << xIndex);
  1652. if ( grn == 0 ) shiftRegisterGrn[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterGrn[i + (j * 8)] |= (1 << xIndex);
  1653. if ( blu == 0 ) shiftRegisterBlu[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterBlu[i + (j * 8)] |= (1 << xIndex);
  1654. }
  1655. }
  1656. }
  1657. // ==============================
  1658. // ~~~ END Fill YZ Axis Plane ~~~
  1659. // ==============================
  1660.  
  1661.  
  1662.  
  1663. // =====================================================================================================
  1664. // ~~~ Start Fill XZ Axis Plane ~~~
  1665. // --------------------------------
  1666. //
  1667. //
  1668. // =====================================================================================================
  1669. void xzPlaneFill(byte yIndex, byte colour) {
  1670.  
  1671. boolean red = colour & B00000001;
  1672. boolean grn = colour & B00000010;
  1673. boolean blu = colour & B00000100;
  1674. Serial.print("red = ");
  1675. Serial.print(red);
  1676.  
  1677. // test column index is within boundary
  1678. if ( yIndex < 0 ) yIndex = 0;
  1679. if ( yIndex > 7 ) yIndex = 7;
  1680.  
  1681. // set the register arrays using bit manipulation
  1682. for (int i = 0; i < 8; i++) {
  1683. if(red == 0) {shiftRegisterRed[i + (yIndex * 8)] = 0;} else {shiftRegisterRed[i + (yIndex * 8)] = 255;}
  1684. if(grn == 0) {shiftRegisterGrn[i + (yIndex * 8)] = 0;} else {shiftRegisterGrn[i + (yIndex * 8)] = 255;}
  1685. if(blu == 0) {shiftRegisterBlu[i + (yIndex * 8)] = 0;} else {shiftRegisterBlu[i + (yIndex * 8)] = 255;}
  1686. }
  1687. }
  1688. // ==============================
  1689. // ~~~ END Fill XZ Axis Plane ~~~
  1690. // ==============================
  1691.  
  1692.  
  1693.  
  1694. // =====================================================================================================
  1695. // ~~~ Start Fill XZ Axis Plane ~~~
  1696. // --------------------------------
  1697. //
  1698. //
  1699. // =====================================================================================================
  1700. void xyPlaneFill(byte zIndex, byte colour) {
  1701.  
  1702. boolean red = colour & B00000001;
  1703. boolean grn = colour & B00000010;
  1704. boolean blu = colour & B00000100;
  1705.  
  1706. // test column index is within boundary
  1707. if ( zIndex < 0 ) zIndex = 0;
  1708. if ( zIndex > 7 ) zIndex = 7;
  1709.  
  1710. // set the register arrays using bit manipulation
  1711. for ( int i = 0; i < 8; i++ ) {
  1712. if ( red == 0 ) {shiftRegisterRed[zIndex + ( 8 * i)] = 0;} else {shiftRegisterRed[zIndex + ( 8 * i)] = 255;}
  1713. if ( grn == 0 ) {shiftRegisterGrn[zIndex + ( 8 * i)] = 0;} else {shiftRegisterGrn[zIndex + ( 8 * i)] = 255;}
  1714. if ( blu == 0 ) {shiftRegisterBlu[zIndex + ( 8 * i)] = 0;} else {shiftRegisterBlu[zIndex + ( 8 * i)] = 255;}
  1715. }
  1716. }
  1717. // =======================
  1718. // ~~~ END of Fill Row ~~~
  1719. // =======================
  1720.  
  1721.  
  1722.  
  1723. // =====================================================================================================
  1724. // ~~~ Start Set Pixel ~~~
  1725. // -----------------------
  1726. // take a pixels x & y co-ordinate, R, G & B binary values and assigns to appropriate shift register bit
  1727. // =====================================================================================================
  1728. void setPixel(byte pixelX, byte pixelY, byte pixelZ, boolean red, boolean grn, boolean blu) {
  1729.  
  1730. // test pixel x & co-ordinates are within boundary
  1731. if(pixelX < 0) pixelX = 0;
  1732. if(pixelX > 7) pixelX = 7;
  1733. if(pixelY < 0) pixelY = 0;
  1734. if(pixelY > 7) pixelY = 7;
  1735. if(pixelZ < 0) pixelZ = 0;
  1736. if(pixelZ > 7) pixelZ = 7;
  1737.  
  1738. // set appropriate registers using bit manipulation.
  1739. // just Google 'bit shifting in c'
  1740. // to find tutorials and explanations of the following:
  1741. if(red == 1) shiftRegisterRed[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if red is 1 set appropriate bit within appropriate red byte to 1
  1742. else shiftRegisterRed[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate red byte to 0
  1743.  
  1744. if(grn == 1) shiftRegisterGrn[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if grn is 1 set appropriate bit within appropriate grn byte to 1
  1745. else shiftRegisterGrn[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate grn byte to 0
  1746.  
  1747. if(blu == 1) shiftRegisterBlu[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if blu is 1 set appropriate bit within appropriate blu byte to 1
  1748. else shiftRegisterBlu[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate blu byte to 0
  1749. }
  1750. // ======================
  1751. // ~~~ END Set Pixel ~~~
  1752. // ======================
  1753.  
  1754.  
  1755.  
  1756. // =====================================================================================================
  1757. // ~~~ START 0f ISR ~~~
  1758. // --------------------
  1759. // Updates the panel. Called every 125uS (8KHz), each row is lit for 1/8th of the time (1KHz)
  1760. // =====================================================================================================
  1761. ISR(TIMER2_COMPA_vect) {
  1762.  
  1763. PORTD |= (1 << SR_BLANK); // temporarely disable the SR outputs
  1764. for (int i = 0; i < 8; i++) {
  1765. SPI.transfer(shiftRegisterRed[i + anodeIndex * 8]); // send the red SR byte for the given anode level
  1766. SPI.transfer(shiftRegisterGrn[i + anodeIndex * 8]); // send the grn SR byte for the given anode level
  1767. SPI.transfer(shiftRegisterBlu[i + anodeIndex * 8]); // send the blu SR byte for the given anode level
  1768. }
  1769. SPI.transfer(anodeLevel[anodeIndex]); // send the anode multiplex byte
  1770. anodeIndex = (anodeIndex + 1) % 8; // incrument anode index ready for next ISR
  1771. PORTD |= (1 << SR_LATCH); // set latch pin LOW
  1772. PORTD &= ~(1 << SR_LATCH); // set latch pin HIGH - SR outputs now have new data
  1773. PORTD &= ~(1 << SR_BLANK); // re-enable the SR outputs
  1774. }
  1775. // ==================
  1776. // ~~~ END of ISR ~~~
  1777. // ==================
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement