PRAKTIKUM 9

ANTARMUKA MIKROKONTROLER DENGAN LED DOT MATRIK

A. TUJUAN
1. Membuat aplikasi system tampilan karakter yang berupa LED Dot Matrik dengan
menggunakan mikrokontroler Arduino
2. Membuat program untuk menampilkan karekter pada media LED Dot Matrik

B. DASAR TEORI

LED Dot Matrix merupakan salah satu aplikasi dari LED yang disusun secara Matrix dan
dapat berfungsi untuk menampilkan berbagai macam karakter. Terdapat berbagai macam
tampilan yang dapat dihasilkan melalui LED Dot Matrix. Pada LED Dot Matrix 5×7 terdapat 5
pin kolom dan 7 pin baris yang digunakan untuk menentukan kondisi masing-masing LED. Jika
salah satu bagian menjadi input maka bagian yang lain harus sebagai output atau sebaliknya.
Maksudnya salah satu bagian akan menjadi tempat masuknya arus dan bagian yang lain akan
menjadi tempat keluarnya arus tergantung pada kondisi posisi Anoda/katoda LED yang
terpasang didalamnya. Jika Anoda dari LED terpasang pada bagian kolom maka semua pin pada
bagian kolom merupakn tempat masuknya arus dan bagian baris merupakan tempat keluarnya
arus. Apabila bagian kolom diberi arus atau diberi data 1 (high) maka kolom tersebut aktif
atau LED pada kolom tersebut siap menyala. LED yang menyala akan tergantung pada bagian
baris yang diberi data 0 (low).

.
Gambar 9.1 LED dot matrik

Dot matrik 5 x7 memilki arti bahwa 1 dot matrik berukuran 5 kolom x 7 baris susunan
LED. Jadi 1 dot matriki terdapat 35 buah LED. Berikut adalah ilustrasi 3 buah dot matrik yang
sudah terpakai untuk menampilkan beberapa karakter. Setiap karakter antar dot matrik
sebaiknya diberi spasi agar karakter yang tampil terlihat jelas dan tidak tampak berdekatan.
Dalam setiap display dotmatrik selalu terdapat istilah baris dan kolom. Jumlah baris selalu sama
dengan 7. Namun jumlah kolom sebanyak jumlah dot matrik dikali dengan 5 kolom/dot matrik.
Pada gambar 1 di atas terdapat 15 kolom.
Prinsip kerja dot matrik sebenarnya menggunakan system Scanning kolom. Scanning
kolom adalah pada satu waktu dari sekian banyak kolom pada gambar 1 hanya satu kolom yang
menyala merah. Karena proses pengulangan penyalaan kolom dari kolom 1 sampai kolom 15
begitu cepat dan berulang-ulang maka huruf ABH tampak nyala bersamaan. Proses scanning
kolom yang cepat menipu mata atau penglihatan manusia sehingga mata menangkap huruf ABH
seolah-olah menyala secara bersamaan. Apabila proses scanning kolom dipelankan sampai mata
dapat melihat, maka pergeseran penyalaan kolom akan terlihat satu persatu.

Gambar 9.2 LED Dot Matrik 5 x 7

Prinsip kerja LED Dot Matriks

› saat kolom pertama ( scan kolom 1 = 1 / high/2.4 v) maka bit yg diberi

pada baris berupa “1110000”, sehingga jika ketemu 1 vs 1 ga ada arus
mengalir, jadi LED mati, jika 1 ketemu 0 maka arus mengalir, led menyala

› Begitu juga untuk kolom kedua, ketika kolom kedua diberi tegangan maka
pada baris bit yg diberikan adalah “1101011”

› Dan seterusnya, ketika kolom nya mencapai ujung maka akan diulang ke
kolom 1 lagi

› Untuk melakukan scanning biasanya dilakukan dengan memanfaatkan

shift register, atau paling sederhana dengan menggunakan IC 4017 yang
di cascade menjadi led berjalan yang panjang.
 Dot Matriks Led Display Menampilkan (display) dari sebuah program yang dikirim
secara paralel. Misalnya, 8 × 8 matriks LED Anoda bersama-sama dalam baris (R1 - R8),
dan katoda dalam kolom (C1 - C8), jumlah yang diperlukan pin I /O = 16.
Scanning Led

1. LED dot matrix 8x8 (Data Sheet)

