API tools faq
paste
Advertisement
Guest User

arduino code

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