LED Cube 4x4x4 very easy code with shift registers

How to make diffrent patterns for LED Cube 4x4x4 with shift registers

Apr 24, 2021

•

27441 views

•

7 respects

•

LGPL3+

lights

Devices & Components

Arduino Nano

Pushbutton Switch, Momentary

Shift Register 75HC595

LED (generic)

Hardware & Tools

Materia 101

Project description

Code

ShiftRegister Tab

arduino

1
2#define latchPin 10   //PORT B2
3#define clockPin 9    //PORT B1
4#define  dataPin 11    //PORT B3
5#define resetPin 8    //PORT B0
6
7void InitializeShiftReg()  {
8  DDRB |= B1111;  //pins D8-D11 as OUTPUTS
9  PORTB |= B0001; //resetPin  to HIGH 
10}
11
12void SetShiftReg(unsigned int value) {
13   bitClear(PORTB,  2);   //digitalWrite(latchPin, LOW);
14   shiftOut(dataPin, clockPin, MSBFIRST,  value >> 8);   //shift out high byte, alternative: LSBFIRST / MSBFIRST
15   shiftOut(dataPin,  clockPin, MSBFIRST, value);        //shift out low byte, alternative: LSBFIRST /  MSBFIRST
16   bitSet(PORTB, 2);    //digitalWrite(latchPin, HIGH);
17}

#define latchPin 10   //PORT B2
#define clockPin 9    //PORT B1
#define  dataPin 11    //PORT B3
#define resetPin 8    //PORT B0

void InitializeShiftReg()  {
  DDRB |= B1111;  //pins D8-D11 as OUTPUTS
  PORTB |= B0001; //resetPin  to HIGH 
}

void SetShiftReg(unsigned int value) {
   bitClear(PORTB,  2);   //digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, MSBFIRST,  value >> 8);   //shift out high byte, alternative: LSBFIRST / MSBFIRST
   shiftOut(dataPin,  clockPin, MSBFIRST, value);        //shift out low byte, alternative: LSBFIRST /  MSBFIRST
   bitSet(PORTB, 2);    //digitalWrite(latchPin, HIGH);
}

The main loop

arduino

1
2#define buttonPin 2
3
4unsigned int layer[4] = {0, 0, 0, 0};   //65535  filled layer
5byte k = 0;
6bool start = true;
7unsigned long delayTime;
8int  speedTime = 0;
9int count;
10
11void setup() {
12  InitializeShiftReg();
13  InitializeMyLedCube();
14}
15
16void InitializeMyLedCube() {
17  DDRD = B11110000;         //pins D0-D3 as INPUTS, D4-D7 as OUTPUTS
18  PORTD |= B11110000;     //turn  OFF layers
19  pinMode(buttonPin, INPUT_PULLUP);
20  attachInterrupt(digitalPinToInterrupt(buttonPin),  PushButton, FALLING);
21  delayTime = millis();
22}
23
24byte patternNum = 28;
25byte  pattern = patternNum - 1;
26
27void loop() {
28  if (start) {
29    detachInterrupt(digitalPinToInterrupt(buttonPin));
30    delay(500);   //wait for releasing PushButton
31    pattern++; 
32    if (pattern  > patternNum) pattern = 1;
33    attachInterrupt(digitalPinToInterrupt(buttonPin),  PushButton, FALLING);
34    count = 0;
35  }
36  if (((millis() - delayTime)  > speedTime) || start) { 
37    switch (pattern) {
38      case 1: LayersUpDown();  break;
39      case 2: FallingDot(); break;
40      case 3: Rain(); break;
41      case 4: AllCube(); break;
42      case 5: Cut(); break;
43      case 6:  Cube(); break;
44      case 7: Diagonal(); break;
45      case 8: Mixer(); break;
46      case 9: Random(); break;
47      case 10: FallingLayer(); break;
48      case  11: LayerCut(); break;
49      case 12: Circle(); break;
50      case 13: RandomWay();  break;
51      case 14: SmallCube(); break;
52      case 15: RandomWayCube();  break;
53      case 16: GrowingCube(); break;
54      case 17: FallingLayers();  break;
55      case 18: GrowingLine(); break;
56      case 19: CircleEdges();  break;
57      case 20: CircleSide(); break;
58      case 21: RandomWayLine();  break;
59      case 22: RandomWaySide(); break;
60      case 23: DJCube(); break;
61      case 24: FillingCube(); break;
62      case 25: NanoBuilding(); break;
63      case 26: Curve(); break;
64      case 27: Snake(); break;
65      case 28:  Julka(); break;
66      default: break;
67    }
68    delayTime = millis();
69  }
70
71  //this part displays layers as they are set in functions
72  SetShiftReg(layer[k]);    //send layer data to shift registers
73  bitClear(PORTD, 4 + k);   //turn ON  layer k
74  delay(1);                 //important for brightness of leds
75  PORTD  |= B11110000;       //turn OFF layers
76  k++; if (k > 3) k = 0;    //take another  layer in the loop
77}
78
79void PushButton() {
80  start = true;
81}

#define buttonPin 2

unsigned int layer[4] = {0, 0, 0, 0};   //65535  filled layer
byte k = 0;
bool start = true;
unsigned long delayTime;
int  speedTime = 0;
int count;

void setup() {
  InitializeShiftReg();
  InitializeMyLedCube();
}

void InitializeMyLedCube() {
  DDRD = B11110000;         //pins D0-D3 as INPUTS, D4-D7 as OUTPUTS
  PORTD |= B11110000;     //turn  OFF layers
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin),  PushButton, FALLING);
  delayTime = millis();
}

byte patternNum = 28;
byte  pattern = patternNum - 1;

