4x4x4 PCB LED CUBE

In this tutorial I'll show you guys how to make this super simple 4x4x4 PCB LED cube "without over complicating anything".

Oct 25, 2024

•

5629 views

•

4 respects

•

GPL3+

Embedded

Environmental Sensing

Lights

Toys

Robots

Components and supplies

Arduino Nano

Tools and machines

Arduino Web Editor

Apps and platforms

Arduino IDE 2.0 (beta)

Project description

Code

The Code

Code

1/*
2  4x4x4 LED Cube
3  Connection Setup: 
4  Columns
5  [(x,y)-Pin]
6  (1,1)-13
7  (1,2)-12
8  (1,3)-11
9  (1,4)-10
10  (2,1)-9
11  (2,2)-8
12  (2,3)-7
13  (2,4)-6
14  (3,1)-5
15  (3-2)-4
16  (3-3)-3
17  (3,4)-2
18  (4,1)-1
19  (4,2)-0
20  (4,3)-A5
21  (4,4)-A4
22  Layers
23  [layer-Pin]
24  a-A0
25  b-A1
26  c-A2
27  d-A3
28*/
29#include <avr/wdt.h>
30
31//initializing and declaring led rows
32  int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
33//initializing and declaring led layers
34  int layer[4]={A3,A2,A1,A0};
35
36  int time = 250;
37 
38void setup() {
39  //setting rows to ouput
40  for(int i = 0; i<16; i++)
41  {
42    pinMode(column[i], OUTPUT);
43  }
44  //setting layers to output
45  for(int i = 0; i<4; i++)
46  {
47    pinMode(layer[i], OUTPUT);
48  }
49  //seeding random for random pattern
50  randomSeed(analogRead(10));
51};
52
53//xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
54//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
55
56void loop() {
57  turnEverythingOff();//turn all off
58  randomflicker();
59  turnEverythingOff();//turn all off
60  flickerOn();
61  turnEverythingOn();//turn all on
62  delay(time);
63  turnOnAndOffAllByLayerUpAndDownNotTimed();
64  layerstompUpAndDown();
65  turnOnAndOffAllByColumnSideways();
66  delay(time);
67  aroundEdgeDown();
68  turnEverythingOff();
69  TopBottomTwoBlink();
70  randomflicker();
71  randomRain();
72  diagonalRectangle();
73  goThroughAllLedsOneAtATime();
74  propeller();
75  CenterSquare(10);
76  CornerBlink(10);
77  randomflicker();
78  spiralInAndOut();
79  flickerOff();
80  turnEverythingOff();
81  CornerAndInnerAlternateBlink();
82  delay(1000);
83  
84  reboot(); // Soft Reset the Arduino
85};
86
87//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxSOFT REBOOTxxxxxxxxxxxxxxxxxxxxxxxxxxxx
88//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
89void reboot() {
90  wdt_disable();
91  wdt_enable(WDTO_1S);
92  while (1) {}
93};
94
95//xxxxxxxxxxxxxxxxxxxxLED HANDLER FUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxx
96//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
97
98///////////////////////////////////////////////////////////turn all off
99void turnEverythingOff() {
100   for(int i = 0; i<16; i++)
101   {
102     digitalWrite(column[i], 1);
103   }
104   for(int i = 0; i<4; i++)
105   {
106     digitalWrite(layer[i], 0);
107   }
108 };
109 
110////////////////////////////////////////////////////////////turn all on
111void turnEverythingOn() {
112  for(int i = 0; i<16; i++)
113  {
114    digitalWrite(column[i], 0);
115  }
116  //turning on layers
117  for(int i = 0; i<4; i++)
118  {
119    digitalWrite(layer[i], 1);
120  }
121};
122///////////////////////////////////////////////////////turn columns off
123void turnColumnsOff() {
124  for(int i = 0; i<16; i++)
125  {
126    digitalWrite(column[i], 1);
127  }
128};
129/////////////////////////////////////////////////////Square in the center 
130void CenterSquare(int x) {
131  for(int i = 0; i<x; i++)
132  {
133    turnEverythingOff();
134    delay(200);
135    digitalWrite(column[5], 0);
136    digitalWrite(column[6], 0);
137    digitalWrite(column[9], 0);
138    digitalWrite(column[10], 0);
139    digitalWrite(layer[1], 1);
140    digitalWrite(layer[2], 1);
141    delay(200);
142  };
143};
144
145////////////////////////////////////////////////////////////Corner blink 
146void CornerBlink(int x) {
147  for(int i = 0; i<x; i++)
148  {
149    turnEverythingOff();
150    delay(200);
151    digitalWrite(column[0], 0);
152    digitalWrite(column[3], 0);
153    digitalWrite(column[12], 0);
154    digitalWrite(column[15], 0);
155    digitalWrite(layer[0], 1);
156    digitalWrite(layer[3], 1);
157    delay(200);
158  };
159};
160
161////////////////////Function that lets the top and bottom layers to blink
162void TopBottomTwoBlink() {
163  for(int i = 0; i<15; i++)
164  {
165    turnEverythingOff();
166    delay(50);
167    for(int i = 0; i<16; i++)
168    {
169      digitalWrite(column[i], 0);
170    };
171    digitalWrite(layer[0], 1);
172    digitalWrite(layer[1], 1);
173    digitalWrite(layer[2], 0);
174    digitalWrite(layer[3], 0);
175    delay(50);
176  };
177  
178  for(int i = 0; i<15; i++)
179  {
180    turnEverythingOff();
181    delay(50);
182    for(int i = 0; i<16; i++)
183    {
184      digitalWrite(column[i], 0);
185    };
186    digitalWrite(layer[0], 0);
187    digitalWrite(layer[1], 0);
188    digitalWrite(layer[2], 1);
189    digitalWrite(layer[3], 1);
190    delay(50);
191  };
192};
193
194///////////////////////////////////////Corner And Inner Alternate Blink
195void CornerAndInnerAlternateBlink() {
196  for(int i = 0; i<15; i++)
197  {
198    CenterSquare(2);
199    CornerBlink(2);
200  };
201};
202/////////////////////////////////////////////////////////////flicker on
203void flickerOn()
204{
205  int i = 150;
206  while(i != 0)
207  {
208    turnEverythingOn();
209    delay(i);
210    turnEverythingOff();
211    delay(i);
212    i-= 5;
213  }
214}
215//////////////turn everything on and off by layer up and down NOT TIMED
216void turnOnAndOffAllByLayerUpAndDownNotTimed()
217{
218  int x = 75;
219  for(int i = 5; i != 0; i--)
220  {
221    turnEverythingOn();
222    for(int i = 4; i!=0; i--)
223    {
224      digitalWrite(layer[i-1], 0);
225      delay(x);
226    }
227    for(int i = 0; i<4; i++)
228    {
229      digitalWrite(layer[i], 1);
230      delay(x);
231    }
232      for(int i = 0; i<4; i++)
233    {
234      digitalWrite(layer[i], 0);
235      delay(x);
236    }
237    for(int i = 4; i!=0; i--)
238    {
239      digitalWrite(layer[i-1], 1);
240      delay(x);
241    }
242  }
243}
244//////////////////////////turn everything on and off by column sideways
245void turnOnAndOffAllByColumnSideways()
246{
247  int x = 75;
248  turnEverythingOff();
249  //turn on layers
250  for(int i = 0; i<4; i++)
251  {
252    digitalWrite(layer[i], 1);
253  }
254  for(int y = 0; y<3; y++)
255  {
256    //turn on 0-3
257    for(int i = 0; i<4; i++)
258    {
259      digitalWrite(column[i], 0);
260      delay(x);
261    }
262    //turn on 4-7
263    for(int i = 4; i<8; i++)
264    {
265      digitalWrite(column[i], 0);
266      delay(x);
267    }
268    //turn on 8-11
269    for(int i = 8; i<12; i++)
270    {
271      digitalWrite(column[i], 0);
272      delay(x);
273    }
274    //turn on 12-15
275    for(int i = 12; i<16; i++)
276    {
277      digitalWrite(column[i], 0);
278      delay(x);
279    }
280    //turn off 0-3
281    for(int i = 0; i<4; i++)
282    {
283      digitalWrite(column[i], 1);
284      delay(x);
285    }
286    //turn off 4-7
287    for(int i = 4; i<8; i++)
288    {
289      digitalWrite(column[i], 1);
290      delay(x);
291    }
292    //turn off 8-11
293    for(int i = 8; i<12; i++)
294    {
295      digitalWrite(column[i], 1);
296      delay(x);
297    }
298    //turn off 12-15
299    for(int i = 12; i<16; i++)
300    {
301      digitalWrite(column[i], 1);
302      delay(x);
303    }
304    //turn on 12-15
305    for(int i = 12; i<16; i++)
306    {
307      digitalWrite(column[i], 0);
308      delay(x);
309    }
310    //turn on 8-11
311    for(int i = 8; i<12; i++)
312    {
313      digitalWrite(column[i], 0);
314      delay(x);
315    }
316    //turn on 4-7
317    for(int i = 4; i<8; i++)
318    {
319      digitalWrite(column[i], 0);
320      delay(x);
321    }
322    //turn on 0-3
323    for(int i = 0; i<4; i++)
324    {
325      digitalWrite(column[i], 0);
326      delay(x);
327    }
328    //turn off 12-15
329    for(int i = 12; i<16; i++)
330    {
331      digitalWrite(column[i], 1);
332      delay(x);
333    }
334    //turn off 8-11
335    for(int i = 8; i<12; i++)
336    {
337      digitalWrite(column[i], 1);
338      delay(x);
339    }
340    //turn off 4-7
341    for(int i = 4; i<8; i++)
342    {
343      digitalWrite(column[i], 1);
344      delay(x);
345    }
346    //turn off 0-3
347    for(int i = 0; i<4; i++)
348    {
349      digitalWrite(column[i], 1);
350      delay(x);
351    }
352  }
353}
354/////////////////////////////////////////up and down single layer stomp
355void layerstompUpAndDown()
356{
357  int x = 75;
358  for(int i = 0; i<4; i++)
359  {
360    digitalWrite(layer[i], 0);
361  }
362  for(int y = 0; y<5; y++)
363  {
364    for(int count = 0; count<1; count++)
365    { 
366      for(int i = 0; i<4; i++)
367      {
368        digitalWrite(layer[i], 1);
369        delay(x);
370        digitalWrite(layer[i], 0);
371      }
372      for(int i = 4; i !=0; i--)
373      {
374        digitalWrite(layer[i-1], 1);
375        delay(x);
376        digitalWrite(layer[i-1], 0);
377      }
378    }
379    for(int i = 0; i<4; i++)
380    {
381      digitalWrite(layer[i], 1);
382      delay(x);
383    }
384    for(int i = 4; i!=0; i--)
385    {
386      digitalWrite(layer[i-1], 0);
387      delay(x);
388    }
389  }
390}
391////////////////////////////////////////////////////////////flicker off
392void flickerOff()
393{
394  turnEverythingOn();
395  for(int i = 0; i!= 150; i+=5)
396  {
397    turnEverythingOff();
398    delay(i+50);
399    turnEverythingOn();
400    delay(i);
401  }
402}
403///////////////////////////////////////////around edge of the cube down
404void aroundEdgeDown()
405{
406  for(int x = 200; x != 0; x -=50)
407  {
408    turnEverythingOff();
409    for(int i = 4; i != 0; i--)
410    {
411      digitalWrite(layer[i-1], 1);
412      digitalWrite(column[5], 0);
413      digitalWrite(column[6], 0);
414      digitalWrite(column[9], 0);
415      digitalWrite(column[10], 0);
416      
417      digitalWrite(column[0], 0);
418      delay(x);
419      digitalWrite(column[0], 1);
420      digitalWrite(column[4], 0);
421      delay(x);
422      digitalWrite(column[4], 1);
423      digitalWrite(column[8], 0);
424      delay(x);
425      digitalWrite(column[8], 1);
426      digitalWrite(column[12], 0);
427      delay(x);
428      digitalWrite(column[12], 1);
429      digitalWrite(column[13], 0);
430      delay(x);
431      digitalWrite(column[13], 1);
432      digitalWrite(column[15], 0);
433      delay(x);
434      digitalWrite(column[15], 1);
435      digitalWrite(column[14], 0);
436      delay(x);
437      digitalWrite(column[14], 1);
438      digitalWrite(column[11], 0);
439      delay(x);
440      digitalWrite(column[11], 1);
441      digitalWrite(column[7], 0);
442      delay(x);
443      digitalWrite(column[7], 1);
444      digitalWrite(column[3], 0);
445      delay(x);
446      digitalWrite(column[3], 1);
447      digitalWrite(column[2], 0);
448      delay(x);
449      digitalWrite(column[2], 1);
450      digitalWrite(column[1], 0);
451      delay(x);
452      digitalWrite(column[1], 1);
453    }
454  }
455}
456/////////////////////////////////////////////////////////random flicker
457void randomflicker()
458{
459  turnEverythingOff();
460  int x = 10;
461  for(int i = 0; i !=750; i+=2)
462  {
463  int randomLayer = random(0,4);
464  int randomColumn = random(0,16);
465  
466  digitalWrite(layer[randomLayer], 1);
467  digitalWrite(column[randomColumn], 0);
468  delay(x);
469  digitalWrite(layer[randomLayer], 0);
470  digitalWrite(column[randomColumn], 1);
471  delay(x); 
472  }
473}
474////////////////////////////////////////////////////////////random rain
475void randomRain()
476{
477  turnEverythingOff();
478  int x = 100;
479  for(int i = 0; i!=60; i+=2)
480  {
481    int randomColumn = random(0,16);
482    digitalWrite(column[randomColumn], 0);
483    digitalWrite(layer[0], 1);
484    delay(x+50);
485    digitalWrite(layer[0], 0);
486    digitalWrite(layer[1], 1);
487    delay(x);
488    digitalWrite(layer[1], 0);
489    digitalWrite(layer[2], 1);
490    delay(x);
491    digitalWrite(layer[2], 0);
492    digitalWrite(layer[3], 1);
493    delay(x+50);
494    digitalWrite(layer[3], 0);
495    digitalWrite(column[randomColumn], 1);
496  }
497}
498/////////////////////////////////////////////////////diagonal rectangle
499void diagonalRectangle()
500{
501  int x = 350;
502  turnEverythingOff();
503  for(int count = 0; count<5; count++)
504  {
505    //top left
506    for(int i = 0; i<8; i++)
507    {
508      digitalWrite(column[i], 0);
509    }
510    digitalWrite(layer[3], 1);
511    digitalWrite(layer[2], 1);
512    delay(x);
513    turnEverythingOff();
514    //middle middle
515    for(int i = 4; i<12; i++)
516    {
517      digitalWrite(column[i], 0);
518    }
519    digitalWrite(layer[1], 1);
520    digitalWrite(layer[2], 1);
521    delay(x);
522    turnEverythingOff();
523    //bottom right
524    for(int i = 8; i<16; i++)
525    {
526      digitalWrite(column[i], 0);
527    }
528    digitalWrite(layer[0], 1);
529    digitalWrite(layer[1], 1);
530    delay(x);
531    turnEverythingOff();
532    //bottom middle
533    for(int i = 4; i<12; i++)
534    {
535      digitalWrite(column[i], 0);
536    }
537    digitalWrite(layer[0], 1);
538    digitalWrite(layer[1], 1);
539    delay(x);
540    turnEverythingOff();
541    //bottom left
542    for(int i = 0; i<8; i++)
543    {
544      digitalWrite(column[i], 0);
545    }
546    digitalWrite(layer[0], 1);
547    digitalWrite(layer[1], 1);
548    delay(x);
549    turnEverythingOff();
550    //middle middle
551    for(int i = 4; i<12; i++)
552    {
553      digitalWrite(column[i], 0);
554    }
555    digitalWrite(layer[1], 1);
556    digitalWrite(layer[2], 1);
557    delay(x);
558    turnEverythingOff();
559    //top right
560    for(int i = 8; i<16; i++)
561    {
562      digitalWrite(column[i], 0);
563    }
564    digitalWrite(layer[2], 1);
565    digitalWrite(layer[3], 1);
566    delay(x);
567    turnEverythingOff();
568    //top middle
569    for(int i = 4; i<12; i++)
570    {
571      digitalWrite(column[i], 0);
572    }
573    digitalWrite(layer[2], 1);
574    digitalWrite(layer[3], 1);
575    delay(x);
576    turnEverythingOff();
577  }
578  //top left
579  for(int i = 0; i<8; i++)
580  {
581    digitalWrite(column[i], 0);
582  }
583  digitalWrite(layer[3], 1);
584  digitalWrite(layer[2], 1);
585  delay(x);
586  turnEverythingOff();
587}
588//////////////////////////////////////////////////////////////propeller
589void propeller()
590{
591  turnEverythingOff();
592  int x = 90;
593  for(int y = 4; y>0; y--)
594  {
595    for(int i = 0; i<6; i++)
596    {
597      //turn on layer
598      digitalWrite(layer[y-1], 1);
599      //a1
600      turnColumnsOff();
601      digitalWrite(column[0], 0);
602      digitalWrite(column[5], 0);
603      digitalWrite(column[10], 0);
604      digitalWrite(column[15], 0);
605      delay(x);
606      //b1
607      turnColumnsOff();
608      digitalWrite(column[4], 0);
609      digitalWrite(column[5], 0);
610      digitalWrite(column[10], 0);
611      digitalWrite(column[11], 0);
612      delay(x);
613      //c1
614      turnColumnsOff();
615      digitalWrite(column[6], 0);
616      digitalWrite(column[7], 0);
617      digitalWrite(column[8], 0);
618      digitalWrite(column[9], 0);
619      delay(x);
620      //d1
621      turnColumnsOff();
622      digitalWrite(column[3], 0);
623      digitalWrite(column[6], 0);
624      digitalWrite(column[9], 0);
625      digitalWrite(column[12], 0);
626      delay(x);
627      //d2
628      turnColumnsOff();
629      digitalWrite(column[2], 0);
630      digitalWrite(column[6], 0);
631      digitalWrite(column[9], 0);
632      digitalWrite(column[13], 0);
633      delay(x);
634      //d3
635      turnColumnsOff();
636      digitalWrite(column[1], 0);
637      digitalWrite(column[5], 0);
638      digitalWrite(column[10], 0);
639      digitalWrite(column[14], 0);
640      delay(x);
641    }
642  }
643  //d4
644  turnColumnsOff();
645  digitalWrite(column[0], 0);
646  digitalWrite(column[5], 0);
647  digitalWrite(column[10], 0);
648  digitalWrite(column[15], 0);
649  delay(x);
650}
651//////////////////////////////////////////////////////spiral in and out
652void spiralInAndOut()
653{
654  turnEverythingOn();
655  int x = 60;
656  for(int i = 0; i<6; i++)
657  {
658    //spiral in clockwise
659    digitalWrite(column[0], 1);
660    delay(x);
661    digitalWrite(column[1], 1);
662    delay(x);
663    digitalWrite(column[2], 1);
664    delay(x);
665    digitalWrite(column[3], 1);
666    delay(x);
667    digitalWrite(column[7], 1);
668    delay(x);
669    digitalWrite(column[11], 1);
670    delay(x);
671    digitalWrite(column[15], 1);
672    delay(x);
673    digitalWrite(column[14], 1);
674    delay(x);
675    digitalWrite(column[13], 1);
676    delay(x);
677    digitalWrite(column[12], 1);
678    delay(x);
679    digitalWrite(column[8], 1);
680    delay(x);
681    digitalWrite(column[4], 1);
682    delay(x);
683    digitalWrite(column[5], 1);
684    delay(x);
685    digitalWrite(column[6], 1);
686    delay(x);
687    digitalWrite(column[10], 1);
688    delay(x);
689    digitalWrite(column[9], 1);
690    delay(x);
691    ///////////////////////////////////////spiral out counter clockwise
692    digitalWrite(column[9], 0);
693    delay(x);
694    digitalWrite(column[10], 0);
695    delay(x);
696    digitalWrite(column[6], 0);
697    delay(x);
698    digitalWrite(column[5], 0);
699    delay(x);
700    digitalWrite(column[4], 0);
701    delay(x);
702    digitalWrite(column[8], 0);
703    delay(x);
704    digitalWrite(column[12], 0);
705    delay(x);
706    digitalWrite(column[13], 0);
707    delay(x);
708    digitalWrite(column[14], 0);
709    delay(x);
710    digitalWrite(column[15], 0);
711    delay(x);
712    digitalWrite(column[11], 0);
713    delay(x);
714    digitalWrite(column[7], 0);
715    delay(x);
716    digitalWrite(column[3], 0);
717    delay(x);
718    digitalWrite(column[2], 0);
719    delay(x);
720    digitalWrite(column[1], 0);
721    delay(x);
722    digitalWrite(column[0], 0);
723    delay(x);
724    ///////////////////////////////////////spiral in counter clock wise
725    digitalWrite(column[0], 1);
726    delay(x);
727    digitalWrite(column[4], 1);
728    delay(x);
729    digitalWrite(column[8], 1);
730    delay(x);
731    digitalWrite(column[12], 1);
732    delay(x);
733    digitalWrite(column[13], 1);
734    delay(x);
735    digitalWrite(column[14], 1);
736    delay(x);
737    digitalWrite(column[15], 1);
738    delay(x);
739    digitalWrite(column[11], 1);
740    delay(x);
741    digitalWrite(column[7], 1);
742    delay(x);
743    digitalWrite(column[3], 1);
744    delay(x);
745    digitalWrite(column[2], 1);
746    delay(x);
747    digitalWrite(column[1], 1);
748    delay(x);
749    digitalWrite(column[5], 1);
750    delay(x);
751    digitalWrite(column[9], 1);
752    delay(x);
753    digitalWrite(column[10], 1);
754    delay(x);
755    digitalWrite(column[6], 1);
756    delay(x);
757    //////////////////////////////////////////////spiral out clock wise
758    digitalWrite(column[6], 0);
759    delay(x);
760    digitalWrite(column[10], 0);
761    delay(x);
762    digitalWrite(column[9], 0);
763    delay(x);
764    digitalWrite(column[5], 0);
765    delay(x);
766    digitalWrite(column[1], 0);
767    delay(x);
768    digitalWrite(column[2], 0);
769    delay(x);
770    digitalWrite(column[3], 0);
771    delay(x);
772    digitalWrite(column[7], 0);
773    delay(x);
774    digitalWrite(column[11], 0);
775    delay(x);
776    digitalWrite(column[15], 0);
777    delay(x);
778    digitalWrite(column[14], 0);
779    delay(x);
780    digitalWrite(column[13], 0);
781    delay(x);
782    digitalWrite(column[12], 0);
783    delay(x);
784    digitalWrite(column[8], 0);
785    delay(x);
786    digitalWrite(column[4], 0);
787    delay(x);
788    digitalWrite(column[0], 0);
789    delay(x);
790  }
791}
792//////////////////////////////////////go through all leds one at a time
793void goThroughAllLedsOneAtATime()
794{
795  int x = 15;
796  turnEverythingOff();
797  for(int y = 0; y<5; y++)
798  {
799    //0-3
800    for(int count = 4; count != 0; count--)
801    {
802      digitalWrite(layer[count-1], 1);
803      for(int i = 0; i<4; i++)
804      {
805        digitalWrite(column[i], 0);
806        delay(x);
807        digitalWrite(column[i], 1);
808        delay(x);
809      }
810    digitalWrite(layer[count-1], 0);
811    }
812    //4-7
813    for(int count = 0; count < 4; count++)
814    {
815      digitalWrite(layer[count], 1);
816      for(int i = 4; i<8; i++)
817      {
818        digitalWrite(column[i], 0);
819        delay(x);
820        digitalWrite(column[i], 1);
821        delay(x);
822      }
823    digitalWrite(layer[count], 0);
824    }
825    //8-11
826    for(int count = 4; count != 0; count--)
827    {
828      digitalWrite(layer[count-1], 1);
829      for(int i = 8; i<12; i++)
830      {
831        digitalWrite(column[i], 0);
832        delay(x);
833        digitalWrite(column[i], 1);
834        delay(x);
835      }
836    digitalWrite(layer[count-1], 0);
837    }
838    //12-15
839    for(int count = 0; count < 4; count++)
840    {
841      digitalWrite(layer[count], 1);
842      for(int i = 12; i<16; i++)
843      {
844        digitalWrite(column[i], 0);
845        delay(x);
846        digitalWrite(column[i], 1);
847        delay(x);
848      }
849    digitalWrite(layer[count], 0);
850    }
851  }
852}