Gambar 9.3 Scanning LED dot matriks 8 x 8 (Data Sheet)

Nilai data karakter dalam variabel array :

{{0x18,0x24,0x24,0x24,0x24,0x24,0x24,0x18}, // 0
{0x08,0x18,0x08,0x08,0x08,0x08,0x08,0x1C}, // 1
{0x18,0x24,0x04,0x08,0x10,0x20,0x20,0x3C}, // 2
{0x18,0x24,0x04,0x18,0x04,0x04,0x24,0x18}, // 3
dst}

2. LED dot matrix 8x8 dua warna

Gambar 9.4 Scanning LED dot matriks 8 x 8 dua warna

Nilai data karakter dalam variabel array :
{0x00, 0x84, 0x86, 0xFF, 0xFF, 0x80, 0x80, 0x00,// 1
0x00, 0xFC, 0xFE, 0x37, 0x37, 0xFE, 0xFC, 0x0, // A}
 3. LED dot matrix 8x8 (dua data)
Gambar 9.4 Scanning LED dot matriks 8 x 8 dua data

DRIVER
› IC driver : UDN2981A dan ULN2803A
› UDN2981A : driver ke transistor sekaligus mengatur anoda LED.
› ULN2803A : driver ke transistor sekaligus mengatur katoda LED.

Gambar 9.5 Driver Anode dan Katode

C. LANGKAH PERCOBAAN
› Rangkaian
 - Interface Led Dot Matriks dengan Driver

- Interface Led Dot Matriks dengan Arduino

› Hardware
 Arduino Uno Board
 1x Breadboard
 1x LED Dot Matrik 5x7
 Kabel jumper

› Program 1
int idx = 0; unsigned long last;
void setup() {
last = millis();
//Kolom
pinMode( 9, OUTPUT );
pinMode( 10, OUTPUT );
pinMode( 11, OUTPUT );
pinMode( 12, OUTPUT );
pinMode( 13, OUTPUT );
//Baris
pinMode( 2, OUTPUT );
 pinMode( 3, OUTPUT );
pinMode( 4, OUTPUT );
pinMode( 5, OUTPUT );
pinMode( 6, OUTPUT );
pinMode( 7, OUTPUT );
pinMode( 8, OUTPUT );
for( int r = 0; r < 7; r++) {
digitalWrite( r + 2, LOW );
}
for( int c = 0; c < 5; c++) {
digitalWrite( c + 9, HIGH);
}
}
byte leds[7][5];
void setPattern( byte pattern[20][5], int idx ) {
for( int r =0; r < 7; r++) {
for( int c = 0; c < 5; c++) {
leds[r][c] = pattern[r + idx][c];
}
}
}
void draw() {
for( int r =0; r < 7; r ++ ) {
digitalWrite( r + 2, HIGH );
for( int c=0; c < 5; c ++ ) {
digitalWrite( 13 - c, ( leds[r][c] == 1 ? LOW : HIGH ));
}
delayMicroseconds(900);
digitalWrite( r + 2, LOW );
}
}
void loop() {
if ( millis() - last > 400 ) {
idx = (idx == 0 ? 7 : 0);
last = millis();
}
byte tmp[14][5] = {
{ 0,0,0,0,0},
{ 0,1,0,1,0},
{ 0,0,0,0,0},
{ 0,1,1,1,0},
{ 0,1,0,1,0},
{ 0,1,1,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0},
{ 0,1,0,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0},
{ 0,1,1,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0},
};
setPattern( tmp, idx );
draw();
}
› Program 2
#include <FrequencyTimer2.h>
#define SPACE { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0} \
}
#define H { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}
#define E { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}
#define small_E { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0} \
}
#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}
#define small_L { \
{0, 1, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 1, 1, 0} \
}
#define O { \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
#define small_O { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
#define small_W { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 1, 0, 1}, \
{0, 1, 0, 1, 0} \
}
#define small_R { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 0, 1, 1}, \
{0, 1, 1, 0, 0}, \
{0, 1, 0, 0, 0}, \
{0, 1, 0, 0, 0}, \
{0, 1, 0, 0, 0} \
}
#define small_D { \
{0, 0, 0, 0, 1}, \
{0, 0, 0, 0, 1}, \
{0, 1, 1, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 1} \
}
byte col = 0;
byte leds[5][7]; // columns x rows
int pins[13]= {-1, 2, 9, 3, 11, 12, 13, 5, 6, 10, 4, 8, 7};
int cols[5] = {pins[1], pins[3], pins[10], pins[7], pins[8]};
int rows[7] = {pins[12], pins[11], pins[2], pins[9], pins[4], pins[5], pins[6]};
const int numPatterns = 12;
byte patterns[numPatterns][7][5] = {
SPACE, H, small_E, small_L, small_L, small_O,
SPACE, small_W, small_O, small_R, small_L, small_D
};
int pattern = 0;
void setup()
{
for (int i = 1; i <= 12; i++) {
pinMode(pins[i], OUTPUT);
}
for (int i = 1; i <= 5; i++) {
digitalWrite(cols[i - 1], LOW);
}
for (int i = 1; i <= 7; i++) {
digitalWrite(rows[i - 1], LOW);
}
clearLeds();
FrequencyTimer2::disable();
FrequencyTimer2::setPeriod(2000);
FrequencyTimer2::setOnOverflow(display);
setPattern(pattern);
}
void loop()
{
pattern = ++pattern % numPatterns;
slidePattern(pattern, 100);
}
void clearLeds()
{
// Clear display array
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 7; j++) {
leds[i][j] = 0;
}
}
}
void setPattern(int pattern)
{
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 7; j++) {
leds[i][j] = patterns[pattern][j][i];
}
}
}
void slidePattern(int pattern, int del)
{
for (int newcol = 0; newcol <= 4; newcol++) {
// shift the first 4 columns left
for (int row = 0; row <= 6; row++)
for (int col = 0; col <= 3; col++)
leds[col][row] = leds[col+1][row];
for (int row = 0; row <= 6; row++)
leds[4][row] =
patterns[pattern][row][newcol];
delay(del);
}
}
void display()
{
// Turn whole previous column off:
digitalWrite(cols[col], LOW);
col++;
 if (col == 5) {
col = 0;
}
for (int row = 0; row < 7; row++) {
if (leds[col][row] == 1) {
digitalWrite(rows[row], LOW); // Turn on this led
}
else {
digitalWrite(rows[row], HIGH); // Turn off this led
}
}

digitalWrite(cols[col], HIGH);
}

