This document contains code for driving a 5x5x5 LED cube display. It sets up input and output pins, initializes variables, and defines interrupt routines. The setup() function configures pins for row drivers, shift register control, and input selection. The main loop() handles pattern selection via inputs and loads patterns into the active_display array. An interrupt service routine (ISR) refreshes the display by shifting out row data to the shift register and latching/driving each row over multiple interrupts.
This document contains code for driving a 5x5x5 LED cube display. It sets up input and output pins, initializes variables, and defines interrupt routines. The setup() function configures pins for row drivers, shift register control, and input selection. The main loop() handles pattern selection via inputs and loads patterns into the active_display array. An interrupt service routine (ISR) refreshes the display by shifting out row data to the shift register and latching/driving each row over multiple interrupts.
This document contains code for driving a 5x5x5 LED cube display. It sets up input and output pins, initializes variables, and defines interrupt routines. The setup() function configures pins for row drivers, shift register control, and input selection. The main loop() handles pattern selection via inputs and loads patterns into the active_display array. An interrupt service routine (ISR) refreshes the display by shifting out row data to the shift register and latching/driving each row over multiple interrupts.
This document contains code for driving a 5x5x5 LED cube display. It sets up input and output pins, initializes variables, and defines interrupt routines. The setup() function configures pins for row drivers, shift register control, and input selection. The main loop() handles pattern selection via inputs and loads patterns into the active_display array. An interrupt service routine (ISR) refreshes the display by shifting out row data to the shift register and latching/driving each row over multiple interrupts.
OUTPUT); // setup and turn off all 5 row driver transistors digitalWrite(row0Pin, LOW); pinMode(row1Pin, OUTPUT); digitalWrite(row1Pin, LOW); pinMode(row2Pin, OUTPUT); digitalWrite(row2Pin, LOW); pinMode(row3Pin, OUTPUT); digitalWrite(row3Pin, LOW); pinMode(row4Pin, OUTPUT); digitalWrite(row4Pin, LOW); // setup and turn off 3 shift register control pins pinMode(clockPin, OUTPUT); digitalWrite(clockPin, LOW); pinMode(dataPin, OUTPUT); digitalWrite(dataPin, LOW); pinMode(latchPin, OUTPUT); digitalWrite(latchPin, LOW); // four input pins used to select pattern update type by jumper ground clip on driver/processor board pinMode(7, INPUT); digitalWrite(7, HIGH); //jumper will select pattern 0 on/off pinMode(8, INPUT); digitalWrite(8, HIGH); //jumper will select pattern 1 alternating on/off pinMode(9, INPUT); digitalWrite(9, HIGH); //jumper will select pattern 2 random pattern pinMode(10, INPUT); digitalWrite(10, HIGH); //jumper will select pattern 3 EEPROM script pattern for (byte j = 0; j < 32; j++) { // set shift reg to all columns outputs off, in case shift reg doesn't power-up cleared digitalWrite (dataPin, LOW); // probably not needed, but why not start in a known all off condition. digitalWrite(clockPin, HIGH); // clock 32 low bits to shift regester digitalWrite(clockPin, LOW); } digitalWrite(latchPin, HIGH); //latch all zeros to 25 column output pins digitalWrite(latchPin, LOW); randomSeed(analogRead(1)); // used for random LED pattern mode for cube Serial.begin(57600); Serial.println ("5X5X5 Cube Ready"); // signal initalization done MsTimer2::set(2, refresh_display); // 2ms period, generates a 2msec interrupt to the ISR routine MsTimer2::start(); } // End of setup void loop() { // select pattern to use if(!digitalRead(7)){ Pattern = 0; // on/off } if(!digitalRead(8)) { Pattern = 1; // alternate lamps on/off } if(!digitalRead(9)){ Pattern = 2; //random lamps } if(! digitalRead(10)){ Pattern = 3; // get script pattern from eprom } // phase one pattern loading noInterrupts(); // we want new pattern data to transfer 'atomic' so as not to effect display for (byte i = 0; i <= 4; i++) { if (Pattern == 0) { active_display[i] = all_on_display[i]; } if (Pattern == 1) { active_display[i] = alt_on_display[i]; } if (Pattern == 2) { active_display[i] = random(0x02000000); } if (Pattern == 3) { active_display[i] = eeprom_read_dword((uint32_t *)address); address = address + 4; } } interrupts(); if (updatetype == 0) { patternDelay = timedelay; // fixed cube update time via fixed constant } if (updatetype == 1) { patternDelay = analogRead(potInput); if (patternDelay < 20) { patternDelay = 20; // variable time interval, clamp variable update time to 50hz minimum } } if (updatetype == 2) { patternDelay = (((active_display[4] >> 25) +2)*10); //high 7 bits of active_display[4] +2 X 10 msec // Serial.println (patternDelay); // for debugging eeprom data as EEPROM scripting not tested yet. } if (Pattern == 2) { patternDelay = random(100,200); // added to give a littl random delay to make random pattern more uh random. } delay(patternDelay); noInterrupts(); // phase two, for on/off, alt pattern usage, otherwise only one phase would have been required in main loop for (byte i = 0; i < 5; i++) { if (Pattern == 0) { active_display[i] = all_off_display[i]; } if (Pattern == 1) { active_display[i] = alt_off_display[i]; } if (Pattern == 2) { active_display[i] = random(); } if (Pattern == 3) { active_display[i] = eeprom_read_dword((uint32_t *)address);
25) * 20; //high 7 bits (0-127) X 20 msec patternDelay = (((active_display[4] >> 25) +2)*10); //high 7 bits of active_display[4] +2 X 10 msec // Serial.println (patternDelay); // for debugging eeprom data } if (Pattern == 2) { patternDelay = random(100,200); } delay(patternDelay); } // Start of Interrupt routine for driving a display cube row, all 5 rows (levels) are driven over a 10msec period (5 x 2msec) void refresh_display() { unsigned long shiftdata = active_display[active_row]; // get row data for 25 leds unsigned long shiftmask = 1; for (byte i = 0; i < 32; i++) { // shift 32 bits (only 25 bits are wired up to cube) of data out for the 25 display columns if (shiftdata & shiftmask) { digitalWrite(dataPin, HIGH); } else { digitalWrite(dataPin, LOW); } digitalWrite(clockPin, HIGH); // clock each bit into shift register digitalWrite(clockPin, LOW); shiftmask = shiftmask * 2; //right shift bit mask one bit } if (active_row == 0) { digitalWrite(row4Pin, LOW); // turn off row 4 driver if row 0 is now active, this is wrap around case } else { digitalWrite((active_row + 1), LOW); // turn off driver from prior row update interrupt } digitalWrite(latchPin, HIGH); // turn on shift register output pins, column drivers digitalWrite(latchPin, LOW); digitalWrite((active_row + 2), HIGH); // turn on active row driver transistor // Set next active row number for next timer interrrupt if (active_row >= 4) { active_row = 0; // wraparound case } else { active_row++; // increament row number for next interrupt cycle } }