/*
  4x4x4 LED Cube
  Connection Setup: 
  Columns
  [(x,y)-Pin]
  (1,1)-13
  (1,2)-12
  (1,3)-11
  (1,4)-10
  (2,1)-9
  (2,2)-8
  (2,3)-7
  (2,4)-6
  (3,1)-5
  (3-2)-4
  (3-3)-3
  (3,4)-2
  (4,1)-1
  (4,2)-0
  (4,3)-A5
  (4,4)-A4
  Layers
  [layer-Pin]
  a-A0
  b-A1
  c-A2
  d-A3
*/
#include <avr/wdt.h>

//initializing and declaring led rows
  int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
//initializing and declaring led layers
  int layer[4]={A3,A2,A1,A0};

  int time = 250;
 
void setup() {
  //setting rows to ouput
  for(int i = 0; i<16; i++)
  {
    pinMode(column[i], OUTPUT);
  }
  //setting layers to output
  for(int i = 0; i<4; i++)
  {
    pinMode(layer[i], OUTPUT);
  }
  //seeding random for random pattern
  randomSeed(analogRead(10));
};

//xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void loop() {
  turnEverythingOff();//turn all off
  randomflicker();
  turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  TopBottomTwoBlink();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  CenterSquare(10);
  CornerBlink(10);
  randomflicker();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  CornerAndInnerAlternateBlink();
  delay(1000);
  
  reboot(); // Soft Reset the Arduino
};

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxSOFT REBOOTxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void reboot() {
  wdt_disable();
  wdt_enable(WDTO_1S);
  while (1) {}
};

