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 Joule Thief Sendiri

Pendahuluan

kalau dilihat dari namanya memang agak lucu, "Joule" sendiri merupakan satuan untuk energi dan kata "Thief" sendiri dari bahasa inggris yaitu pencuri, jadi kalau digabung kurang lebih Pencuri Energi. sebenarnya bukan Pencuri Energi, melainkan kita bisa menggunakan tegangan yang rendah misalnya pada baterai yang sudah hampir mati dengan tegangan dibawah 1 V untuk mendrive Lampu LED super Bright, Wah hebat bukan. mari kita lihat cara kerja dan rangkaiannya.

Cara Kerja 

untuk mengetahui cara kerja Joule Thief ada baiknya kita memperhatikan skematik Joule Thief diatas. seperti yang ada pada gambar terdapat baterai, resistor, dua kumparan yang dililitan pada Toroida, Transistor NPN dan sebuah LED.

ketika pertama kali power Baterai ON, maka Arus akan melalui resistor kemudian melewati kumparan secondary dan menuju ke basis emitor, lalu apa yang terjadi, Transistor akan ON dan arus akan melalui kumparan primer menuju kolektor dan emiter. lampu LED masih belum menyala. karen arus melalui kumparan primer maka akan menginduksi kumparan secondary memberikan tegangan positif, sehingga arus basis akan semakin besar dan arus melalui kumparan primer juga semakin besar.

pada saat arus semakin besar melalui kumparan primer menuju kolektor dan emiter. supply arus menuju ke basis akan semakin berkurang karena arus short melalui kolektor emiter, akibatnya transistor akan cut off. ketika transistor cut off, medan magnet pada toroid akan collapse, yang mengakibatkan tegangan induksi yang cukup tinggi pada kumparan primer dengan arah terbalik sehingga dapat menyalakan lampu LED. ketika medan magnet kembali ke nol. proses akan berulang kembali dari awal.

Proses Pembuatan Joule Thief

bahan-bahan yang perlu disiapkan yaitu : baterai, resistor 1k ohm, transistor NPN, dua kabel untuk kumparan, dan Toroida.

pertama-tama lilitan dua kabel pada kumparan toroid sehingga kabel akan habis dililit ke toroid. anggap ada kabel merah dan kabel hijau. hubungkan kabel merah awal lilitan ke kabel hijau akhir lilitan bersama-sama hubungkan ke bagian positif baterai, kemudian kabel  hijau awal lilitan hubungkan ke dihubungkan ke resistor dan resistor ke basis transistor. kabel merah akhir lilitan dihubungkan ke kolektor transistor dan positif lampu LED, kemudian hubungkan emiter dan negatif LED ke Negatif Baterai. seperti gambar dibawah ini :

sangat mudah bukan untuk membuat joule Thief. sehingga kita bisa menggunakan baterai yang sudah habis untuk membuat sumber cahaya dengan lampu LED. sekian tutorial tentang Joule Thief. semoga bermanfaat. terima kasih

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.

Menjalankan Crhomium otomatis saat boot

Pendahuluan

Terkadang kita perlu untuk menjalankan aplikasi Chromium saat pertama kali Raspberry Pi boot up, atau pertama kali hidup. ini biasanya digunakan apabila kita mempunyai program web based dan ingin running secara full screen saat pertama kali Raspberry Pi hidup, sehingga user tidak perlu menjalankan program secara manual. lalu bagaimana cara konfigurasi yang diperlukan pada Raspberry Pi. caranya cukup mudah.

yang diperlukan yaitu dengan mengedit sebuah file bernama .bashrc yang terletak pada /home/pi. perlu diingat bahwa file ini merupakan file tersembunyi sehingga untuk melihatnya kita perlu perintah ls dengan opion -a. untuk lebih jelasnya bisa memperhatikan tutorial berikut ini :

Mengedit bashrc

file .bashrc terletak pada directory /home/pi/. dengan terdapat tanda titik (.) didepannya menandakan bahwa file tersebut merupakan file hidden sehingga kita perlu melihatnya dengan command ls -a untuk masuk ke dalam directory /home/pi kita cukup dengan mengetikan perintah dibawah ini :

