Bermain Dengan Dot Matrix "LoveHurt"

Siapkan bahan-bahan seperti berikut:

Attiny 2313
Led matrix 7x5
R 10K
Diode 4148
PCB lobang
Header 2x5 buat ISP programmer (optional - Bisa diprogram di Breadboard)
Socket 20 untuk ATtiny, dan soket 14 ( dibelah dua ) buat tempat Led matrix
rangkaiannya seperti ini :

Kemudian komponen dirangkai diatas PCB lobang, ato bisa juga memakai bahan lain( disesuaikan dengan
tempat yg mau di pake, misale kotak hadiah , papan tripleks dan lain sebagainya)

letakkan LED MATRIX sesuai dengan SOCKET IC yg dibelah tadi

karena ga ada baterai ( punya tempatnya doang) jadi pake adaptor 3 Volt aja

Script code dalam Bahasa C /WinAvr seperti berikut:

#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <avr/eeprom.h>
//Progmem simpannya di FLASH memory
const char love1[] PROGMEM =
{
0b0011110,
0b0100001,
0b1000010,
0b0100001,
0b0011110
};
const char love2[] PROGMEM =
{
0b0001100,
0b0010010,
0b0100100,
0b0010010,
0b0001100
};
const
const
const
const
const
const
const
const

char
char
char
char
char
char
char
char

L[]
O[]
V[]
E[]
H[]
U[]
R[]
T[]

PROGMEM
PROGMEM
PROGMEM
PROGMEM
PROGMEM
PROGMEM
PROGMEM
PROGMEM

={0x7f,
={0x3e,
={0x3f,
={0x7f,
={0x7f,
={0x3f,
={0x7f,
={0x03,

0x7f,
0x7f,
0x7e,
0x7f,
0x7f,
0x7f,
0x7f,
0x03,

0x40,
0x41,
0x40,
0x49,
0x08,
0x40,
0x11,
0x7f,

0x40,
0x41,
0x20,
0x49,
0x08,
0x40,
0x29,
0x03,

0x20};
0x3e};
0x1f};
0x41};
0x7f};
0x3f};
0x46};
0x02};

const char creature[]={0x4e, 0x31, 0x35, 0x31, 0x4e}; //simpan di memory/RAM aja
uint8_t EEMEM tengkorak[5]= {0x1e, 0x75, 0x61, 0x75, 0x1e}; //simpan di EEPROM
uint8_t EEMEM pacman[5]= {0x26, 0x67, 0x67, 0x7f, 0x3e}; //simpan di EEPROM
char dotnya[5],scrolnya[7];
void tulis(uint8_t lama)
{
uint8_t a,b;
for(a=0 ; a<lama ; a++)
{
for(b=0 ; b<5 ; b++)
{
PORTB = ~(1<<b) ;
PORTD = dotnya[b];
_delay_ms(2);
}
}
}
void geser(uint8_t lama)
{
uint8_t a,b;
for(a=0 ; a<11 ; a++)
{
if( a<6)
{
for(b=0 ; b<(5-a) ; b++) dotnya[b]=0x80;
for(b=(5-a); b<5 ;b++) dotnya[b]=scrolnya[b-5+a];
tulis(10);
}
else if (a==6) tulis(lama);
else
{ for(b=0 ; b<11-a ; b++) dotnya[b]=scrolnya[a-5+b];

for(b=(11-a); b<11 ;b++) dotnya[b]=0x80;

tulis(10);
}
}
}
void naik (uint8_t lama)
{
{ uint8_t q,step=0;
while(step!=16)
{
if( step <8)
{
for(q=0 ; q < 5 ; q++) dotnya[q] = scrolnya[q] << (7 - step) ;
tulis(10);
}
else if (step == 8)
{
tulis(lama);
}
else
{
for(q=0 ; q < 5 ; q++)
tulis(10);

dotnya[q] = scrolnya[q] >> (step - 7) ;

}
step++;
}
}
}
int main(void)
{
DDRD = 0b1111111; // untuk baris
DDRB = 0b11111; // untuk kolom
PORTD =0; // Set all pins low
PORTB =0b11111; //matikan layar
while(1)
{
// yang ini nulis langsung
strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);
strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);
strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);
//yang ini pake function geser
strncpy_P(scrolnya,L,5);
geser(50);
strncpy_P(scrolnya,O,5);
geser(50);
strncpy_P(scrolnya,V,5);
geser(50);
strncpy_P(scrolnya,E,5);
geser(50);
strncpy_P(scrolnya,H,5);
geser(50);
strncpy_P(scrolnya,U,5);
geser(50);
strncpy_P(scrolnya,R,5);
geser(50);
strncpy_P(scrolnya,T,5);
geser(50);

