Scrolling Teks ke kanan pada Led Matriks Max7219 dengan Arduino

Pendahuluan

Kali ini saya akan membuat program atas permintaan rekan saya, untuk membuat scrolling tulisan ke kanan pada led matriks max7219 dengan Arduino. program ini menggunakan library maxmatrix yang dapat ditemui pada GitHub berikut : https://github.com/riyas-org/max7219/tree/master/MaxMatrix . pada awalnya saya mencari kode program yang sudah mungkin dibuat oleh orang lain di internet namun tidak menemukan. akhirnya saya coba membuat program sendiri  tanpa mencobanya langsung, karena saya tidak mempunyai alat tersebut. sehingga untuk menulis programnya saya hanya mengandalkan logika :).

kita mulai dari membuat Algoritma pemrograman untuk scrolling tulisan ke kanan. berikut Algoritmanya.

Algoritma

1. Reverse String

Input dari program yaitu string berbentuk char array, apabila scrolling ke kiri dimulai dari huruf awal sebuah string, maka untuk scrolling ke kanan dimulai dari huruf terakhir sebuah string. disini kita memerlukan pembalikan huruf pada input-an string. contoh jika input-an string-nya adalah "ABCD" maka jika dibalik menjadi "DCBA" untuk melakukan itu saya menggunakan potongan program berikut ini :

          char string1[] ="ABCD";

    char temp;

    int i = 0;

    int k = sizeof(string1)-2;

    int j = k/2;

    for (i=0; i

        temp = string1[i];

        string1[i] = string1[k];

        string1[k] = temp;

        k--;

      }

2. Ambil Tiap Huruf

untuk mengambil tiap huruf pada string kita bisa melempar setiap array ke sebuah fungsi untuk diproses. fungsi tersebut kita namakan dengan printCharWithShift(* s, speed_shift) dimana  pointer s merupakan char  yang akan diproses dan speed_shift adalah kecepatan geser dengan satuan detik. berikut potongan programnya :

// Extract characters from Scrolling text

void printStringWithShift(char* s, int shift_speed){

while (*s != 0){

printCharWithShift(*s, shift_speed);

s++;

}

}

3. Ambil Font Huruf yang sudah didefinisikan 

proses berikutnya kita akan mengambil font huruf yang sudah didefinisikan sebelumnya yaitu sebagai berikut : 

PROGMEM const unsigned char CH[] = {

3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space

1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !

3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "

5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #

4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $

5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %

5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &

1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '

3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (

3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )

5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *

5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +

2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,

4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -

2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .

4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /

4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0

3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1

4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2

.........................

........................

};

caranya adalah dengan mengurangi nilai ASCII karakter tersebut dengan 32, 32 merupakan nilai ASCII untuk spasi, setelah didapat selisihnya kita kalikan dengan 7 karena setiap karakter terdiri dari 7 byte, maka 7 byte kedepan dari nilai yang dikalikan 7 tersebut merupakan font untuk karakter yang kita proses. misal angka 0 kode ASCII-nya yaitu 48 sehingga prosesnya seperti berikut :

48 - 32 = 16  == > menghitung nilai offset dari spasi
16 * 7 = 112   ==> menentukan index awal font karakter
112 + 6 = 118  ==> index akhir font karakter

maka CH[112] - CH[118] merupakan font karakter dari angka 0.

informasi yang terkandung dalam sebuah font yaitu :
index awal merupakan lebar font dan index kedua merupakan tinggi font, selebihnya 5 index berikutnya merupakan nilai disetiap kolom dari kiri ke kanan.

potongan program untuk melakukan hal tersebut yaitu :

char buffer[10];
.............
..............

void printCharWithShift(char c, int shift_speed){

if (c < 32) return;
c -= 32;
memcpy_P(buffer, CH + 7*c, 7);

.................
..................
}

potongan program di atas merupakan mengambil font karakter dan menyimpannya pada variable buffer.

4. Load font karakter dari kiri ke kanan