cd ~

cd adalah perintah change directory kemudian tanda "~" merupakan shortcut yang menandakan directory /home/pi. setelah mengetikan perintah cd -a kemudian kita akan masuk ke directory /home/pi. untuk membuktikan bahwa kita berada pada directory tersebut dapat dilakukan perintah sebagai berikut :

pwd

perintah pwd merupakan perintah untuk mengetahui bahwa dalam terminal kita berada di directory mana. setelah mengetikan perintah pwd maka akan keluar tulisan /home/pi yang membuktikan bahwa kita berada di directory /home/pi. kemudian kita tuliskan perintah untuk melihat semua file atau folder yang terdapat pada directory tersebut termasuk hidden file atau folder sekalipun. berikut perintahnya

ls -a

ls -a merupakan perintah untuk melihat isi sebuah directory dengan option -a artinya semua file atau folder yang di hidden atau tersembunyi juga dapat dilihat. setelah mengetikan perintah ls -a maka akan muncul output list file yang terdapat pada directory /home/pi. jika kamu menggunakan OS Raspbian Strecth maka akan menjumpai list file atau folder sebagai berikut :

maka kita akan melihat sebuat file dengan nama .bashrc seperti pada gambar diatas yang diberi kotak warna merah. selanjutnya kita perlu mengedit file berikut, untuk mengedit file tersebut kita perlu permission sudoers sehingga dapat dilakukan dengan perintah sebagai berikut :

sudo nano .bashrc

kemudian letakan perintah untuk membuka aplikasi chromium secara terminal, letakan perintah tersebut di paling bawah. perintah untuk membuka chromium secara terminal yaitu :

chromium-browser --kiosk --app=http://localhost/aplikasi_satu

--kiosk merupakan parameter bahwa tampilannya akan full screen jika kamu ingin tampilannya tidak full screen maka dapat menghilangkan parameter --kiosk pada perintah diatas. setelah menambahkan perintah diatas. simpan dengan shortcut CRTL + O dan pastikan namanya .bashrc lalu tekan enter. keluar dengan shotcut CTRL + X.

--app= merupakan parameter untuk mengisikan alamat dari URL aplikasi web based yang akan dibuka, contoh pada perintah diatas yaitu http://localhost/aplikasi_satu. jika menggunakan web server lokal pastikan web server lokal running saat boot up. disini saya menggunakan web server lokal nginx.

Setelah mengedit file .bashrc  pastikan bahwa Raspberry Pi dapat automasi login ke GUI Desktop, jika login ke terminal Chromium tidak akan tampil.  untuk mengkonfigurasi Raspberry Pi login ke GUI Desktop dapat dikonfigurasi dengan perintah sudo raspi-config. kemudian pilih Boot Options kemudian pilih Desktop/CLI kemudian pilih Desktop Autologin.

Restart Raspberry Pi, dengan perintah sudo reboot. Raspbery Pi akan melakukan boot ulang. setelah masuk ke login Pi mode Desktop maka tidak akan lama waktu berselang, akan muncul tampilan aplikasi web based kita terbuka secara full screen atau tidak dengan browser Chromium.

Menggunakan Shift Register 74HC595

Pendahuluan

IC Shift Register 74HC595 merupakan IC dengan input serial dan output paralel 8 bit dengan menambahkan 8 bit Storage Register Type D. secara garis besar IC ini berisi kan serial in, kemudian  8 bit Shift Register yang disambungkan dengan 8 bit Storage Register. karena terdapat dua register yaitu shift dan storage maka pemberian clock pun menjadi terpisah antara clock untuk shift register dan clock untuk storage register. untuk lebih jelasnya bisa melihat blok diagaram IC 74HC595 dibawah ini :

Input dan Output

INPUT

input IC 74HC595 terdiri dari Output Enable (OE) merupakan buffer keluaran dari IC yang terhubung ke storage register, jika input ini diberikan logika High maka ouput akan menjadi High Impedance, jika diberi logika Low maka akan meneruskan output dari storage register.

SRCLK merupakan clock untuk shift register, yaitu clock yang berguna meneruskan serial in ke keluaran shift register, jika diberika logika high maka input dari shift register akan dikeluarkan,.