void loop() {
  if (start) {
    detachInterrupt(digitalPinToInterrupt(buttonPin));
    delay(500);   //wait for releasing PushButton
    pattern++; 
    if (pattern  > patternNum) pattern = 1;
    attachInterrupt(digitalPinToInterrupt(buttonPin),  PushButton, FALLING);
    count = 0;
  }
  if (((millis() - delayTime)  > speedTime) || start) { 
    switch (pattern) {
      case 1: LayersUpDown();  break;
      case 2: FallingDot(); break;
      case 3: Rain(); break;
      case 4: AllCube(); break;
      case 5: Cut(); break;
      case 6:  Cube(); break;
      case 7: Diagonal(); break;
      case 8: Mixer(); break;
      case 9: Random(); break;
      case 10: FallingLayer(); break;
      case  11: LayerCut(); break;
      case 12: Circle(); break;
      case 13: RandomWay();  break;
      case 14: SmallCube(); break;
      case 15: RandomWayCube();  break;
      case 16: GrowingCube(); break;
      case 17: FallingLayers();  break;
      case 18: GrowingLine(); break;
      case 19: CircleEdges();  break;
      case 20: CircleSide(); break;
      case 21: RandomWayLine();  break;
      case 22: RandomWaySide(); break;
      case 23: DJCube(); break;
      case 24: FillingCube(); break;
      case 25: NanoBuilding(); break;
      case 26: Curve(); break;
      case 27: Snake(); break;
      case 28:  Julka(); break;
      default: break;
    }
    delayTime = millis();
  }

  //this part displays layers as they are set in functions
  SetShiftReg(layer[k]);    //send layer data to shift registers
  bitClear(PORTD, 4 + k);   //turn ON  layer k
  delay(1);                 //important for brightness of leds
  PORTD  |= B11110000;       //turn OFF layers
  k++; if (k > 3) k = 0;    //take another  layer in the loop
}

void PushButton() {
  start = true;
}

ShiftRegister Tab

arduino

1
2#define latchPin 10   //PORT B2
3#define clockPin 9    //PORT B1
4#define   dataPin 11    //PORT B3
5#define resetPin 8    //PORT B0
6
7void InitializeShiftReg()   {
8  DDRB |= B1111;  //pins D8-D11 as OUTPUTS
9  PORTB |= B0001; //resetPin   to HIGH 
10}
11
12void SetShiftReg(unsigned int value) {
13   bitClear(PORTB,   2);   //digitalWrite(latchPin, LOW);
14   shiftOut(dataPin, clockPin, MSBFIRST,   value >> 8);   //shift out high byte, alternative: LSBFIRST / MSBFIRST
15   shiftOut(dataPin,   clockPin, MSBFIRST, value);        //shift out low byte, alternative: LSBFIRST /   MSBFIRST
16   bitSet(PORTB, 2);    //digitalWrite(latchPin, HIGH);
17}

#define latchPin 10   //PORT B2
#define clockPin 9    //PORT B1
#define   dataPin 11    //PORT B3
#define resetPin 8    //PORT B0

void InitializeShiftReg()   {
  DDRB |= B1111;  //pins D8-D11 as OUTPUTS
  PORTB |= B0001; //resetPin   to HIGH 
}

void SetShiftReg(unsigned int value) {
   bitClear(PORTB,   2);   //digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, MSBFIRST,   value >> 8);   //shift out high byte, alternative: LSBFIRST / MSBFIRST
   shiftOut(dataPin,   clockPin, MSBFIRST, value);        //shift out low byte, alternative: LSBFIRST /   MSBFIRST
   bitSet(PORTB, 2);    //digitalWrite(latchPin, HIGH);
}

The Patterns Tab

arduino

