Led Dot Matrix 8×8 adalah modul display yang menggunakan kumpulan – kumpulan LED yang dirangkaikan menjadi satu kesatuan dengan 8 baris dan 8 kolom. Modul ini dikontrol menggunakan IC MAX7219 sebagai komponen driver utamanya. Cara pengoperasian modul ini yaitu dengan cara multiplexing atau multiplexed display. Tegangan operasi normal yaitu pada tegangan 5V, sehingga dapat langsung dihubungkan ke mikrokontroler tanpa perlu ada tambahan komponen.
Project kali ini menggunakan 4 modul dot matrix, atau disebut 4in1 dot matrix MAX7219. Penggabungan dari 4 modul dot matrix 8×8 yang dipasang atau disusun secara cascade (bertingkat) horizontal yang mana masing masing modul dikontrol menggunakan driver MAX7219.
Berikut spesifikasi umum dari module dot matrix ini :
Power Supply : 5VDC
Data Interface : SPI Serial
Warna dot : Merah
Driver : 4 x MAX7219
Pada modul ini memiliki 5 pin interface :
VCC = 5V DC IN
GND = 0V / Ground
DIN = Data IN / SDA / MOSI
CS = Shift / SS
CLK = Clock / SCK
Pada project kali ini pengkabelan / wiring dari module 4in1 dot matrix ke Arduino Uno sbb:
CLK D13
DIN D11
CS D10
VCC pin 5V
GND GND
Skema Rangkaian sbb:
Alat dan Bahan yang diperlukan:
Arduino Uno
Komputer + Software IDE Arduino
Modul 4in1 dot matrix
Kabel Jumper
Batterai kotak 9V
Hal yang pertama dilakukan yaitu mendownload library yang diperlukan : Link Download di sini http://arduinocode.codeplex.com/releases.
Setelah file di download, semua library yang dibutuhkan kemudian ekstrak menggunakan aplikasi “Winrar/Winzip” ke folder ‘libraries‘ yang ada pada directory installer Arduino IDE.
Untuk computer / laptop dengan OS Windows, simpan library pada folder: My Documents -> Arduino -> libraries
Library ini didukung hanya Arduino IDE Versi 1.6.5 ke atas. Apabila versi arduino ide anda dibawah versi 1.6.5 kemungkinan tidak akan bisa berjalan/gagal compile. Hal yang harus dilakukan adalah upgrade Arduino IDE dengan versi terbaru.
Program dicompile (verify) dan diupload ke Arduino Uno yang dimana telah dihubungkan ke module dot matrix. Setelah itu amati apa yang tertampil pada layar dot matrix, apabila belum terjadi apa-apa perlu dicek lagi pengkabelannya.
Bila telah selesai upload dan program berjalan normal, seperti yang diharapkan, lepaskan kabel USB dang anti power supply Arduino dengan baterai kotak 9 V. Selesai? Tentunya Belum.
Kita ingin bermain-main dengan 4in1 dot matrix ini.
Dengan display seperti itu, ada banyak hal yang bisa kita buat. Kita bisa menampilkan running text, tampilan waktu atau parameter lainnya, emoji / emoticon / karakter khusus bahkan suatu logo.
Untuk project kali ini, kita akan menampilkan logo dan running text.
Yang perlu kita pahami adalah bagaimana membangkitkan suatu karakter atau suatu huruf.
Misalnya kita ingin membuat huruf A. Huruf A tersusun dalam 4 baris dan 8 kolom dalam sebuah matrix 8×8 dengan driver MAX7219 dengan posisi putar 90° dengan kode Biner. Instruksinya adalah: 4, 8, B1111110, B0010001, B0010001, B1111110, B0000000.
Perlu dikosongkan 1 baris dibawah untuk huruf atau karakter seperti Q, y, g, j, q, dan karakter lainnya, agar rapi dan kompak. Mungkin ini agak membingungkan..? Perhatikan gambar dibawah ini:
Atau bisa dikatakan bahwa 1 = NYALA dan 0 = MATI. Sehingga 0 dan 1 adalah instruksi untuk NYALA dan MATI dalam dot matrix yang dibatasi untuk jumlah baris dan kolomnya. Untuk karakter yang lain, kodenya seperti dibawah ini.
3, 8, B0000000, B0000000, B0000000, B0000000, B0000000, // space
1, 8, B1011111, B0000000, B0000000, B0000000, B0000000, // !
3, 8, B0000011, B0000000, B0000011, B0000000, B0000000, // ”
5, 8, B0010100, B0111110, B0010100, B0111110, B0010100, // #
4, 8, B0100100, B1101010, B0101011, B0010010, B0000000, // $
5, 8, B1100011, B0010011, B0001000, B1100100, B1100011, // %
5, 8, B0110110, B1001001, B1010110, B0100000, B1010000, // &
1, 8, B0000011, B0000000, B0000000, B0000000, B0000000, // ‘
3, 8, B0011100, B0100010, B1000001, B0000000, B0000000, // (
3, 8, B1000001, B0100010, B0011100, B0000000, B0000000, // )
5, 8, B0101000, B0011000, B0001110, B0011000, B0101000, // *
5, 8, B0001000, B0001000, B0111110, B0001000, B0001000, // +
2, 8, B10110000, B1110000, B0000000, B0000000, B0000000, // ,
4, 8, B0001000, B0001000, B0001000, B0001000, B0000000, // –
2, 8, B1100000, B1100000, B0000000, B0000000, B0000000, // .
4, 8, B1100000, B0011000, B0000110, B0000001, B0000000, // /
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // 0
3, 8, B1000010, B1111111, B1000000, B0000000, B0000000, // 1
4, 8, B1100010, B1010001, B1001001, B1000110, B0000000, // 2
4, 8, B0100010, B1000001, B1001001, B0110110, B0000000, // 3
4, 8, B0011000, B0010100, B0010010, B1111111, B0000000, // 4
4, 8, B0100111, B1000101, B1000101, B0111001, B0000000, // 5
4, 8, B0111110, B1001001, B1001001, B0110000, B0000000, // 6
4, 8, B1100001, B0010001, B0001001, B0000111, B0000000, // 7
4, 8, B0110110, B1001001, B1001001, B0110110, B0000000, // 8
4, 8, B0000110, B1001001, B1001001, B0111110, B0000000, // 9
2, 8, B01010000, B0000000, B0000000, B0000000, B0000000, // :
2, 8, B10000000, B01010000, B0000000, B0000000, B0000000, // ;
3, 8, B0010000, B0101000, B1000100, B0000000, B0000000, //
4, 8, B0000010, B1011001, B0001001, B0000110, B0000000, // ?
5, 8, B0111110, B1001001, B1010101, B1011101, B0001110, // @
4, 8, B1111110, B0010001, B0010001, B1111110, B0000000, // A
4, 8, B1111111, B1001001, B1001001, B0110110, B0000000, // B
4, 8, B0111110, B1000001, B1000001, B0100010, B0000000, // C
4, 8, B1111111, B1000001, B1000001, B0111110, B0000000, // D
4, 8, B1111111, B1001001, B1001001, B1000001, B0000000, // E
4, 8, B1111111, B0001001, B0001001, B0000001, B0000000, // F
4, 8, B0111110, B1000001, B1001001, B1111010, B0000000, // G
4, 8, B1111111, B0001000, B0001000, B1111111, B0000000, // H
3, 8, B1000001, B1111111, B1000001, B0000000, B0000000, // I
4, 8, B0110000, B1000000, B1000001, B0111111, B0000000, // J
4, 8, B1111111, B0001000, B0010100, B1100011, B0000000, // K
4, 8, B1111111, B1000000, B1000000, B1000000, B0000000, // L
5, 8, B1111111, B0000010, B0001100, B0000010, B1111111, // M
5, 8, B1111111, B0000100, B0001000, B0010000, B1111111, // N
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // O
4, 8, B1111111, B0001001, B0001001, B0000110, B0000000, // P
4, 8, B0111110, B1000001, B1000001, B10111110, B0000000, // Q
4, 8, B1111111, B0001001, B0001001, B1110110, B0000000, // R
4, 8, B1000110, B1001001, B1001001, B0110010, B0000000, // S
5, 8, B0000001, B0000001, B1111111, B0000001, B0000001, // T
4, 8, B0111111, B1000000, B1000000, B0111111, B0000000, // U
5, 8, B0001111, B0110000, B1000000, B0110000, B0001111, // V
5, 8, B0111111, B1000000, B0111000, B1000000, B0111111, // W
5, 8, B1100011, B0010100, B0001000, B0010100, B1100011, // X
5, 8, B0000111, B0001000, B1110000, B0001000, B0000111, // Y
4, 8, B1100001, B1010001, B1001001, B1000111, B0000000, // Z
2, 8, B1111111, B1000001, B0000000, B0000000, B0000000, // [
4, 8, B0000001, B0000110, B0011000, B1100000, B0000000, // backslash
2, 8, B1000001, B1111111, B0000000, B0000000, B0000000, // ]
3, 8, B0000010, B0000001, B0000010, B0000000, B0000000, // hat
4, 8, B1000000, B1000000, B1000000, B1000000, B0000000, // _
2, 8, B0000001, B0000010, B0000000, B0000000, B0000000, // `
4, 8, B0100000, B1010100, B1010100, B1111000, B0000000, // a
4, 8, B1111111, B1000100, B1000100, B0111000, B0000000, // b
4, 8, B0111000, B1000100, B1000100, B0000000, B0000000, // c // JFM MOD.
4, 8, B0111000, B1000100, B1000100, B1111111, B0000000, // d
4, 8, B0111000, B1010100, B1010100, B0011000, B0000000, // e
3, 8, B0000100, B1111110, B0000101, B0000000, B0000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B0000000, // g
4, 8, B1111111, B0000100, B0000100, B1111000, B0000000, // h
3, 8, B1000100, B1111101, B1000000, B0000000, B0000000, // i
4, 8, B1000000, B10000000, B10000100, B1111101, B0000000, // j
4, 8, B1111111, B0010000, B0101000, B1000100, B0000000, // k
3, 8, B1000001, B1111111, B1000000, B0000000, B0000000, // l
5, 8, B1111100, B0000100, B1111100, B0000100, B1111000, // m
4, 8, B1111100, B0000100, B0000100, B1111000, B0000000, // n
4, 8, B0111000, B1000100, B1000100, B0111000, B0000000, // o
4, 8, B11111100, B0100100, B0100100, B0011000, B0000000, // p
4, 8, B0011000, B0100100, B0100100, B11111100, B0000000, // q
4, 8, B1111100, B0001000, B0000100, B0000100, B0000000, // r
4, 8, B1001000, B1010100, B1010100, B0100100, B0000000, // s
3, 8, B0000100, B0111111, B1000100, B0000000, B0000000, // t
4, 8, B0111100, B1000000, B1000000, B1111100, B0000000, // u
5, 8, B0011100, B0100000, B1000000, B0100000, B0011100, // v
5, 8, B0111100, B1000000, B0111100, B1000000, B0111100, // w
5, 8, B1000100, B0101000, B0010000, B0101000, B1000100, // x
4, 8, B10011100, B10100000, B10100000, B1111100, B0000000, // y
3, 8, B1100100, B1010100, B1001100, B0000000, B0000000, // z
3, 8, B0001000, B0110110, B1000001, B0000000, B0000000, // {
1, 8, B1111111, B0000000, B0000000, B0000000, B0000000, // |
3, 8, B1000001, B0110110, B0001000, B0000000, B0000000, // }
4, 8, B0001000, B0000100, B0001000, B0000100, B0000000, //~
Mungkin mau ganti font ?Atau membuat karakter khusus? Coba ubah 0 dan 1 di atas…, tentunya dengan desain yang matang yaaa…
Sedikit berbeda bila kita ingin membuat suatu logo. Untuk membuat logo kita tidak menggunakan kode biner, tetapi menggunakan kode hexadecimal.
Huruf A yang dinyatakan dalam bilangan biner: 4, 8, B1111110, B0010001, B0010001, B1111110, B0000000. Kode tersebut tersusun atas serangkaian kode biner 0 dan 1 dalam 2byte (1byte = 4bit). Sedangkan dalam hexadecimal, huruf A diatas dinyatakan dengan 0x1E, 0x11, 0x11, 0x1E. Bingungkah….. ? Ini rumusannya:
Project kali ini kita membuat logo RAPI (Radio Antar Penduduk Indonesia)
Logonya seperti ini:
Dengan terbatasnya jumlah baris (hanya 8 baris dot matrix) maka logo kita modifikasi sedemikian rupa, seperti ini:
Nah… coba seperti apa bila desain diatas dinyatakan dalam kode heksadesimal….
Ini program selengkapnya untuk mewujudkan running text dan logo dengan display 4in1 dot matrix Arduino:
// Gunakan MD_Keyswitch library di http://arduinocode.codeplex.com/releases
#define RUN_DEMO 1
#include
#if RUN_DEMO
#define DEMO_DELAY 15 // demo tiap elemen 15s
#else
#include
#endif
#define DEBUG 0 // Enable or disable (default) debugging output
#if DEBUG
#define PRINT(s, v) { Serial.print(F(s)); Serial.print(v); } // Print a string followed by a value (decimal)
#define PRINTX(s, v) { Serial.print(F(s)); Serial.print(v, HEX); } // Print a string followed by a value (hex)
#define PRINTB(s, v) { Serial.print(F(s)); Serial.print(v, BIN); } // Print a string followed by a value (binary)
#define PRINTC(s, v) { Serial.print(F(s)); Serial.print((char)v); } // Print a string followed by a value (char)
#define PRINTS(s) { Serial.print(F(s)); } // Print a string
#else
#define PRINT(s, v) // Print a string followed by a value (decimal)
#define PRINTX(s, v) // Print a string followed by a value (hex)
#define PRINTB(s, v) // Print a string followed by a value (binary)
#define PRINTC(s, v) // Print a string followed by a value (char)
#define PRINTS(s) // Print a string
#endif
//Pin Arduino
#define MAX_DEVICES 4 // Setelan untuk jumlah dotmatriks
#define CLK_PIN 13 // SCK
#define DATA_PIN 11 // MOSI
#define CS_PIN 10 // SS
MD_MAX72XX mx = MD_MAX72XX(CS_PIN, MAX_DEVICES); // SPI hardware interface
//MD_MAX72XX mx = MD_MAX72XX(DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
// Arbitrary pins
#if !RUN_DEMO
#define MODE_SWITCH 9 // Digital Pin
MD_KeySwitch ks = MD_KeySwitch(MODE_SWITCH, LOW);
#endif
// Variasi delay dalam milidetik
#define UNIT_DELAY 25
#define SCROLL_DELAY (2 * UNIT_DELAY)
#define RAPI_DELAY (15 * UNIT_DELAY)
#define RAPI2_DELAY (15 * UNIT_DELAY)
#define CHAR_SPACING 1 // jarak antar karakter
#define BUF_SIZE 100 // character buffer 0.1 detik
// ========== Variabel Umum ===========
uint32_t prevTimeAnim = 0;
// Used for remembering the millis() value in animations
#if RUN_DEMO
uint32_t prevTimeDemo = 0;
// Used for remembering the millis() time in demo loop
uint8_t timeDemo = DEMO_DELAY; // number of seconds left in this demo loop
#endif
// ========== TEKS YANG AKAN DITAMPILKAN ===========
char *msgTab[] =
{
“JZ10QPS.WORDPRESS.COM “,
//silahkan tambah teks…
};
bool scrollText(bool bInit, char *pmsg) //Tampilkan ulang Teks
{
static char curMessage[BUF_SIZE];
static char *p = curMessage;
static uint8_t state = 0;
static uint8_t curLen, showLen;
static uint8_t cBuf[8];
uint8_t colData;
// are we initializing?
if (bInit)
{
// PRINTS(“\n— Initializing ScrollText”);
resetMatrix();
strcpy(curMessage, pmsg);
state = 0;
p = curMessage;
bInit = false;
}
// Is it time to scroll the text?
if (millis()-prevTimeAnim < SCROLL_DELAY)
return(bInit);
// scroll the display
mx.transform(MD_MAX72XX::TSL); // scroll along
prevTimeAnim = millis(); // starting point for next time
// now run the finite state machine to control what we do
PRINT(“\nScroll FSM S:”, state);
switch (state)
{
case 0: // Load the next character from the font table
PRINTC(“\nLoading “, *p);
showLen = mx.getChar(*p++, sizeof(cBuf)/sizeof(cBuf[0]), cBuf);
curLen = 0;
state = 1;
case 1: // display the next part of the character
colData = cBuf[curLen++];
mx.setColumn(0, colData);
if (curLen == showLen)
{
showLen = ((*p != ‘\0’) ? CHAR_SPACING : mx.getColumnCount()-1);
curLen = 0;
state = 2;
}
break;
case 2: // display inter-character spacing (blank column) or scroll off the display
mx.setColumn(0, 0);
if (++curLen == showLen)
{
state = 0;
bInit = (*p == ‘\0’);
}
break;
default:
state = 0;
}
return(bInit);
}
// ========== Desain Grafis ===========
// LOGO RAPI 1
bool graphicRapi(bool bInit)
{
const uint8_t rapi[] = {0xFF, 0xED, 0xED, 0xED, 0x93, 0xBF, 0xAD, 0xAB, 0x87, 0xBF,
0x8D, 0xED, 0xED, 0xF3, 0x81, 0xFF,
};
const uint8_t dataSize = (sizeof(rapi)/sizeof(rapi[0]));
static uint8_t idx = 0;
// are we initializing?
if (bInit)
{
PRINTS(“\n— Rapi init”);
resetMatrix();
bInit = false;
}
// Is it time to animate?
if (millis()-prevTimeAnim < RAPI_DELAY) return(bInit); prevTimeAnim = millis(); // starting point for next time // now run the animation PRINT(“\nRP I:”, idx); mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF); mx.transform(MD_MAX72XX::TSL); mx.setColumn(0, rapi[idx++]); if (idx == dataSize) idx = 0; mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON); return(bInit); } // LOGO RAPI 2 bool graphicRapi2(bool bInit) { const uint8_t rapi2[] = {0x00, 0x12, 0x12, 0x12, 0x6C, 0x40, 0x52, 0x54, 0x78, 0x40, 0x72, 0x12, 0x12, 0x0C, 0x7E, 0x00, }; const uint8_t dataSize = (sizeof(rapi2)/sizeof(rapi2[0])); static uint8_t idx = 0; // are we initializing? if (bInit) { PRINTS(“\n— Rapi2 init”); resetMatrix(); bInit = false; } // Is it time to animate? if (millis()-prevTimeAnim = 1000) { prevTimeDemo = millis(); if (–timeDemo == 0) { timeDemo = DEMO_DELAY; changeState = true; } } #else changeState = ks.read(); #endif if (changeState) { if (state == 0) // awal display { mesg++; if (mesg >= sizeof(msgTab)/sizeof(msgTab[0]))
{
mesg = 0;
state++;
}
}
else
state++;
bRestart = true;
};
// Urutan Display
switch(state)
{
case 0: bRestart = graphicRapi2(bRestart) ; break;
case 1: bRestart = scrollText(bRestart, msgTab[mesg]) ; break;
case 2: bRestart = graphicRapi(bRestart) ; break;
default: state = 0;
}
}
void setup()
{
mx.begin();
prevTimeAnim = millis();
#if RUN_DEMO
prevTimeDemo = millis();
#else
ks.begin();
#endif
#if DEBUG
Serial.begin(57600);
#endif
PRINTS(“\n[MD_MAX72XX JZ10QPS]”);
}
void loop()
{
runMatrixAnimation(); // Nyalakan Display Matrix berikutnya
}
Itulah project kali ini, membangkitkan karakter pada dot matrix 8×8 dengan kode biner dan kode hexadesimal. Sekarang bisa anda bayangkan, seberapa sih 1 byte itu? Untuk membentuk 1 huruf diperlukan berapa byte ? dan seterusnya…
Kepada para suhu Arduino….., terima kasih banyak..