SRCLR merupakan input untuk mereset keluaran menjadi Low. reset keluaran akan aktif atau keluaran akan direset menjadi Low dari Q0 sampai Q7 dengan memberikan logika Low pada input SRCLR.

RCKK merupakan clock untuk storage register, yaitu clock yang berguna untuk meneruskan data dari keluaran shift register sebagai input dari storage register menuju ke keluaran storage register.

OUTPUT

untuk output terdiri dari keluaran buffer tri state yang terhubung dari keluaran storage register. output ini berjumlah 8 pin yaitu dari Q0 sampai Q7. dan terdapat pula Q7 aksen, yaitu keluaran dari shift register ke-8, yang bisa dihubungkan ke input IC 74HC595 kembali sebagai inputan. sehingga dapat dicascade dengan jumlah IC lebih dari satu buah.

ALGORITMA

Untuk menggunakan IC 74HC595 ini, agar dapat mengkonversi serial to paralel, maka alur proses atau algoritmanya yaitu :

pertama-tama set SRCLR atau reset mejadi HIGH sehingga reset menjadi tidak aktif, kemudian set OE atau output enable menjadi Low sehingga output enable aktif.

agar data tidak dikeluarkan baik di shift register maupun di storage register, maka perlu diberikan sinyal LOW pada input CLK shift register (SRCLK) mapaun clock storage register (RCLK).

masukan data serial logika HIGH atau LOW ke input Serial in (SER). kemudian berikan HIGH pada clock shift register (SRCLK) sehingga sinyal pada serial in dikeluarkan ke output shift register. untuk memasukan data kembali set SRCLK menjadi HIGH kemudian baru masukan data kembali ke Serial in (SER). sinyal yang pertama kali masuk ke serial in akan menjadi output terakhir, yaitu Q7 dan sinyal yang terakhir di inputkan ke serial in akan menjadi output yang pertama yaitu Q0. hal ini disebabkan karena data pertama masuk terus akan digeser seiring dengan adanya input baru yang masuk ke serial in.

data yang sudah dikeluarkan oleh shift register masih ditahan oleh storage register. agar data tersebut bisa dikeluarkan menuju output Q0 sampai dengan Q7 maka clock storage register (RCLK) perlu diberikan sinyal HIGH dan Output Enable diberikan sinyal LOW. maka ouput akan menuju ke Q0 sampai Q7.

Penggunaan Aplikasi Shift Register

Mengapa kita perlu repot-repot menggunakan shift register ini. alasannya cukup sederhana, agar kita bisa menghemat ouput keluaran PORT sebuah kontroller misalkan mikrokontroller AVR, Arduino atau Raspberry PI, kita bisa mengeluarkan data ke 16 bit ouput paralel dengan dua shift register 74HC595 ini yang di cascade kan (disambung secara seri) dengan hanya membutuhkan input 4 pin yaitu serial in (SER), clock shift register(SRCLK), clock storage register (RCLK) dan reset (SRCLR). 

pada aplikasinya yang membutuhkan banyak output, biasanya digunakan pada Led Matriks, Display Seven Segment, Aplikasi yang menggerakan banyak lampu Led, dan lain sebagainya. semoga tulisan sedikit ini bisa memberikan pemahaman. terima kasih.

Drive Motor Servo dari GUI HTML pada Raspberry Pi

Pendahuluan

Untuk membuat aplikasi GUI di Raspberry Pi banyak macamnya, salah satunya bisa menggunakan Python, membuat GUI dengan Python menurut saya sendiri agak merepotkan pertama karena harus mempelajari hal yang baru, kedua tampilannya yang sedikit lebih kaku. agak berbeda jika kita membuat GUI dengan HTML scriptnya lebih mudah, tampilannya bisa dipermanis dengan CSS dan Javascript. Artikel ini dibuat sebagai tutorial membuat aplikasi GUI dari HTML untuk mentrigger script Python sebagai script yang dijalankan secara background dan mengembalikan nilai balik ke HTML.