//geser ambil dari RAM

strncpy(scrolnya,creature,5);
naik(50);

//tanpa _P karena ambil di RAM

//ambil dari eeprom ..mengirit..

eeprom_read_block((void*)&scrolnya,(const void*)&tengkorak, 5);
naik(50);
eeprom_read_block((void*)&scrolnya,(const void*)&pacman, 5);
geser(50);
}
return 0;
}

Script code diatas dibuat dalam mode FLASH, RAM, dan EEPROM, jadi ketika download program ke IC harus
memprogram FLASH dulu kemudian dilanjutkan dengan EEPROM.
FLASH extensinya .hex sedangkan isi EEPROM extensinya .eep

Script Break Down - Episode Love Hurt

Kali ini kita akan membahas script dari percobaan led matriks "love hurt" yang ditulis agustus 2011. Project
love hurt ini juga terdapat dalam paket belajar dasar microcontroller yang dapat anda pesan dengan harga yang
cukup terjangkau oleh kantong anak SMA sekalipun.
Seperti pada posting led matrix love hurt rangkaian yang digunakan seperti skematik berikut ini :

Rangkaian nya sangat simple, sesimple scriptnya juga dan marilah kita break down scriptnya
HEADER

#define F_CPU 1000000UL

#include < avr/io.h >
#include < util/delay.h >
#include < avr/pgmspace.h >
#include < string.h >
#include < avr/eeprom.h >

Pada penjelasan terdahulu mengenai dasar-dasar bahasa GCC maka dapat dilihat pada header terdapat inisialisai
dari beberapa parameter. Yang pertama adalah #define F_CPU yang menjelaskan clock microcontroller yang
digunakan. Berdasarkan skematik rangkaian dapat dilihat jika microcontroller attiny2313 yang dipakai tanpa
menggunakan xtal sehingga dapat dikatakan memakai internal clock (Calibrated RC Oscillator). Secara default
ketika ic attiny2313 keluar dari pabrik memiliki clock internal 8MHz dengan pembagian CLKDIV8=ON yang
berarti clock dibagi 8 sehingga menghasilkan angka 1MHz. Untuk melihat clock yang dipakai dapat dilihat
pada pembacaan fusebit, dapat dilakukan melalui menu programming pada AVRSTUDIO.

Selanjutnya didalam header dituliskan beberapa include yang berguna dalam script love hurt seperti definisi
kaki micro (io.h) ,delay.h sebagai pengatur delay waktu, pgmspace.h sebagai trick memanfaatkan flash memory
sebagai static ram, string.h sebagai pengolah data berupa string dan eeprom.h yang memudahkan penulisan
script untuk akses eeprom (memory non-volatile / tidak hilang saat micro tanpa power) .
DEFINISI VARIABEL , RAM & EEPROM
//Progmem simpannya di FLASH memory
const char love1[] PROGMEM =
{
0b0011110,
0b0100001,
0b1000010,
0b0100001,
0b0011110

};
const char love2[] PROGMEM =
{
0b0001100,
0b0010010,
0b0100100,
0b0010010,
0b0001100
};
const char L[] PROGMEM ={0x7f, 0x7f, 0x40, 0x40, 0x20};
const char O[] PROGMEM ={0x3e, 0x7f, 0x41, 0x41, 0x3e};
const char V[] PROGMEM ={0x3f, 0x7e, 0x40, 0x20, 0x1f};
const char E[] PROGMEM ={0x7f, 0x7f, 0x49, 0x49, 0x41};
const char H[] PROGMEM ={0x7f, 0x7f, 0x08, 0x08, 0x7f};
const char U[] PROGMEM ={0x3f, 0x7f, 0x40, 0x40, 0x3f};
const char R[] PROGMEM ={0x7f, 0x7f, 0x11, 0x29, 0x46};
const char T[] PROGMEM ={0x03, 0x03, 0x7f, 0x03, 0x02};
const char creature[]={0x4e, 0x31, 0x35, 0x31, 0x4e}; //simpan di memory/RAM aja
uint8_t EEMEM tengkorak[5]= {0x1e, 0x75, 0x61, 0x75, 0x1e}; //simpan di EEPROM
uint8_t EEMEM pacman[5]= {0x26, 0x67, 0x67, 0x7f, 0x3e}; //simpan di EEPROM