untuk melakukan ini, yaitu dengan mengambil kode kolom font yang terakhir dimasukan ke kolom pertama led matrix, kemudian delay dan geser kekanan dan masukan kembali font kedua dari terakhir ke kolom pertama led matrix, delay dan geser kekanan kembali begitu seterusnya sampai font kolom font tiba ke kolom yang pertama. untuk melakukan hal tersebut maka potongan programnya adalah sebagai berikut :

for (int i = buffer[0]+1; i > 1 ; i--)

{

m.setColumn(0, buffer[i]);

delay(shift_speed);

m.shiftRight(false, false);

}

lalu yang terakhir adalah membuat jeda satu kolom dengan membuat kolom pertama led matrix off semua dengan kode berikut :

delay(shift_speed);

m.setColumn(0, 0);
m.shiftRight(false, false);

itu adalah Algoritma untuk mengeser teks dari kiri kekanan pada Led Matriks 7219 dengan Arduino. Terima Kasih sudah membaca, tinggalkan komentar jika ingin bertanya.untuk melihat program lengkapanya, berikut dibawah ini

Kode Lengkap Source Code Arduino :

#include "MaxMatrix.h"

PROGMEM const unsigned char CH[] = {

3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space

1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !

3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "

5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #

4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $

5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %

5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &

1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '

3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (

3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )

5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *

5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +

2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,

4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -

2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .

4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /

4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0

3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1

4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2

4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3

4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4

4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5

4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6

4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7

4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8

4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9

2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :

2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;

3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // < 

3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // = 

3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >

4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?

5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @

4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A

4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B

4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C

4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D

4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E

4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F

4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G

4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H

3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I

4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J

4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K

4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L

5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M

5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N

4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O

4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P

4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q

4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R

4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S

5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T

4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U

5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V

5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W

5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X

5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y

4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z

2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [

4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash

2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]

3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat

4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _

2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `

4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a

4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b

4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c

4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d

4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e

3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f

4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g

4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h

3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i

4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j

4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k

3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l

5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m

4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n

4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o

4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p

4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q

4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r

4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s

3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t

4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u

5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v

5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w

5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x

4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y

3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z

3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {

1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |

3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }

4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~

};

int data = 11; // DIN pin of MAX7219 module

int load = 10; // CS pin of MAX7219 module

int clock = 13; // CLK pin of MAX7219 module

int maxInUse = 4; //how many MAX7219 are connected

MaxMatrix m(data, load, clock, maxInUse); // define Library

byte buffer[20];

char string1[]="ASSalam";

void setup(){

m.init(); // module MAX7219

m.setIntensity(9); // LED Intensity 0-15

// reverse string 1 

    char temp;

    int i = 0;

    int k = sizeof(string1)-2;

    int j = k/2;

    for (i=0; i

        temp = string1[i];

        string1[i] = string1[k];

        string1[k] = temp;

        k--;

      

    }

}

void loop(){

printStringWithShift(string1, 100); // Send scrolling Text

delay(1000);

}

// Put extracted character on Display

void printCharWithShift(char c, int shift_speed){

if (c < 32) return;

c -= 32;

memcpy_P(buffer, CH + 7*c, 7);

for (int i = buffer[0]+1; i > 1 ; i--)

{

m.setColumn(0, buffer[i]);

delay(shift_speed);

m.shiftRight(false, false);

}

delay(shift_speed);

m.setColumn(0, 0);
m.shiftRight(false, false);

}

// Extract characters from Scrolling text

void printStringWithShift(char* s, int shift_speed){

while (*s != 0){

printCharWithShift(*s, shift_speed);

s++;

}

}

kirim data sensor secara wireless dengan module RF 433MHz

Pendahuluan

Jika kita mempunyai sebuah project dimana terdapat sebuah sensor misal sensor IR di posisi tertentu dan ingin mengambil datanya, maka kita akan menghubungkan sensor IR tersebut dengan kabel ke sebuah kontroller yang kita gunakan, katakanlah Arduino Uno.

Lalu  bagaimana jika kita menggunakan module RF 433MHz untuk mengirimkan data sensor IR tersebut ke Arduino Uno tanpa kabel alias wireless. bagaimana caranya ? baik langsung saja kita mulai step by step.

Module RF 433MHz

Merupakan modul RF yang murah dengan kemampuan yang saya pikir diluar harganya yang murah, kita bisa kirim data secara wireless dengan jangkauan yang cukup jauh. modul ini terdiri dari dua perangkat yaitu Receiver atau Penerima dan Transmiter atau Pemancar, pada bagian Transmiter terdapat 3 Pin yaitu VCC, GND dan Data, dan bagian Receiver terdapat 4 Pin, Vcc, GND, dan dua Pin Data. cukup sederhana bukan.

cara kerja dari module RF ini secara singkat yaitu mengirimkan data sesuai dengan data yang ada di bagian pemancar / transmiter. jika kita kirim data '1' maka di sisi receiver akan menerima data '1' dan sebaliknya. secara teknik module RF ini mengunakan modulasi ASK atau Amplitudo Shift Keying.

Skematik

kita mulai dengan skematik Sensor IR terhubung ke bagian pemancar. kita cukup hubungkan bagian sinyal sensor ke bagian Data Module RF 433MHz dan VCC dan GND pada pemancar dan sensor di berikan VCC dan GND. perhatikan gambar berikut ini :

sekarang kita gunakan Arduino Uno sebagai penerima data sensor secara wireless, kita hubungkan bagian penerima modul 433MHz ke Pin yang kita gunakan sebagai input. katakanlah Pin 12. seperti rangkaian dibawah ini :

dapat diperhatikan diatas sinyal di hubungkan ke PIN 12 sehingga nantinya kita akan memprogram Arduino untuk menerima INputan di PIn 1.

Source Code Arduino

untuk program Arduino Uno, kita gunakan PIN 12 sebagai Input dan disetting Pull Up, artinya jika input dari sensor impedansi Tinggi maka input akan HIGH secara singkat tanpa input default yang dibaca akan HIGH. 

program akan membaca Pin 12 dan jika LOW maka LED akan menyala, disini saya menggunakan Aktif High untuk LED dan sensor jika ada halangan akan mengirimkan logika LOW. artinya jika ada halangan maka LED akan menyala.

sebaliknya jika input HIGH atau tidak ada Halangan makan LED akan Off atau Padam. untuk lebih jelasnya dapat dilihat Source Code berikut ini :

void setup() {
  pinMode(12, INPUT_PULLUP);
  pinMode(13, OUTPUT);

}

void loop() {
  int sensorVal = digitalRead(12);

  if (sensorVal == HIGH) {
    digitalWrite(13, LOW);
  } else {
    digitalWrite(13, HIGH);
  }
}

teman-teman upload kode diatas di Arduino dan Test. jika ada pertanyaan bisa isi komentar dibawah ini. semoga bermanfaat dan Terima Kasih

Robot Beroda dengan Control dari Bluetooth

Pendahuluan

kali ini saya berbagi pengalaman tentang membuat Robot Beroda yang dikendalikan via Bluetooth dari SmartPhone Android. jadi semacan RC Robot, namun remotenya menggunakan SmartPhone Android  cukup menarik bukan.. untuk mekanik Robot, saya menggunakan modul RObot Car yang siap dirakit, jadi fokus tutorial disini lebih Skematik Rangkaian dan Source Code  Arduinonya itu sendiri. mari ikuti tutorialnya :)

Project ini menggunakan Arduino, dimana terdapat modul Bluetooth HC05 yang terhubung ke Arduino melalui Pin Rx dan Tx dan berkomunikasi secara serial. atau bisa juga ke pin mana saja, karena di Arduino sudah terdapat software Serial. sehingga kita bisa menggunakan pin-pin tertentu selain pin Rx dan Tx untuk jadi pin serial. 

Robot Beroda dengan controller Arduino tersebut dikendalikan secara wireless melalui Bluetooh dari smartphone Android. untuk lebih jelasnya berikut skematik diagramnya :

bahan-bahan yang diperlukan untuk membuat RC Robot Beroda. yaitu : Baterai 9V, Arduino Uno, Modul Bluetooth HC 05, Driver Motor dan mekanik Robot Car yang sudah tersedia.

Cara Kerja

Robot Beroda akan bergerak sesuai dengan instruksi dari SmartPhone Android, untuk maju, belok kiri, belok kanan, mundur dan berhenti. Android mengirim perintah melalui Bluetooth dengan kode-kode tertentu. kode-kode tersebut diterima Arduino kemudian diterjemahkan menjadi perintah yang akan dieskusi apakah itu, gerak maju, belok kiri, belok kanan, mundur atau berhenti.

Program Android

Program Android disini digunakan sebagai pengirim kode-kode melalui Bluetooth. terdapat lima Tombol, yaitu maju, kanan, kiri, mundur dan stop, setiap tombol ketika ditekan akan mengirimkan kode tertentu. untuk kodenya yaitu, tombol maju mengirimkan kode '0', tombol kiri akan mengirimkan kode '1', tombol kanan jika ditekan akan mengirimkan kode '2', tombol kiri mengirimkan kode '3' dan terakhir tombol diam akan mengirimkan kode '4'. berikut Layout dari program Androidnya :

untuk program Androidnya tidak saya bahas disini, teman-teman cukup download file APK yang sudah saya sediakan pada link berikut : link program Android. 

Source Code Arduino

Arduino Uno bertugas untuk menerima input kode yang dikirim oleh SmartPhone Android, kemudian menerjemahkanya ke perintah-perintah tertentu. untuk menerima kode yang di kirimkan Android, Arduino cukup mendengarkan input Serial dari modul Bluetooth HC 05. karena kode yang dikirimkan oleh Android akan diteruskan oleh modul Bluetooth melalui komunikasi serial.

apabila menerima input dari komunikasi serial kode tertentu. kode tersebut langsung di-check, apakah 0, 1, 2, 3 atau 4 dan setiap kode akan menjalan function yang sudah dibuat yaitu function maju(), function kiri(), function kanan(), function mundur() dan function diam(). untuk lebih jelasnya bisa melihat source code berikut ini :

#include <SoftwareSerial.h>

int ma1 = 12;
int ma2 = 11;
int mb1 = 10;
int mb2 = 9;

char inbyte = 0;

SoftwareSerial bT (9, 8); //RX, TX

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  bT.begin(9600);
  pinMode(ma1, OUTPUT);
  pinMode(ma2, OUTPUT);
  pinMode(mb1, OUTPUT);
  pinMode(mb2, OUTPUT);

  digitalWrite(ma1, LOW);
  digitalWrite(ma2, LOW);
  digitalWrite(mb1, LOW);
  digitalWrite(mb2, LOW);

}

void loop() {
  // put your main code here, to run repeatedly:

  if (bT.available() > 0)
  {
    inbyte = bT.read();
    if (inbyte == '0'){
           maju();
    }
    else if (inbyte == '1'){     
          kiri();
    }
    else if (inbyte == '2'){     
          kanan();
    }
    else if (inbyte == '3'){     
          mundur();
    }
    else if (inbyte == '4'){
      diam();
    }
    
  }

}

void maju(){
digitalWrite(ma1, HIGH);
digitalWrite(ma2, LOW);
digitalWrite(mb1, HIGH);
digitalWrite(mb2, LOW);
}

void kiri(){
digitalWrite(ma1, HIGH);
digitalWrite(ma2, LOW);
digitalWrite(mb1, LOW);
digitalWrite(mb2, HIGH);
}

void kanan(){
digitalWrite(ma1, LOW);
digitalWrite(ma2, HIGH);
digitalWrite(mb1, HIGH);
digitalWrite(mb2, LOW);
}

void mundur(){
digitalWrite(ma1, LOW);
digitalWrite(ma2, HIGH);
digitalWrite(mb1, LOW);
digitalWrite(mb2, HIGH);
}

void diam(){
digitalWrite(ma1, LOW);
digitalWrite(ma2, LOW);
digitalWrite(mb1, LOW);
digitalWrite(mb2, LOW);
}

untuk gerak maju, kiri, kanan, mundur. teman-teman bisa kalibrasi dengan mengetes function terlebih dahulu, jalankan satu per satu function maju, kiri, kanan, mundur dan diam. jika ada kesalahan koreksi. lalu jika sudah benar semua baru tambahkan source diatas selain funtion maju, kiri, kanan, mundur dan diam.

setelah selesai upload dan test dengan program Android. saya sudah coba dan berkerja dengan baik. jika ada pertanyaan yang kurang jelas bisa tanyakan di kolom komentar. terima kasih semoga bisa bermanfaat.

Membuat Tulisan Berjalan dengan Border pada P10 di Arduino Uno

Pendahuluan

kali ini saya akan membuat tutorial pemrograman Arduino, yaitu membuat tulisan berjalan atau scrolling text yang memiliki border. tulisan ini dibuat dalam rangka ketika saya sendiri awalnya cukup kesulitan dalam membuat tulisan teks berjalan dengan border, dengan mengotak atik fungsi yang sudah ada pada lib DMD panel P10 yang dikeluarkan oleh freetronics. namun kenyataannya tidak perlu mengotak atik fungsi yang sudah ada, cukup dengan melakukan algoritma yang sederhana. 

1. Panel P10

Panel P10 merupakan dot matriks yang dapat digunakana secara praktrs. terdiri dari 32 kolom dan 16 baris. sudah terdapat kontroller didalamnya dan berkomunikasi dengan SPI ke Arduino Uno. berikut merupakan interface Arduino ke Panel P10:

2. Algorima Pemrograman

untuk algoritma pemrograman yaitu dengan mengambar border yaitu dengan fungsi drawBox. kemudian jika kita menggunakan fungsi drawMarquee dan stepMarquee, maka border akan hilang. sehingga perlu cara lain untuk membuat teks berjalan. yaitu cukup sederhana dengan menggunakan fungsi drawString untuk menulis array char ke panel p10. 

drawString kita buat dimulai dari koordinat terakhir yaitu X =  63, koordinat Y disesuaikan dengan font, pada kasus saya yang menggunakan system font 5 x7 menggunakan Y = 3 dan gambar border kembali dengan drawBox,  beri delay secukupnya (100ms) kemudian ulangi sebanyak jumlah lebar karakter kali, dengan koordinat X dikurangi satu setiap looping, nilai setiap lebar karakter bisa kita dapatkan dari fungsi charWidth dalam dmd. berikut source lengkapnya:

#include <SPI.h>        
#include <DMD.h>        
#include <TimerOne.h>   
#include "SystemFont5x7.h"
#include "Arial_black_16.h"

//Fire up the DMD library as dmd
#define DISPLAYS_ACROSS 2
#define DISPLAYS_DOWN 1
DMD dmd(DISPLAYS_ACROSS, DISPLAYS_DOWN);

void ScanDMD()
{ 
 dmd.scanDisplayBySPI();
}


void setup(void)
{  
  Timer1.initialize( 5000 );           
  Timer1.attachInterrupt( ScanDMD );     
  dmd.clearScreen( true );  
}


void loop(void)
{ 
  dmd.clearScreen( true );
 // dmd.selectFont(Arial_Black_16);
  dmd.selectFont(System5x7);

char teks[] = "Scrolling Text";
int lebarTeks = 0;
for (int i = 0; i < sizeof(teks)+1; i++) {
  lebarTeks += dmd.charWidth(teks[i]) + 1;
}

dmd.drawBox(  0,  0, (32*DISPLAYS_ACROSS)-1, (16*DISPLAYS_DOWN)-1, GRAPHICS_NORMAL );
for (int i = 0; i<lebarTeks; i++) {
  dmd.drawString (63-i, 3, teks, sizeof(teks), GRAPHICS_NORMAL);
  dmd.drawBox(  0,  0, (32*DISPLAYS_ACROSS)-1, (16*DISPLAYS_DOWN)-1, GRAPHICS_NORMAL );
  delay(100);
} 
  
}

perlu di ingat library yang digunakan yaitu DMD dan Timerone. dan tempatkan pada folder library di folder Arduino.jika teman teman merasa kesulitan dalam mendapatkan file pendukung library diatas, kamu bisa dapatkan pada link berikut:

http://imamfisika.blogspot.com/2016/12/file-pendukung-pelatihan-smkn-29.html

berikut video hasilnya :

semoga bisa bermanfaat, jika ada pertanyaan bisa tinggalkan komentar dibawah ini. Terima Kasih.