Disini saya akan membuat Aplikasi dimana terdapat dua tombol untuk menggerakan motor Servo dan tampilan bar progress yang memperlihatkan nilai sebuah sensor. ya tentu saja untuk urusan GUI kita buat dengan menggunakan HTML dan Bootstrap agar tampilannya eyecatching. dan script Python bertugas sebagai pelaksana untuk mengerakan motor Servo dan mengambil nilai sebuah sensor.

perlu diketahui bahwa sebelum memulai, diperlukan web server nginx dan CGI dengan program uwsg, dimana terdapat pada artikel sebelumnya pada link http://www.plankton123.info/2018/10/install-web-server-nginx-baca-engine-x.html. web server dan CGI diperlukan agar script Python bisa berjalan dari Web Browser.

GUI HTML

Kita akan membuat GUI sederhana dengan HTML, membuat GUI dengan HTML sangatlah mudah, karena HTML merupakan script pemrograman berbasis Tag, sebagai contoh jika kita membuat tombol mempunyai tag button maka contohnya yaitu <button> Gerak Servo </button> 

untuk mempelajari GUI HTML bisa dipelajari terpisah dari artikel ini. baik langsung saja saya membuat GUI HTML sebagai berikut :

<!DOCTYPE html>
<html>
<head>
 <title>GUI HTML</title>
</head>
<body>

 <div style="margin-top: 100px; margin-left: 100px;">
  <button id="servoKanan">Servo >></button>  
 </div>

 
</body>
</html>

simpanlah script HTML diatas difolder baru pada folder web dengan nama index.html, jika di Raspberry Pi milik saya dengan web server nginx, maka folder webnya berada di /var/www/html/ kemudian buat folder baru yaitu guihtml. dan simpan file index.html tersebut di folder /var/www/html/guihtml/.

kemudian setting konfigurasi nginx agar supaya folder baru guihtml dapat dibuka, yaitu dengan mengedit file /etc/nginx/sites-available/defaut  dengan menambahkan location baru  dengan perintah

 location /guihtml {
     try_files $uri $uri/ =404;
 }

dan reset service nginx dengan perintah diterminal sudo service nginx restart dan buka di browser http://ip-raspberry-pi/guihtml dikomputer lain yang satu jaringan dengan raspberry Pi anda. sehingga ketika dibuka akan tampil seperti berikut ini :

Menggunakan Javascript

project ini tidak terlepas dari bantuan javascript, javascript disini menggunakan framework jquery dan ajax. jquery dibutuhkan oleh ajax dalam melakukan tugasnya yaitu merequest sebuah halaman web, mengirimkan data, dan mendapatkan nilai balik dari sebuah halaman yang direquest. dalam hal ini halaman yang direquest merupakan script Python untuk melakukan sesuatu, misalnya menggerakan motor Servo atau mengambil nilai sebuah sensor dan mengirimkan nilai balik ke ajax tersebut.

karena menggunakan jquery maka jquery bisa kamu dapatkan pada link  https://jquery.com/download/  , letakan jquery didalam folder baru yang sudah dibuat tadi (folder guihtml). kemudian tambahkan baris kode diatas tag </body> file index.html dengan baris kode berikut ini :

<script type="text/javascript" src="http://172.20.10.14/guihtml/jquery-3.3.1.min.js"></script>
<script type="text/javascript">
  
$('#servoKanan').click(function() {
  $.ajax({
   type:'get',
   url:'http://172.20.10.14/cgi-bin/servo.py?pulsa=4.5',
   success:function(data){
          alert (data);
       } 
   });
});
</script> 

kode diatas merupakan perintah untuk mendengarkan event klik button dengan id=servoKanan kemudian akan menjalankan ajax untuk melakukan request ke sebuah halaman script Python dengan nama servo.py dengan mengirimkan variable GET bernama pulsa bernilai '4.5'  kemudian nilai balikan dari hasil servo.py dikembalikan dalam bentuk parameter funtion (data) dan ditunjukan berupa alert javascript. jika terdapat alamat IP address diatas bisa diganti dengan alamat IP Address Raspberry Pi Anda sendiri, untuk mengetahui IP Address Raspberry Pi dapat melakukan ifconfig di terminal. berikut adalah kode lengkap untuk file index.html

