LED Cube Anduino adalah
proyek yang menarik untuk dibuat, karena dapat digunakan sebagai hiasan atau
digunakan dengan peralatan lain seperti mikrofon atau sensor gerak untuk
berbagai aplikasi. Pada dasarnya LED Cube adalah kubus 3 dimensi yang terbuat
dari Light Emitting Diodes (LED). Kubus dapat dibuat dengan berbagai cara
tetapi untuk proyek ini akan menggunakan cara yaitu dikendalikan oleh
mikrokontroler Arduino Uno.
Seperti yang terlihat pada
gambar di bawah, kubus terdiri dari sumbu XY dan 4 lapisan yang ditumpuk satu
sama lain. Lapisan bawah adalah nomor 0 dan yang atas adalah nomor 3. Demikian
pula, LED diberi nomor seperti matriks 3 dimensi. Jadi, LED kiri bawah adalah
(1,1) pada layer 0. Yang di atasnya juga (1,1) tetapi pada layer 1. Yang di
sebelah kanan LED sudut ini adalah (2,1) pada layer 0 dan seterusnya. Semua
lapisan horizontal adalah pin positif dari LED yang disolder bersama.
Semua pin negatif LED diletakkan
pada kolom kubus matriks ini. Jadi akan memiliki 4 lapisan dan 16 kolom yang
menjadikannya 20 kabel yang terhubung ke Arduino. Pin positif (lapisan)
memiliki resistor 100 Ohm untuk membatasi aliran arus hingga 20mA (arus standar
untuk LED).
Proses Pembuatan
Mikrokontroler – dalam kasus
ini digunakan Arduino Uno, arduino uno memiliki batasan sumber arus pada pinoutnya,
yaitu hanya dapat mengirimkan arus dalam jumlah yang aman sebelum terjadi
kerusakan. Dalam kasus Arduino Uno, ini memiliki sumber arus 40mA. Jadi kalian
pasti bertanya-tanya, tunggu dulu, jika sebuah LED membutuhkan 20mA, kenapa
kita bisa menyalakan semua lampu secara bersamaan dan masih tidak membakar
board Arduino? Ini karena pada waktu tertentu, hanya satu LED yang menyala.
Mata manusia (karena
kegigihan penglihatan) tidak dapat melihat kedipan cepat LED jika dinyalakan
dan dimatikan dengan sangat cepat. Karena kode pada Arduino berjalan sangat
cepat, mata kita memikirkan beberapa LED seperti menyala. Ini juga membatasi
arus ke tingkat yang aman karena pada waktu tertentu hanya satu LED yang
menyala dan bahkan jika kita mengambil arus rata-rata dalam 1 detik, itu jauh
di bawah ambang batas bahaya. Misalnya Anda ingin menyalakan LED di kiri bawah
kubus, Anda akan memberikan sinyal positif dari mikrokontroler ke lapisannya
yaitu lapisan 0, ini akan memberi tegangan positif pada pin positif LED.
Kemudian Anda harus menginstruksikan mikrokontroler untuk membumikan pin kolom
yang relevan dari LED itu, ini akan menghubungkan pin negatif LED ke ground dan
Anda memiliki rangkaian bias maju lengkap yang akan menyalakan LED.
Bahan yang perlu disiapkan
yaitu :
- Karton atau kayu (tebal
sekitar 1 inci)
- baterai 3V
- Amplas (kelas sedang)
- 64 x Dioda Pemancar Cahaya
Biru (LED)
- 4 x 100 Ohm Resistor
- 24 x Kabel Pita Berwarna
Pria-Pria
- 1 x Female Pin Socket/Header
(harus memiliki 20 pin socket inline)
- PCB Perfboard (sekitar 24×10
cm)
- Arduino Uno + Kabel USB
- Adaptor soket daya Arduino
Uno
- Adaptor baterai 9V
- Baterai 9V
- Zip-dasi (25 cm)
- Pistol Lem + Tongkat Lem
- Besi Solder + Kawat Solder +
Busa Basah
- Pompa Pematrian (jika
penyolderan buruk)
- Kaca pembesar (untuk melihat
penyolderan Anda)
- Pemotong Kawat Mini
- Tang Hidung Mini
- Kabel koneksi untuk kabel di
bawah PCB (sekitar 1m) dan selotip
Tahap pembuatan led cube
Pertama-tama, Anda
membutuhkan karton atau kayu yang cukup tebal (kira-kira satu inci sudah
cukup). Bor lubang ke dalamnya sehingga membentuk pola kubus 4x4 dengan jarak
yang sama antara semua lubang.
Dalam hal ini, pola tercetak
ditempatkan di atas karton dan lubang 5mm (setiap lubang berjarak 2,4cm dari
lubang berikutnya (tengah-tengah) dibor untuk LED. Pada gambar di bawah, Anda
dapat melihat panah yang menunjuk ke arah kaki LED.
Sekarang, Anda harus menguji
dan menyiapkan LED Anda. Anda dapat menggunakan baterai dengan daya 3V untuk
tujuan ini. Uji semua LED agar Anda terhindar dari masalah nanti kaerna jika
ada led yang bermasalah akan susah menggantinya dan cukup memakan waktu ketika
setelah dirangkai secara keseluruhan.
Jika Anda ingin cahaya
keluar dari semua sisi LED, Anda dapat menggosok keseluruhan kaca LED dengan
amplas seperti pada gambar dibawah ini.
Pada gambar di bawah, LED di
sebelah kiri menyebar dan yang di sebelah kanan dalam bentuk transparan
aslinya. Terlihat perbedaan pada cahaya yang dihasilkan.
Ingat, bahwa kaki LED yang
pendek adalah Katodanya (- pin) dan kaki panjangnya adalah Anode (+ pin). Jika
Anda tidak yakin, maka Anda dapat mengujinya dengan multimeter atau baterai 3v
untuk menemukan polaritasnya. Sekarang, dengan tang tekuk katoda (kaki pendek)
pada sudut 90 derajat ke kanan dan tekuk lagi ke atas untuk membuat bentuk
seperti yang ditunjukkan pada gambar di bawah.
Tempatkan LED di karton
tetapi hati-hati dengan orientasinya. Ingat panah pada gambar di atas? Pin
negatif dari LED yang ditekuk harus disejajarkan seperti panah. Ini karena kita
akan membuat empat lapisan seperti itu dan mudah untuk menyoldernya. Tekuk
semua kaki positif dari semua LED dan lakukan sedemikian rupa sehingga
menghubungkan semua terminal positif LED bersama-sama, ini akan membuat lapisan
arus positif
Namun, Anda akan melihat
bahwa dua area di tengah lapisan ini dibiarkan tidak terhubung seperti yang
ditunjukkan oleh lingkaran merah. Anda dapat menghubungkan pin ini dengan kabel
tunggal atau kaki dari LED yang dipotong.
Sekarang, dengan menggunakan
baterai 3v, buat penguji sederhana untuk memeriksa apakah semua LED berfungsi.
Hubungkan kabel positif ke sembarang tempat pada lapisan dan satu per satu
periksa semua kolom dengan kabel negatif.
Sekarang telah jadi lapisan
pertama, kemudian buat 3 lapisan lagi sehingga menjadi 4 lapisan
Dalam proyek ini, potongan
karton sederhana dipotong dan ditempatkan di antara lapisan yang akan disolder.
Ini membuatnya mudah untuk menyoldernya tetapi Anda selalu dapat menggunakan
alat lain seperti dudukan PCB, dll.
Setelah menyolder tiga
lapisan, ada baiknya untuk memeriksa semua LED sekali lagi untuk berjaga-jaga.
Seperti sebelumnya, hubungkan pin positif tester sel tombol Anda ke layer dan
kemudian pin negatif ke semua kolom LED (- pin) satu per satu
Akhirnya, kubus LED disolder
dan seperti inilah tampilannya:
Solder 20 pin (atau lebih)
inline female header (celah 0,1 inci antara pin) ke PCB perfboard siap pakai
dan letakkan Kubus di atasnya (pin kolom). Anda dapat menekuk beberapa kaki
kubus LED di bawah papan untuk sementara agar tidak jatuh tetapi belum
menyoldernya. Mereka akan disolder dengan kabel yang berasal dari pin header
perempuan nanti.
Solder resistor dengan satu
kaki terhubung ke pin header perempuan dan satu lagi untuk dihubungkan ke
setiap lapisan terpisah pada kubus. Ingatlah untuk melihat pengaturan koneksi.
Dalam proyek ini sisi paling kiri adalah pin nomor 0 pada Arduino hingga pin
nomor 13 dan kemudian empat pin Analog untuk lapisan dan kemudian dua pin
Analog untuk kolom yang tersisa. Lakukan beberapa pengujian cepat melalui soket
header perempuan juga.
Hubungkan semua wirings
menggunakan kabel pita jumper (male-male) sesuai dengan tabel koneksi yang
ditunjukkan di bawah ini. Arduino dapat ditempel ke papan dengan doubletape
sehingga dapat dengan mudah dilepas untuk digunakan dalam proyek lain. Anda
dapat menyalakan Arduino dengan baterai 9V dan colokan listrik Arduino (setelah
mengupload kode program ke papan arduino)
Setelah mengupload kode ke
Arduino Uno, LED Cube 4x4x4 Anda sudah siap dinikmati.
[program]
/*
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
*/
//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
flickerOn();
turnEverythingOn();//turn all on
delay(time);
turnOnAndOffAllByLayerUpAndDownNotTimed();
layerstompUpAndDown();
turnOnAndOffAllByColumnSideways();
delay(time);
aroundEdgeDown();
turnEverythingOff();
randomflicker();
randomRain();
diagonalRectangle();
goThroughAllLedsOneAtATime();
propeller();
spiralInAndOut();
flickerOff();
turnEverythingOff();
delay(2000);
}
//xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//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);
}
}
/////////////////////////////////////////////////////////////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);
}
}
}