1
2bool direct;
3unsigned int actualValue;
4byte lay, xVal, yVal;
5byte  place;
6
7void SetLayers(unsigned int value) {
8  layer[0] = value; layer[1]  = value; layer[2] = value; layer[3] = value;
9}
10
11void InversLayers() {
12  layer[0] = 65535 - layer[0];
13  layer[1] = 65535 - layer[1];
14  layer[2] =  65535 - layer[2];
15  layer[3] = 65535 - layer[3];
16}
17
18void ClearLayers()  {
19  SetLayers(0);
20}
21
22void LayersUpDown() {
23  if (start) {
24    start  = false;                                                                                                                                                                                                                                              speedTime  = 500;
25    direct = true;
26  }
27  ClearLayers();
28  layer[count] = 65535;
29  if (direct) {
30   count++; 
31   if (count > 3) { 
32     direct = false;
33     count = 2;
34   }
35  } else {
36    count--; if (count < 1) direct = true;
37  }
38}
39
40void FallingDot() {
41  if (start) {
42    start = false; speedTime  = 100;
43    count = 4;
44    actualValue = 1;
45    direct = true;
46  }
47  count--;
48  ClearLayers();
49  layer[count] = actualValue;
50  if (count ==  0) {
51    count = 4;
52    actualValue = actualValue << 1;
53    if (actualValue  == 0) actualValue = 1;
54  }
55}
56
57void Rain() {
58  if (start) {
59    start  = false; speedTime = 200;
60    ClearLayers();
61  }
62  layer[0] = layer[1];
63  layer[1] = layer[2];
64  layer[2] = layer[3];
65  layer[3] = 1 << random(16);
66}
67
68void  Random() {
69  if (start) {
70    start = false; speedTime = 200;
71  }
72  layer[0]  = random(65536);
73  layer[1] = random(65536);
74  layer[2] = random(65536);
75  layer[3] = random(65536);
76}
77
78void AllCube() {
79  if (start) {
80    start  = false; speedTime = 2000;
81  }
82  ClearLayers();
83  switch (count) {
84    case 0:
85      SetLayers(65535);
86      break;
87    case 1:
88      layer[1]  = 1632; 
89      layer[2] = 1632;  
90      break; 
91  }
92  count++; if (count  > 1) count = 0;
93}
94
95void Cut() {
96  if (start) {
97    start = false;  speedTime = 2000;
98    layer[0] = 4369; 
99    layer[1] = 13107; 
100    layer[2]  = 30583; 
101    layer[3] = 65535;
102  }
103  InversLayers();
104}
105
106void  Cube() {
107  if (start) {
108    start = false; speedTime = 2000;
109    layer[0]  = 15+16+128+256+2048+4096+8192+16384+32768; 
110    layer[1] = 1+8+4096+32768; 
111    layer[2] = layer[1]; 
112    layer[3] = layer[0];
113  }
114  InversLayers();
115}
116
117void  Diagonal() {
118  if (start) {
119    start = false; speedTime = 2000;
120    layer[0]  = 33825; 
121    layer[1] = 33825; 
122    layer[2] = 33825; 
123    layer[3] =  33825;
124  }
125  InversLayers();
126}
127
128void Mixer() {
129  if (start) {
130    start = false; speedTime = 100;
131  }
132  switch (count) {
133    case 0:  actualValue = 33825; break;
134    case 1: actualValue = 17442; break;
135    case  2: actualValue = 8772; break;
136    case 3: actualValue = 4680; break;
137    case  4: actualValue = 960; break;
138    case 5: actualValue = 3120; break;
139  }
140  SetLayers(actualValue); 
141  count++;
142  if (count > 5) count = 0;
143}
144
145void  FallingLayer() {
146  if (start) {
147    start = false; speedTime = 100;
148    actualValue  = 0;
149    direct = false;
150  }
151  if (actualValue == 0) {
152    actualValue  = 1;
153    ClearLayers();
154    direct = !direct;
155    layer[3 - (direct? 0:3)]  = 65535;
156  }
157  switch (count) {
158    case 0:
159      layer[3 - (direct?  0:3)] -= actualValue;
160      layer[2 - (direct? 0:1)] = actualValue;
161      break;
162    case 1:
163      layer[1 + (direct? 0:1)] = layer[2  - (direct? 0:1)];
164      layer[2  - (direct? 0:1)] = 0;
165      break;
166    case 2:
167      layer[0 + (direct?  0:3)] += layer[1 + (direct? 0:1)];
168      layer[1 + (direct? 0:1)] = 0;
169      actualValue  = actualValue << 1;
170      break;
171  }
172  count++; if (count > 2) count =  0;
173}
174
175void LayerCut() {
176  if (start) {
177    start = false; speedTime  = 100;
178  }
179  if (count) layer[0] = layer[0] << 1;
180  else layer[0] = 4369;
181  SetLayers(layer[0]);
182  count++;
183  if (count > 20) count = 0;
184}
185
186void  Circle() {
187  if (start) {
188    start = false; speedTime = 100;
189    lay =  3;
190  }
191  switch (count) {
192    case 0: ClearLayers(); layer[lay] = 1; break;
193    case 1: layer[lay] = 2; break;
194    case 2: layer[lay] = 4; break;
195    case  3: layer[lay] = 8; break;
196    case 4: layer[lay] = 128; break;
197    case 5:  layer[lay] = 2048; break;
198    case 6: layer[lay] = 32768; break;
199    case  7: layer[lay] = 16384; break;
200    case 8: layer[lay] = 8192; break;
201    case  9: layer[lay] = 4096; break;
202    case 10: layer[lay] = 256; break;
203    case  11: layer[lay] = 16; break;
204    case 12: layer[lay] = 1; break;
205  }
206  count++;
207  if (count > 12) {
208    count = 0;
209    if (lay == 0) lay = 3;
210    else  lay--;
211  }
212}
213
214void RandomWay() {
215  if (start) {
216    start = false;  speedTime = 200;
217    lay = random(4);
218    xVal = random(4);
219    yVal =  random(4);
220  }
221  switch (random(7)) {
222    case 0: if ((lay + 1) <= 3) lay++;  break;
223    case 1: if ((lay - 1) >= 0) lay--; break;
224    case 2: if ((xVal  + 1) <= 3) xVal++; break;
225    case 3: if ((xVal - 1) >= 0) xVal--; break;
226    case 4: if ((yVal + 1) <= 3) yVal++; break;
227    case 5: if ((yVal - 1) >=  0) yVal--; break;
228    default: break;
229  }
230  ClearLayers();
231  layer[lay]  = (1 << xVal) << (4 * yVal);
232}
233
234void SmallCube() {
235  if (start) {
236    start = false; speedTime = 200;
237  }
238  switch (count) {
239    case 0:  lay = random(3); ClearLayers(); actualValue = 51; break;
240    case 1: actualValue  = actualValue << 1; break;
241    case 2: actualValue = actualValue << 1; break;
242    case 3: actualValue = actualValue << 4; break;
243    case 4: actualValue =  actualValue << 4; break;
244    case 5: actualValue = actualValue >> 1; break;
245    case 6: actualValue = actualValue >> 1; break;
246    case 7: actualValue =  actualValue >> 4; break;
247    case 8: actualValue = actualValue >> 4; break;
248  }
249  layer[lay] = actualValue;
250  layer[lay+1] = actualValue;
251  count++;  if (count > 8) count = 0;
252}
253
254void RandomWayCube() {
255  if (start) {
256    start = false; speedTime = 200;
257    lay = random(3);
258    xVal = random(3);
259    yVal = random(3);
260  }
261  switch (random(7)) {
262    case 0: if ((lay +  1) < 3) lay++; break;
263    case 1: if ((lay - 1) >= 0) lay--; break;
264    case  2: if ((xVal + 1) < 3) xVal++; break;
265    case 3: if ((xVal - 1) >= 0) xVal--;  break;
266    case 4: if ((yVal + 1) < 3) yVal++; break;
267    case 5: if ((yVal  - 1) >= 0) yVal--; break;
268    default: break;
269  }
270  ClearLayers();
271  layer[lay] = (51 << xVal) << (4 * yVal);
272  layer[lay+1] = layer[lay];
273}
274
275void  GrowingCube() {
276  if (start) {
277    start = false; speedTime = 1000;
278  }
279  switch (count) {
280    case 0: ClearLayers(); layer[0] = 1; break;
281    case  1: layer[0] = 51; layer[1] = 51; break;
282    case 2: layer[0] = 1911; layer[1]  = 1911; layer[2] = 1911; break;
283    case 3: SetLayers(65535); break;
284    default:  break;
285  }
286  count++; if (count > 4) count = 0;
287}
288
289void FallingLayers()  {
290  if (start) {
291    start = false; speedTime = 200;
292    actualValue =  0;
293    lay = 4;
294  }
295  if (actualValue == 0) {
296    lay--; if (lay < 1)  lay = 3;
297    actualValue = 1;
298    ClearLayers();
299    layer[lay] = 65535;
300  }
301  layer[lay] -= actualValue;
302  layer[lay-1] += actualValue;
303  actualValue  = actualValue << 1;
304}
305
306void GrowingLine() {
307  if (start) {
308    start  = false; speedTime = 100;
309  }
310  switch (count) {
311    case 0:
312      ClearLayers();
313      layer[0] = 1;
314      lay = 0; xVal = 0; yVal = 0;
315      while ((lay ==  0) && (xVal == 0) && (yVal == 0)) {
316        lay = random(2);
317        xVal  = random(2);
318        yVal = random(2);
319      }
320      break;
321    case  1: layer[lay] += ((xVal==0)?1:2) << (4 * yVal); break;
322    case 2: layer[2 *  lay] += ((xVal==0)?1:4) << (8 * yVal); break;
323    case 3: layer[3 * lay] += ((xVal==0)?1:8)  << (12 * yVal); break; 
324    case 4: layer[3 * lay] -= ((xVal==0)?1:8) << (12  * yVal); break; 
325    case 5: layer[2 * lay] -= ((xVal==0)?1:4) << (8 * yVal);  break;
326    default: break;     
327  }
328  count++; if (count > 5) count = 0;
329}
330
331void  CircleEdges() {
332  if (start) {
333    start = false; speedTime = 100;
334    lay  = 3;
335    ClearLayers();
336  }
337  switch (count) {
338    case 0: layer[lay]  = 1; break;
339    case 1: layer[lay] += 2; break;
340    case 2: layer[lay] +=  4; break;
341    case 3: layer[lay] += 8; break;
342    case 4: layer[lay] += 128;  break;
343    case 5: layer[lay] += 2048; break;
344    case 6: layer[lay] += 32768;  break;
345    case 7: layer[lay] += 16384; break;
346    case 8: layer[lay] += 8192;  break;
347    case 9: layer[lay] += 4096; break;
348    case 10: layer[lay]+= 256;  break;
349    case 11: layer[lay] += 16; break;
350    default: break;
351  }
352  count++;
353  if (count > 12) {
354    count = 0;
355    if (lay == 0) {
356      lay  = 3;
357      ClearLayers();
358    }
359    else lay--;
360  }
361}
362
363void  CircleSide() {
364  if (start) {
365    start = false; speedTime = 1000;
366  }
367  switch (count) {
368    case 0: SetLayers(15); break;
369    case 1: SetLayers(34952);  break;
370    case 2: SetLayers(61440); break;
371    case 3: SetLayers(4369); break;
372    case 4: ClearLayers(); layer[0] = 65535; break;
373    case 5: SetLayers(34952);  break;
374    case 6: ClearLayers(); layer[3] = 65535; break;
375    case 7: SetLayers(4369);  break;
376  }
377  count++;
378  if (count > 7) count = 0;
379}
380
381void RandomWayLine()  {
382  if (start) {
383    start = false; speedTime = 200;
384    lay = random(3);
385    yVal = random(3);
386  }
387  switch (random(5)) {
388    case 0: if ((lay +  1) <= 3) lay++; break;
389    case 1: if ((lay - 1) >= 0) lay--; break;
390    case  2: if ((yVal + 1) <= 3) yVal++; break;
391    case 3: if ((yVal - 1) >= 0) yVal--;  break;
392    default: break;
393  }
394  ClearLayers();
395  layer[lay] = 15 <<  (4 * yVal);
396}
397
398void RandomWaySide() {
399  if (start) {
400    start =  false; speedTime = 200;
401    xVal = random(3);
402  }
403  switch (random(3))  {
404    case 0: if ((xVal + 1) <= 3) xVal++; break;
405    case 1: if ((xVal -  1) >= 0) xVal--; break;
406    default: break;
407  }
408  ClearLayers();
409  actualValue  = 4369 << xVal;
410  switch (random(2)) {
411    case 0: SetLayers(actualValue);  break;
412    case 1: layer[1] = actualValue; layer[2] = actualValue; break;
413  }
414}
415
416void DJCube() {
417  if (start) {
418    start = false; speedTime  = 200;
419    xVal = random(3);
420  }
421  switch (random(3)) {
422    case 0:  if ((xVal + 1) <= 3) xVal++; break;
423    case 1: if ((xVal - 1) >= 0) xVal--;  break;
424    default: break;
425  }
426  switch (xVal) {
427    case 0: SetLayers(4369);  break;
428    case 1: SetLayers(13107); break;
429    case 2: SetLayers(30583);  break;
430    case 3: SetLayers(65535); break;
431  }
432}
433
434void FillingCube()  {
435  if (start) {
436    start = false; speedTime = 200;
437    count = 4;
438    actualValue = 1;
439  }
440  if ((count == 4) && (actualValue == 1)) ClearLayers();
441  count--;
442  layer[count] += actualValue;
443  if (count == 0) {
444    count  = 4;
445    actualValue = actualValue << 1;
446    if (actualValue == 0) actualValue  = 1;
447  }
448}
449
450void NanoBuilding() {
451  if (start) {
452    start = false;  speedTime = 150;
453    actualValue = 0;
454    place = 1;
455    direct = true;
456  }
457  if (direct) {
458    direct = false;
459    while ((actualValue < place)  && (place < 64)) {
460      lay = random(4);
461      xVal = random(4);
462      yVal  = random(4);     
463      actualValue = xVal + (yVal * 4) + (lay * 16);
464    }
465  }
466  actualValue = 0;
467  int xValP = xVal;
468  int yValP = yVal;
469  int  layP = lay;
470  while ((actualValue < place) && (place < 64)) {
471    xVal = xValP;
472    yVal = yValP;
473    lay = layP;
474    switch (random(7)) {
475      case 0:  if ((lay + 1) <= 3) lay++; break;
476      case 1: if ((lay - 1) >= 0) lay--; break;
477      case 2: if ((xVal + 1) <= 3) xVal++; break;
478      case 3: if ((xVal - 1)  >= 0) xVal--; break;
479      case 4: if ((yVal + 1) <= 3) yVal++; break;
480      case  5: if ((yVal - 1) >= 0) yVal--; break;
481      default: break;
482    }
483    actualValue  = xVal + (yVal * 4) + (lay * 16);
484  }
485  if (actualValue == place) {
486    place++;
487    direct = true;
488  }
489  ClearLayers();
490  if (place < 16) layer[0] = (1  << place) - 1;
491  else {
492    if (place < 32) {
493      layer[1] = (1 << (place  - 16)) - 1;
494      layer[0] = 65535;
495    } else {
496      if (place < 48)  {
497        layer[2] = (1 << (place - 32)) - 1;
498        layer[0] = 65535;
499        layer[1] = 65535;
500      } else {
501        if (place < 64) {
502          SetLayers(65535);
503          layer[3] = (1 << (place - 48)) - 1;
504        } else place = 1;
505      }
506    }
507  }
508  layer[lay] |= ((1 << xVal) << (4 * yVal));
509}
510
511void Curve()  {
512  int line[4] = {4369, 8738, 17476, 34952};
513  byte pos[12] = {0, 1, 2, 3,  3, 2, 1, 0, 0, 1, 2, 3};
514  
515  if (start) {
516    start = false; speedTime  = 100;
517  }
518  layer[0] = ((pos[count] == 0) ? line[0]: 0) + ((pos[count+1]  == 0) ? line[1]: 0) + ((pos[count+2] == 0) ? line[2]: 0) + ((pos[count+3] == 0)  ? line[3]: 0);
519  layer[1] = ((pos[count] == 1) ? line[0]: 0) + ((pos[count+1]  == 1) ? line[1]: 0) + ((pos[count+2] == 1) ? line[2]: 0) + ((pos[count+3] == 1)  ? line[3]: 0);
520  layer[2] = ((pos[count] == 2) ? line[0]: 0) + ((pos[count+1]  == 2) ? line[1]: 0) + ((pos[count+2] == 2) ? line[2]: 0) + ((pos[count+3] == 2)  ? line[3]: 0);
521  layer[3] = ((pos[count] == 3) ? line[0]: 0) + ((pos[count+1]  == 3) ? line[1]: 0) + ((pos[count+2] == 3) ? line[2]: 0) + ((pos[count+3] == 3)  ? line[3]: 0);
522  count++; if (count > 7) count = 0; 
523}
524
525struct snake  {
526  byte x, y, z;
527} obj[7]; 
528
529void Snake() {
530  int k;
531  byte c  = 7;
532  if (start) {
533    start = false; speedTime = 200;
534    for (k = 0;  k < c; k++) {
535      obj[k].x = 0;
536      obj[k].y = 0;
537      obj[k].z =  0;
538    }
539    lay = 0;
540    xVal = 0;
541    yVal = 0;
542  }
543  int xValP  = xVal;
544  int yValP = yVal;
545  int layP = lay;
546  direct = true;
547  while  (direct) {
548    xVal = xValP;
549    yVal = yValP;
550    lay = layP;
551    switch  (random(6)) {
552      case 0: if ((lay + 1) <= 3) lay++; break;
553      case 1:  if ((lay - 1) >= 0) lay--; break;
554      case 2: if ((xVal + 1) <= 3) xVal++;  break;
555      case 3: if ((xVal - 1) >= 0) xVal--; break;
556      case 4: if  ((yVal + 1) <= 3) yVal++; break;
557      case 5: if ((yVal - 1) >= 0) yVal--; break;
558      default: break;
559    }
560    direct = false;
561    for (k = 0; k < c;  k++) {
562      if ((xVal == obj[k].x) && (yVal == obj[k].y) && (lay == obj[k].z))  direct = true;
563    }
564  }
565  for (k = c-2; k >= 0; k--) {
566    obj[k+1].x  = obj[k].x;
567    obj[k+1].y = obj[k].y;
568    obj[k+1].z = obj[k].z;
569  }
570  obj[0].x = xVal;
571  obj[0].y = yVal;
572  obj[0].z = lay;
573  ClearLayers();
574  for (k = 0; k < c; k++) {
575    layer[obj[k].z] += (1 << obj[k].x) << (4 * obj[k].y);  
576  }
577}
578
579void Julka() {
580  int letters[5] = {59556, 43694, 8750,  58446, 60138};
581  if (start) {
582    start = false; speedTime = 1000;
583    ClearLayers();
584  }
585  layer[3] = letters[count];
586  count++;
587  if (count == 5) count = 0;
588}