//xxxxxxxxxxxxxxxxxxxxLED HANDLER FUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

///////////////////////////////////////////////////////////turn all off
void turnEverythingOff() {
   for(int i = 0; i<16; i++)
   {
     digitalWrite(column[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     digitalWrite(layer[i], 0);
   }
 };
 
////////////////////////////////////////////////////////////turn all on
void turnEverythingOn() {
  for(int i = 0; i<16; i++)
  {
    digitalWrite(column[i], 0);
  }
  //turning on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
};
///////////////////////////////////////////////////////turn columns off
void turnColumnsOff() {
  for(int i = 0; i<16; i++)
  {
    digitalWrite(column[i], 1);
  }
};
/////////////////////////////////////////////////////Square in the center 
void CenterSquare(int x) {
  for(int i = 0; i<x; i++)
  {
    turnEverythingOff();
    delay(200);
    digitalWrite(column[5], 0);
    digitalWrite(column[6], 0);
    digitalWrite(column[9], 0);
    digitalWrite(column[10], 0);
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(200);
  };
};

////////////////////////////////////////////////////////////Corner blink 
void CornerBlink(int x) {
  for(int i = 0; i<x; i++)
  {
    turnEverythingOff();
    delay(200);
    digitalWrite(column[0], 0);
    digitalWrite(column[3], 0);
    digitalWrite(column[12], 0);
    digitalWrite(column[15], 0);
    digitalWrite(layer[0], 1);
    digitalWrite(layer[3], 1);
    delay(200);
  };
};

////////////////////Function that lets the top and bottom layers to blink
void TopBottomTwoBlink() {
  for(int i = 0; i<15; i++)
  {
    turnEverythingOff();
    delay(50);
    for(int i = 0; i<16; i++)
    {
      digitalWrite(column[i], 0);
    };
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 0);
    digitalWrite(layer[3], 0);
    delay(50);
  };
  
  for(int i = 0; i<15; i++)
  {
    turnEverythingOff();
    delay(50);
    for(int i = 0; i<16; i++)
    {
      digitalWrite(column[i], 0);
    };
    digitalWrite(layer[0], 0);
    digitalWrite(layer[1], 0);
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(50);
  };
};

///////////////////////////////////////Corner And Inner Alternate Blink
void CornerAndInnerAlternateBlink() {
  for(int i = 0; i<15; i++)
  {
    CenterSquare(2);
    CornerBlink(2);
  };
};
/////////////////////////////////////////////////////////////flicker on
void flickerOn()
{
  int i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    delay(i);
    turnEverythingOff();
    delay(i);
    i-= 5;
  }
}
//////////////turn everything on and off by layer up and down NOT TIMED
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  int x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
      for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 0);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 1);
      delay(x);
    }
  }
}
//////////////////////////turn everything on and off by column sideways
void turnOnAndOffAllByColumnSideways()
{
  int x = 75;
  turnEverythingOff();
  //turn on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
  for(int y = 0; y<3; y++)
  {
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
  }
}
/////////////////////////////////////////up and down single layer stomp
void layerstompUpAndDown()
{
  int x = 75;
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 0);
  }
  for(int y = 0; y<5; y++)
  {
    for(int count = 0; count<1; count++)
    { 
      for(int i = 0; i<4; i++)
      {
        digitalWrite(layer[i], 1);
        delay(x);
        digitalWrite(layer[i], 0);
      }
      for(int i = 4; i !=0; i--)
      {
        digitalWrite(layer[i-1], 1);
        delay(x);
        digitalWrite(layer[i-1], 0);
      }
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
  }
}
////////////////////////////////////////////////////////////flicker off
void flickerOff()
{
  turnEverythingOn();
  for(int i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    delay(i+50);
    turnEverythingOn();
    delay(i);
  }
}
///////////////////////////////////////////around edge of the cube down
void aroundEdgeDown()
{
  for(int x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(int i = 4; i != 0; i--)
    {
      digitalWrite(layer[i-1], 1);
      digitalWrite(column[5], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[10], 0);
      
      digitalWrite(column[0], 0);
      delay(x);
      digitalWrite(column[0], 1);
      digitalWrite(column[4], 0);
      delay(x);
      digitalWrite(column[4], 1);
      digitalWrite(column[8], 0);
      delay(x);
      digitalWrite(column[8], 1);
      digitalWrite(column[12], 0);
      delay(x);
      digitalWrite(column[12], 1);
      digitalWrite(column[13], 0);
      delay(x);
      digitalWrite(column[13], 1);
      digitalWrite(column[15], 0);
      delay(x);
      digitalWrite(column[15], 1);
      digitalWrite(column[14], 0);
      delay(x);
      digitalWrite(column[14], 1);
      digitalWrite(column[11], 0);
      delay(x);
      digitalWrite(column[11], 1);
      digitalWrite(column[7], 0);
      delay(x);
      digitalWrite(column[7], 1);
      digitalWrite(column[3], 0);
      delay(x);
      digitalWrite(column[3], 1);
      digitalWrite(column[2], 0);
      delay(x);
      digitalWrite(column[2], 1);
      digitalWrite(column[1], 0);
      delay(x);
      digitalWrite(column[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////random flicker
void randomflicker()
{
  turnEverythingOff();
  int x = 10;
  for(int i = 0; i !=750; i+=2)
  {
  int randomLayer = random(0,4);
  int randomColumn = random(0,16);
  
  digitalWrite(layer[randomLayer], 1);
  digitalWrite(column[randomColumn], 0);
  delay(x);
  digitalWrite(layer[randomLayer], 0);
  digitalWrite(column[randomColumn], 1);
  delay(x); 
  }
}
////////////////////////////////////////////////////////////random rain
void randomRain()
{
  turnEverythingOff();
  int x = 100;
  for(int i = 0; i!=60; i+=2)
  {
    int randomColumn = random(0,16);
    digitalWrite(column[randomColumn], 0);
    digitalWrite(layer[0], 1);
    delay(x+50);
    digitalWrite(layer[0], 0);
    digitalWrite(layer[1], 1);
    delay(x);
    digitalWrite(layer[1], 0);
    digitalWrite(layer[2], 1);
    delay(x);
    digitalWrite(layer[2], 0);
    digitalWrite(layer[3], 1);
    delay(x+50);
    digitalWrite(layer[3], 0);
    digitalWrite(column[randomColumn], 1);
  }
}
/////////////////////////////////////////////////////diagonal rectangle
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(int count = 0; count<5; count++)
  {
    //top left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[3], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //bottom right
    for(int i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //top right
    for(int i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
    //top middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
  }
  //top left
  for(int i = 0; i<8; i++)
  {
    digitalWrite(column[i], 0);
  }
  digitalWrite(layer[3], 1);
  digitalWrite(layer[2], 1);
  delay(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////propeller
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //turn on layer
      digitalWrite(layer[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(column[0], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(column[4], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(column[6], 0);
      digitalWrite(column[7], 0);
      digitalWrite(column[8], 0);
      digitalWrite(column[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(column[3], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(column[2], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(column[1], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(column[0], 0);
  digitalWrite(column[5], 0);
  digitalWrite(column[10], 0);
  digitalWrite(column[15], 0);
  delay(x);
}
//////////////////////////////////////////////////////spiral in and out
void spiralInAndOut()
{
  turnEverythingOn();
  int x = 60;
  for(int i = 0; i<6; i++)
  {
    //spiral in clockwise
    digitalWrite(column[0], 1);
    delay(x);
    digitalWrite(column[1], 1);
    delay(x);
    digitalWrite(column[2], 1);
    delay(x);
    digitalWrite(column[3], 1);
    delay(x);
    digitalWrite(column[7], 1);
    delay(x);
    digitalWrite(column[11], 1);
    delay(x);
    digitalWrite(column[15], 1);
    delay(x);
    digitalWrite(column[14], 1);
    delay(x);
    digitalWrite(column[13], 1);
    delay(x);
    digitalWrite(column[12], 1);
    delay(x);
    digitalWrite(column[8], 1);
    delay(x);
    digitalWrite(column[4], 1);
    delay(x);
    digitalWrite(column[5], 1);
    delay(x);
    digitalWrite(column[6], 1);
    delay(x);
    digitalWrite(column[10], 1);
    delay(x);
    digitalWrite(column[9], 1);
    delay(x);
    ///////////////////////////////////////spiral out counter clockwise
    digitalWrite(column[9], 0);
    delay(x);
    digitalWrite(column[10], 0);
    delay(x);
    digitalWrite(column[6], 0);
    delay(x);
    digitalWrite(column[5], 0);
    delay(x);
    digitalWrite(column[4], 0);
    delay(x);
    digitalWrite(column[8], 0);
    delay(x);
    digitalWrite(column[12], 0);
    delay(x);
    digitalWrite(column[13], 0);
    delay(x);
    digitalWrite(column[14], 0);
    delay(x);
    digitalWrite(column[15], 0);
    delay(x);
    digitalWrite(column[11], 0);
    delay(x);
    digitalWrite(column[7], 0);
    delay(x);
    digitalWrite(column[3], 0);
    delay(x);
    digitalWrite(column[2], 0);
    delay(x);
    digitalWrite(column[1], 0);
    delay(x);
    digitalWrite(column[0], 0);
    delay(x);
    ///////////////////////////////////////spiral in counter clock wise
    digitalWrite(column[0], 1);
    delay(x);
    digitalWrite(column[4], 1);
    delay(x);
    digitalWrite(column[8], 1);
    delay(x);
    digitalWrite(column[12], 1);
    delay(x);
    digitalWrite(column[13], 1);
    delay(x);
    digitalWrite(column[14], 1);
    delay(x);
    digitalWrite(column[15], 1);
    delay(x);
    digitalWrite(column[11], 1);
    delay(x);
    digitalWrite(column[7], 1);
    delay(x);
    digitalWrite(column[3], 1);
    delay(x);
    digitalWrite(column[2], 1);
    delay(x);
    digitalWrite(column[1], 1);
    delay(x);
    digitalWrite(column[5], 1);
    delay(x);
    digitalWrite(column[9], 1);
    delay(x);
    digitalWrite(column[10], 1);
    delay(x);
    digitalWrite(column[6], 1);
    delay(x);
    //////////////////////////////////////////////spiral out clock wise
    digitalWrite(column[6], 0);
    delay(x);
    digitalWrite(column[10], 0);
    delay(x);
    digitalWrite(column[9], 0);
    delay(x);
    digitalWrite(column[5], 0);
    delay(x);
    digitalWrite(column[1], 0);
    delay(x);
    digitalWrite(column[2], 0);
    delay(x);
    digitalWrite(column[3], 0);
    delay(x);
    digitalWrite(column[7], 0);
    delay(x);
    digitalWrite(column[11], 0);
    delay(x);
    digitalWrite(column[15], 0);
    delay(x);
    digitalWrite(column[14], 0);
    delay(x);
    digitalWrite(column[13], 0);
    delay(x);
    digitalWrite(column[12], 0);
    delay(x);
    digitalWrite(column[8], 0);
    delay(x);
    digitalWrite(column[4], 0);
    delay(x);
    digitalWrite(column[0], 0);
    delay(x);
  }
}
//////////////////////////////////////go through all leds one at a time
void goThroughAllLedsOneAtATime()
{
  int x = 15;
  turnEverythingOff();
  for(int y = 0; y<5; y++)
  {
    //0-3
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(int i = 0; i<4; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count-1], 0);
    }
    //4-7
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(int i = 4; i<8; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count], 0);
    }
    //8-11
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(int i = 8; i<12; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count-1], 0);
    }
    //12-15
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(int i = 12; i<16; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count], 0);
    }
  }
}

Comments

Only logged in users can leave comments

trist1101

2 months ago

Awesome, but the custom board thing complicates things. still, 100% love this. if i knew more about the project, would make it.

trist1101

2 months ago

Awesome, but the custom board thing complicates things. still, 100% love this. if i knew more about the project, would make it.

tarantula3

0 Followers

•

13 Projects

Intro

Components and supplies

Tools and machines

Apps and platforms

Project description

Code