<!DOCTYPE html>
<html>
<head>
 <title>GUI HTML</title>
</head>
<body>

 <div style="margin-top: 100px; margin-left: 100px;">
  <button id="servoKanan">Servo >></button>  
 </div>

 

 <script type="text/javascript" src="http://172.20.10.14/guihtml/jquery-3.3.1.min.js"></script>
 <script type="text/javascript">
  
  $('#servoKanan').click(function() {
    $.ajax({
         type:'get',
         url:'http://172.20.10.14/cgi-bin/servo.py?pulsa=4.5',
         success:function(data){
         alert (data);
         } 
      });
  });
 </script>

 
</body>
</html>

Servo.py (Script Python)

Dan terakhir kita akan membuat script Python dengan nama servo.py untuk menggerakan motor servo. seperti yang sudah pernah kalian ketahui bahwa motor servo digerakan dengan mengirimkan keluaran sinyal PWM (Pulse Width Modulation), oleh karena itu kita akan membuat keluaran sinyal PWM dengan duty cycle berupa data yang dikirimkan dari javascript menggunakan methode GET. berikut script Python yang sudah saya buat :

#!/usr/bin/env python

import RPi.GPIO as GPIO
import time
import cgi

form = cgi.FieldStorage()

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

GPIO.setup(18, GPIO.OUT)

pwm = GPIO.PWM(18, 50)

pulsa = form.getvalue('pulsa')
pwm.start(float(pulsa))

time.sleep(1)

pwm.stop()
GPIO.cleanup()

print "Content-type: text/html\n\n"
print form.getvalue('pulsa')

script Python diatas pertama-tama membuat keluaran sinyal PWM dengan frekuensi 50 Hz, duty cycle berupa data yang dikirimkan melalui GET dengan nama pulsa  di Pin 18 BCM GPIO Raspberry Pi. kemudian mengembalikan nilai data variable pulsa yang dikirimkan melalui GET sebelumnya.

sejak PWM yang dikeluarkan yaitu 50Hz, maka periodenya yaitu 20ms, karena servo bergerak sepanjang 0 - 180 derajat dengan lebar pulsa minimal 0.5ms sampai 2.5ms, maka perhitungan duty cyclenya yaitu :

 0.5ms = 0.5/20 x 100% = 2.5%

1.5ms = 1.5/20 x 100% = 7.5%

2.5ms = 2.5/20 x 100% = 12.5%

sehingga untuk duty cycle yang digunakan yaitu dari 2.5 sampai 12.5

script Python diatas disimpan di folder CGI, pada kasus saya sendiri, saya simpan pada /usr/lib/cgi-bin/servo.py

agar www-data (akses halaman web untuk pada linux) dapat menjalankankan GPIO maka, perlu kita setting permission agar www-data dapat mengakses GPIO. untuk melakukan itu yaitu dapat melakukan perintah

$ sudo usermod -a -G gpio www-data
$ sudo groups www-data

kemudian restart Raspberry Pi. lanjut untuk testing.

Testing

setelah semuanya sudah selesai kita bisa mencoba testing. sebelumnya letakan Servo pin data ke GPIO nomor 18 BCM. kemudian buka web browser dikomputer lain yang satu jaringan dengan Raspberry Pi dan ketikan di Address Bar http://ip-address-Raspberry-Pi/guihtml/ dalam kasus saya buka http://172.20.10.14/guihtml/ kemudian tekan button servo >> maka seharusnya motor servo gerak dengan duty cycle PWM 4.5 % dan pada halaman browser akan ada alert variable GET seperti berikut :

Simple Input Output GPIO

Pendahuluan

Pada project embeded system hal yang paling dasar adalah bagaimana menggunakan input-output pada pin-pin controller yang digunakan. dalam kasus Raspberry Pi yang digunakan sebagai controller maka GPIO (General Purpose Input Output) merupakan pin-pin output atau gerbang interface ke dunia luar. karena dalam Raspberry Pi salah satu bahasa pemrograman yang didukung adalah Python. maka dalam artikel ini kita batasi dengan menggunakan bahasa pemrograman Python.