bool direct;
unsigned int actualValue;
byte lay, xVal, yVal;
byte  place;

void SetLayers(unsigned int value) {
  layer[0] = value; layer[1]  = value; layer[2] = value; layer[3] = value;
}

void InversLayers() {
  layer[0] = 65535 - layer[0];
  layer[1] = 65535 - layer[1];
  layer[2] =  65535 - layer[2];
  layer[3] = 65535 - layer[3];
}

void ClearLayers()  {
  SetLayers(0);
}

void LayersUpDown() {
  if (start) {
    start  = false;                                                                                                                                                                                                                                              speedTime  = 500;
    direct = true;
  }
  ClearLayers();
  layer[count] = 65535;
  if (direct) {
   count++; 
   if (count > 3) { 
     direct = false;
     count = 2;
   }
  } else {
    count--; if (count < 1) direct = true;
  }
}

void FallingDot() {
  if (start) {
    start = false; speedTime  = 100;
    count = 4;
    actualValue = 1;
    direct = true;
  }
  count--;
  ClearLayers();
  layer[count] = actualValue;
  if (count ==  0) {
    count = 4;
    actualValue = actualValue << 1;
    if (actualValue  == 0) actualValue = 1;
  }
}

void Rain() {
  if (start) {
    start  = false; speedTime = 200;
    ClearLayers();
  }
  layer[0] = layer[1];
  layer[1] = layer[2];
  layer[2] = layer[3];
  layer[3] = 1 << random(16);
}