char dotnya[5],scrolnya[7];

Untuk mengetahui angka hexa yang terdapat dalam array ada lebih baiknya terlebih dahulu membuka software
generator dot matrix yang dapat dilihat disini.
Pada penulisan array diatas ada 3 type yang dipergunakan yaitu RAM, PROGMEM dan EEMEM. Kenapa
mesti seperti ini ya karena dikarenakan attiny2313 yang memiliki kapasitas RAM yang super irit yaitu 128byte
saja, sehingga untuk menambah memory maka kita manfaatkan memory flash (program) yang cukup lumayan
2048byte atau 2Kbyte (ini aja masih kecil banget). Untuk memanfaatkan flash diperlukan inisialisasi tambahan
berupa PROGMEM dan tidak bisa dipakai langsung seperti halnya jika ditempatkan pada RAM umum, harus
ada proses memindahkan flash PROGMEM menuju memory RAM. Tentunya tidak semuanya tapi yang akan
diolah saja yang dipindahkan. Pada inisialisasi variabel array diatas terdapat 2 buah array RAM yaitu dotnya[5]
dan scrolnya[7] yang akan ditimpa dengan isi PROGMEM jika dibutuhkan.
Pada project lovehurt diperlihatkan juga cara mengakses memory EEPROM dengan inisialisai berupa EEMEM.
Tujuan menggunakan memory EEPROM adalah sifatnya yang tidak terhapus jika baterai atau power dimatikan
(non-volatile memory)
BAGIAN MENULIS KE LED MATRIX
void tulis(uint8_t lama)
{
uint8_t a,b;
for(a=0 ; a<lama ; a++)
{
for(b=0 ; b<5 ; b++)
{
PORTB = ~(1<<b) ;

PORTD = dotnya[b];
_delay_ms(2);
}
}
}

void geser(uint8_t lama)

{
uint8_t a,b;
for(a=0 ; a<11 ; a++)
{
if( a<6)
{
for(b=0 ; b<(5-a) ; b++)

dotnya[b]=0x80;

for(b=(5-a); b<5 ;b++) dotnya[b]=scrolnya[b-5+a];

tulis(10);
}
else if (a==6) tulis(lama);
else
{

for(b=0 ; b<11-a ; b++) dotnya[b]=scrolnya[a-5+b];

for(b=(11-a); b<11 ;b++) dotnya[b]=0x80;
tulis(10);

}
}
}
void naik (uint8_t lama)
{ uint8_t q,step=0;

while(step!=16)
{
if( step <8)
{
for(q=0 ; q < 5 ; q++) dotnya[q] = scrolnya[q] << (7 - step) ;
tulis(10);
}
else if (step == 8)
{
tulis(lama);
}
else
{
for(q=0 ; q < 5 ; q++)
tulis(10);
}
step++;
}
}

dotnya[q] = scrolnya[q] >> (step - 7) ;