Hal dasar yang perlu diketahui tentang level logic yaitu pada saat Raspberry Pi mengeluarkan data High atau logika '1' maka secara fisika mengeluarkan tegangan 3.3 Volt dan saat Raspberry Pi mengeluarkan data Low atau logika '0' maka secara real mengeluarkan tegangan 0 Volt. maka didapat disimpulkan bahwa Raspberry Pi memiliki level tegangan 3.3 Volt

Akses GPIO dari Python

Untuk mengakses GPIO dari Python maka salah satu hal yang diperlukan yaitu menginstall package bernama RPi.GPIO. RPi.GPIO merupakan package Python yang berisi class untuk mengontrol GPIO pada Raspberry Pi. menurut dokumentasi Python penggunaan package ini tidak cocok untuk aplikasi yang memerlukan waktu yang sangat presisi, mengingat kita tidak bisa memprediksi kapan Python akan melakukan garbage collecting. juga karena jalan di OS under Linux dimana priority process ditentukan oleh CPU itu sendiri. untuk menginstall package RPi.GPIO dapat dilakukan dengan perintah dibawah ini :

sudo pip install RPi.GPIO

setelah terinstall tanpa error, package RPi.GPIO siap digunakan pada script Python. untuk menggunakannya langkah-langkahnya yaitu : pertama kita perlu mengimport package RPi.GPIO dengan perintah import RPi.GPIO as gpio, kemudian ada dua mode yang memetakan pin-pin di GPIO, pertama yaitu mode BOARD dimana mode ini menamakan pin sesuai dengan angka yang tercetak pada GPIO Raspberry PI. dan yang kedua mode BCM mode ini menamakan pin sesuai dengan standar "Broadcom SOC Channel". untuk mengetahui nomor pin dapat digunakan perintah pinout pada terminal sehingga akan tampil seperti gambar berikut ini :

dapat dilihat pada gambar diatas, untuk mode BOARD menggunakan nomor yang didalam tanda kurung berwarna putih, sedangkan pada mode BCM menggunakan nomor setelah tulisan GPIO berwarna hijau. contoh, pada mode BOARD pin nomor 12 akan sama dengan mode BCM pin nomor 18. untuk mengatur mode dengan perintah gpio.setmode(gpio.BOARD) jika digunakan sebagai mode BOARD dan perintah gpio.setmode(gpio.BCM) jika digunakan sebagai mode BCM.

MODE OUTPUT

Setelah menentukan mode, kemudian menentukan mode input atau output pada pin tertentu. jika digunakan sebagai output maka perintahnya yaitu gpio.setup(pin_number, gpio.OUT) contoh gpio.setup(12, gpio.OUT). untuk mengeluarkan data HIGH dapat digunakan perintah gpio.output(pin_number, gpio.HIGH) contoh gpio.output(12, gpio.HIGH).

Sedangkan untuk mengeluarkan data low dengan perintah gpio.output(pin_number, gpio.LOW) contoh gpio.output(12, gpio.lOW). contoh berikut ini merupakan script untuk membuat blink led jika terhubung ke pin 12 mode BOARD.

import RPi.GPIO as gpio 
import time 

gpio.setmode(gpio.BOARD) 
gpio.setup(12, gpio.OUT) 

gpio.output(12, gpio.LOW) 
time.sleep(1) 
gpio.output(12, gpio.HIGH) 

gpio.cleanup()

untuk rangkaian LED ke pin GPIO perlu tambahan resistor untuk mengatur arus sebesar 15mA melalui LED. untuk mengetahui besaran berapa nilai resitor tersebut dapat digunakan hukum Ohm yaitu R = V / I, jika tegangan level logika HIGH adalah 3.3 V serta tegangan jatuh pada LED adalah 2.1 V dan I = 15mA maka nilai Resitor yang harus dipasaang yaitu 3.3 - 2.1/ 0.015 = 80 ohm.

MODE INPUT

untuk menset pin menjadi mode input, maka pada fungsi setup di gpio mempunyai tiga parameter yaitu pin number, gpio.IN dan pull_up_down=gpio.PUD_DOWN atau pull_up_down=gpio.PUD_UP. contoh gpio.setup(11, gpio.IN, pull_up_down=gpio.PUD_DOWN)