void  Random() {
  if (start) {
    start = false; speedTime = 200;
  }
  layer[0]  = random(65536);
  layer[1] = random(65536);
  layer[2] = random(65536);
  layer[3] = random(65536);
}

void AllCube() {
  if (start) {
    start  = false; speedTime = 2000;
  }
  ClearLayers();
  switch (count) {
    case 0:
      SetLayers(65535);
      break;
    case 1:
      layer[1]  = 1632; 
      layer[2] = 1632;  
      break; 
  }
  count++; if (count  > 1) count = 0;
}

void Cut() {
  if (start) {
    start = false;  speedTime = 2000;
    layer[0] = 4369; 
    layer[1] = 13107; 
    layer[2]  = 30583; 
    layer[3] = 65535;
  }
  InversLayers();
}

void  Cube() {
  if (start) {
    start = false; speedTime = 2000;
    layer[0]  = 15+16+128+256+2048+4096+8192+16384+32768; 
    layer[1] = 1+8+4096+32768; 
    layer[2] = layer[1]; 
    layer[3] = layer[0];
  }
  InversLayers();
}

void  Diagonal() {
  if (start) {
    start = false; speedTime = 2000;
    layer[0]  = 33825; 
    layer[1] = 33825; 
    layer[2] = 33825; 
    layer[3] =  33825;
  }
  InversLayers();
}

void Mixer() {
  if (start) {
    start = false; speedTime = 100;
  }
  switch (count) {
    case 0:  actualValue = 33825; break;
    case 1: actualValue = 17442; break;
    case  2: actualValue = 8772; break;
    case 3: actualValue = 4680; break;
    case  4: actualValue = 960; break;
    case 5: actualValue = 3120; break;
  }
  SetLayers(actualValue); 
  count++;
  if (count > 5) count = 0;
}

void  FallingLayer() {
  if (start) {
    start = false; speedTime = 100;
    actualValue  = 0;
    direct = false;
  }
  if (actualValue == 0) {
    actualValue  = 1;
    ClearLayers();
    direct = !direct;
    layer[3 - (direct? 0:3)]  = 65535;
  }
  switch (count) {
    case 0:
      layer[3 - (direct?  0:3)] -= actualValue;
      layer[2 - (direct? 0:1)] = actualValue;
      break;
    case 1:
      layer[1 + (direct? 0:1)] = layer[2  - (direct? 0:1)];
      layer[2  - (direct? 0:1)] = 0;
      break;
    case 2:
      layer[0 + (direct?  0:3)] += layer[1 + (direct? 0:1)];
      layer[1 + (direct? 0:1)] = 0;
      actualValue  = actualValue << 1;
      break;
  }
  count++; if (count > 2) count =  0;
}