Nah inilah bagian utama dari penggerak tulisan geser kiri atau naik. Perhatikan pertama bagian function tulis
dimana terdapat isian variabel lama yang berarti lama looping dieksekusi yang akan menentukan lama tulisan
ditampilkan. Begitu pula jika ingin menggeser maka variabel lama perlu dimasukkan untuk menentukan lama
nya teks diam setelah digeser.
Bagaimana sih cara menghidupkan dotmatrix ? sebaiknya baca penjelasannya disini . Jadi pada intinya nilai
hexa yang diinisialisaikan pada array diawal berjumlah 5 buah array. Sedangkan bit yang digunakan adalah 7
bit karena memang dot matrix yang dgunakan bertype 5x7 (5 kolom x 7 baris) . Perhatikan loop berikut :
for(b=0 ; b<5 ; b++)
{
PORTB = ~(1<<b) ;
PORTD = dotnya[b];
_delay_ms(2);
}
Skematik menunjukkan bahwa kolom di kontrol oleh port B0 - B3 dan baris dikontrol oleh port D0 - D6. Loop
diatas menunjukkan proses geser kolom (scanning) dengan perintah PORTB = ~(1<<b) yang artinya angka
1(biner) digeser ke sebelah kiri sebanyak dari nilai b kemudian dinegasi . Variabel b mengontrol pergeseran
berdasarkan loop. Jika kolom dot matrix '0' akan menyebabkan LED pada baris yang mendapat bit '1' menyala.
Hal ini dapat dikatakan kolom aktif LOW dan baris aktif HIGH. Urutan loop dari scanning pada PORTB seperti
berikut (11110) , (11101) ,(11011) ,(10111) ,(01111).
Ingat penjelasan terdahulu bahwa array yang ada pada flash (PROGMEM) atau EEPROM harus dipindahkan
kedalam array memori RAM dotnya[b]. Sekali lagi variabel b berperan dalam menentukan array baris yang
sesuai dengan kolom yang sedang aktif atau mendapat scanning "LOW" (0).
Untuk proses geser ke kiri dan geser keatas ada sebuah variabel yaitu step yang berfungsi sebagai penanda
posisi pergeseran yang sedang tampil sehingga text yang tampil pada dot matrix memiliki efek bergeser.
Selebihnya yang diperlukan hanya proses kreatif mengeser-geser bit dari baris berdasarkan loop yang sedang
berjalan dan dipindahkan ke array scrolnya[ ].
MAIN PROGRAM
int main(void)
{
DDRD = 0b1111111; // untuk baris
DDRB = 0b11111;

// untuk kolom

PORTD =0; // Set all pins low

PORTB =0b11111; //matikan layar

while(1)
{
// yang ini nulis langsung
strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);

strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);
strncpy_P(dotnya,love2,5);
tulis(20);
strncpy_P(dotnya,love1,5);
tulis(40);
//yang ini pake function geser
strncpy_P(scrolnya,L,5);
geser(50);
strncpy_P(scrolnya,O,5);
geser(50);
strncpy_P(scrolnya,V,5);
geser(50);
strncpy_P(scrolnya,E,5);
geser(50);
strncpy_P(scrolnya,H,5);
geser(50);
strncpy_P(scrolnya,U,5);
geser(50);
strncpy_P(scrolnya,R,5);
geser(50);
strncpy_P(scrolnya,T,5);
geser(50);
//geser ambil dari RAM
strncpy(scrolnya,creature,5);

//tanpa _P karena ambil di RAM

naik(50);
//ambil dari eeprom ..mengirit..
eeprom_read_block((void*)&scrolnya,(const void*)&tengkorak, 5);
naik(50);
eeprom_read_block((void*)&scrolnya,(const void*)&pacman, 5);
geser(50);
}
return 0;
}

Pada bagian awal dari function main( ) terdapat inisialisai port dari attiny yang digunakan yaitu PORTB dan
PORTD yang kesemuanya diberi bit 1 yang artinya port tersebut dipakai sebagai port output.
Script yang digunakan untuk memindahkan memory flash (PROGMEM) menuju RAM adalah operasi
string strncpy_P, ingat array dari char (8byte) dapat dianggap sebagai string, seperti contoh
strncpy_P(dotnya,love2,5) yang artinya isi dari array dotnya[ ] diisi dengan array dari array PROGMEM
love2. Jika diambil dari RAM langsung maka operasi copy ini menggunakan strncpy( ) tanpa _P.
Untuk pemindahan isi dari EEPROM menuju RAM menggunakan syntax eeprom_read_block
( *pointer_ram_tujuan, *posisi_memori_eeprom, jumlah blok ), seperti contoh
eeprom_read_block((void*)&scrolnya,(const void*)&tengkorak, 5). Jangan dipusingkan dengan void dan *

