JUDUL
3D
Led Cube 4x4x4 berbasis ATMEGA 32
LATAR BELAKANG
Proyek
Akhir ini sebenarnya dapat dibuat dan diselesaikan dengan menggunakan bahasa
pemrograman selain bahasa C. Namun, untuk proyek kali ini kelompok kami
menggunakan bahasa ini untuk membuat proyek. Alasan kenapa kami memilih
menggunakan bahasa C karena disamping bahasa ini mudah untuk dipahami juga
bahasa ini adalah bahasa mayoritas bagi kaum cendekiawan teknika
Elektronika-Elektro. Disamping itu alasan mengapa kami menggunakan bahasa C adalah
karena IC yang digunakan adalah IC dari keluarga Atmel AVR. IC ini biasanya di
program menggunakan bahasa C dengan softwarenya yang bernama CV AVR. Penggunaan
bahasa C saat ini adalah bersifat umum karena banyak di luar sana kita jumpai
alat-alat yang control nya menggunakan IC jenis ini. Maka tidak heran apabila
dalam proyek ini kami juga menggunakannya.
Dalam layar
dot matrix, beberapa LED di dalamya ada kabel bersama-sama dalam baris dan
kolom. Hal ini dilakukan untuk meminimalkan jumlah pin yang diperlukan. Misalnya,
8 × 8 dot matriks LED akan membutuhkan 64 I / O pin, satu untuk setiap pixel
LED. Dengan kabel dari semua anoda yang digabung menjadi satu dalam baris
(R1 melalui R8), dan katoda dalam kolom (C1 melalui C8), jumlah yang diperlukan
pin I / O dikurangi menjadi 16. Setiap LED ditujukan demi baris dan jumlah
kolom. Pada gambar bawah ini, jika R4 adalah ditarik tinggi dan C3 ditarik
rendah, LED di baris keempat dan kolom ketiga akan dihidupkan. Karakter
dapat ditampilkan oleh pemindaian cepat baik baris atau kolom.
Namun
pada era sekarang, kita bisa mengenal pengembangan dari dotmatrik yaitu dengan
LED Cube. LED ini bentuknya jauh lebih kecil dan jauh lebih efisien daripada
dotmatrik. Disamping itu, biaya untuk membuat LED cube juga tidak terlalu
mahal. Hanya saja, proses pembuatannya sedikit memakan waktu agak lama. LED
Cube adalah pekembangan inovasi dari dot matrik led yang sifatnya hampir bisa
dikatakan 3D. Namun disamping kelebihan yang dimiliki LED ini, ada juga
kekurangannya. Jika pada dot matrix display, tulisannya bisa muncul semuanya,
untuk LED Cube ini tidak bisa muncul semuanya sekaligus atau dengan kata lain,
tulisannya muncul per kata.
Untuk
masalah rangkaian, rangkaian ini tergolong rangkaian yang tidak terlalu rumit.
Yang rumit hanyalah ketika membuat programya saja. Rangkaian LED Cube hanya
membutuhkan sebuah system minimum seperti gambar di atas dan rangkaian cube
nya.
TUJUAN PEMBUATAN
1. Mahasiswa
dapat mengaplikasikan bahasa pemrograman terutama bahasa C untuk rangkaian elektronik
berbasis mikrokontroller tipe Atmel.
2. Mahasiswa
dapat mengerti perkembangan teknologi 3D
Led Cube sebagai perkembangan inovasi
dari Led Matrix.
3. Mahasiswa
dapat membuat rangkaian Led Cube 4x4
sederhana.
LANGKAH PEMBUATAN
Langkah
pembuatan project :
1.
Pembuatan
desain rancangan dengan menggunakan aplikasi Proteus 7.10. rancangan yang di maksut yaitu rangkaian sistem
minimum, rangkaian LED cube 4x4, dan rangkaian regulator.
2.
Melakukan
pengeprintnan desain rancangan yang sudah menjadi Ares / jalur pada pcb.
3.
Hasil
print lalu di setrika ke bagian pcb agar jalur pada kertas glosi menempel di
bagian pcb.
4.
Setelah
itu pcb di larutkan menggunakan feriklorit / carian pelarut pcb.
5.
Pemasangan
komponen dan penyoldieran komponen.
6.
Merangkai
LED agar menjadi berbetuk kubus supaya terlihat 3D.
7.
Pada
perangkaian LED ini memerlukan cetakan / tempat peletakkan LED.
8.
Untuk
pola yang akan di tempilkan pada LED diperlukan software tersendiri yaitu Cube Polaers.
9.
Yang
terakhir pembuatan kode program menggukanan AVR.
DESAIN RANCANGAN
1. Rangkaian
Sistem Minimum
Gambar 1. Rangkaian Sistem Minimum Led Cube 4x4 pada
software ISIS
Rangkaian minimum ini menggunakan IC
Atmega 32. PORT A dan PORT C pada IC ini digunakan untuk sambungan anoda LED.
Sementara PORT D.0 sampai PORT D.3 digunakan untuk button pilihan menu, dan
PORT D.4 sampai PORT D.7 digunakan untuk
pemilihan layer. Setelah rangkaian digambar pada ISIS, rangkaian ini kemudian
dijadikan layout jalur PCB dengan menggunakan software ARES. Hasilnya adalah
seperti pada gambar di bawah ini.
Gambar 2. Layout PCB Rangkaian
Sistem Minimum LED Cube 4x4
2.
Rangkaian LED Cube 4x4
Gambar 3. Rangkaian LED Cube 4x4
Rangkaian ini terdiri atas susunan LED
yang berjumlah sebanyak 64 jumlah. Setiap LED nantinya akan di program dengan
fitur Timer pada CV AVR agar nantinya LED bisa dihidupkan. Namun, LED ini tidak
di program untuk menyala sembarangan. Sebelumnya, terlebih dahulu kita membuat
pola LED nya. Untuk membentuk pola LED, digunakanlah software Cube Dot agar
saat memprogram nanti tidak perlu memikirkan dot berapa yang harus hidup karena
di software ini sudah terdapat fitur copy untuk meng-copy nilai hexa dot LED berapa
saja yang nantinya akan dihidupkan dan dibentuk polanya dan tinggal dimasukkan
saja ke dalam programnya. Dan dibawah ini adalah gambar layout LED Cube 4x4x4 yang sudah dibuat pada
software ARES.
Gambar 4. Layout PCB Rangkaian LED
Cube 4x4x4
3. Rangkaian
Regulator (Penurun Tegangan)
Gambar 5. Rangkaian Regulator dengan IC 7805
Rangkaian regulator ini menggunakan
IC 7805 dimana nanti IC ini berfungsi untuk menurunkan tegangan dari 12V (DC)
menjadi 5 V (DC). Jika rangkaian ini tidak memakai regulator, maka nantinya
akan berdampak pada mikrokontroller yang tidak akan bisa untuk menahan tegangan
masuk, sehingga menyebabkan rangkaian minimumnya akan terbakar dan tidak dapat
berjalan.
FLOWCHART
Gambar
6. Flowchart Rangkaian LED Cube 4x4x4
Flowchart
ini dibuat agar dapat mempermudah kinerja dalam membuat program. Dalam
flowchart ini disebutkan ada 10 efek 3D yang nantinya akan ditampilkan. Dan
setelah program ini selesai running,
program ini masih dapat diulang apabila kita menekan tombol start.
PENGUJIAN
Dalam
pengujian disini saya perlihatkan pengujian dalam bentuk video, di bawah ini
videonya :
KODE PROGRAM
/*****************************************************
This
program was produced by the
CodeWizardAVR
V2.05.0 Professional
Automatic
Program Generator
©
Copyright 1998-2010 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project
: Led Cube
Version
:
Date : 09/06/2014
Author : SetiaBn
Company
:
Comments:
Chip
type :
ATmega32
Program
type : Application
AVR
Core Clock frequency : 12,000000 MHz
Memory
model : Small
External
RAM size : 0
Data
Stack size : 512
*****************************************************/
#include
<mega32.h>
#include
<delay.h>
//
Alphanumeric LCD Module functions
#include
<alcd.h>
//blok
definisi
#define
baris0 PORTA
#define
baris1 PORTC
#define
layer PORTD
#define
all_off 0x0f
#define
all_on 0xf0
#define
start !PIND.3
#define
prev !PIND.2
#define
next !PIND.1
#define
keep !PIND.0
//deklarasi
variabel variabel yang sering digunakan pada perulangan
unsigned
char i,j,k;
//data0
untuk mengisi PORTA dan data1 untuk PORTC
//array
berisi 4 elemen karena ada 4 layer
//data[0]
untuk layer teratas dan data[3] terbawah
unsigned
char data0[4], data1[4];
//variabel
layer on digunakan untuk mengeset layer mana yang akan dinyalakan
unsigned
char layer_on = 0;
//variabel
layer_ke digunakan untuk mengisi data ke PORTD
unsigned
char layer_ke;
//
Timer 0 overflow interrupt service routine
//frekuensi
timer = 11719.
//timer0
akan menghitung dari 0 ke 255 dan kemudian baru melakukan interupsi
//sehingga
interupsi dilakukan 45 kali per detik
//karena
ada 4 layer maka pergantian nyala dalam 1 detik ada 45/4 = 12,5 fps
interrupt
[TIM0_OVF] void timer0_ovf_isr(void)
{
//mematikan
semua led agar update data tidak terlihat
layer
&= all_off;
//mengisikan
data ke PORT
baris0
= data0[layer_on];
baris1
= data1[layer_on];
layer
|= (0x80 >> layer_on);
//tiap
layer dinyalakan bergantian
layer_on
++;
//jika
layer sudah 4 maka dikembalikan ke layer 0 lagi
if(layer_on
== 4) layer_on = 0;
}
//
Timer2 overflow interrupt service routine
interrupt
[TIM2_OVF] void timer2_ovf_isr(void)
{
TCNT0
= 243;
}
//------------------
fungsi2 yang digunakan untuk inisialisasi atmega --------------------
//----------------------------------------------------------------------------------------
void
timer_init()
{
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 11,719 kHz
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x05;
TCNT0=0x00;
OCR0=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFFFF
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: 11,719 kHz
// Mode: Normal top=0xFF
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x05;
TCNT2=0x00;
OCR2=0x00;
}
void
ioinit()
{
PORTA=0x00;
DDRA=0xFF;
PORTB=0x00;
DDRB=0xff;
PORTC=0x00;
DDRC=0xFF;
PORTD=0x0F;
DDRD=0xF0;
timer_init();
MCUCR=0x00;
MCUCSR=0x00;
// Timer(s)/Counter(s) Interrupt(s)
initialization
TIMSK=0x41;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by
Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
TWCR=0x00;
// Alphanumeric LCD initialization
// Connections specified in the
// Project|Configure|C
Compiler|Libraries|Alphanumeric LCD menu:
// RS - PORTB Bit 0
// RD - PORTB Bit 1
// EN - PORTB Bit 2
// D4 - PORTB Bit 3
// D5 - PORTB Bit 4
// D6 - PORTB Bit 5
// D7 - PORTB Bit 7
// Characters/line: 16
lcd_init(16);
}
//----------------------------------------------------------------------------------------
//---------------------
fungsi2 yang digunakan untuk grafik cube -------------------------
//----------------------------------------------------------------------------------------
//digunakan
untuk mengisi semua layer dengan data yang sama
void
fill(unsigned char grid0, unsigned char grid1)
{
unsigned char i;
for(i=0;i<4;i++)
{
data0[i] = grid0;
data1[i] = grid1;
}
}
//digunakan
untuk mengisi seluruh cube dengan data yang berbeda
void
isi_cube(unsigned char baris00, unsigned char baris01,
unsigned char baris10, unsigned
char baris11,
unsigned char baris20, unsigned
char baris21,
unsigned char baris30, unsigned
char baris31)
{
data0[0] = baris00; data1[0] = baris01;
data0[1] = baris10; data1[1] = baris11;
data0[2] = baris20; data1[2] = baris21;
data0[3] = baris30; data1[3] = baris31;
}
void
isi_layer(unsigned char layer_ke, unsigned char grid0, unsigned char grid1)
{
data0[layer_ke] = grid0; data1[layer_ke] =
grid1;
}
//void
setbit digunakan untuk mengeset salah satu led agar on
//formatnya x,y
//kanan
adalah depan
//sehingga
x menentukan posisi depan belakang
//dan
y menentukan kanan kiri
//sedangkan
z atas bawah
// 3,0 2,0 1,0 0,0
// 3,1 2,1 1,1 0,1
// 3,2 2,2 1,2 0,2
// 3,3 2,3 1,3 0,3
//4
data dikanan(depan) merupakan data1[...] dan
//4
data dikiri(belakang) merupakan data0[...]
void
set_bit(unsigned char x, unsigned char y, unsigned char z)
{
if(x<2) data1[z] |=
((1<<y)<<(x*4));
else data0[z] |=
((0x80>>y)>>((x-2)*4));
}
void
clear_bit(unsigned char x, unsigned char y, unsigned char z)
{
if(x<2) data1[z] &=
~((1<<y)<<(x*4));
else data0[z] &=
~((0x80>>y)>>((x-2)*4));
}
void
tarik_depan(unsigned char layer)
{
unsigned char temp;
data1[layer] = data1[layer]>>4;
temp = data0[layer]&0xf0;
temp = 15-temp;
data1[layer] = data1[layer] | temp;
data0[layer] = data0[layer]<<4;
}
//catatan
khusus geser_kiri dan geser_kanan masih masalah----------------------
//digunakan
untuk menggeser tampilan ke kanan
void
geser_kanan()
{unsigned char j;
for(j=0;j<4;j++)
{
data0[j]=data0[j] << 1;
data1[j]=data1[j] >> 1;
}
}
//digunakan
untuk menggeser tampilan ke kiri
void
geser_kiri()
{unsigned char j;
for(j=0;j<4;j++)
{
data0[j]=data0[j] >> 1;
data1[j]=data1[j] << 1;
}
}
//-----------------------------------------------------------------------------
//digunakan
untuk menggeser tampilan ke atas
void
geser_atas()
{
unsigned char j;
for(j=0;j<3;j++)
{
data0[j]=data0[j+1];
data1[j]=data1[j+1];
}
data0[3] = 0x00;
data1[3] = 0x00;
}
//digunakan
untuk menggeser tampilan ke bawah
void
geser_bawah()
{
unsigned char j;
for(j=3;j>0;j--)
{
data0[j]=data0[j-1];
data1[j]=data1[j-1];
}
data0[0] = 0x00;
data1[0] = 0x00;
}
//----------------------------------------------------------------------------------------
//--------------------
fungsi2 yang digunakan untuk efek dasar cube ----------------------
//----------------------------------------------------------------------------------------
//memberikan
efek pola dari atas dan seolah-olah memanjang ke bawah
void
turun(int tunda, unsigned char grid0,unsigned char grid1)
{
fill(0x00, 0x00);
data0[0] = grid0; data1[0] = grid1;
delay_ms(tunda);
data0[1] = grid0; data1[1] = grid1;
delay_ms(tunda);
data0[2] = grid0; data1[2] = grid1;
delay_ms(tunda);
data0[3] = grid0; data1[3] = grid1;
delay_ms(tunda);
}
//memberikan
efek pola dari bawah dan seolah-olah memanjang ke atas
void
naik(int tunda, unsigned char grid0,unsigned char grid1)
{
fill(0x00, 0x00);
data0[3] = grid0; data1[3] = grid1;
delay_ms(tunda);
data0[2] = grid0; data1[2] = grid1;
delay_ms(tunda);
data0[1] = grid0; data1[1] = grid1;
delay_ms(tunda);
data0[0] = grid0; data1[0] = grid1;
delay_ms(tunda);
}
//----------------------------------------------------------------------------------------
//------------------
fungsi2 yang digunakan untuk efek lanjutan cube ---------------------
//----------------------------------------------------------------------------------------
//menulis
LED
void
rusuk_kubus()
{
unsigned char data,i;
data = 0x01;
for(i=0;i<3;i++)
{
data0[0] = data;
data1[0] = data;
data = (data<<1)+1;
delay_ms(50);
}
delay_ms(200);
isi_layer(0,0x9d,0x9d); delay_ms(50);
isi_layer(0,0x9f,0x9f); delay_ms(250);
isi_layer(1,0x01,0x01); delay_ms(50);
isi_layer(2,0x01,0x01); delay_ms(50);
isi_layer(3,0x01,0x01); delay_ms(250);
data = 0x01;
for(i=0;i<3;i++)
{
data0[3] = data;
data1[3] = data;
data = (data<<1)+1;
delay_ms(50);
}
delay_ms(200);
isi_layer(3,0x9d,0x9d); delay_ms(50);
isi_layer(3,0x9f,0x9f); delay_ms(200);
}
void
led_cube()
{
//Huruf L
isi_cube(0x00, 0x08, 0x00, 0x08, 0x00,
0x08, 0x00, 0x0f);
delay_ms(800);
//matikan cube
fill(0x00,0x00);
delay_ms(500);
//huruf E
isi_cube(0x00, 0x0f, 0x00, 0x0f, 0x00,
0x08, 0x00, 0x0f);
delay_ms(800);
//matikan cube
fill(0x00,0x00);
delay_ms(500);
//huruf D
isi_cube(0x00, 0x0e, 0x00, 0x09, 0x00,
0x09, 0x00, 0x0e);
delay_ms(800);
//matikan cube
fill(0x00,0x00);
delay_ms(1500);
//nyalakan rusuk cube
rusuk_kubus();
delay_ms(500);
isi_cube(0x9f, 0x9f, 0x09, 0x09, 0x09,
0x09, 0x9f, 0x9f);
delay_ms(2500);
}
void
puyuh()
{
unsigned char i,z;
int tunda = 30;
fill(0x00,0x00);
for(i=4;i>0;i--)
{
z=i-1;
set_bit(2,0,z); delay_ms(tunda);
clear_bit(2,0,z);
set_bit(1,0,z); delay_ms(tunda);
clear_bit(1,0,z);
set_bit(0,1,z); delay_ms(tunda);
clear_bit(0,1,z);
set_bit(0,2,z); delay_ms(tunda);
clear_bit(0,2,z);
set_bit(1,3,z); delay_ms(tunda);
clear_bit(1,3,z);
set_bit(2,3,z); delay_ms(tunda);
clear_bit(2,3,z);
set_bit(3,2,z); delay_ms(tunda);
clear_bit(3,2,z);
set_bit(3,1,z); delay_ms(tunda);
clear_bit(3,1,z);
}
for(z=0;z<4;z++)
{
set_bit(2,0,z); delay_ms(tunda);
clear_bit(2,0,z);
set_bit(1,0,z); delay_ms(tunda);
clear_bit(1,0,z);
set_bit(0,1,z); delay_ms(tunda);
clear_bit(0,1,z);
set_bit(0,2,z); delay_ms(tunda);
clear_bit(0,2,z);
set_bit(1,3,z); delay_ms(tunda);
clear_bit(1,3,z);
set_bit(2,3,z); delay_ms(tunda);
clear_bit(2,3,z);
set_bit(3,2,z); delay_ms(tunda);
clear_bit(3,2,z);
set_bit(3,1,z); delay_ms(tunda);
clear_bit(3,1,z);
}
}
void
air_mancur()
{
unsigned char i;
//kosongkan cube
fill(0x00,0x00);
//nyalakan salah satu led pada kubus
terbawah
data0[3] = 0x20;
//naikkan led tersebut
naik(200,0x20,0x00);
//buat efek ledakan dengan mengaktifkan led
ke arah bawah
turun(130,0xff,0xff);
for(i=0;i<3;i++)
{
naik(100,0xff,0xff);
turun(100,0xff,0xff);
if(next) break;
if(keep) i=0;
}
}
void
moving_box()
{
isi_cube(0x00, 0x33, 0x00, 0x33, 0x00,
0x00, 0x00, 0x00);
delay_ms(300);
geser_bawah();
delay_ms(100);
geser_bawah();
delay_ms(80);
geser_bawah();
delay_ms(300);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x66, 0x00, 0x66);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0xcc, 0x00, 0xcc);
delay_ms(300);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x30,
0xc0, 0x30, 0xc0);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x33,
0x00, 0x33, 0x00);
delay_ms(300);
geser_atas();
delay_ms(80);
geser_atas();
delay_ms(300);
isi_cube(0x60, 0x60, 0x60, 0x60, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
}
void
grow_box()
{
isi_cube(0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(200);
isi_cube(0x00, 0x33, 0x00, 0x33, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
isi_cube(0xe0, 0x77, 0xe0, 0x77, 0xe0,
0x77, 0x00, 0x00);
delay_ms(80);
isi_cube(0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff);
delay_ms(80);
isi_cube(0x00, 0x00, 0x77, 0xe0, 0x77,
0xe0, 0x77, 0xe0);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x33,
0x00, 0x33, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(200);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x33,
0x00, 0x33, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x77, 0xe0, 0x77,
0xe0, 0x77, 0xe0);
delay_ms(80);
delay_ms(80);
isi_cube(0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff);
delay_ms(80);
isi_cube(0xe0, 0x77, 0xe0, 0x77, 0xe0,
0x77, 0x00, 0x00);
delay_ms(80);
isi_cube(0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(200);
}
//void
flip digunakan untuk membuat efek kertas yang melipat
void
flip_tb() // top to back
{
isi_cube(0xff, 0xff, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
isi_cube(0xff, 0x00, 0x00, 0xff, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
isi_cube(0x0f, 0x00, 0xf0, 0x00, 0x00,
0xf0, 0x00, 0x0f);
delay_ms(80);
isi_cube(0x0f, 0x00, 0x0f, 0x00, 0xf0,
0x00, 0xf0, 0x00);
delay_ms(80);
isi_cube(0x0f, 0x00, 0x0f, 0x00, 0x0f,
0x00, 0x0f, 0x00);
delay_ms(80);
}
void
flip_bd() // back to down
{
isi_cube(0x0f, 0x00, 0x0f, 0x00, 0x0f,
0x00, 0x0f, 0x00);
delay_ms(80);
isi_cube(0xf0, 0x00, 0xf0, 0x00, 0x0f,
0x00, 0x0f, 0x00);
delay_ms(80);
isi_cube(0x00, 0x0f, 0x00, 0xf0, 0xf0,
0x00, 0x0f, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0x00);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xff, 0xff);
delay_ms(80);
}
void
flip_df() //down front
{
isi_cube(0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xff, 0xff);
delay_ms(80);
isi_cube(0x00, 0x00, 0x00, 0x00, 0xff,
0x00, 0x00, 0xff);
delay_ms(80);
isi_cube(0x0f, 0x00, 0xf0, 0x00, 0x00,
0xf0, 0x00, 0x0f);
delay_ms(80);
isi_cube(0x00, 0xf0, 0x00, 0xf0, 0x00,
0x0f, 0x00, 0x0f);
delay_ms(80);
isi_cube(0x00, 0x0f, 0x00, 0x0f, 0x00,
0x0f, 0x00, 0x0f);
delay_ms(80);
}
void
flip_ft() //front top
{
isi_cube(0x00, 0x0f, 0x00, 0x0f, 0x00,
0x0f, 0x00, 0x0f);
delay_ms(80);
isi_cube(0x00, 0x0f, 0x00, 0x0f, 0x00,
0xf0, 0x00, 0xf0);
delay_ms(80);
isi_cube(0x00, 0x0f, 0x00, 0xf0, 0xf0,
0x00, 0x0f, 0x00);
delay_ms(80);
isi_cube(0x00, 0xff, 0xff, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
isi_cube(0xff, 0xff, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00);
delay_ms(80);
}
//digunakan
untuk meringkas kode hujan garis
void
bantu1(unsigned char awal0, unsigned char awal1,
unsigned char tengah0, unsigned
char tengah1,
unsigned char akhir0, unsigned char
akhir1)
{
isi_layer(0,awal0, awal1);
isi_layer(1,tengah0, tengah1);
delay_ms(80); isi_layer(1,0x00, 0x00);
isi_layer(2,tengah0, tengah1);
delay_ms(80); isi_layer(2,0x00, 0x00);
isi_layer(3,akhir0, akhir1); delay_ms(150);
}
//digunakan
untuk meringkas kode hujan garis
void
bantu2(unsigned char awal0, unsigned char awal1,
unsigned char tengah0, unsigned
char tengah1,
unsigned char akhir0, unsigned char
akhir1)
{
isi_layer(3,awal0, awal1);
isi_layer(2,tengah0, tengah1);
delay_ms(80); isi_layer(2,0x00, 0x00);
isi_layer(1,tengah0, tengah1);
delay_ms(80); isi_layer(1,0x00, 0x00);
isi_layer(0,akhir0, akhir1); delay_ms(150);
}
void
hujan_garis()
{
//mengisi penuh layer atas
fill(0x00,0x00); delay_ms(300);
isi_layer(0,0x11,0x88); delay_ms(80);
isi_layer(0,0x33,0xcc); delay_ms(80);
isi_layer(0,0x77,0xee); delay_ms(80);
isi_layer(0,0xff,0xff); delay_ms(300);
//garis pertama turun
bantu1(0x77,0xee,0x88,0x11,0x88, 0x11);
//garis kedua turun
bantu1(0x33,0xcc,0x44,0x22,0xcc,0x33);
//garis ketiga turun
bantu1(0x11,0x88,0x22, 0x44,0xee, 0x77);
//garis keempat turun
bantu1(0x00,0x00,0x11,0x88,0xff,0xff);
delay_ms(300);
//garis pertama naik
bantu2(0x77,0xee,0x88,0x11,0x88, 0x11);
//garis kedua naik
bantu2(0x33,0xcc,0x44,0x22,0xcc,0x33);
//garis ketiga naik
bantu2(0x11,0x88,0x22, 0x44,0xee, 0x77);
//garis keempat naik
bantu2(0x00,0x00,0x11,0x88,0xff,0xff);
isi_layer(0,0xff,0xff); delay_ms(250);
isi_layer(0,0xf0,0xff); delay_ms(80);
isi_layer(0,0x00,0xff); delay_ms(80);
isi_layer(0,0x00, 0x0f); delay_ms(80);
fill(0x00,0x00);
}
void
dna()
{
isi_cube(0x08, 0x08, 0x80, 0x80, 0x10,
0x10, 0x01, 0x01);
delay_ms(150);
isi_cube(0x04, 0x04, 0x08, 0x08, 0x80,
0x80, 0x10, 0x10);
delay_ms(150);
isi_cube(0x02, 0x02, 0x04, 0x04, 0x08,
0x08, 0x80, 0x80);
delay_ms(150);
isi_cube(0x01, 0x01, 0x02, 0x02, 0x04,
0x04, 0x08, 0x08);
delay_ms(150);
isi_cube(0x10, 0x10, 0x01, 0x01, 0x02,
0x02, 0x04, 0x04);
delay_ms(150);
isi_cube(0x80, 0x80, 0x10, 0x10, 0x01,
0x01, 0x02, 0x02);
delay_ms(150);
}
void
dot_fill()
{
unsigned char x, y, z;
fill(0x00,0x00);
for(z=0;z<4;z++)
{
for(y=0;y<4;y++)
{
for(x=0;x<4;x++)
{
set_bit(x,y,z);
delay_ms(40);
}
delay_ms(100);
}
}
for(z=0;z<4;z++)
{
for(y=0;y<4;y++)
{
for(x=0;x<4;x++)
{
clear_bit(x,y,z);
delay_ms(40);
}
delay_ms(100);
}
}
}
void
maju2 (unsigned char grid0,unsigned char grid1)
{
fill(0x00,0x00);
data0[0] = grid0; data1[0] = grid1;
delay_ms(500);
tarik_depan(0);
delay_ms(500);
tarik_depan(0);
delay_ms(500);
tarik_depan(0);
}
void
ledakan()
{
isi_cube(0x00, 0x00, 0x00, 0x00, 0x60,
0x60, 0x60, 0x60);delay_ms(200);
isi_cube(0x00, 0x00, 0x00, 0x00, 0xf6,
0xf6, 0xf6, 0xf6);delay_ms(80);
isi_cube(0x00, 0x00, 0x60, 0x60, 0xff,
0xff, 0xff, 0xff);delay_ms(80);
isi_cube(0x00, 0x00, 0xf6, 0xf6, 0xff,
0xff, 0xff, 0xff);delay_ms(80);
isi_cube(0x60, 0x60, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff);delay_ms(80);
isi_cube(0xf6, 0xf6, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff);delay_ms(80);
isi_cube(0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff);delay_ms(500);
for(i=0;i<4;i++)
{
data0[i]=0;
data1[i]=0;
delay_ms(150);
}
}
void
UNY()
{
lcd_clear();
lcd_putsf(" U");
isi_cube(0x09, 0x00, 0x09, 0x00, 0x09,
0x00, 0x0f, 0x00); delay_ms(80);
isi_cube(0x90, 0x00, 0x90, 0x00, 0x90,
0x00, 0xf0, 0x00); delay_ms(80);
isi_cube(0x00, 0x90, 0x00, 0x90, 0x00,
0x90, 0x00, 0xf0); delay_ms(80);
isi_cube(0x00, 0x09, 0x00, 0x09, 0x00,
0x09, 0x00, 0x0f); delay_ms(200);
lcd_putsf("N");
isi_cube(0x09, 0x00, 0x0b, 0x00, 0x0d,
0x00, 0x09, 0x00); delay_ms(80);
isi_cube(0x90, 0x00, 0xb0, 0x00, 0xd0,
0x00, 0x90, 0x00); delay_ms(80);
isi_cube(0x00, 0x90, 0x00, 0xd0, 0x00,
0xb0, 0x00, 0x90); delay_ms(80);
isi_cube(0x00, 0x09, 0x00, 0x0d, 0x00,
0x0b, 0x00, 0x09); delay_ms(200);
lcd_putsf("Y");
isi_cube(0x09, 0x00, 0x0f, 0x00, 0x06,
0x00, 0x06, 0x00); delay_ms(80);
isi_cube(0x90, 0x00, 0xf0, 0x00, 0x60,
0x00, 0x60, 0x00); delay_ms(80);
isi_cube(0x00, 0x90, 0x00, 0xf0, 0x00,
0x60, 0x00, 0x60); delay_ms(80);
isi_cube(0x00, 0x09, 0x00, 0x0f, 0x00,
0x06, 0x00, 0x06); delay_ms(200);
ledakan();
lcd_clear();
for(i=0;i<5;i++)
{
lcd_putsf("-");
delay_ms(50);
}
lcd_putsf(" UNY ");
for(i=0;i<22;i++)
{
lcd_putsf("-");
delay_ms(50);
}
}
//----------------------------------------------------------------------------------------
void
main(void)
{
//
Declare your local variables here
ioinit();
//
Global enable interrupts
#asm("sei")
lcd_putsf("---
LED Cube ---");
lcd_putsf("----
4x4x4 -----");
led_cube();
delay_ms(1000);
lcd_clear();
lcd_putsf("-
Tekan start --");
fill(0x00,0x00);
while(start
== 0) {;}
ulang:
lcd_clear();
lcd_putsf("1.
Air Mancur");
air_mancur();
lcd_clear();
lcd_putsf("2.
Hula Hoop");
fill(0x00,0x00);
for(i=0;i<3;i++)
{
puyuh();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("3.Fade
in out");
for(i=0;i<3;i++)
{
dot_fill();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("4.
Box jalan");
for(i=0;i<3;i++)
{
moving_box();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("5.
Ombak");
for(i=0;i<3;i++)
{
grow_box();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("6.
LED Koprol");
for(i=0;i<3;i++)
{
flip_tb();
flip_bd();
flip_df();
flip_ft();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("7.Garis
jatuh");
for(i=0;i<3;i++)
{
hujan_garis();
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("8.
OX");
for(i=0;i<3;i++)
{
turun(100,0x69,0x69);
naik(100,0x96,0x96);
if(next) break;
if(keep) i=0;
}
lcd_clear();
lcd_putsf("9.
Balerina");
for(i=0;i<12;i++)
{
dna();
if(next) break;
if(keep) i=0;
}
UNY();
delay_ms(2000);
lcd_clear();
turun(100,0xff,
0xff);
lcd_putsf("-
Tekan start --");
while(1)
{
if(start) goto ulang;
}
}
KESIMPULAN
Dari
pembuatan project di atas dapat di simpulkan :
1. Untuk
membuat rangkaian LED Cube ini tidak terlal rumit karena hanya membutuhkan LED
dan system minimum saja. Selebihnya yang sedikit sulit adalah pada pembuatan
programnya.
2. Perlu
di ingat bahwa dalam pembuatan rangkaian ini, harus ada rangkaian regulator
yang berfungsi untuk menurunkan tegangan input menjadi tegangan batasan yang
dipakai. Karena apabila kita tidak memakai regulator, dampak terbesarnya adalah
rangkaian tidak akan berjalan. Hal ini disebabkan karena mikrokontoller yang
dipakai hanya dapat dimasuki tegangan ±5V. Selebihnya nanti dapat merusak
mikro. Jika mikro sudah rusak, maka kita harus menggantinya dengan yang baru.
3. Bahasa
C sangat awam digunakan untuk membuat beberapa rangkaian elektronik termasuk
untuk proyek akhir ini. Dan perlu diketahui pula bahwa bahasa C juga penting
untuk dipelajari karena untuk dapat membuat alat elektronik berbasis kendali
control jaman sekarang ini semuanya menggunakan program, dan lebih spesifiknya
program bahasa C.