void LayerCut() {
  if (start) {
    start = false; speedTime  = 100;
  }
  if (count) layer[0] = layer[0] << 1;
  else layer[0] = 4369;
  SetLayers(layer[0]);
  count++;
  if (count > 20) count = 0;
}

void  Circle() {
  if (start) {
    start = false; speedTime = 100;
    lay =  3;
  }
  switch (count) {
    case 0: ClearLayers(); layer[lay] = 1; break;
    case 1: layer[lay] = 2; break;
    case 2: layer[lay] = 4; break;
    case  3: layer[lay] = 8; break;
    case 4: layer[lay] = 128; break;
    case 5:  layer[lay] = 2048; break;
    case 6: layer[lay] = 32768; break;
    case  7: layer[lay] = 16384; break;
    case 8: layer[lay] = 8192; break;
    case  9: layer[lay] = 4096; break;
    case 10: layer[lay] = 256; break;
    case  11: layer[lay] = 16; break;
    case 12: layer[lay] = 1; break;
  }
  count++;
  if (count > 12) {
    count = 0;
    if (lay == 0) lay = 3;
    else  lay--;
  }
}

void RandomWay() {
  if (start) {
    start = false;  speedTime = 200;
    lay = random(4);
    xVal = random(4);
    yVal =  random(4);
  }
  switch (random(7)) {
    case 0: if ((lay + 1) <= 3) lay++;  break;
    case 1: if ((lay - 1) >= 0) lay--; break;
    case 2: if ((xVal  + 1) <= 3) xVal++; break;
    case 3: if ((xVal - 1) >= 0) xVal--; break;
    case 4: if ((yVal + 1) <= 3) yVal++; break;
    case 5: if ((yVal - 1) >=  0) yVal--; break;
    default: break;
  }
  ClearLayers();
  layer[lay]  = (1 << xVal) << (4 * yVal);
}

void SmallCube() {
  if (start) {
    start = false; speedTime = 200;
  }
  switch (count) {
    case 0:  lay = random(3); ClearLayers(); actualValue = 51; break;
    case 1: actualValue  = actualValue << 1; break;
    case 2: actualValue = actualValue << 1; break;
    case 3: actualValue = actualValue << 4; break;
    case 4: actualValue =  actualValue << 4; break;
    case 5: actualValue = actualValue >> 1; break;
    case 6: actualValue = actualValue >> 1; break;
    case 7: actualValue =  actualValue >> 4; break;
    case 8: actualValue = actualValue >> 4; break;
  }
  layer[lay] = actualValue;
  layer[lay+1] = actualValue;
  count++;  if (count > 8) count = 0;
}

void RandomWayCube() {
  if (start) {
    start = false; speedTime = 200;
    lay = random(3);
    xVal = random(3);
    yVal = random(3);
  }
  switch (random(7)) {
    case 0: if ((lay +  1) < 3) lay++; break;
    case 1: if ((lay - 1) >= 0) lay--; break;
    case  2: if ((xVal + 1) < 3) xVal++; break;
    case 3: if ((xVal - 1) >= 0) xVal--;  break;
    case 4: if ((yVal + 1) < 3) yVal++; break;
    case 5: if ((yVal  - 1) >= 0) yVal--; break;
    default: break;
  }
  ClearLayers();
  layer[lay] = (51 << xVal) << (4 * yVal);
  layer[lay+1] = layer[lay];
}

void  GrowingCube() {
  if (start) {
    start = false; speedTime = 1000;
  }
  switch (count) {
    case 0: ClearLayers(); layer[0] = 1; break;
    case  1: layer[0] = 51; layer[1] = 51; break;
    case 2: layer[0] = 1911; layer[1]  = 1911; layer[2] = 1911; break;
    case 3: SetLayers(65535); break;
    default:  break;
  }
  count++; if (count > 4) count = 0;
}

void FallingLayers()  {
  if (start) {
    start = false; speedTime = 200;
    actualValue =  0;
    lay = 4;
  }
  if (actualValue == 0) {
    lay--; if (lay < 1)  lay = 3;
    actualValue = 1;
    ClearLayers();
    layer[lay] = 65535;
  }
  layer[lay] -= actualValue;
  layer[lay-1] += actualValue;
  actualValue  = actualValue << 1;
}

void GrowingLine() {
  if (start) {
    start  = false; speedTime = 100;
  }
  switch (count) {
    case 0:
      ClearLayers();
      layer[0] = 1;
      lay = 0; xVal = 0; yVal = 0;
      while ((lay ==  0) && (xVal == 0) && (yVal == 0)) {
        lay = random(2);
        xVal  = random(2);
        yVal = random(2);
      }
      break;
    case  1: layer[lay] += ((xVal==0)?1:2) << (4 * yVal); break;
    case 2: layer[2 *  lay] += ((xVal==0)?1:4) << (8 * yVal); break;
    case 3: layer[3 * lay] += ((xVal==0)?1:8)  << (12 * yVal); break; 
    case 4: layer[3 * lay] -= ((xVal==0)?1:8) << (12  * yVal); break; 
    case 5: layer[2 * lay] -= ((xVal==0)?1:4) << (8 * yVal);  break;
    default: break;     
  }
  count++; if (count > 5) count = 0;
}

void  CircleEdges() {
  if (start) {
    start = false; speedTime = 100;
    lay  = 3;
    ClearLayers();
  }
  switch (count) {
    case 0: layer[lay]  = 1; break;
    case 1: layer[lay] += 2; break;
    case 2: layer[lay] +=  4; break;
    case 3: layer[lay] += 8; break;
    case 4: layer[lay] += 128;  break;
    case 5: layer[lay] += 2048; break;
    case 6: layer[lay] += 32768;  break;
    case 7: layer[lay] += 16384; break;
    case 8: layer[lay] += 8192;  break;
    case 9: layer[lay] += 4096; break;
    case 10: layer[lay]+= 256;  break;
    case 11: layer[lay] += 16; break;
    default: break;
  }
  count++;
  if (count > 12) {
    count = 0;
    if (lay == 0) {
      lay  = 3;
      ClearLayers();
    }
    else lay--;
  }
}

void  CircleSide() {
  if (start) {
    start = false; speedTime = 1000;
  }
  switch (count) {
    case 0: SetLayers(15); break;
    case 1: SetLayers(34952);  break;
    case 2: SetLayers(61440); break;
    case 3: SetLayers(4369); break;
    case 4: ClearLayers(); layer[0] = 65535; break;
    case 5: SetLayers(34952);  break;
    case 6: ClearLayers(); layer[3] = 65535; break;
    case 7: SetLayers(4369);  break;
  }
  count++;
  if (count > 7) count = 0;
}

void RandomWayLine()  {
  if (start) {
    start = false; speedTime = 200;
    lay = random(3);
    yVal = random(3);
  }
  switch (random(5)) {
    case 0: if ((lay +  1) <= 3) lay++; break;
    case 1: if ((lay - 1) >= 0) lay--; break;
    case  2: if ((yVal + 1) <= 3) yVal++; break;
    case 3: if ((yVal - 1) >= 0) yVal--;  break;
    default: break;
  }
  ClearLayers();
  layer[lay] = 15 <<  (4 * yVal);
}

void RandomWaySide() {
  if (start) {
    start =  false; speedTime = 200;
    xVal = random(3);
  }
  switch (random(3))  {
    case 0: if ((xVal + 1) <= 3) xVal++; break;
    case 1: if ((xVal -  1) >= 0) xVal--; break;
    default: break;
  }
  ClearLayers();
  actualValue  = 4369 << xVal;
  switch (random(2)) {
    case 0: SetLayers(actualValue);  break;
    case 1: layer[1] = actualValue; layer[2] = actualValue; break;
  }
}

void DJCube() {
  if (start) {
    start = false; speedTime  = 200;
    xVal = random(3);
  }
  switch (random(3)) {
    case 0:  if ((xVal + 1) <= 3) xVal++; break;
    case 1: if ((xVal - 1) >= 0) xVal--;  break;
    default: break;
  }
  switch (xVal) {
    case 0: SetLayers(4369);  break;
    case 1: SetLayers(13107); break;
    case 2: SetLayers(30583);  break;
    case 3: SetLayers(65535); break;
  }
}

void FillingCube()  {
  if (start) {
    start = false; speedTime = 200;
    count = 4;
    actualValue = 1;
  }
  if ((count == 4) && (actualValue == 1)) ClearLayers();
  count--;
  layer[count] += actualValue;
  if (count == 0) {
    count  = 4;
    actualValue = actualValue << 1;
    if (actualValue == 0) actualValue  = 1;
  }
}

void NanoBuilding() {
  if (start) {
    start = false;  speedTime = 150;
    actualValue = 0;
    place = 1;
    direct = true;
  }
  if (direct) {
    direct = false;
    while ((actualValue < place)  && (place < 64)) {
      lay = random(4);
      xVal = random(4);
      yVal  = random(4);     
      actualValue = xVal + (yVal * 4) + (lay * 16);
    }
  }
  actualValue = 0;
  int xValP = xVal;
  int yValP = yVal;
  int  layP = lay;
  while ((actualValue < place) && (place < 64)) {
    xVal = xValP;
    yVal = yValP;
    lay = layP;
    switch (random(7)) {
      case 0:  if ((lay + 1) <= 3) lay++; break;
      case 1: if ((lay - 1) >= 0) lay--; break;
      case 2: if ((xVal + 1) <= 3) xVal++; break;
      case 3: if ((xVal - 1)  >= 0) xVal--; break;
      case 4: if ((yVal + 1) <= 3) yVal++; break;
      case  5: if ((yVal - 1) >= 0) yVal--; break;
      default: break;
    }
    actualValue  = xVal + (yVal * 4) + (lay * 16);
  }
  if (actualValue == place) {
    place++;
    direct = true;
  }
  ClearLayers();
  if (place < 16) layer[0] = (1  << place) - 1;
  else {
    if (place < 32) {
      layer[1] = (1 << (place  - 16)) - 1;
      layer[0] = 65535;
    } else {
      if (place < 48)  {
        layer[2] = (1 << (place - 32)) - 1;
        layer[0] = 65535;
        layer[1] = 65535;
      } else {
        if (place < 64) {
          SetLayers(65535);
          layer[3] = (1 << (place - 48)) - 1;
        } else place = 1;
      }
    }
  }
  layer[lay] |= ((1 << xVal) << (4 * yVal));
}

void Curve()  {
  int line[4] = {4369, 8738, 17476, 34952};
  byte pos[12] = {0, 1, 2, 3,  3, 2, 1, 0, 0, 1, 2, 3};
  
  if (start) {
    start = false; speedTime  = 100;
  }
  layer[0] = ((pos[count] == 0) ? line[0]: 0) + ((pos[count+1]  == 0) ? line[1]: 0) + ((pos[count+2] == 0) ? line[2]: 0) + ((pos[count+3] == 0)  ? line[3]: 0);
  layer[1] = ((pos[count] == 1) ? line[0]: 0) + ((pos[count+1]  == 1) ? line[1]: 0) + ((pos[count+2] == 1) ? line[2]: 0) + ((pos[count+3] == 1)  ? line[3]: 0);
  layer[2] = ((pos[count] == 2) ? line[0]: 0) + ((pos[count+1]  == 2) ? line[1]: 0) + ((pos[count+2] == 2) ? line[2]: 0) + ((pos[count+3] == 2)  ? line[3]: 0);
  layer[3] = ((pos[count] == 3) ? line[0]: 0) + ((pos[count+1]  == 3) ? line[1]: 0) + ((pos[count+2] == 3) ? line[2]: 0) + ((pos[count+3] == 3)  ? line[3]: 0);
  count++; if (count > 7) count = 0; 
}

struct snake  {
  byte x, y, z;
} obj[7]; 

void Snake() {
  int k;
  byte c  = 7;
  if (start) {
    start = false; speedTime = 200;
    for (k = 0;  k < c; k++) {
      obj[k].x = 0;
      obj[k].y = 0;
      obj[k].z =  0;
    }
    lay = 0;
    xVal = 0;
    yVal = 0;
  }
  int xValP  = xVal;
  int yValP = yVal;
  int layP = lay;
  direct = true;
  while  (direct) {
    xVal = xValP;
    yVal = yValP;
    lay = layP;
    switch  (random(6)) {
      case 0: if ((lay + 1) <= 3) lay++; break;
      case 1:  if ((lay - 1) >= 0) lay--; break;
      case 2: if ((xVal + 1) <= 3) xVal++;  break;
      case 3: if ((xVal - 1) >= 0) xVal--; break;
      case 4: if  ((yVal + 1) <= 3) yVal++; break;
      case 5: if ((yVal - 1) >= 0) yVal--; break;
      default: break;
    }
    direct = false;
    for (k = 0; k < c;  k++) {
      if ((xVal == obj[k].x) && (yVal == obj[k].y) && (lay == obj[k].z))  direct = true;
    }
  }
  for (k = c-2; k >= 0; k--) {
    obj[k+1].x  = obj[k].x;
    obj[k+1].y = obj[k].y;
    obj[k+1].z = obj[k].z;
  }
  obj[0].x = xVal;
  obj[0].y = yVal;
  obj[0].z = lay;
  ClearLayers();
  for (k = 0; k < c; k++) {
    layer[obj[k].z] += (1 << obj[k].x) << (4 * obj[k].y);  
  }
}