extra parameter atau parameter ketiga pada fungsi setup ini memberikan tambahan informasi bahwa perlu diaktifkan resistor pull up atau resistor pull down. jika diberikan pull_up_down= gpio.PUD_DOWN maka resistor pull down akan aktif sehingga dalam posisi ambang atau tidak ada masukan logika pin akan bernilai LOW.

jika diberikan pull_up_down=gpio.PUD_UP maka resistor pull up akan aktif, dan dalam posisi ambang atau tanpa masukan logika tegangan pin akan bernilai HIGH. untuk membaca nilai input dapat digunakan perintah gpio.INPUT(pin number) contoh gpio.INPUT(11). berikut ini adalah contoh penggunaan mode input pada GPIO.

import RPi.GPIO as gpio 
import time 

gpio.setmode(gpio.BOARD) 
gpio.setup(12, gpio.OUT) 
gpio.setup(11, gpio.IN, pull_up_down=gpio.PUD_DOWN) 

try:
   while True :
      if gpio.input(11) == gpio.HIGH :
         gpio.output(12, gpio.LOW)
      else :
         gpio.output(12, gpio.HIGH)

except KeyboardInterrupt:
  gpio.cleanup()

OUTPUT PWM (Pulse Width Modulation)

PWM atau pulse width modulation adalah teknik mengatur lebar pulsa atau duty cycle pada frekuensi yang tetap. sebagai contoh jika terdapat sebuah sinyal kotak-kotak dengan frekuensi 50 Hz yang berarti nilai periodenya yaitu 1 /50 = 0.02 sekon atau 20mS.  dengan mengatur lebar pulsa maka lebar HIGH-nya dapat berubah-rubah begitu juga lebar LOW-nya berubah-rubah, yang mana jika dijumlahkan nilainya harus tetap yaitu 20mS. 

modulasi lebar pulsa bisa digunakan untuk mengatur terang redup nyala lampu LED, mengatuh kecepatan motor DC, menentukan derajat perputaran motor servo dan lain sebagainya. 

setiap Pin I/O pada GPIO Raspberry Pi secara software dapat dijadikan output PWM dengan menggunakan package RPi.GPIO. untuk menggunakan sebagai PWM, pin perlu di setup sebagai output kemudian ditentukan nilai frekuensinya dan mengatur duty cycle awalan dalam satuan %, kemudian dapat mengubah duty cycle pada proses berikutnya  berikut adalah contoh script output PWM dengan duty cylce 5.5 % untuk awalan :

import RPi.GPIO as GPIO
import time

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

GPIO.setup(18, GPIO.OUT)

pwm = GPIO.PWM(18, 50)

pwm.start(5.5)
time.sleep(1)

pwm.ChangeDutyCycle(7.5)
time.sleep(1)


pwm.stop()
GPIO.cleanup()

dapat dilihat pada script di atas dimana mode yang digunakan BCM pin 18 sama dengan pin 12 mode BOARD, kemudian pin 18 dijadikan output, dan dibuat objek pwm dengan pin 18 sebagai output pwm dan frekuensi 50 Hz yaitu pada perintah pwm = GPIO.PWM(18, 50). dengan frekuensi 50 Hz maka periodenya yaitu 1/ 50 = 20ms/

kemudian dilanjutkan dengan menset duty cycle awal sebesar 5.5 % selama 1 detik dengan perintah pwm.start (5.5) time.sleep(1). duty cycle 5.5 % artinya memiliki Ton yaitu sebesar 5.5/100 * 20ms = 1.1 ms dan Toff sebesar 20ms - 1.1ms = 18.9ms. dilanjutkan dengan merubahnya ke nilai 7.5 % selama 1 detik dengan perintah pwm.ChangeDutyCycle(7.5) time.sleep(1). duty cycle 7.5 % artinya memliliki Ton = 7.5/100 * 20ms = 1.5ms dan Toff = 20ms - 1.5ms = 18.5ms

selanjutnya pwm berhenti dan mengembali pin-pin GPIO secara default. dengan perintah pwm.stop() GPIO.cleanup(). semoga artikel ini dapat bermanfaat bagi teman-teman. selamat bereksperimen :) .