(pointer) karena itu hanya atribut yang menyatakan type data diabaikan.
MUDAH BUKAN ? jika ada pertanyaan atau request script break down yang lain akan saya bahas dengan
senang hati.

Tutorial: Text Scroll 12 Led Matrix

Ayo kita bikin scroll text dengan led matrix yang panjang. Pada paket belajar microcontroller yang dijual disini
terdapat project terakhir yaitu 1 led matrix yang bisa ditulisi text yang dinamakan project LOVEHURT
(pembahasan script disini). Bagaimana dengan led matrix yang lebih panjang ? Wah kaki microcontroller pasti
habis tuh ? Tenang saja, kita pernah bahas membuat LED BERJALAN yang panjang dengan cara cascading
4017. Jadi clock dan reset dari 4017 dikendalikan oleh microcontroller, sedangkan outputnya akan melakukan
scanning kolom dari led matrix [5 x N(jumlah led matrix)]. Sedangkan untuk 7 bit baris akan diparalel dan data text
dikirim sesuai timing scaning kolom.
Skematiknya agak ribet, bisa dilihat disini ya .. (klik untuk memperjelas)

*) Pin CLK dari semua 4017 dihubungkan ke PE1

*) pin 4017 terakhir (scan ke 61) dapat juga dihubungkan ke Reset 4017 pertama menggunakan diode 1n4148
untuk IC AVR lain silahkan menyesuaikan

Untuk mendrive setiap kolom maka diperlukan IC ULN 2003 sebagai inverter logika "1" dari output scanning
4017 ke Ground dan ada keuntungan lainnya yaitu dengan komponen transistor darlington pada ULN akan
menyeragamkan nyala tiap dot dari LED MATRIX walaupun yang menyala hanya 1 buah atau 7 buah dalam
tiap scanning. Skematik dibawah merupakan kreasi penulis untuk memudahkan penyusunan ULN2003 ke LED
MATRIX agar lebih simple dan tidak memerlukan kabel yang banyak.

Jika rangkaian sudah disusun kemudian downloadkan script program yang sudah saya upload disini. Untuk
contoh program dari script yang dulu saya buat untuk rekan dari aceh yang kita gunakan adalah internal memori
dan eeprom untuk text dan animasi. Terdapat juga script untuk kalender dimana tombol untuk setting kalender
dihubungkan ke pin INT (yang ada resistor pull up) sehingga switch diharuskan menghubungkan pin ke GND.

Contoh ini menggunakan xtal 8MHZ atau internal default 1MHZ juga bisa asal dilakukan penyesuaian pada
script.
Pada contoh script yang menggunakan xtal 7.3728 MHz ditujukan untuk kontrol via PC/ komputer melalui
program SecureCrt (silahkan cari di google) dan dihubungkan menggunakan serial port atau USB to serial
converter jika serial port tidak tersedia. SecureCrt sangatlah memudahkan programing karena ada fasilitas
scripting Visual Basic sehingga perintah serial dapat dikirimkan secara otomatis.

Cara Me-Run script pada SecureCrt

Contoh-contoh script VB - SecureCrt ada pada file yg sama yang didownload sebelumnya (script).

Mengenal dot matrix 7x5

Dot matrix adalah titik titik yang membentuk sebuah matrix dimana titik titik tersebut adalah led, Jadi untuk
membentuk sebuah dot matrix 7x5 dibutuhkan 35 buah led. Inilah bentuk fisik dari dot matrix disebut
sebelumnya.

Dot matrix biasanya digunakan untu membuat running teks atau untuk membuat counter atau pencacah pada
bangjo atau traffic light. Biasanya dot matrix yang digunakan untuk membuat alat2 tersebut digunakan lebih
dari satu dot matrix. berikut merupakan scematic dari susunan led-nya

Untuk menyalakan dot matrix ini dengan cara menyalakan satu per satu pada setiap kolomnya atau lebih keren
disebut dengan metode scanning. Supaya karakter yang ditampilkan pada dot matrix dapat terlihat utuh maka
proses scanning ini harus berlangsung dengan sangat cepat.
Aplikasi
Dalam aplikasi ini hanya menggunakan satu buah dot matrix saja (maklum baru belajar). Rangkaiannya seperti
dibawah ini.

Kemudian program buat ATMega8 sebagai ini dibawah berikut.

$regfile = "m8def.dat"
$crystal = 8000000
Config Portc = Output
Config Portd = Output
dress Alias Portc
Data_ Alias Portd
Dim Lima As Byte

Dim Tujuh As Byte

Dim N_lima As Byte
Dim N_tujuh As Byte
Dim A As Byte
Dim B As Byte
Dim C As Byte
Dim D As Byte
Dim E As Byte
Dim F As Byte
Dim G As Byte
Dim Digit As Byte
N_lima = 0
N_tujuh = 0
Do
C = 33
For E = 0 To 33
For B = 0 To 4
For A = 0 To 4
Lima = Lookup(a , Alamat)
Adress = Lima
D = A+ C
Tujuh = Lookup(d , Wahyu)
Data_ = Tujuh
Waitms 1
Next
Waitms 1
Next
Decr C
Next
Loop
Alamat:
Data &B111101
Data &B111011
Data &B110111
Data &B101111
Data &B011111
Wahyu:
'u
Data &B00000000
Data &B00000000
Data &B00000000
Data &B00000000
Data &B01111110

Data &B00000001
Data &B00000001
Data &B00000001
Data &B01111110
Data &B00000000
'y
Data &B01110000
Data &B00001000
Data &B00001111
Data &B00001000
Data &B01110000
Data &B00000000
'h
Data &B01111111
Data &B00001000
Data &B00001000
Data &B00001000
Data &B01111111
Data &B00000000
'a
Data &B00111111
Data &B01001000
Data &B01001000
Data &B01001000
Data &B00111111
Data &B00000000
'w
Data &B01111110
Data &B00000001
Data &B01111111
Data &B00000001
Data &B01111110
Data &B00000000
Data &B00000000
Data &B00000000
Data &B00000000
Program tersebut akan membuat dot matrix menampilkan "nama saya" sekali kali nebeng, secara geser ke kiri.
Dalam program tersebut proses scanning terjadi pada potongan program
For A = 0 To 4
Lima = Lookup(a , Alamat)
Adress = Lima
D = A+ C
Tujuh = Lookup(d , Wahyu)
Data_ = Tujuh
Waitms 1
Next
Pada potogan program tersebut terdapat rumus D = A + C, rumus ini digunakan untuk menggeser karakter yang
ditampilkan oleh dot matrix sebanyak satu kali kearah kiri. pada potongan program tersebut proses scanning
hanya untuk 5 kolom saja, jika proses ini hanya diulangi sekali saja maka karakter yang ditampilkan tidak akan

terlihat karena terlalu cepat, oleh karena itu proses ini juga diulang ulang sebanyak 5 kali supaya tampilan dapat
dilihat dengan jelas, sehingga program menjadi
For B = 0 To 4
For A = 0 To 4
Lima = Lookup(a , Alamat)
Adress = Lima
D = A+ C
Tujuh = Lookup(d , Wahyu)
Data_ = Tujuh
Waitms 1
Next
Waitms 1
Next
kemudian ditambah lagi dengan satu looping for....next yang digunakan untuk menggeser karakter yaitu.
C = 33
For E = 0 To 33
.
.
Decr C
Next
nilai awal variabel c digunakan untuk menentukan jumlah perulangannya. trust me it work ,semoga bermanfaat.
wasallam