Latihan :
1. Buatlah program untuk tulisan (huruf A) berjalan dari kiri ke kanan.
2. Buatlah program untuk menampilkan 2,T,A,B
3. Buatlah program satu angka paling belakang dari NRP anda menggunakan metode
scanning
4. Buatlah program untuk menampilkan karakter menggunakan IC Driver
HASIL PERCOBAAN PRAKTIKUM LED DOT MATRIKS
1. PROGRAM 1
Source Code :
int idx = 0; unsigned long last; leds[r][c] = pattern[r +
void setup() { idx][c];
last = millis(); }
//Kolom }
pinMode( 9, OUTPUT ); }
pinMode( 10, OUTPUT );
pinMode( 11, OUTPUT ); void draw() {
pinMode( 12, OUTPUT );
pinMode( 13, OUTPUT ); for( int r =0; r < 7; r ++ ) {
//Baris digitalWrite( r + 2, HIGH );
pinMode( 2, OUTPUT ); for( int c=0; c < 5; c ++ ) {
pinMode( 3, OUTPUT ); digitalWrite( 13 - c, (
pinMode( 4, OUTPUT ); leds[r][c] == 1 ? LOW : HIGH ));
pinMode( 5, OUTPUT ); }
int idx = 0; unsigned long last; delayMicroseconds(900);
void setup() { digitalWrite( r + 2, LOW );
last = millis(); }
//Kolom }
pinMode( 9, OUTPUT );
pinMode( 10, OUTPUT ); void loop() {
pinMode( 11, OUTPUT ); if ( millis() - last > 400 ) {
pinMode( 12, OUTPUT ); idx = (idx == 0 ? 7 : 0);
pinMode( 13, OUTPUT ); last = millis();
//Baris }
pinMode( 2, OUTPUT ); byte tmp[14][5] = {
pinMode( 3, OUTPUT ); { 0,0,0,0,0},
pinMode( 4, OUTPUT ); { 0,1,0,1,0},
pinMode( 5, OUTPUT ); { 0,0,0,0,0},
pinMode( 6, OUTPUT ); { 0,1,1,1,0},
pinMode( 7, OUTPUT ); { 0,1,0,1,0},
pinMode( 8, OUTPUT ); { 0,1,1,1,0},
for( int r = 0; r < 7; r++) { { 0,0,0,0,0},
digitalWrite( r + 2, LOW ); { 0,0,0,0,0},
} { 0,1,0,1,0},
for( int c = 0; c < 5; c++) { { 0,0,0,0,0},
digitalWrite( c + 9, HIGH); { 0,0,0,0,0},
} { 0,1,1,1,0},
} { 0,0,0,0,0},
{ 0,0,0,0,0},
byte leds[7][5]; };
void setPattern( byte
pattern[20][5], int idx ) { setPattern( tmp, idx );
for( int r =0; r < 7; r++) { draw();
for( int c = 0; c < 5; c++) { }

Hasil :
2. PROGRAM 2
Source Code :
#include <FrequencyTimer2.h>
#define SPACE { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0} \
} {1, 0, 0, 0, 1}, \
#define H { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
} {1, 0, 1, 0, 1}, \
#define E { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
} {0, 1, 0, 0, 0}, \
#define small_E { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0} \
} {1, 0, 0, 0, 1}, \
#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
} int cols[5] = {pins[1], pins[3],
#define small_L { \
{0, 1, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 1, 1, 0} \
} SPACE, H, small_E, small_L,
#define O { \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
#define small_O { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
#define small_W { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{0, 1, 0, 1, 0} \
}
#define small_R { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 0, 1, 1}, \
{0, 1, 1, 0, 0}, \
{0, 1, 0, 0, 0}, \
{0, 1, 0, 0, 0} \
}
#define small_D { \
{0, 0, 0, 0, 1}, \
{0, 0, 0, 0, 1}, \
{0, 1, 1, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 1} \
}
byte col = 0;
byte leds[5][7]; // columns x
rows
int pins[13]= {-1, 2, 9, 3, 11,
12, 13, 5, 6, 10, 4, 8, 7};
pins[10], pins[7], pins[8]};
int rows[7] = {pins[12],
pins[11], pins[2], pins[9],
pins[4], pins[5], pins[6]};
const int numPatterns = 12;
byte patterns[numPatterns][7][5]
= {
small_L, small_O,
SPACE, small_W, small_O,
small_R, small_L, small_D
};
int pattern = 0;
void setup()
{ patterns[pattern][row][newcol];
for (int i = 1; i <= 12; i++) {
pinMode(pins[i], OUTPUT); delay(del);
} }
for (int i = 1; i <= 5; i++) }
{ void display()
digitalWrite(cols[i - 1], {
LOW); // Turn whole previous column
} off:
for (int i = 1; i <= 7; i++) digitalWrite(cols[col], LOW);
{ col++;
digitalWrite(rows[i - 1], if (col == 5) {
LOW); col = 0;
} }
clearLeds(); for (int row = 0; row < 7;
row++) {
FrequencyTimer2::disable(); if (leds[col][row] == 1) {
digitalWrite(rows[row],
FrequencyTimer2::setPeriod(2000); LOW); // Turn on this led
}
FrequencyTimer2::setOnOverflow(di else {
splay); digitalWrite(rows[row],
HIGH); // Turn off this led
setPattern(pattern); }
} }
void loop()
{ digitalWrite(cols[col], HIGH);
pattern = ++pattern % }
numPatterns;
slidePattern(pattern, 100);
}
void clearLeds()
{
// Clear display array
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 7; j++) {
leds[i][j] = 0;
}
}
}

void setPattern(int pattern)

{
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 7; j++) {
leds[i][j] =
patterns[pattern][j][i];
}
}
}
void slidePattern(int pattern,
int del)
{
for (int newcol = 0; newcol <=
4; newcol++) {
// shift the first 4 columns
left
for (int row = 0; row <= 6;
row++)
for (int col = 0; col <= 3;
col++)
leds[col][row] =
leds[col+1][row];

for (int row = 0; row <= 6;

row++)
leds[4][row] =
Hasil :
HASIL PERCOBAAN LATIHAN LED DOT MATRIKS
1. LATIHAN 1 : TULISAN A BERJALAN KIRI KE KANAN
Source Code :
#include <LedControl.h>
LedControl
int DIN = 12; lc=LedControl(DIN,CLK,CS,0);
int CS = 11;
int CLK = 10; void setup(){
lc.shutdown(0,false); //The
byte a1[8]= MAX72XX is in power-saving mode on
{0x00,0x00,0x80,0x80,0x80,0x80,0x80 startup
,0x80}; lc.setIntensity(0,15); // Set
byte a2[8]= the brightness to maximum value
{0x00,0x80,0xC0,0xC0,0xC0,0xC0,0xC0 lc.clearDisplay(0); // and
,0xC0}; clear the display
byte a3[8]= }
{0x80,0xC0,0x60,0x60,0xE0,0xE0,0x60
,0x60}; void loop(){
byte a4[8]= printEduc8s();
{0xC0,0xE0,0x30,0x30,0xF0,0xF0,0x30 lc.clearDisplay(0);
,0x30}; delay(1000);
byte a5[8]= }
{0x60,0xF0,0x98,0x98,0xF8,0xF8,0x98
,0x98}; void printEduc8s()
byte a6[8]= {
{0x30,0x78,0xCC,0xCC,0xFC,0xFC,0xCC printByte(a1);delay(500);
,0xCC}; printByte(a2);delay(500);
byte a7[8]= printByte(a3);delay(500);
{0x18,0x3C,0x66,0x66,0x7E,0x7E,0x66 printByte(a4);delay(500);
,0x66}; printByte(a5);delay(500);
byte a8[8]= printByte(a6);delay(500);
{0x0C,0x1E,0x33,0x33,0x3F,0x3F,0x33 printByte(a7);delay(500);
,0x33}; printByte(a8);delay(500);
byte a9[8]= printByte(a9);delay(500);
{0x06,0x0F,0x19,0x19,0x1F,0x1F,0x19 printByte(a10);delay(500);
,0x19}; printByte(a11);delay(500);
byte a10[8]= printByte(a12);delay(500);
{0x03,0x07,0x0C,0x0C,0x0F,0x0F,0x0C printByte(a13);delay(500);
,0x0C}; }
byte a11[8]=
{0x01,0x03,0x06,0x06,0x07,0x07,0x06 void printByte(byte character [])
,0x06}; {
byte a12[8]= int i = 0;
{0x00,0x01,0x03,0x03,0x03,0x03,0x03 for(i=0;i<8;i++)
,0x03}; {
byte a13[8]= lc.setRow(0,i,character[i]);
{0x00,0x00,0x01,0x01,0x01,0x01,0x01 }
,0x01}; }

Hasil :
2. LATIHAN 2 : MENAMPILKAN 2,T,A,B
Source Code :
#include <LedControl.h> lc.clearDisplay(0); //
and clear the display
int DIN = 12; }
int CS = 11;
int CLK = 10; void loop(){
printEduc8s();
byte Dua[8]= lc.clearDisplay(0);
{0x7C,0x7C,0x0C,0x7C,0x7C,0x60,0x delay(1000);
7C,0x7C}; }
byte T[8]=
{0x7E,0x7E,0x18,0x18,0x18,0x18,0x void printEduc8s()
18,0x18}; {
byte A[8]= printByte(Dua);delay(500);
{0x18,0x3C,0x66,0x66,0x7E,0x7E,0x printByte(T);delay(500);
66,0x66}; printByte(A);delay(500);
byte B[8]= printByte(B);delay(500);
{0x7C,0x7E,0x66,0x7C,0x7C,0x66,0x }
7E,0x7C};
void printByte(byte character [])
LedControl {
lc=LedControl(DIN,CLK,CS,0); int i = 0;
for(i=0;i<8;i++)
void setup(){ {
lc.shutdown(0,false); lc.setRow(0,i,character[i]);
//The MAX72XX is in power-saving }
mode on startup }
lc.setIntensity(0,15); //
Set the brightness to maximum
value

Hasil :
 DUINO1

U1

microcontrolandos.blogspot.com
1 14
DIN A
12 16
LOAD B
13 20
CLK C
23
AREF D
21
E
13 15
PB5/SCK F
12 17
PB4/MISO G
RESET 11 22
~PB3/MOSI/OC2A DP
10
~ PB2/SS/OC1B
9 2
~ PB1/OC1A DIG0
8 11
PB0/ICP1/CLKO DIG1
6
ATMEGA328P-PU
1121

DIGITAL (~PWM)
DIG2
7 7
ANALOG IN

PD7/AIN1 DIG3
6 3
A0 ~ PD6/AIN0 DIG4
PC0/ADC0 5 10
A1 ~ PD5/T1 DIG5
PC1/ADC1 4 18 5
A2 PD4/T0/XCK ISET DIG6
PC2/ADC2 3 24 8
A3 ~ PD3/INT1 DOUT DIG7
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1 MAX7219
A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD

ARDUINO UNO R3

3. LATIHAN 3 : MENAMPILKAN NRP PALING BELAKANG

Source Code :
#include <LedControl.h> }

int DIN = 12; void loop(){

int CS = 11; printEduc8s();
int CLK = 10; lc.clearDisplay(0);
delay(1000);
byte Tiga[8]= }
{0x7C,0x7E,0x06,0x7E,0x7E,0x06,0x
7E,0x7C}; void printEduc8s()
{
LedControl printByte(Tiga);delay(500);
lc=LedControl(DIN,CLK,CS,0); }

void setup(){ void printByte(byte character [])

lc.shutdown(0,false); {
//The MAX72XX is in power-saving int i = 0;
mode on startup for(i=0;i<8;i++)
lc.setIntensity(0,15); // {
Set the brightness to maximum lc.setRow(0,i,character[i]);
value }
lc.clearDisplay(0); // }
and clear the display

Hasil :
 DUINO1

U1

microcontrolandos.blogspot.com
1 14
DIN A
12 16
LOAD B
13 20
CLK C
23
AREF D
21
E
13 15
PB5/SCK F
12 17
PB4/MISO G
RESET 11 22
~PB3/MOSI/OC2A DP
10
~ PB2/SS/OC1B
9 2
~ PB1/OC1A DIG0
8 11
PB0/ICP1/CLKO DIG1
6
ATMEGA328P-PU
1121

DIGITAL (~PWM)
DIG2
7 7
ANALOG IN

PD7/AIN1 DIG3
6 3
A0 ~ PD6/AIN0 DIG4
PC0/ADC0 5 10
A1 ~ PD5/T1 DIG5
PC1/ADC1 4 18 5
A2 PD4/T0/XCK ISET DIG6
PC2/ADC2 3 24 8
A3 ~ PD3/INT1 DOUT DIG7
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1 MAX7219
A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD

ARDUINO UNO R3

4. LATIHAN 4 : MENAMPILKAN ABJAD A-Z

Source Code :
#include <LedControl.h> 0110000,B00101000,B00100100,B0010
0100,B00000000};
int DIN = 12; byte L[] =
int CS = 11; {B00000000,B00100000,B00100000,B0
int CLK = 10; 0100000,B00100000,B00100000,B0011
1100,B00000000};
byte A[] = byte M[] =
{B00000000,B00011000,B00100100,B0 {B00000000,B00000000,B01000100,B1
0100100,B00111100,B00100100,B0010 0101010,B10010010,B10000010,B1000
0100,B00000000}; 0010,B00000000};
byte B[] = byte N[] =
{B01111000,B01001000,B01001000,B0 {B00000000,B00100010,B00110010,B0
1110000,B01001000,B01000100,B0100 0101010,B00100110,B00100010,B0000
0100,B01111100}; 0000,B00000000};
byte C[] = byte O[] =
{B00000000,B00011110,B00100000,B0 {B00000000,B00111100,B01000010,B0
1000000,B01000000,B01000000,B0010 1000010,B01000010,B01000010,B0011
0000,B00011110}; 1100,B00000000};
byte D[] = byte P[] =
{B00000000,B00111000,B00100100,B0 {B00000000,B00111000,B00100100,B0
0100010,B00100010,B00100100,B0011 0100100,B00111000,B00100000,B0010
1000,B00000000}; 0000,B00000000};
byte E[] = byte Q[] =
{B00000000,B00111100,B00100000,B0 {B00000000,B00111100,B01000010,B0
0111000,B00100000,B00100000,B0011 1000010,B01000010,B01000110,B0011
1100,B00000000}; 1110,B00000001};
byte F[] = byte R[] =
{B00000000,B00111100,B00100000,B0 {B00000000,B00111000,B00100100,B0
0111000,B00100000,B00100000,B0010 0100100,B00111000,B00100100,B0010
0000,B00000000}; 0100,B00000000};
byte G[] = byte S[] =
{B00000000,B00111110,B00100000,B0 {B00000000,B00111100,B00100000,B0
0100000,B00101110,B00100010,B0011 0111100,B00000100,B00000100,B0011
1110,B00000000}; 1100,B00000000};
byte H[] = byte T[] =
{B00000000,B00100100,B00100100,B0 {B00000000,B01111100,B00010000,B0
0111100,B00100100,B00100100,B0010 0010000,B00010000,B00010000,B0001
0100,B00000000}; 0000,B00000000};
byte I[] = byte U[] =
{B00000000,B00111000,B00010000,B0 {B00000000,B01000010,B01000010,B0
0010000,B00010000,B00010000,B0011 1000010,B01000010,B00100100,B0001
1000,B00000000}; 1000,B00000000};
byte J[] = byte V[] =
{B00000000,B00011100,B00001000,B0 {B00000000,B00100010,B00100010,B0
0001000,B00001000,B00101000,B0011 0100010,B00010100,B00010100,B0000
1000,B00000000}; 1000,B00000000};
byte K[] = byte W[] =
{B00000000,B00100100,B00101000,B0 {B00000000,B10000010,B10010010,B0
1010100,B01010100,B00101000,B0000
0000,B00000000}; printByte(A);delay(500);printByte
byte X[] = (B);delay(500);printByte(C);delay
{B00000000,B01000010,B00100100,B0 (500);printByte(D);delay(500);pri
0011000,B00011000,B00100100,B0100 ntByte(E);delay(500);printByte(F)
0010,B00000000}; ;delay(500);
byte Y[] =
{B00000000,B01000100,B00101000,B0 printByte(G);delay(500);printByte
0010000,B00010000,B00010000,B0001 (H);delay(500);printByte(I);delay
0000,B00000000}; (500);printByte(J);delay(500);pri
byte Z[] = ntByte(K);delay(500);printByte(L)
{B00000000,B00111100,B00000100,B0 ;delay(500);
0001000,B00010000,B00100000,B0011
1100,B00000000}; printByte(M);delay(500);printByte
(N);delay(500);printByte(O);delay
LedControl (500);printByte(P);delay(500);pri
lc=LedControl(DIN,CLK,CS,0); ntByte(Q);delay(500);printByte(R)
;delay(500);
void setup(){
lc.shutdown(0,false); printByte(S);delay(500);printByte
//The MAX72XX is in power-saving (T);delay(500);printByte(U);delay
mode on startup (500);printByte(V);delay(500);pri
lc.setIntensity(0,15); // ntByte(W);delay(500);printByte(X)
Set the brightness to maximum ;delay(500);
value
lc.clearDisplay(0); // printByte(Y);delay(500);printByte
and clear the display (Z);delay(500);
} }

void loop(){ void printByte(byte character [])

printEduc8s(); {
lc.clearDisplay(0); int i = 0;
delay(1000); for(i=0;i<8;i++)
} {
lc.setRow(0,i,character[i]);
void printEduc8s() }
{ }

Hasil :
DUINO1

U1
microcontrolandos.blogspot.com

1 14
DIN A
12 16
LOAD B
13 20
CLK C
23
AREF D
21
E
13 15
PB5/SCK F
12 17
PB4/MISO G
RESET 11 22
~PB3/MOSI/OC2A DP
10
~ PB2/SS/OC1B
9 2
~ PB1/OC1A DIG0
8 11
PB0/ICP1/CLKO DIG1
6
ATMEGA328P-PU
1121

DIGITAL (~PWM)

DIG2
7 7
ANALOG IN

PD7/AIN1 DIG3
6 3
A0 ~ PD6/AIN0 DIG4
PC0/ADC0 5 10
A1 ~ PD5/T1 DIG5
PC1/ADC1 4 18 5
A2 PD4/T0/XCK ISET DIG6
PC2/ADC2 3 24 8
A3 ~ PD3/INT1 DOUT DIG7
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1 MAX7219
A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD

ARDUINO UNO R3
5. LATIHAN 5 : MEMBUAT BENTUK-BENTUK UNIK
Source Code :
#include <LedControl.h>

int DIN = 12;

int CS = 11;
int CLK = 10;

byte gerak1[8]=
{0xFF,0x81,0xBD,0xA5,0xA5,0xBD,0x
81,0xFF};
byte gerak2[8]=
{0x00,0x7E,0x42,0x5A,0x5A,0x42,0x
7E,0x00};

LedControl
lc=LedControl(DIN,CLK,CS,0);

void setup(){
lc.shutdown(0,false);
//The MAX72XX is in power-saving
mode on startup
lc.setIntensity(0,15); //
Set the brightness to maximum
value
lc.clearDisplay(0); //
and clear the display
}

void loop(){
printEduc8s();
delay(100);
}

void printEduc8s()
{
printByte(gerak1);delay(100);
printByte(gerak2);delay(100);
}

void printByte(byte character [])

{
int i = 0;
for(i=0;i<8;i++)
{
lc.setRow(0,i,character[i]);
}
}
Hasil :
Analisa:

Pada percobaan antarmuka mikrokontroller dengan LED Dot Matrik, kita membuat
aplikasi sistem tampilan karakter yang berupa LED Dot Matrik dengan
menggunakan mikrokontroler arduino dan membuat program untuk menampilkan
karakter pada media LED Dot Matrik.
Pada percobaan pertama, dilakukan inisialisasi untuk baris dan kolom dari LED Dot
Matrik. Pada percobaan ini, ditampilkan suatu pola pad LED dengan melakukakn
scanning LED untuk nilai bit untuk membentuk pola yang dapat dilihat pada hasil
percobaan. Pada perobaan kedua, digunakan program untuk menamilkan tulisan
hello world yang dapat berjalan. Pada program, dilakukan scanning LED untuk nilai
data dari tiap tiap karakter yang membentuk Hello World. Selanjutnya dilakukan
inisialisasi pin untuk baris dan kolom. Kemudian pada void serup dan void loop
dilakukan beberapa looping yang mengatur jalannya karakter Hello World dari kanan
ke kiri.
Selanjutnya untuk latihan pertama, kita membuat animasi tulisan berjalan dari kiri ke
kanan pada LED Dot Matrik. Pada program, dilakukan scanning pada LED untuk
dapat menampilkan karakter, sehingga terdapat variabel array a1[], a[2], dan
seterusnya yang merupakan nilai data dari karakter. Pada void setup, digunakan
fungsi dari library LedControl.h seperti lc.shutdown untuk mengatur power saving
mode, lc.setIntensity(0,15) untuk mengatur kecerahan dari LED dan lc.clearDisplay
untuk mengapus isi dari layar LED. Pada void loop, dipanggil fungsi printEduc8s,
lalu setelah itu layar di clear dengan delay sebesar 1000 ms. Pada fungsi printEduc8s,
dipanggil fungsi printByte dengan parameter array dari nilai data karakter yaitu
a1,a2, dan seterusnya dengan delay 500 ms. Selanjutnya di fungsi printByte,
dilakukan looping dari 0 sampai 8 untuk dapat menggeser karakter. Kemudian untuk
latihan kedua yaitu untuk menampilkan karakter 2,T,A, dan B. Untuk menampilkan
karakter tersebut, dilakukan scanning LED seperti sebelumnya yaitu dengan
menggunakan nilai data dari masing masing karakter. Lalu pada void loop
ditampilkan seperti sebelumnya dengan memanggil fungsi lain yang mengatur
tampilan tiap tiap karakter. Latihan ini hampir sama dengan latihan latihan
selanjutnya yaitu untuk menampilkan nrp belakang, menampilkan huruf abjad A-Z
dan menampilkan karakter unik. Hanya saja terdapat perbedaan saat scanning LED
untuk nilai data dari masing masing karakter yang ingin ditampilkan.
Kesimpulan :
Pada percobaan antarmuka mikrokontroller dengan LED Dot Matrik dapat
disimpulkan bahwa :
 Untuk menampilkan suatu karakter pada LED Dot Matrik dilakukan scanning
pada LED dengan mengatur nilai data dari karakter yang ingin ditampilkan
 Dalam membuat program untuk LED Dot matrik, terdapat file library yang
memiliki beberapa fungsi seperti lc.clearDisplay, lc.shutdown,
lc.setIntensity, dan lain lain yang dapat digunakan untuk mengatur tampilan
pada LED