void Julka() {
  int letters[5] = {59556, 43694, 8750,  58446, 60138};
  if (start) {
    start = false; speedTime = 1000;
    ClearLayers();
  }
  layer[3] = letters[count];
  count++;
  if (count == 5) count = 0;
}

The main loop

arduino

1
2#define buttonPin 2
3
4unsigned int layer[4] = {0, 0, 0, 0};   //65535
5  filled layer
6byte k = 0;
7bool start = true;
8unsigned long delayTime;
9int
10  speedTime = 0;
11int count;
12
13void setup() {
14  InitializeShiftReg();
15
16  InitializeMyLedCube();
17}
18
19void InitializeMyLedCube() {
20  DDRD = B11110000;
21         //pins D0-D3 as INPUTS, D4-D7 as OUTPUTS
22  PORTD |= B11110000;     //turn
23  OFF layers
24  pinMode(buttonPin, INPUT_PULLUP);
25  attachInterrupt(digitalPinToInterrupt(buttonPin),
26  PushButton, FALLING);
27  delayTime = millis();
28}
29
30byte patternNum = 28;
31byte
32  pattern = patternNum - 1;
33
34void loop() {
35  if (start) {
36    detachInterrupt(digitalPinToInterrupt(buttonPin));
37
38    delay(500);   //wait for releasing PushButton
39    pattern++; 
40    if (pattern
41  > patternNum) pattern = 1;
42    attachInterrupt(digitalPinToInterrupt(buttonPin),
43  PushButton, FALLING);
44    count = 0;
45  }
46  if (((millis() - delayTime)
47  > speedTime) || start) { 
48    switch (pattern) {
49      case 1: LayersUpDown();
50  break;
51      case 2: FallingDot(); break;
52      case 3: Rain(); break;
53
54      case 4: AllCube(); break;
55      case 5: Cut(); break;
56      case 6:
57  Cube(); break;
58      case 7: Diagonal(); break;
59      case 8: Mixer(); break;
60
61      case 9: Random(); break;
62      case 10: FallingLayer(); break;
63      case
64  11: LayerCut(); break;
65      case 12: Circle(); break;
66      case 13: RandomWay();
67  break;
68      case 14: SmallCube(); break;
69      case 15: RandomWayCube();
70  break;
71      case 16: GrowingCube(); break;
72      case 17: FallingLayers();
73  break;
74      case 18: GrowingLine(); break;
75      case 19: CircleEdges();
76  break;
77      case 20: CircleSide(); break;
78      case 21: RandomWayLine();
79  break;
80      case 22: RandomWaySide(); break;
81      case 23: DJCube(); break;
82
83      case 24: FillingCube(); break;
84      case 25: NanoBuilding(); break;
85
86      case 26: Curve(); break;
87      case 27: Snake(); break;
88      case 28:
89  Julka(); break;
90      default: break;
91    }
92    delayTime = millis();
93
94  }
95
96  //this part displays layers as they are set in functions
97  SetShiftReg(layer[k]);
98    //send layer data to shift registers
99  bitClear(PORTD, 4 + k);   //turn ON
100  layer k
101  delay(1);                 //important for brightness of leds
102  PORTD
103  |= B11110000;       //turn OFF layers
104  k++; if (k > 3) k = 0;    //take another
105  layer in the loop
106}
107
108void PushButton() {
109  start = true;
110}

#define buttonPin 2

unsigned int layer[4] = {0, 0, 0, 0};   //65535
  filled layer
byte k = 0;
bool start = true;
unsigned long delayTime;
int
  speedTime = 0;
int count;

void setup() {
  InitializeShiftReg();

  InitializeMyLedCube();
}

void InitializeMyLedCube() {
  DDRD = B11110000;
         //pins D0-D3 as INPUTS, D4-D7 as OUTPUTS
  PORTD |= B11110000;     //turn
  OFF layers
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin),
  PushButton, FALLING);
  delayTime = millis();
}

byte patternNum = 28;
byte
  pattern = patternNum - 1;

void loop() {
  if (start) {
    detachInterrupt(digitalPinToInterrupt(buttonPin));

    delay(500);   //wait for releasing PushButton
    pattern++; 
    if (pattern
  > patternNum) pattern = 1;
    attachInterrupt(digitalPinToInterrupt(buttonPin),
  PushButton, FALLING);
    count = 0;
  }
  if (((millis() - delayTime)
  > speedTime) || start) { 
    switch (pattern) {
      case 1: LayersUpDown();
  break;
      case 2: FallingDot(); break;
      case 3: Rain(); break;

      case 4: AllCube(); break;
      case 5: Cut(); break;
      case 6:
  Cube(); break;
      case 7: Diagonal(); break;
      case 8: Mixer(); break;

      case 9: Random(); break;
      case 10: FallingLayer(); break;
      case
  11: LayerCut(); break;
      case 12: Circle(); break;
      case 13: RandomWay();
  break;
      case 14: SmallCube(); break;
      case 15: RandomWayCube();
  break;
      case 16: GrowingCube(); break;
      case 17: FallingLayers();
  break;
      case 18: GrowingLine(); break;
      case 19: CircleEdges();
  break;
      case 20: CircleSide(); break;
      case 21: RandomWayLine();
  break;
      case 22: RandomWaySide(); break;
      case 23: DJCube(); break;

      case 24: FillingCube(); break;
      case 25: NanoBuilding(); break;

      case 26: Curve(); break;
      case 27: Snake(); break;
      case 28:
  Julka(); break;
      default: break;
    }
    delayTime = millis();

  }

  //this part displays layers as they are set in functions
  SetShiftReg(layer[k]);
    //send layer data to shift registers
  bitClear(PORTD, 4 + k);   //turn ON
  layer k
  delay(1);                 //important for brightness of leds
  PORTD
  |= B11110000;       //turn OFF layers
  k++; if (k > 3) k = 0;    //take another
  layer in the loop
}

void PushButton() {
  start = true;
}

Comments

Only logged in users can leave comments

viliamk

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content