Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include "SPI.h"
- #define SPI_SCK 13 // SPI clock - must be pin 13
- #define SPI_MOSI 11 // SPI data out - must be pin 11
- #define SR_LATCH 3 // shift register latch - any non SPI pin
- #define SR_BLANK 2 // shift register output enable - any non SPI pin
- #define TD1 80 // time delay 1 - 100ms
- #define TD2 3000 // time delay 2 - 3 seconds
- #define TD3 1000 // time delay 3 - 1 second
- #define TD4 20 // time delay 4 - 20ms
- #define TD5 400 // time delay 5 - 400ms
- #define TD6 120 // time delay 5 - 400ms
- #define TD7 100 // time delay 5 - 400ms
- #define TD8 100
- #define TD9 20
- #define TD10 100
- #define TD11 3000
- #define TD12 50
- #define TD13 1000
- #define TD14 20
- #define TD15 100
- #define TD16 100
- #define TD17 50
- #define TD18 1000
- // =====================================================================================================
- // variables used by Inturrupt Service Routine (ISR), must be volatile
- // =====================================================================================================
- volatile byte shiftRegisterRed[64]; // red shift register data, 8 bytes, 1 byte per common anode
- volatile byte shiftRegisterGrn[64]; // green shift register data, 8 bytes, 1 byte per common anode
- volatile byte shiftRegisterBlu[64]; // blue shift register data, 8 bytes, 1 byte per common anode
- volatile byte anodeIndex = 0; // keeps track of which common anode is active
- volatile byte anodeLevel[] = { // used by 74HC595N shift register to control the anode multiplexing
- B11111110, // This is not an efficient use of variable memory, but what the heck!
- B11111101, // at least it shows how the anode multiplexing is done.
- B11111011,
- B11110111,
- B11101111,
- B11011111,
- B10111111,
- B01111111};
- byte colours[] = { 1, 2, 4, 3, 6, 5, 7 };
- // =====================================================================================================
- // font definition
- // =====================================================================================================
- char font8x8_basic[95][8] = {
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii ( )
- {0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x00}, // Ascii (!)
- {0x14, 0x14, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (")
- {0x14, 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x14, 0x00}, // Ascii (#)
- {0x08, 0x3C, 0x0A, 0x1C, 0x28, 0x1E, 0x08, 0x00}, // Ascii ($)
- {0x06, 0x26, 0x10, 0x08, 0x04, 0x32, 0x30, 0x00}, // Ascii (%)
- {0x0C, 0x12, 0x0A, 0x04, 0x2A, 0x12, 0x2C, 0x00}, // Ascii (&)
- {0x0C, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (')
- {0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08, 0x00}, // Ascii (()
- {0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02, 0x00}, // Ascii ())
- {0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x00, 0x00}, // Ascii (*)
- {0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00}, // Ascii (+)
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x02}, // Ascii (,)
- {0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00}, // Ascii (-)
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00}, // Ascii (.)
- {0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00}, // Ascii (/)
- {0x1C, 0x22, 0x32, 0x2A, 0x26, 0x22, 0x1C, 0x00}, // Ascii (0)
- {0x08, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x1C, 0x00}, // Ascii (1)
- {0x1C, 0x22, 0x20, 0x18, 0x04, 0x02, 0x3E, 0x00}, // Ascii (2)
- {0x1C, 0x22, 0x20, 0x18, 0x20, 0x22, 0x1C, 0x00}, // Ascii (3)
- {0x10, 0x18, 0x14, 0x12, 0x3E, 0x10, 0x10, 0x00}, // Ascii (4)
- {0x3E, 0x02, 0x1E, 0x20, 0x20, 0x22, 0x1C, 0x00}, // Ascii (5)
- {0x18, 0x04, 0x02, 0x1E, 0x22, 0x22, 0x1C, 0x00}, // Ascii (6)
- {0x3E, 0x20, 0x10, 0x08, 0x04, 0x04, 0x04, 0x00}, // Ascii (7)
- {0x1C, 0x22, 0x22, 0x1C, 0x22, 0x22, 0x1C, 0x00}, // Ascii (8)
- {0x1C, 0x22, 0x22, 0x3C, 0x20, 0x10, 0x0C, 0x00}, // Ascii (9)
- {0x00, 0x0C, 0x0C, 0x00, 0x0C, 0x0C, 0x00, 0x00}, // Ascii (:)
- {0x00, 0x00, 0x0C, 0x0C, 0x00, 0x0C, 0x08, 0x04}, // Ascii (;)
- {0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00}, // Ascii (<)
- {0x00, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x00, 0x00}, // Ascii (=)
- {0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02, 0x00}, // Ascii (>)
- {0x1C, 0x22, 0x20, 0x10, 0x08, 0x00, 0x08, 0x00}, // Ascii (?)
- {0x1C, 0x22, 0x20, 0x2C, 0x2A, 0x2A, 0x1C, 0x00}, // Ascii (@)
- {0x1C, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x00}, // Ascii (A)
- {0x1E, 0x22, 0x22, 0x1E, 0x22, 0x22, 0x1E, 0x00}, // Ascii (B)
- {0x1C, 0x22, 0x02, 0x02, 0x02, 0x22, 0x1C, 0x00}, // Ascii (C)
- {0x0E, 0x12, 0x22, 0x22, 0x22, 0x12, 0x0E, 0x00}, // Ascii (D)
- {0x3E, 0x02, 0x02, 0x1E, 0x02, 0x02, 0x3E, 0x00}, // Ascii (E)
- {0x3E, 0x02, 0x02, 0x1E, 0x02, 0x02, 0x02, 0x00}, // Ascii (F)
- {0x1C, 0x22, 0x02, 0x02, 0x32, 0x22, 0x3C, 0x00}, // Ascii (G)
- {0x22, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x00}, // Ascii (H)
- {0x0E, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0E, 0x00}, // Ascii (I)
- {0x38, 0x10, 0x10, 0x10, 0x10, 0x12, 0x0C, 0x00}, // Ascii (J)
- {0x22, 0x12, 0x0A, 0x06, 0x0A, 0x12, 0x22, 0x00}, // Ascii (K)
- {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x3E, 0x00}, // Ascii (L)
- {0x22, 0x36, 0x2A, 0x2A, 0x22, 0x22, 0x22, 0x00}, // Ascii (M)
- {0x22, 0x22, 0x26, 0x2A, 0x32, 0x22, 0x22, 0x00}, // Ascii (N)
- {0x1C, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00}, // Ascii (O)
- {0x1E, 0x22, 0x22, 0x1E, 0x02, 0x02, 0x02, 0x00}, // Ascii (P)
- {0x1C, 0x22, 0x22, 0x22, 0x2A, 0x12, 0x2C, 0x00}, // Ascii (Q)
- {0x1E, 0x22, 0x22, 0x1E, 0x0A, 0x12, 0x22, 0x00}, // Ascii (R)
- {0x1C, 0x22, 0x02, 0x1C, 0x20, 0x22, 0x1C, 0x00}, // Ascii (S)
- {0x3E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00}, // Ascii (T)
- {0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00}, // Ascii (U)
- {0x22, 0x22, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00}, // Ascii (V)
- {0x22, 0x22, 0x22, 0x2A, 0x2A, 0x2A, 0x14, 0x00}, // Ascii (W)
- {0x22, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00}, // Ascii (X)
- {0x22, 0x22, 0x14, 0x08, 0x08, 0x08, 0x08, 0x00}, // Ascii (Y)
- {0x3E, 0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x00}, // Ascii (Z)
- {0x0E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0E, 0x00}, // Ascii ([)
- {0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00}, // Ascii (\)
- {0x0E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0E, 0x00}, // Ascii (])
- {0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (^)
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E}, // Ascii (_)
- {0x02, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00}, // Ascii (`)
- {0x00, 0x00, 0x1C, 0x20, 0x3C, 0x22, 0x3C, 0x00}, // Ascii (a)
- {0x02, 0x02, 0x1A, 0x26, 0x22, 0x22, 0x1E, 0x00}, // Ascii (b)
- {0x00, 0x00, 0x0C, 0x12, 0x02, 0x12, 0x0C, 0x00}, // Ascii (c)
- {0x20, 0x20, 0x2C, 0x32, 0x22, 0x22, 0x3C, 0x00}, // Ascii (d)
- {0x00, 0x00, 0x1C, 0x22, 0x3E, 0x02, 0x1C, 0x00}, // Ascii (e)
- {0x08, 0x14, 0x04, 0x0E, 0x04, 0x04, 0x04, 0x00}, // Ascii (f)
- {0x00, 0x00, 0x3C, 0x22, 0x22, 0x3C, 0x20, 0x1C}, // Ascii (g)
- {0x02, 0x02, 0x1A, 0x26, 0x22, 0x22, 0x22, 0x00}, // Ascii (h)
- {0x04, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00}, // Ascii (i)
- {0x08, 0x00, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x06}, // Ascii (j)
- {0x02, 0x02, 0x12, 0x0A, 0x06, 0x0A, 0x12, 0x00}, // Ascii (k)
- {0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0E, 0x00}, // Ascii (l)
- {0x00, 0x00, 0x16, 0x2A, 0x2A, 0x22, 0x22, 0x00}, // Ascii (m)
- {0x00, 0x00, 0x1A, 0x16, 0x12, 0x12, 0x12, 0x00}, // Ascii (n)
- {0x00, 0x00, 0x0C, 0x12, 0x12, 0x12, 0x0C, 0x00}, // Ascii (o)
- {0x00, 0x00, 0x0E, 0x12, 0x12, 0x0E, 0x02, 0x02}, // Ascii (p)
- {0x00, 0x00, 0x1C, 0x12, 0x12, 0x1C, 0x10, 0x10}, // Ascii (q)
- {0x00, 0x00, 0x14, 0x0C, 0x04, 0x04, 0x04, 0x00}, // Ascii (r)
- {0x00, 0x00, 0x1C, 0x02, 0x0C, 0x10, 0x0E, 0x00}, // Ascii (s)
- {0x04, 0x04, 0x0E, 0x04, 0x04, 0x04, 0x0C, 0x00}, // Ascii (t)
- {0x00, 0x00, 0x12, 0x12, 0x12, 0x12, 0x1C, 0x00}, // Ascii (u)
- {0x00, 0x00, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00}, // Ascii (v)
- {0x00, 0x00, 0x22, 0x22, 0x2A, 0x2A, 0x14, 0x00}, // Ascii (w)
- {0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x00}, // Ascii (x)
- {0x00, 0x00, 0x12, 0x12, 0x12, 0x1C, 0x10, 0x0C}, // Ascii (y)
- {0x00, 0x00, 0x3E, 0x10, 0x08, 0x04, 0x3E, 0x00}, // Ascii (z)
- {0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08, 0x00}, // Ascii ({)
- {0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00}, // Ascii (|)
- {0x02, 0x04, 0x04, 0x08, 0x04, 0x04, 0x02, 0x00}, // Ascii (})
- {0x2C, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; // Ascii (~)
- // =====================================================================================================
- // ~~~ START of SETUP ~~~
- // =====================================================================================================
- void setup() {
- // set up IO pins as outputs
- // -------------------------------------------------------------
- pinMode(SPI_SCK, OUTPUT);
- pinMode(SPI_MOSI, OUTPUT);
- pinMode(SR_LATCH, OUTPUT);
- pinMode(SR_BLANK, OUTPUT);
- digitalWrite(SR_BLANK, HIGH); // temporarily disable all shift register outputs
- digitalWrite(SR_LATCH, LOW); // set shift register latch to initial state
- // set up Timer 2 for 8KHz (125uS) interrupt
- // code example from Amanda Ghassaei
- // http://www.instructables.com/id/Arduino-Timer-Interrupts/?ALLSTEPS
- // ------------------------------------------------------------------
- cli(); // stop interrupts
- TCCR2A = 0; // set entire TCCR2A register to 0
- TCCR2B = 0; // same for TCCR2B
- TCNT2 = 0; // initialize counter value to 0
- OCR2A = 249; // Set compare match register for 16KHz. Increments calculated as follows:
- // Arduino clk frequency 16MHz / (required frequency * Prescaler of 8) - 1, Result must be < 256.
- // So for this instance we calculate 16,000,000 / (8,000 * 8) - 1 = 249
- TCCR2A |= (1 << WGM21); // turn on CTC mode
- TCCR2B |= (1 << CS21); // Set CS21 bit for 8 pre-scalar
- TIMSK2 |= (1 << OCIE2A); // enable timer compare interrupt
- sei(); // allow interrupts
- // end code example from Amanda Ghassaei
- // -------------------------------------------------------------
- // initialise SPI
- // -------------------------------------------------------------
- SPI.setDataMode (SPI_MODE0 ); // mode 0 rising edge of data, keep clock low
- SPI.setBitOrder (MSBFIRST ); // most significant bit first
- SPI.setClockDivider(SPI_CLOCK_DIV2); // run the data in at 16MHz/2 - 8MHz (max speed)
- SPI.begin(); // start up SPI
- // initialise Serial Port for de-bugging
- // -------------------------------------------------------------
- Serial.begin (115200 ); // set up serial port for 115200 baud rate
- Serial.println("Start"); // display Start in Terminal Window
- randomSeed(analogRead(0)); // set random seed
- // display some text, only runs once
- // -------------------------------------------------------------
- //displaySomeText("WELCOME TO THE 8x8 RGB LED PANEL TESTING... ", TD5);
- }
- // ====================
- // ~~~ END of SETUP ~~~
- // ====================
- byte colourIndex = 0;
- // =====================================================================================================
- // ~~~ START of LOOP ~~~
- // =====================================================================================================
- void loop() {
- animatieEen(TD8,TD9);
- animatieTwee(TD10,TD11);
- animatieDrie (TD12,TD13);
- animatieVier (TD14);
- animatieVijf(TD15);
- animatieZes(TD16,1,0,0);
- animatieZes(TD16,1,1,1);
- animatieZes(TD16,0,1,1);
- animatieZes(TD16,1,0,1);
- animatieZeven(TD17,TD18);
- }
- // ===================
- // ~~~ END of LOOP ~~~
- // ===================
- void animatieEen (int TD99, int TD98) {
- ////////////////////////////////////////// nieuwe functie 1
- for (int j = 0; j < 8; j++) {
- for(int i = 0; i < 8; i++){
- setPixel(0,i,j,1,1,0);
- delay(TD99);
- }
- }
- /////////////////////////////////////////////////////////////////////////// 2
- for (int i = 0; i < 8; i++) {
- setPixel(1,i,0,1,1,0);
- setPixel(0,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(2,i,0,1,1,0);
- setPixel(0,i,6,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(3,i,0,1,1,0);
- setPixel(0,i,5,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(4,i,0,1,1,0);
- setPixel(0,i,4,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(5,i,0,1,1,0);
- setPixel(0,i,3,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(6,i,0,1,1,0);
- setPixel(0,i,2,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,0,1,1,0);
- setPixel(0,i,1,0,0,0);
- }
- delay(TD98);
- /////////////////////////////////////////////////////////////////////////////////////////// 3
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,1,1,1,0);
- setPixel(0,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,2,1,1,0);
- setPixel(1,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,3,1,1,0);
- setPixel(2,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,4,1,1,0);
- setPixel(3,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,5,1,1,0);
- setPixel(4,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,6,1,1,0);
- setPixel(5,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,7,1,1,0);
- setPixel(6,i,0,0,0,0);
- }
- delay(TD98);
- /////////////////////////////////////////////////////////////////////////////// 4
- for (int i = 0; i < 8; i++) {
- setPixel(6,i,7,1,1,0);
- setPixel(7,i,0,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(5,i,7,1,1,0);
- setPixel(7,i,1,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(4,i,7,1,1,0);
- setPixel(7,i,2,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(3,i,7,1,1,0);
- setPixel(7,i,3,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(2,i,7,1,1,0);
- setPixel(7,i,4,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(1,i,7,1,1,0);
- setPixel(7,i,5,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,7,1,1,0);
- setPixel(7,i,6,0,0,0);
- }
- delay(TD98);
- ////////////////////////////////////////////////////////////////////////////// 5
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,6,1,1,0);
- setPixel(7,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,5,1,1,0);
- setPixel(6,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,4,1,1,0);
- setPixel(5,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,3,1,1,0);
- setPixel(4,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,2,1,1,0);
- setPixel(3,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,1,1,1,0);
- setPixel(2,i,7,0,0,0);
- }
- delay(TD98);
- for (int i = 0; i < 8; i++) {
- setPixel(0,i,0,1,1,0);
- setPixel(1,i,7,0,0,0);
- }
- delay(TD98);
- //////////////////////////////////////////////////////////////////////// 6
- for (int i = 0; i < 8; i++) {
- setPixel(0,0,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,1,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,2,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,3,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,4,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,5,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,6,i,0,0,0);
- delay(TD99);
- }
- for (int i = 0; i < 8; i++) {
- setPixel(0,7,i,0,0,0);
- delay(TD99);
- }
- }
- void animatieTwee(int TD97,int TD96) {
- beginleds();
- een(1,8,1,8,TD97);
- vijf(0,7,1,8,TD97);
- drie(0,7,0,7,TD97);
- zes(0,7,0,7,TD97);
- twee(0,7,1,8,TD97);
- vier(1,8,1,8,TD97);
- vijf(1,8,1,8,TD97);
- een(1,8,0,7,TD97);
- drie(0,7,0,7,TD97);
- zes(0,7,0,7,TD97);
- vier(0,8,1,8,TD97);
- delay(TD96);
- }
- void beginleds () {
- for (int a = 0; a < 8; a++) {
- for (int b = 0; b < 8; b++) {
- setPixel(0,a,b,1,1,0);
- }
- }
- for (int a = 0; a < 8; a++) {
- for (int b = 0; b < 8; b++) {
- setPixel(b,a,0,1,1,0);
- }
- }
- for (int a = 0; a < 8; a++) {
- for (int b = 0; b < 8; b++) {
- setPixel(a,0,b,1,1,0);
- }
- }
- };
- void een (int u, int v, int w, int x, int TD95) {
- for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(c,a,b,1,1,0); //1
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(d,a,b,0,0,0); //0
- }
- }
- delay(TD95);
- }
- };
- void twee (int u, int v, int w, int x, int TD95) {
- for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(c,a,b,1,1,0); //6
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(d,a,b,0,0,0); //7
- }
- }
- delay(TD95);
- }
- };
- void drie (int u, int v, int w, int x, int TD95) {
- for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,c,b,1,1,0);
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,d,b,0,0,0);
- }
- }
- delay(TD95);
- }
- };
- void vier (int u, int v, int w, int x, int TD95) {
- for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,c,b,1,1,0);
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,d,b,0,0,0);
- }
- }
- delay(TD95);
- }
- };
- void vijf (int u, int v, int w, int x, int TD95) {
- for (int c = 1, d = 0 ; (c < 8) && (d < 7); c++, d++) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,b,c,1,1,0);
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,b,d,0,0,0);
- }
- }
- delay(TD95);
- }
- };
- void zes (int u, int v, int w, int x, int TD95) {
- for (int c = 6, d = 7 ; (c > -1) && (d > 0); c--, d--) {
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,b,c,1,1,0);
- }
- }
- for (int a = u; a < v; a++) {
- for (int b = w; b < x; b++) {
- setPixel(a,b,d,0,0,0);
- }
- }
- delay(TD95);
- }
- };
- void animatieDrie (int TD94,int TD93) {
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,0,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,1,0,1,1,0);
- setPixel(i,0,1,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,2,0,1,1,0);
- setPixel(i,0,2,1,1,0);
- setPixel(i,1,1,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,3,0,1,1,0);
- setPixel(i,0,3,1,1,0);
- setPixel(i,1,2,1,1,0);
- setPixel(i,2,1,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,4,0,1,1,0);
- setPixel(i,3,1,1,1,0);
- setPixel(i,1,3,1,1,0);
- setPixel(i,2,2,1,1,0);
- setPixel(i,0,4,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,5,0,0,1,0);
- setPixel(i,4,1,1,1,0);
- setPixel(i,3,2,1,1,0);
- setPixel(i,2,3,1,1,0);
- setPixel(i,1,4,1,1,0);
- setPixel(i,0,5,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,6,0,1,1,0);
- setPixel(i,5,1,1,1,0);
- setPixel(i,4,2,1,1,0);
- setPixel(i,3,3,1,1,0);
- setPixel(i,2,4,1,1,0);
- setPixel(i,1,5,1,1,0);
- setPixel(i,0,6,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,0,1,1,0);
- setPixel(i,6,1,1,1,0);
- setPixel(i,5,2,0,1,0);
- setPixel(i,4,3,1,1,0);
- setPixel(i,3,4,1,1,0);
- setPixel(i,2,5,1,1,0);
- setPixel(i,1,6,1,1,0);
- setPixel(i,0,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,1,1,1,0);
- setPixel(i,6,2,1,1,0);
- setPixel(i,5,3,1,1,0);
- setPixel(i,4,4,1,1,0);
- setPixel(i,3,5,1,1,0);
- setPixel(i,2,6,1,1,0);
- setPixel(i,1,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,2,1,1,0);
- setPixel(i,6,3,1,1,0);
- setPixel(i,5,4,1,1,0);
- setPixel(i,4,5,1,1,0);
- setPixel(i,3,6,1,1,0);
- setPixel(i,2,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,3,1,1,0);
- setPixel(i,6,4,1,1,0);
- setPixel(i,5,5,1,1,0);
- setPixel(i,4,6,1,1,0);
- setPixel(i,3,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,4,1,1,0);
- setPixel(i,6,5,1,1,0);
- setPixel(i,5,6,1,1,0);
- setPixel(i,4,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,5,1,1,0);
- setPixel(i,6,6,1,1,0);
- setPixel(i,5,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,6,1,1,0);
- setPixel(i,6,7,1,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,7,1,1,0);
- }
- delay (TD94);
- delay (TD93);
- for (int i = 0; i < 8; i++) {
- for (int j = 0; j < 8; j++) {
- for (int k = 0; k < 8; k++) {
- setPixel(i,j,k,0,0,0);
- }
- }
- }
- ///////////////////////////////////////////////
- for (int i = 0; i < 8; i++) {
- setPixel(i,7,7,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,6,7,0,1,0);
- setPixel(i,7,6,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,5,7,0,1,0);
- setPixel(i,6,6,0,1,0);
- setPixel(i,7,5,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,4,7,0,1,0);
- setPixel(i,5,6,0,1,0);
- setPixel(i,6,5,0,1,0);
- setPixel(i,7,4,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,3,7,0,1,0);
- setPixel(i,4,6,0,1,0);
- setPixel(i,5,5,0,1,0);
- setPixel(i,6,4,0,1,0);
- setPixel(i,7,3,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,2,7,0,1,0);
- setPixel(i,3,6,0,1,0);
- setPixel(i,4,5,0,1,0);
- setPixel(i,5,4,0,1,0);
- setPixel(i,6,3,0,1,0);
- setPixel(i,7,2,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,1,7,0,1,0);
- setPixel(i,2,6,0,1,0);
- setPixel(i,3,5,0,1,0);
- setPixel(i,4,4,0,1,0);
- setPixel(i,5,3,0,1,0);
- setPixel(i,6,2,0,1,0);
- setPixel(i,7,1,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,7,0,1,0);
- setPixel(i,1,6,0,1,0);
- setPixel(i,2,5,0,1,0);
- setPixel(i,3,4,0,1,0);
- setPixel(i,4,3,0,1,0);
- setPixel(i,5,2,0,1,0);
- setPixel(i,6,1,0,1,0);
- setPixel(i,7,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,6,0,1,0);
- setPixel(i,1,5,0,1,0);
- setPixel(i,2,4,0,1,0);
- setPixel(i,3,3,0,1,0);
- setPixel(i,4,2,0,1,0);
- setPixel(i,5,1,0,1,0);
- setPixel(i,6,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,5,0,1,0);
- setPixel(i,1,4,0,1,0);
- setPixel(i,2,3,0,1,0);
- setPixel(i,3,2,0,1,0);
- setPixel(i,4,1,0,1,0);
- setPixel(i,5,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,4,0,1,0);
- setPixel(i,1,3,0,1,0);
- setPixel(i,2,2,0,1,0);
- setPixel(i,3,1,0,1,0);
- setPixel(i,4,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,3,0,1,0);
- setPixel(i,1,2,0,1,0);
- setPixel(i,2,1,0,1,0);
- setPixel(i,3,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,2,0,1,0);
- setPixel(i,1,1,0,1,0);
- setPixel(i,2,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,1,0,1,0);
- setPixel(i,1,0,0,1,0);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(i,0,0,0,1,0);
- }
- delay (TD94);
- delay (TD93);
- for (int i = 0; i < 8; i++) {
- for (int j = 0; j < 8; j++) {
- for (int k = 0; k < 8; k++) {
- setPixel(i,j,k,0,0,0);
- }
- }
- }
- ////////////////////////////////////////////////////////////
- for (int i = 0; i < 8; i++) {
- setPixel(7,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,6,i,0,1,1);
- setPixel(6,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,5,i,0,1,1);
- setPixel(6,6,i,0,1,1);
- setPixel(5,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,4,i,0,1,1);
- setPixel(6,5,i,0,1,1);
- setPixel(5,6,i,0,1,1);
- setPixel(4,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,3,i,0,1,1);
- setPixel(6,4,i,0,1,1);
- setPixel(5,5,i,0,1,1);
- setPixel(4,6,i,0,1,1);
- setPixel(3,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,2,i,0,1,1);
- setPixel(6,3,i,0,1,1);
- setPixel(5,4,i,0,1,1);
- setPixel(4,5,i,0,1,1);
- setPixel(3,6,i,0,1,1);
- setPixel(2,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,1,i,0,1,1);
- setPixel(6,2,i,0,1,1);
- setPixel(5,3,i,0,1,1);
- setPixel(4,4,i,0,1,1);
- setPixel(3,5,i,0,1,1);
- setPixel(2,6,i,0,1,1);
- setPixel(1,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,0,i,0,1,1);
- setPixel(6,1,i,0,1,1);
- setPixel(5,2,i,0,1,1);
- setPixel(4,3,i,0,1,1);
- setPixel(3,4,i,0,1,1);
- setPixel(2,5,i,0,1,1);
- setPixel(1,6,i,0,1,1);
- setPixel(0,7,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(6,0,i,0,1,1);
- setPixel(5,1,i,0,1,1);
- setPixel(4,2,i,0,1,1);
- setPixel(3,3,i,0,1,1);
- setPixel(2,4,i,0,1,1);
- setPixel(1,5,i,0,1,1);
- setPixel(0,6,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(5,0,i,0,1,1);
- setPixel(4,1,i,0,1,1);
- setPixel(3,2,i,0,1,1);
- setPixel(2,3,i,0,1,1);
- setPixel(1,4,i,0,1,1);
- setPixel(0,5,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(4,0,i,0,1,1);
- setPixel(3,1,i,0,1,1);
- setPixel(2,2,i,0,1,1);
- setPixel(1,3,i,0,1,1);
- setPixel(0,4,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(3,0,i,0,1,1);
- setPixel(2,1,i,0,1,1);
- setPixel(1,2,i,0,1,1);
- setPixel(0,3,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(2,0,i,0,1,1);
- setPixel(1,1,i,0,1,1);
- setPixel(0,2,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(1,0,i,0,1,1);
- setPixel(0,1,i,0,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(0,0,i,0,1,1);
- }
- delay (TD94);
- delay (TD93);
- for (int i = 0; i < 8; i++) {
- for (int j = 0; j < 8; j++) {
- for (int k = 0; k < 8; k++) {
- setPixel(i,j,k,0,0,0);
- }
- }
- }
- /////////////////////////////////////////////////////////
- for (int i = 0; i < 8; i++) {
- setPixel(7,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,1,i,1,1,1);
- setPixel(6,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,2,i,1,1,1);
- setPixel(6,1,i,1,1,1);
- setPixel(5,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,3,i,1,1,1);
- setPixel(6,2,i,1,1,1);
- setPixel(5,1,i,1,1,1);
- setPixel(4,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,4,i,1,1,1);
- setPixel(6,3,i,1,1,1);
- setPixel(5,2,i,1,1,1);
- setPixel(4,1,i,1,1,1);
- setPixel(3,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,5,i,1,1,1);
- setPixel(6,4,i,1,1,1);
- setPixel(5,3,i,1,1,1);
- setPixel(4,2,i,1,1,1);
- setPixel(3,1,i,1,1,1);
- setPixel(2,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,6,i,1,1,1);
- setPixel(6,5,i,1,1,1);
- setPixel(5,4,i,1,1,1);
- setPixel(4,3,i,1,1,1);
- setPixel(3,2,i,1,1,1);
- setPixel(2,1,i,1,1,1);
- setPixel(1,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(7,7,i,1,1,1);
- setPixel(6,6,i,1,1,1);
- setPixel(5,5,i,1,1,1);
- setPixel(4,4,i,1,1,1);
- setPixel(3,3,i,1,1,1);
- setPixel(2,2,i,1,1,1);
- setPixel(1,1,i,1,1,1);
- setPixel(0,0,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(6,7,i,1,1,1);
- setPixel(5,6,i,1,1,1);
- setPixel(4,5,i,1,1,1);
- setPixel(3,4,i,1,1,1);
- setPixel(2,3,i,1,1,1);
- setPixel(1,2,i,1,1,1);
- setPixel(0,1,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(5,7,i,1,1,1);
- setPixel(4,6,i,1,1,1);
- setPixel(3,5,i,1,1,1);
- setPixel(2,4,i,1,1,1);
- setPixel(1,3,i,1,1,1);
- setPixel(0,2,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(4,7,i,1,1,1);
- setPixel(3,6,i,1,1,1);
- setPixel(2,5,i,1,1,1);
- setPixel(1,4,i,1,1,1);
- setPixel(0,3,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(3,7,i,1,1,1);
- setPixel(2,6,i,1,1,1);
- setPixel(1,5,i,1,1,1);
- setPixel(0,4,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(2,7,i,1,1,1);
- setPixel(1,6,i,1,1,1);
- setPixel(0,5,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(1,7,i,1,1,1);
- setPixel(0,6,i,1,1,1);
- }
- delay (TD94);
- for (int i = 0; i < 8; i++) {
- setPixel(0,7,i,1,1,1);
- }
- delay (TD94);
- delay (TD93);
- for (int i = 0; i < 8; i++) {
- for (int j = 0; j < 8; j++) {
- for (int k = 0; k < 8; k++) {
- setPixel(i,j,k,0,0,0);
- }
- }
- }
- }
- void zigZagFill (boolean red, boolean green, boolean blue, int TD92) {
- for(int k = 0; k < 8; k=k+2){
- for(int j = 0; j < 8; j++){
- for(int i = 0; i < 8; i++){
- setPixel(j,k,i,red,green,blue);
- }
- delay(TD92);
- }
- for(int j = 7; j > -1; j--){
- for(int i = 0; i < 8; i++){
- setPixel(j,k+1,i,red,green,blue);
- }
- delay(TD92);
- }
- }
- }
- void animatieVier (int TD91) {
- zigZagFill(1, 0, 0, TD91);
- zigZagFill(0, 1, 0, TD91);
- zigZagFill(0, 0, 1, TD91);
- zigZagFill(1, 1, 1, TD91);
- zigZagFill(1, 0, 1, TD91);
- zigZagFill(1, 1, 0, TD91);
- zigZagFill(0, 1, 1, TD91);
- }
- void bovenonder (boolean red, boolean green, boolean blue, int TD90) {
- for(int k = 0; k < 8; k++){
- for(int i = 0; i < 8; i++){
- for(int j= 0; j < 8; j++){
- setPixel(i,k,j,red,green,blue);
- }
- }
- delay(TD90);
- for(int i = 0; i < 8; i++){
- for(int j= 0; j < 8; j++){
- setPixel(i,k,j,0,0,0);
- }
- }
- }
- }
- void linksrechts (boolean red, boolean green, boolean blue, int TD90) {
- for(int k = 0; k < 8; k++){
- for(int i = 0; i < 8; i++){
- for(int j= 0; j < 8; j++){
- setPixel(k,i,j,red,green,blue);
- }
- }
- delay(TD90);
- for(int i = 0; i < 8; i++){
- for(int j= 0; j < 8; j++){
- setPixel(k,i,j,0,0,0);
- }
- }
- }
- }
- void animatieVijf (int TD89) {
- bovenonder(1,0,0,TD89);
- bovenonder(0,1,0,TD89);
- bovenonder(0,0,1,TD89);
- bovenonder(1,1,1,TD89);
- bovenonder(1,1,0,TD89);
- bovenonder(0,1,1,TD89);
- linksrechts(1,0,0,TD89);
- linksrechts(0,1,0,TD89);
- linksrechts(0,0,1,TD89);
- linksrechts(1,1,1,TD89);
- linksrechts(1,1,0,TD89);
- linksrechts(0,1,1,TD89);
- }
- void animatieZes (int TD88, int red, int green, int blue) {
- for(int z = 0; z < 14; z++ ){
- int v = z - 2;
- int w = z - 4;
- int x = z - 6;
- if (z < 8) {
- for(int k = 0; k < 8; k++){
- setPixel(0,k,z,red,green,blue);
- }
- for(int k = 0; k < 8; k++){
- setPixel(k,0,z,red,green,blue);
- }
- for(int k = 0; k < 8; k++){
- setPixel(7,k,z,red,green,blue);
- }
- for(int k = 0; k < 8; k++){
- setPixel(k,7,z,red,green,blue);
- }
- }
- if (v > -1 && v < 8) {
- for(int k = 1; k < 7; k++){
- setPixel(1,k,v,red,green,blue);
- }
- for(int k = 1; k < 7; k++){
- setPixel(k,1,v,red,green,blue);
- }
- for(int k = 1; k < 7; k++){
- setPixel(6,k,v,red,green,blue);
- }
- for(int k = 1; k < 7; k++){
- setPixel(k,6,v,red,green,blue);
- }
- }
- if (w > -1 && w < 8) {
- for(int k = 2; k < 6; k++){
- setPixel(2,k,w,red,green,blue);
- }
- for(int k = 2; k < 6; k++){
- setPixel(k,2,w,red,green,blue);
- }
- for(int k = 2; k < 6; k++){
- setPixel(5,k,w,red,green,blue);
- }
- for(int k = 2; k < 6; k++){
- setPixel(k,5,w,red,green,blue);
- }
- }
- if (x > -1 && x < 8) {
- for(int k = 3; k < 5; k++){
- setPixel(3,k,x,red,green,blue);
- }
- for(int k = 3; k < 5; k++){
- setPixel(k,3,x,red,green,blue);
- }
- for(int k = 3; k < 5; k++){
- setPixel(4,k,x,red,green,blue);
- }
- for(int k = 3; k < 5; k++){
- setPixel(k,4,x,red,green,blue);
- }
- }
- delay(TD88);
- if (z < 8) {
- for(int k = 0; k < 8; k++){
- setPixel(0,k,z,0,0,0);
- }
- for(int k = 0; k < 8; k++){
- setPixel(k,0,z,0,0,0);
- }
- for(int k = 0; k < 8; k++){
- setPixel(7,k,z,0,0,0);
- }
- for(int k = 0; k < 8; k++){
- setPixel(k,7,z,0,0,0);
- }
- }
- if (v > -1 && v < 8) {
- for(int k = 1; k < 7; k++){
- setPixel(1,k,v,0,0,0);
- }
- for(int k = 1; k < 7; k++){
- setPixel(k,1,v,0,0,0);
- }
- for(int k = 1; k < 7; k++){
- setPixel(6,k,v,0,0,0);
- }
- for(int k = 1; k < 7; k++){
- setPixel(k,6,v,0,0,0);
- }
- }
- if (w > -1 && w < 8) {
- for(int k = 2; k < 6; k++){
- setPixel(2,k,w,0,0,0);
- }
- for(int k = 2; k < 6; k++){
- setPixel(k,2,w,0,0,0);
- }
- for(int k = 2; k < 6; k++){
- setPixel(5,k,w,0,0,0);
- }
- for(int k = 2; k < 6; k++){
- setPixel(k,5,w,0,0,0);
- }
- }
- if (x > -1 && x < 8) {
- for(int k = 3; k < 5; k++){
- setPixel(3,k,x,0,0,0);
- }
- for(int k = 3; k < 5; k++){
- setPixel(k,3,x,0,0,0);
- }
- for(int k = 3; k < 5; k++){
- setPixel(4,k,x,0,0,0);
- }
- for(int k = 3; k < 5; k++){
- setPixel(k,4,x,0,0,0);
- }
- }
- }
- }
- void animatieZeven (int TD87, int TD86) {
- for (int i = 8; i > -1; i--) {
- setPixel(0,i,0,1,0,0);
- delay(TD87);
- }
- for (int i = 1; i < 8; i++) {
- setPixel(i,0,0,1,0,0);
- setPixel(0,0,i,1,0,0);
- delay(TD87);
- }
- ///////////////////////////////
- for (int i = 0; i < 8; i++) {
- setPixel(7,i,0,1,1,0);
- delay(TD87);
- }
- for (int i = 6, k = 1; (i > -1) && (k < 8); i--, k++) {
- setPixel(i,7,0,1,1,0);
- setPixel(7,7,k,1,1,0);
- delay(TD87);
- }
- ///////////////////////////////////////////////////////////////////
- for (int i = 8; i > -1; i--) {
- setPixel(i,7,7,1,1,1);
- delay(TD87);
- }
- for (int i = 6; i > -1; i--) {
- setPixel(0,7,i,1,1,1);
- setPixel(0,i,7,1,1,1);
- delay(TD87);
- }
- ////////////////////////////////////////////////////////
- for (int i = 0; i < 8 ; i++) {
- setPixel(i,0,7,1,0,1);
- delay(TD87);
- }
- for (int i = 6, k = 1; (i > -1) && (k < 8); i--, k++) {
- setPixel(7,0,i,1,0,1); //i--
- setPixel(7,k,7,1,0,1); //i++
- delay(TD87);
- }
- delay(TD86);
- //////////////////////////////////////////////////////////////////
- for (int v = 0; v < 8; v++) {
- for (int i = 0; i < 8; i++) {
- for (int l = 0; l < 8; l++) {
- setPixel(v,l,i,0,0,0);
- }
- }
- }
- }
- // =====================================================================================================
- // ~~~ START of DISPLAY SOME TEXT ~~~
- // ----------------------------------
- // takes a string of text and displays it one character at a time with each new word a random colour
- // =====================================================================================================
- void displaySomeText(String someText, int pauseTime) {
- byte aChar; // grabs one character at a time from the message string
- int stringLen; // length of text message
- byte myColour; // random colour
- uint16_t charScroll[8] = {0x0000, 0x0000, // 8 row 16 bit display buffer
- 0x0000, 0x0000, // 8x8 panel maps to the 8 MSB's
- 0x0000, 0x0000, // aChar loads into 8 LSB's
- 0x0000, 0x0000}; // bit shifts to the left to scroll new char in and old char out
- stringLen = someText.length(); // find length of text message
- myColour = random(7) + 1; // select first random colour
- for(int i = 0; i < stringLen; i++){ // loop for as many characters in text message
- aChar = int(someText[i] - 0x20); // get ascii value for each character and remove offset
- // load a character into buffers 8 Least Significant Bits
- for(int j = 0; j < 8; j++){
- charScroll[j] += font8x8_basic[aChar][7 - j] << 8;
- }
- // shift buffer left one bit then load shift registers with the buffers 8 Most Significant Bits
- for(int j = 0; j < 7; j++){
- for(int k = 0; k < 8; k++){
- charScroll[k] = charScroll[k] >> 1;
- if(myColour & 0x01) {shiftRegisterRed[k] = 0x00ff & charScroll[k];} else {shiftRegisterRed[k] = 0;}
- if(myColour & 0x02) {shiftRegisterGrn[k] = 0x00ff & charScroll[k];} else {shiftRegisterGrn[k] = 0;}
- if(myColour & 0x04) {shiftRegisterBlu[k] = 0x00ff & charScroll[k];} else {shiftRegisterBlu[k] = 0;}
- }
- delay(60);
- }
- // if a space is detected chose a new random colour for the next word
- if(aChar == 0x00){ myColour = random(7) + 1; }
- }
- delay(1000);
- }
- // ================================
- // ~~~ END of DISPLAY SOME TEXT ~~~
- // ================================
- // =====================================================================================================
- // ~~~ START Draw Rectanle Outline ~~~
- // -----------------------------------
- // draw a 3d wireframe rectangle
- // =====================================================================================================
- void drawRectangleOutline(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
- for (int x = xMin; x < xMax + 1; x++) {
- setPixel( x, yMin, zMin, red, grn, blu);
- setPixel( x, yMin, zMax, red, grn, blu);
- setPixel( x, yMax, zMax, red, grn, blu);
- setPixel( x, yMax, zMin, red, grn, blu);
- }
- for (int y = yMin; y < yMax + 1; y++) {
- setPixel( xMin, y, zMin, red, grn, blu);
- setPixel( xMin, y, zMax, red, grn, blu);
- setPixel( xMax, y, zMax, red, grn, blu);
- setPixel( xMax, y, zMin, red, grn, blu);
- }
- for (int z = zMin; z < zMax + 1; z++) {
- setPixel( xMin, yMin, z, red, grn, blu);
- setPixel( xMin, yMax, z, red, grn, blu);
- setPixel( xMax, yMax, z, red, grn, blu);
- setPixel( xMax, yMin, z, red, grn, blu);
- }
- }
- // =================================
- // ~~~ END Draw Rectanle Outline ~~~
- // =================================
- // =====================================================================================================
- // ~~~ START Draw Rectanle Sides ~~~
- // ---------------------------------
- // draw a 3d rectangle filled sides
- // =====================================================================================================
- void drawRectangleSides(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
- for (int x = xMin; x < xMax + 1; x++) {
- for (int y = yMin; y < yMax + 1; y++) {
- setPixel( x, y, zMin, red, grn, blu);
- setPixel( x, y, zMax, red, grn, blu);
- }
- }
- for (int y = yMin; y < yMax + 1; y++) {
- for (int z = zMin; z < zMax + 1; z++) {
- setPixel( xMin, y, z, red, grn, blu);
- setPixel( xMax, y, z, red, grn, blu);
- }
- }
- for (int x = xMin; x < xMax + 1; x++) {
- for (int z = zMin; z < zMax + 1; z++) {
- setPixel( x, yMin, z, red, grn, blu);
- setPixel( x, yMax, z, red, grn, blu);
- }
- }
- }
- // ===============================
- // ~~~ END Draw Rectanle Sides ~~~
- // ===============================
- // =====================================================================================================
- // ~~~ START Draw Rectanle Filled ~~~
- // ----------------------------------
- // draw a 3d rectangle filled
- // =====================================================================================================
- void drawRectangleFilled(int xMin, int yMin , int zMin, int xMax, int yMax, int zMax, boolean red, boolean grn, boolean blu) {
- for (int x = xMin; x < xMax + 1; x++) {
- for (int y = yMin; y < yMax + 1; y++) {
- for (int z = zMin; z < zMax + 1; z++) {
- setPixel(x, y, z, red, grn, blu);
- }
- }
- }
- }
- // ================================
- // ~~~ END Draw Rectanle Filled ~~~
- // ================================
- // =====================================================================================================
- // ~~~ Start Flood Fill ~~~
- // ------------------------
- // fills entire panel with chosen colour via direct manipulation of the shift register arrays
- // (much faster than setting individual pixels)
- // =====================================================================================================
- void floodFill(boolean red, boolean grn, boolean blu) {
- for ( int indexY = 0; indexY < 8; indexY++ ) {
- if(red == 1) {shiftRegisterRed[indexY] = B11111111;} else {shiftRegisterRed[indexY] = B00000000;}
- if(grn == 1) {shiftRegisterGrn[indexY] = B11111111;} else {shiftRegisterGrn[indexY] = B00000000;}
- if(blu == 1) {shiftRegisterBlu[indexY] = B11111111;} else {shiftRegisterBlu[indexY] = B00000000;}
- }
- }
- // =========================
- // ~~~ END of Flood Fill ~~~
- // =========================
- // =====================================================================================================
- // ~~~ Start Fill YZ Axis Plane ~~~
- // --------------------------------
- //
- //
- // =====================================================================================================
- void yzPlaneFill(byte xIndex, byte colour) {
- boolean red = colour & B00000001;
- boolean grn = colour & B00000010;
- boolean blu = colour & B00000100;
- Serial.print("red = ");
- Serial.print(red);
- // test column index is within boundary
- if ( xIndex < 0) xIndex = 0;
- if ( xIndex > 7) xIndex = 7;
- // set the register arrays using bit manipulation
- for ( int i = 0; i < 8; i++ ) {
- for ( int j = 0; j < 8; j++ ) {
- if ( red == 0 ) shiftRegisterRed[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterRed[i + (j * 8)] |= (1 << xIndex);
- if ( grn == 0 ) shiftRegisterGrn[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterGrn[i + (j * 8)] |= (1 << xIndex);
- if ( blu == 0 ) shiftRegisterBlu[i + (j * 8)] &= ~(1 << xIndex); else shiftRegisterBlu[i + (j * 8)] |= (1 << xIndex);
- }
- }
- }
- // ==============================
- // ~~~ END Fill YZ Axis Plane ~~~
- // ==============================
- // =====================================================================================================
- // ~~~ Start Fill XZ Axis Plane ~~~
- // --------------------------------
- //
- //
- // =====================================================================================================
- void xzPlaneFill(byte yIndex, byte colour) {
- boolean red = colour & B00000001;
- boolean grn = colour & B00000010;
- boolean blu = colour & B00000100;
- Serial.print("red = ");
- Serial.print(red);
- // test column index is within boundary
- if ( yIndex < 0 ) yIndex = 0;
- if ( yIndex > 7 ) yIndex = 7;
- // set the register arrays using bit manipulation
- for (int i = 0; i < 8; i++) {
- if(red == 0) {shiftRegisterRed[i + (yIndex * 8)] = 0;} else {shiftRegisterRed[i + (yIndex * 8)] = 255;}
- if(grn == 0) {shiftRegisterGrn[i + (yIndex * 8)] = 0;} else {shiftRegisterGrn[i + (yIndex * 8)] = 255;}
- if(blu == 0) {shiftRegisterBlu[i + (yIndex * 8)] = 0;} else {shiftRegisterBlu[i + (yIndex * 8)] = 255;}
- }
- }
- // ==============================
- // ~~~ END Fill XZ Axis Plane ~~~
- // ==============================
- // =====================================================================================================
- // ~~~ Start Fill XZ Axis Plane ~~~
- // --------------------------------
- //
- //
- // =====================================================================================================
- void xyPlaneFill(byte zIndex, byte colour) {
- boolean red = colour & B00000001;
- boolean grn = colour & B00000010;
- boolean blu = colour & B00000100;
- // test column index is within boundary
- if ( zIndex < 0 ) zIndex = 0;
- if ( zIndex > 7 ) zIndex = 7;
- // set the register arrays using bit manipulation
- for ( int i = 0; i < 8; i++ ) {
- if ( red == 0 ) {shiftRegisterRed[zIndex + ( 8 * i)] = 0;} else {shiftRegisterRed[zIndex + ( 8 * i)] = 255;}
- if ( grn == 0 ) {shiftRegisterGrn[zIndex + ( 8 * i)] = 0;} else {shiftRegisterGrn[zIndex + ( 8 * i)] = 255;}
- if ( blu == 0 ) {shiftRegisterBlu[zIndex + ( 8 * i)] = 0;} else {shiftRegisterBlu[zIndex + ( 8 * i)] = 255;}
- }
- }
- // =======================
- // ~~~ END of Fill Row ~~~
- // =======================
- // =====================================================================================================
- // ~~~ Start Set Pixel ~~~
- // -----------------------
- // take a pixels x & y co-ordinate, R, G & B binary values and assigns to appropriate shift register bit
- // =====================================================================================================
- void setPixel(byte pixelX, byte pixelY, byte pixelZ, boolean red, boolean grn, boolean blu) {
- // test pixel x & co-ordinates are within boundary
- if(pixelX < 0) pixelX = 0;
- if(pixelX > 7) pixelX = 7;
- if(pixelY < 0) pixelY = 0;
- if(pixelY > 7) pixelY = 7;
- if(pixelZ < 0) pixelZ = 0;
- if(pixelZ > 7) pixelZ = 7;
- // set appropriate registers using bit manipulation.
- // just Google 'bit shifting in c'
- // to find tutorials and explanations of the following:
- if(red == 1) shiftRegisterRed[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if red is 1 set appropriate bit within appropriate red byte to 1
- else shiftRegisterRed[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate red byte to 0
- if(grn == 1) shiftRegisterGrn[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if grn is 1 set appropriate bit within appropriate grn byte to 1
- else shiftRegisterGrn[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate grn byte to 0
- if(blu == 1) shiftRegisterBlu[(8 * pixelY) + (7 - pixelZ)] |= (1 << pixelX); // if blu is 1 set appropriate bit within appropriate blu byte to 1
- else shiftRegisterBlu[(8 * pixelY) + (7 - pixelZ)] &= ~(1 << pixelX); // otherwise set appropriate bit within appropriate blu byte to 0
- }
- // ======================
- // ~~~ END Set Pixel ~~~
- // ======================
- // =====================================================================================================
- // ~~~ START 0f ISR ~~~
- // --------------------
- // Updates the panel. Called every 125uS (8KHz), each row is lit for 1/8th of the time (1KHz)
- // =====================================================================================================
- ISR(TIMER2_COMPA_vect) {
- PORTD |= (1 << SR_BLANK); // temporarely disable the SR outputs
- for (int i = 0; i < 8; i++) {
- SPI.transfer(shiftRegisterRed[i + anodeIndex * 8]); // send the red SR byte for the given anode level
- SPI.transfer(shiftRegisterGrn[i + anodeIndex * 8]); // send the grn SR byte for the given anode level
- SPI.transfer(shiftRegisterBlu[i + anodeIndex * 8]); // send the blu SR byte for the given anode level
- }
- SPI.transfer(anodeLevel[anodeIndex]); // send the anode multiplex byte
- anodeIndex = (anodeIndex + 1) % 8; // incrument anode index ready for next ISR
- PORTD |= (1 << SR_LATCH); // set latch pin LOW
- PORTD &= ~(1 << SR_LATCH); // set latch pin HIGH - SR outputs now have new data
- PORTD &= ~(1 << SR_BLANK); // re-enable the SR outputs
- }
- // ==================
- // ~~~ END of ISR ~~~
- // ==================
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement