Kendali Running Text pada Dot Matrix Berbasis Arduino

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

dot matrix

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:

skema dotmatrix

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.

huruf A

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:

hexadesimal

Project kali ini kita membuat logo RAPI (Radio Antar Penduduk Indonesia)

Logonya seperti ini:

RAPI2

Dengan terbatasnya jumlah baris (hanya 8 baris dot matrix) maka logo kita modifikasi sedemikian rupa, seperti ini:

dotm rapi

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..

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *