Kontrol Kecepatan Kipas AC Dengan Kontrol Fuzzy

5 Votes

Fuzzy set pertama kali diperkenalkan oleh prof. Lotfi Zadeh pada tahun 1965 dalam papernya
yang berjudul “Fuzzy Set”. Dalam paper tersebut dipaparkan ide dasar fuzzy set yang meliputi
inclusion, union, intersection, complement, relation dan convexity. Ide tersebut terus
dimatangkan oleh Zadeh dengan paper-papernya yang diantaranya berjudul “Probability
Measures of Fuzzy Events”, “Decision-Making in a Fuzzy Environment”, “Similarity
Relations and Fuzzy Ordering” dan lain-lain. Pelopor aplikasi fuzzy set dalam bidang
kontrol yan merupakan aplikasi pertama dan utama dari fuzzy set adalah Prof. Ebrahim
Mamdani dan kawan-kawan dari Queen Mary College London. Aplikasinya meliputi proses
pada tangki pencampur dan mesin uap yang semuanya dalam skala lab. Penerapan kontrol
logika fuzzy secara nyata diindustri banyak dipelopori para ahli dari Jepang misalnya Prof.
Sugeno dan kawan-kawan dari Tokyo Institute of Technology, Prof. Yamakawa dari Kyusu
Institute of Technology melakukan penelitian dasar dari komputer fuzzy, sedangkan Togai
dan Watanabe dari Bell Telephne Labs berhasil menciptakan untuk pertama kalinya chip
logika fuzzy.

Begitulah sedikit pengantar tentang sejarah logika fuzzy dan pelopor penerapan logika fuzzy
dalam bidang kontrol. Dalam tulisan ini akan dibahas sedikit tentang contoh sederhana
penerapan logika fuzzy untuk pengontrolan kecepatan kipas angin dengan 2 parameter input
yaitu jumlah orang dalam ruangan dan suhu ruangan serta 1 parameter output yaitu PWM
kipas angin. Dalam aplikasi ini sensor yang digunakan untuk mencounter jumlah orang dalam
ruangan adalah dua pasang sensor IR yang diletakkan di pintu ruangan sedangkan untuk
mengukur suhu ruangan digunakan sensor LM35 yang memiliki tingkat kepresisian yang
lumayan bagus. Semua parameter tersebut diinputkan pada sebuah kontoler Atmega 16 dan
output dari kontoler di umpankan pada rangkaian switching solid state untuk mengatur
kecepatan dari kipas angin.

Dalam kontrol logika fuzzy terdapat beberapa tahapan yaitu Fuzzyfikasi, Fuzzy Rule (rule
based) dan Defuzzyfikasi. Fuzzyfikasi adalah proses untuk mendapatkan besarnya derajat
keanggotaan masukan yang berupa suatu variabel numerik non-fuzzy (elemen himpunan)
dalam suatu himpunan fuzzy atau dengan kata lain fuzzyfikasi adalah proses pengubahan
data-data numerik dari parameter input (sensor) menjadi data-data fuzzy untuk proses
pengolahan fuzzy lebih lanjut. Dalam hal ini proses fuzzyfikasi adalah bagaimana kita
menyajikan data-data numerik input yang bersifat riil pada suatu grafik fuzzy dengan sumbu-
x sebagai semesta pembicaraan dan sumbu-y sebagai derajat keanggotaan. Penentuan
keanggotan suatu himpunan fuzzy tidak dibatasi oleh aturan-aturan tertentu. Terdapat tiga
macam keanggotaan yang sering digunakan yaitu fungsi keangotaan S, π dan T (segitiga).
Dalam aplikasi ini proses fuzzyfikasi menggunakan fungsi keanggotaan T (segitiga) dengan
derajat keanggotaan max 100 dan semesta pembicaraan sesuai dengan nilai yang kita
inginkan. Berikut adalah fuzzyfikasi dari masukan kontrol diatas.
Sedangkan penerapan pada listing program sebagai berikut

//fuzzyfikasi jumlah orang

if(sigm<=5) //sigm=jumlah orang

{
sdk=100-(sigm*20); //sdk=sedikit
sdg=(sigm*20); //sdg=sedang
byk=0; //byk=banyak
fll=0; //fll=full
}
else if(sigm>5 && sigm<=10)
{
sdk=0;
sdg=200-(sigm*20);
byk=(sigm*20)-100;
fll=0;
}
else if(sigm>10 && sigm<=15)
{
sdk=0;
sdg=0;
byk=300-(sigm*20);
fll=(sigm*20)-200;
}
else
{
sdk=0;
sdg=0;
byk=0;
fll=100;
}
Sedangkan penerapan pada listing program sebagai berikut

//fuzzyfikasi suhu
if(tmp<=16) //tmp=temperatur terukur
{
sdgn=100; //sdgn=sangat dingin
dgn=0; //dgn=gingin
nrml=0; //nrml=normal
pns=0; //pns=panas
}
else if(tmp>16 && tmp<=24)
{
sdgn=300-((float)(tmp*25)/2);
dgn=((float)(tmp*25)/2)-200;
nrml=0;
pns=0;
}
else if(tmp>24 && tmp<=32)
{
sdgn=0;
dgn=400-((float)(tmp*25)/2);
nrml=((float)(tmp*25)/2)-300;
pns=0;
}
else if(tmp>32 && tmp<=40)
{
sdgn=0;
dgn=0;
nrml=500-((float)(tmp*25)/2);
pns=((float)(tmp*25)/2)-400;
}
else
{
sdgn=0;
dgn=0;
nrml=0;
pns=100;
}

sedangkan untuk penerapan membership function dari putaran kipas dalam listing program
disangkut pautkan dengan rule based dari kontrol fuzzy tersebut. Hal ini karena membership
function dari putaran kipas merupakan grafik fuzzy dari keluaran kontrol yang diharapkan
dari aturan fuzzy yang dibuat. Pada umumnya aturan-aturan/rule fuzzy dinyatakan dalam
bentuk “IF-THEN” Misalnya dalam dalam aturan fuzzy “jika kondisi suhu panas dan
jumlah orang sedang maka kecepatan kipas cepat”. Berikut adalah rule dari kontrol aplikasi
ini

DM=dianggap mati, P=pelan, S=sedang dan C=cepat

Sedangkan penerapan membership function dari putaran kipas pada listing program dalam
kaitannya dalam penerapan pada rule base sebagai berikut

//rule based
if(sdk<sdgn)
{ptr[0]=sdk;nilteng[0]=64;}
else
{ptr[0]=sdgn;nilteng[0]=64;}

if(sdk<dgn)
{ptr[1]=sdk;nilteng[1]=64;}
else
{ptr[1]=dgn;nilteng[1]=64;}

if(sdk<nrml)
{ptr[2]=sdk;nilteng[2]=128;}
else
{ptr[2]=nrml;nilteng[2]=128;}

if(sdk<pns)
{ptr[3]=sdk;nilteng[3]=192;}
else
{ptr[3]=pns;nilteng[3]=192;}

if(sdg<sdgn)
{ptr[4]=sdg;nilteng[4]=64;}
else
{ptr[4]=sdgn;nilteng[4]=64;}

if(sdg<dgn)
{ptr[5]=sdg;nilteng[5]=64;}
else
{ptr[5]=dgn;nilteng[5]=64;}

if(sdg<nrml)
{ptr[6]=sdg;nilteng[6]=128;}
else
{ptr[6]=nrml;nilteng[6]=128;}

if(sdg<pns)
{ptr[7]=sdg;nilteng[7]=255;}
else
{ptr[7]=pns;nilteng[7]=255;}

if(byk<sdgn)
{ptr[8]=byk;nilteng[8]=64;}
else
{ptr[8]=sdgn;nilteng[8]=64;}

if(byk<dgn)
{ptr[9]=byk;nilteng[9]=64;}
else
{ptr[9]=dgn;nilteng[9]=64;}

if(byk<nrml)
{ptr[10]=byk;nilteng[10]=192;}
else
{ptr[10]=nrml;nilteng[10]=192;}

if(byk<pns)
{ptr[11]=byk;nilteng[11]=255;}
else
{ptr[11]=pns;nilteng[11]=255;}

if(fll<sdgn)
{ptr[12]=fll;nilteng[12]=64;}
else
{ptr[12]=sdgn;nilteng[12]=64;}

if(fll<dgn)
{ptr[13]=fll;nilteng[13]=128;}
else
{ptr[13]=dgn;nilteng[13]=128;}

if(fll<nrml)
{ptr[14]=fll;nilteng[14]=192;}
else
{ptr[14]=nrml;nilteng[14]=192;}

if(fll<pns)
{ptr[15]=fll;nilteng[15]=255;}
else
{ptr[15]=pns;nilteng[15]=255;}

ket:

ptr[ ]=adalah variabel untuk menampung nilai derajat keanggotaan dari input yang diambil
nilai derajat keanggotaan terkecil. Variabel ini dibentuk dalam format array.

nilteng[ ]=adalah nilai titik tengah dari grafik fuzzyfikasi putaran kipas angin yang
merupakan implementasi dari rule. Misalnya jika suhu panas dan jumlah orang sedang maka
putaran kipas angin berdasarkan rule adalah cepat dengan nilteng=255.

Sedangkan tahap terakhir dalam kontrol logika fuzzy adalah defuzzyfikasi. Defuzzyfikasi
adalah proses pengubahan data-data fuzzy menjadi data-data numerik yang dapat dikirimkan
ke alat pengendalian. Dalam aplikasi ini proses defuzzyfikasi menggunakan metode Center
Of Area (COA) yang memiliki rumus

Sedangkan listing program untuk proses defuzzyfikasi dari aplikasi ini sebagai berikut

jml_nil=ptr[0]+ptr[1]+ptr[2]+ptr[3]+ptr[4]+ptr[5]+ptr[6]+ptr[7]+ptr[8]+ptr[9]+ptr[10]+ptr[11]+ptr[12]+ptr[13]+ptr[14]+ptr[15];
jml_nilteng=(ptr[0]*nilteng[0])+(ptr[1]*nilteng[1])+(ptr[2]*nilteng[2])+(ptr[3]*nilteng[3])+(ptr[4]*nilteng[4])+
(ptr[5]*nilteng[5])+(ptr[6]*nilteng[6])+(ptr[7]*nilteng[7])+(ptr[8]*nilteng[8])+(ptr[9]*nilteng[9])+(ptr[10]*nilt
eng[10])+(ptr[11]*nilteng[11])+(ptr[12]*nilteng[12])+(ptr[13]*nilteng[13])+(ptr[14]*nilteng[14])+(ptr[15]*nilt
eng[15]);

//defuzzyfikasi
if(jml_nil==0)
{
coa=0;
}
else
{
coa=jml_nilteng/jml_nil;
}

nah nilai coa diatas adalah nilai output dari kontrol logika fuzzy yang nantinya nilai ini
ditransfer pada perangkat pengendalian.

ref:

 Son Kuswadi “Kendali Cerdas Teori dan Aplikasi Praktisnya”

 zalbud ” TA Kontrol Kecepatan Kipas AC berbasis Fuzzy Logic”

1. Q : mengapa rumusnya berbeda antara fuzzifikasi orang dan suhu?

A : Rumusnya berbeda karena yang menjadi acuan bukanlah rumus itu sendiri tapi mencari
nilai membership function.

fuzzifikasi orang –> mengacu pada grafik membership function yang segitiga sedikit dan
sedang.

if(sigm<=5) //sigm=jumlah orang

{
sdk=100-(sigm*20); //sdk=sedikit
sdg=(sigm*20); //sdg=sedang
byk=0; //byk=banyak
fll=0; //fll=full
}

untuk perhitungannya misal jumlah orang 2 orang maka berdasar pada grafik nilai
membership function:
grafik sedikit : 60
grafik sedang : 40
banyak : 0
full : 0

kalau dengan rumusnya dari program :

sdk = 100-(2 orang*20) = 60
sdg = 2 orang * 20 = 40
byk = 0
fll = 0

fuzzyfikasi temperature –> mengacu pada grafik membership function yang segitiga sangat
dingin dan dingin

if(tmp>16 && tmp<=24)

{
sdgn=300-((float)(tmp*25)/2);
dgn=((float)(tmp*25)/2)-200;
nrml=0;
pns=0;
}

untuk perhitungannya misal temperature 20 maka berdasar pada grafik nilai membership
function:
sangat dingin : 50
dingin : 50
normal : 0
panas : 0

kalau dengan rumusnya dari program :

sdgn = 300-((float)(20*25)/2) = 50
dgn=((float)(20*25)/2)-200 = 50
nrml=0
pns=0

Intinya rumus tersebut tidak baku asal sesuai dengan nilai membership function nya.

2. Q : Kenapa tidak lgsung " if orang is sdk and suhu is sdgn then kipas is DM"?
A : sebenarnya memang begitu tetapi logika tersebut harus diartikan dalam logika fuzzy
sebagaimana yang dijelaskan diatas.

Dalam mengevaluasi rule base/ fuzzy fire, nilai dari dua variable dibandingkan terlebih
dahulu sesuai rule base dan nilai membership function yang diambil adalah nilai terkecil.

Dengan mengacu pada grafik putaran kipas dan rule base itu sendiri dimisalkan jumlah orang
sedikit (2 orang) dan suhu sangat dingin (20 derajat) maka putaran kipas adalah dianggap
mati.

mengartikan secara fuzzy nya sbb:

MF sedikit = 60
MF sangat dingin = 50
Maka nilai yang diambil adalah yang 50 dan nilai tengah dari Dianggap mati adalah 64. maka
programnya sbb:

if(sdk<sdgn)
{ptr[0]=sdk;nilteng[0]=64;}
else
{ptr[0]=sdgn;nilteng[0]=64;}

 aslkum, permisi tanya: bagaimana cara penulisan main program-nya (while (1) )
pak,mohon pencerahannya. terima kasih

Main program yang diproses berulang-ulang adalah yang proses pembacaan sensor
atau input, pemanggilan rutin dari proses fuzzy dan pengaturan out put dari proses itu
sendiri.

Misalnya (semua proses dibuat dalam rutin) :

Input –> sensor1, sensor2.
proses fuzzy –> fuzzifikasi, rule dan defuzzifikasi
output –> output1

jadi dalam program utama yang diproses berulang-ulang adalah

While(1)
{
sensor1();
sensor2();
fuzzyfikasi();
rule();
defuzzifikasi();
output1();
}

Kalau maksudnya nilai sumbu x atau yang dikenal dengan semesta pembicaraan maka
alangkah baiknya menggunakan nilai hasil konversi dari sensor yang berupa data
dapat yang kita kenal sehingga jika terjadi masalah kita dengan mudah men-trace
kesalahannya dimana. misalnya sensor suhu –> data digital adc = 101111 dan misal
 jika dikonversi ke suhu adalah 33 derajat maka tentu kita akan lebih mudah membaca
33 derajat daripada 101111.

void fuzzifikasi_quad() //fuzzifikasi

{
NE=0;
ME=0;
PE=0;

ND=0;
MD=0;
PD=0;

NI=0;
MI=0;
PI=0;

//==========================================
//Error
//==========================================
if((XERROR=-10))
{

NE = 1; //=========1
equ_aktif_0 = 1;//NE;
equ_aktif_1 = 1;//NE;
}
else if((XERROR=-0.2))
{

NE = (-5)*XERROR; //=========2
ME = ((10)*XERROR)+1; //=========3
equ_aktif_0 = 1;//NE;
equ_aktif_1 = 2;//ME;
}
else if((XERROR=0))
{

ME = ((-10)*XERROR)+1;//=========4
PE = ((5)*XERROR);//=========5
equ_aktif_0 = 2;//ME;
equ_aktif_1 = 3;//PE;
}
else if((XERROR=0.2))
{
PE=1;//=========6
equ_aktif_0 = 3;//PE;
equ_aktif_1 = 3;//PE;
}

//==========================================
//DIFERENTIAL
//==========================================
if((XDIFFERENTIAL=-20))
{

ND = 1; //=========1
equ_aktif_2 = 4;//ND;
equ_aktif_3 = 4;//ND;
}
else if((XDIFFERENTIAL=-1))
{

ND = ((-1.333)*XDIFFERENTIAL)-0.333; //=========2
MD = XDIFFERENTIAL+1; //=========3
equ_aktif_2 = 4;//ND;
equ_aktif_3 = 5;//MD;
}
else if((XDIFFERENTIAL=0))
{

MD = ((-1)*XDIFFERENTIAL)+1;//=========4
PD = ((1.333)*XDIFFERENTIAL)-0.333;//=========5
equ_aktif_2 = 5;//MD;
equ_aktif_3 = 6;//PD;
}
else if((XDIFFERENTIAL=1))
{
PD=1;//=========6
equ_aktif_2 = 6;//PD;
equ_aktif_3 = 6;//PD;
}

//==========================================
//INTEGRAL
//==========================================
if((XINTEGRAL=-20))
{

NI = 1; //=========1
equ_aktif_4 = 7;//NI;
equ_aktif_5 = 7;//NI;
}
else if((XINTEGRAL=-0.8))
{
NI = ((-1.666)*XINTEGRAL)-0.333; //=========2
MI = ((1.538)*XINTEGRAL)+1; //=========3
equ_aktif_4 = 7;//NI;
equ_aktif_5 = 8;//MI;
}
else if((XINTEGRAL=0))
{

MI = ((-1.538)*XINTEGRAL)+1;//=========4
PI = XINTEGRAL;//=========5
equ_aktif_4 = 8;//MI;
equ_aktif_5 = 9;//PI;
}
else if((XINTEGRAL=1))
{
PI=1;//=========6
equ_aktif_4 = 9;//PI;
equ_aktif_5 = 9;//PI;
}

void inferensi_mamdani_or_sugeno_model()
{
NB=NS=Z=PS=PB=0;

if( ((equ_aktif_0==1)||(equ_aktif_1 ==1)) && ((equ_aktif_2 ==4)||(equ_aktif_3==4)) &&

((equ_aktif_4 ==7)||(equ_aktif_5 ==7))) //=======1 NE-ND-NI => PB
{
//CONJUCTION
if((NE< ND) &&(NE ND) &&(NE>NI))
{
PB = ND;
PB = NI;
}
//CONJUCTION
else if((ND< NE) &&(ND NE) &&(ND>NI))
{
PB = NE;
PB = NI;
}
//CONJUCTION
else if((NI< ND) &&(NIND) &&(NI>NE))
{
PB = ND;
PB = NE;
}

if( ((equ_aktif_0==1)||(equ_aktif_1 ==1)) && ((equ_aktif_2 ==4)||(equ_aktif_3==4)) &&

((equ_aktif_4 = 8)||(equ_aktif_5 = 8))) //=======2 ND-NE-MI => PB
{
//CONJUCTION
if((ND < NE)&&(ND PB)
{
PB = ND;
}
}
else if ((ND > NE)&&(ND>MI))
{
//DISJUNCTION
if((NE > PB) && (MI > PB))
{
PB= NE;
PB= MI;
}
}

//CONJUCTION
else if((NE < ND)&&(NE PB)
{
PB = NE;
}
}
else if ((NE > ND)&&(NE>MI))
{
//DISJUNCTION
if((ND > PB) && (MI > PB))
{
PB= ND;
PB= MI;
}
}

//CONJUCTION
else if((MI < ND)&&(MI PB)
{
PB = MI;
}
}
else if ((MI > ND)&&(MI>NE))
{
//DISJUNCTION
if((ND > PB) && (NE > PB))
{
PB= ND;
PB= NE;
}
}

}
Mas, saya kan make 3 input satu output untuk fuzzynya. Dari syntaks di atas, saya coba buat
contoh rule base sebanyak 2 dulu pada void inferensi_mamdani_or_sugeno_model(). Saya
mau nanya mas, benar gak penulisan dari bentuk syntaks rule base di atas klo di tulis di avr
dimana inputnya ada 3 dan otputnya ada 1?
Mohon pencerahannya ya gan.
Tks banyak.. :)
catatan: output yg ditulis dari kedua rule base di atas adalah PB.

ensor SHT11

4 Votes

SHT11 adalah sensor digital untuk temperatur sekaligus kelembapan pertama didunia yang
diklaim oleh pabrik pembuatnya yaitu Sensirion Corp yang mempunyai kisaran pengukuran
dari 0-100% RH dan akurasi RH absolut +/- 3% RH. Sedangkan akurasi pengukuran
temperatur +/- 0.4oC pada suhu 25 oC. Modul sensor ini sudah memiliki keluaran digital dan
sudah terkalibrasi, jadi pengguna tidak perlu lagi melakukan konversi A/D ataupun kalibrasi
data sensor. Antarmuka modul ini adalah serial 2-wire (bukan I2C) sehingga sangat
menghemat jalur I/O kontroler.

Dalam tulisan ini akan dibahas cara menghubungkan modul SHT11 dengan rangkaian sistem
minimum dan berikut ulasan tentang programnya menggunakan bahasa c. Hubungan antara
modul SHT11 dengan sistem mikrokontroler Atmega8535 sebagai berikut:

*pin ini tidak mutlak dan dapat diganti dengan pin lain tetapi program juga harus disesuaikan

PA.0 digunakan untuk membaca dan menulis data dari/ke modul SHT11. Sedangkan PA.1
digunakan untuk menghasilkan pulsa (clock) untuk sinkronisasi proses komunikasi 2-wire.
Dalam permintaan pengukuran temperatur dan kelembapan secara teknis sama hanya
perbedaannya terletak nilai byte permintaan pengukuran yaitu nilai byte=0x03 untuk
temperatur dan nilai byte=0x05 untuk kelembapan. Diagram alir program untuk meminta
modul SHT11 melakukan pegukuran temperatur serta membaca hasil pengukuran sebagai
berikut :
Dari flowchart diatas, pembacaan suhu dimulai dengan mengirim sinyal start untuk memulai
komunikasi serial 2-wire. Setelah itu program mengirim 0x03 ke SHT11 yang merupakan
perintah untuk memulai pengukuran suhu. Rutin SHTWriteByte (0x03) akan memberikan
nilai ACK yang disimpan dalam variabel AckBit. Jika variabel AckBit bernilai 0, maka
program akan menunggu selesainya pengukuran SHT11 dengan memanggil rutin SHTWait().
Rutin SHTWait() akan memberikan suatu nilai yang kemudian disimpan pada variabel
TimeOut. Variabel TimeOut akan bernilai 0 jika pengukuran SHT11 selesai dan data siap.
Setelah pengukuran selesai, data suhu akan dibaca MSB dulu kemudian LSB. Pembacaan
data MSB dilakukan dengan memberi nilai variabel AckBit = 0, sedangkan pembacaan data
LSB dilakukan dengan memberi nilai variabel AckBit = 1. berikut potongan listing program
pembacaan suhu
void SHTReadTemp (void)
{
StartSignal();
SHTWriteByte(0x03); //Command Measure Temperature
if (AckBit==0)
{
SHTWait(); //Tunggu sampai pengukuran selesai
if (TimeOut==0)
{
AckBit=0; //Kirim ACK untuk menerima byte berikutnya
SHTReadByte(); // Ambli Byte MSB
DataTempSHT = DataRead;
DataTempSHT <<= 8;
AckBit=1; //Kirim NACK untuk mengakhiri pengambilan data
SHTReadByte(); //Ambil byte LSB
DataTempSHT |= DataRead;
DataRead = DataTempSHT;
}
}
}

untuk mendapatkan nilai temperatur dan kelembapan, data hasil pembacaan SHT11 perlu
dikonversi terlebih dahulu sebelum ditampilkan di LCD yaitu dengan rumus:

RH=(DataRead* x 0.0405) – (DataRead* x DataRead* x 0.0000028)-4;

Temp=(DataRead* – 4000)/100;

*DataRead adalah data hasil pembacaan sensor SHT11

TUNING KONTROLER PID LINE FOLLOWER

Tunning kontrol PID ini bertujuan untuk menentukan paramater aksi kontrol Proportional,
Integratif, Derivatif pada robot line follower. Proses ini dapat dilakukan dengan cara trial and
error . Keunggulan cara ini kita gak perlu mengidentifikasi plant, membuat model matematis
plant, menentukan parameter plant dengan grafis ataupun analitis…cukup dengan cara coba-
coba memberikan konstanta P-I-D pada formula PID hingga di peroleh hasil yang di
inginkan, dengan mengacu pada karakteristik masing-masing kontrol P-I-D.

Nach kalo kita menggunakan kendali PID artinya kita nantinya bertujuan mengolah suatu
sinyal kesalahan atau error, nilai error tersebut diolah dengan formula PID untuk dijadikan
suatu sinyal kendali atau sinyal kontrol yang akan diteruskan ke aktuator. Gampangnya
perhatikan saja blok diagram umpan balik loop tertutup pada perancangan kedali PID pada
robot line follower berikut ini:

Dari blok diagram diatas dapat q jelasin sebagai berikut

1. SP = Set point, secara simple maksudnya ialah suatu prameter nilai acuan atau nilai
yang kita inginkan.
2. PV = Present Value, kalo yang ini maksudnya ialah nilai bobot pembacaan sensor saat
itu atau variabel terukur yang di umpan balikan oleh sensor (sinyal feedback dari
sensor).
3. Error = nilai kesalahan, nach kalo yang ini pengertiannya ialah Deviasi atau
simpangan antar variabel terukur atau bobot sensor (PV) dengan nilai acuan (SP)

Setelah memahami alur pengendalian PID nach berikut ilustrasi pemberian bobot sensor
(nilai kesalahan pembacaan sensor) pada robot line follower:

Dari blok iliustrasi tersebut dapat q jelasin sebagai berikut:

Proses pemberian bobot sensor dapat dilakukan dengan proses pemetaan (mapping)
pembacaan sensor terhadap garis, berikut salah satu sample proses mapping sensor:

11111110 (PV=-7)

11111000 (PV=-6)

11111100 (PV=-6)
 11111101 (PV=-5)

11110001 (PV=-4)

11111001 (PV=-4)

11111011 (PV=-3)

11100011 (PV=-2)

11110011 (PV=-2)

11110111 (PV=-1)

11100111 (PV=0)

11101111 (PV=1)

11000111 (PV=2)

11001111 (PV=2)

11011111 (PV=3)

10001111 (PV=4)

10011111 (PV=4)

10111111 (PV=5)

00011111 (PV=6)

00111111 (PV=6)

01111111 (PV=7)

11111111 (PV=8 / -8)

Kondisi ideal robot terjadi saat kondisi robot pada PV= 0 (misal kondisi nilai sensor =
11100111, nilai 0 merepresentasikan sensor mengenai garis). Atau SP = 0 ialah kondisi ideal
dari robot line follower. Jika PV tidak sama dengan 0 berarti robot tidak berada pada kondisi
ideal dan artinya ada sinyal kesalahan (error). Pada kondisi error inilah formula PID akan
menentukan hasil sinyal kendalinya. Nach berikut ini penjelasan tentang penerapan PID pada
robot line follower:

Proporsional kontrol

Kondisi ideal pada robot adalah bergerak maju lurus mengikuti garis, dengan kata lain PV =
0 (nilai sensor = 11100111). Dari sini dapat diasumsikan bahwa Set Point (SP) / kondisi ideal
adalah saat SP = 0. Nilai sensor yang dibaca oleh sensor disebut Process Variable (PV) / nilai
aktual pembacaan. Menyimpangnya posisi robot dari garis disebut sebagai error (e), yang
didapat dari e = SP – PV. Dengan mengetahui besar error, mikrokontroler dapat memberikan
nilai PWM motor kiri dan kanan yang sesuai agar dapat menuju ke posisi ideal (SP = 0).
Besarnaya nilai PWM ini dapat diperoleh dengan menggunakan kontrol Proporsional (P),
dimana P = e Kp (Kp adalah konstanta proporsional yang nilainya di set sendiri dari hasil
tuning).

Saat Sensor = 11111111 nilai PV dapat ditentukan dengan cara membandingkan kondisi PV
sebelumnya, jika PV lebih besar dari 0, maka nilai PV dapat diasumsikan 30 dan jika PV
kurang dari 0, maka nilai PV dapat diasumsikan -30 atau dengan cara menyimpan nilai error
yang lalu.

Dalam pemrograman robot line follower ini kodenya ditulis secara sederhana seperti berikut:

If Sensor = &B11111111 Then

If Pv < 0 Then : Pv = -30

End If

If Pv > 0 Then : Pv = 30

End If

End If

Perhitungan Kontroler Proporsional

Sp_sensor = 0 ‘setpoint sensor

Error = Sp_sensor – Pv ‘nilai error

P = Kp * Error ‘proporsional kontrol

Aplikasi kontrol proporsional pada PWM ialah sebagai berikut:

Pwm = Sp_kecepatan + P ‘motor kiri

Pwm = Sp_kecepatan – P ‘motor kanan

Derivatif kontrol

Jika pergerakan robot masih terlihat bergelombang, bisa ditambahkan kontrol Derivatif (D).
Kontrol D digunakan untuk mengukur seberapa cepat robot bergerak dari kiri ke kanan atau
dari kanan ke kiri. Semakin cepat bergerak dari satu sisi ke sisi lainnya, maka semakin besar
nilai D. Konstanta D (Kd) digunakan untuk menambah atau mengurangi imbas dari derivatif.
Dengan mendapatkan nilai Kd yang tepat pergerakan sisi ke sisi yang bergelombang akibat
dari kontrol proporsional bisa diminimalisasi. Nilai D didapat dari D = Kd/Ts * rate, dimana
Ts ialah time sampling atau waktu cuplik dan rate = e(n) – e(n-1). Dalam program nilai error
(SP – PV) saat itu menjadi nilai last_error, sehingga rate didapat dari error – last_error. Untuk
menambahkan kontrol D, program dimodifikasi menjadi:

Perhitungan Kontroler Proporsional + Derivatif

Sp_sensor = 0 ‘setpoint sensor

Error = Sp_sensor – Pv ‘nilai error

P = Kp * Error ‘proporsional kontrol

D1 = Kd * 10 ‘derivatif kontrol

D2 = D1 / Ts

D3 = Error – Last_error ‘rate

D = D2 * D3

Last_error = Error ‘error lampau

Pd = P + D ‘proporsional-derivatif kontrol

Aplikasi kontrol proporsional dan drivatif pada PWM ialah sebagai berikut:

Pwm = Sp_kecepatan + Pd ‘motor kiri

Pwm = Sp_kecepatan – Pd ‘motor kanan

Integratif kontrol

Jika dengan P + D sudah membuat pergerakan robot cukup smooth, maka penambahan
Integratif menjadi opsional. Jika ingin mencoba-coba bisa ditambahakan Integratif (I). I
digunakan untuk mengakumulasi error dan mengetahui durasi error. Dengan menjumlahkan
error disetiap pembacaan PV akan memberikan akumulasi offset yang harus diperbaiki
sebelumnya. Saat robot bergerak menjauhi garis, maka nilai error akan bertambah. Semakin
lama tidak mendapatkan SP, maka semakin besar nilai I. Degan mendapatkan nilai Ki yang
tepat, imbas dari Integratif bisa dikurangi. Nilai akumulasi error didapat dari: error +
last_error. Untuk menambahkan kontrol I, maka program di modifikasi menjadi:

Perhitungan Kontroler Proporsional + Integratif + Derivatif

Sp_sensor = 0 ‘setpoint sensor

Error = Sp_sensor – Pv ‘nilai error

P = Kp * Error ‘proporsional kontrol

D1 = Kd * 10 ‘derivatif kontrol
D2 = D1 / Ts

D3 = Error – Last_error ‘rate

D = D2 * D3

I1 = Ki / 10 ‘integratif kontrol

I2 = Error + Last_error ‘akumulasi error

I3 = I1 * I2

I = I3 * Ts

Last_error = Error ‘error lampau

Pd = P + D ‘proporsional-derivatif kontrol

Pid = Pd+I ‘proporsional-integratif-derivatif

Aplikasi kontrol proporsional, integratif dan drivatif pada PWM ialah sebagai berikut:

Pwm = Sp_kecepatan + Pid ‘motor kiri

Pwm = Sp_kecepatan – Pid ‘motor kanan

Parameter Nilai Konstanta Kontroler P I D

Nilai konstanta perhitungan PID di tuning secara trial and error, proses ini dilakukan dengan
metode mencoba-coba (eksperimental) nilai proporsional, derivatif dan integratif pada
formula PID hingga ditemukan hasil sistem yag stabil, adapun cara yang dilakukan untuk
mentuning PID pada robot line follower ialah sebagai berikut:

1. Langkah awal gunakan kontrol proporsional terlebih dahulu, abaikan konstanta

integratif dan derivatifnya dengan memberikan nilai nol pada integratif dan derivatif.
2. Tambahkan terus konstanta proporsional maksimum hingga keadaan stabil namun
robot masih berosilasi.
3. Untuk meredam osilasi, tambahkan konstanta derivatif dengan membagi dua nilai
proporsional, amati keadaan sistem robot hingga stabil dan lebih responsif.
4. Jika sistem robot telah stabil, kontrol integratif dapat menjadi opsional, dalam artian
jika ingin mencoba-coba tambahkan kontrol integratif tersebut, namun pemberian
nilai integratif yang tidak tepat dapat membuat sistem robot menjadi tidak stabil.
5. Nilai set point kecepatan dan nilai batas bawah/atas memberikan patokan kecepatan
robot.
6. Nilai time sampling (waktu cuplik) juga mempengaruhi perhitungan PID, tentunnya
saat penggunaan kontrol integratif dan derivatif.
7. Periksa kembali perfoma sistem hingga mendapatkan hasil yang memuaskan.

Acuan penentuan parameter Kp, Ki dan Kd dapat diadopsi dari watak dari kontroler
itu masing seperti yang dijelaskan pada tabel berikut ini:
Simulasi PID Parameter : klik here

Dan berikut ini sample coding PID line followerku dengan pemrograman BASCOM
AVR :

$regfile = “m8535.dat”
$crystal = 12000000
$eeprom

‘—————————inisialisasi pwm————————————
Config Timer1 = Pwm , Pwm = 10 , Prescale = 64 , Compare A Pwm = Clear Down ,
Compare B Pwm = Clear Down ‘pwm dengan settingan fast pwm 10 bit

‘—————————inisialisasi adc————————————
Config Adc = Single , Prescaler = Auto

‘—————————inisialisasi lcd————————————
Config Lcdpin = Pin , Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portc.6 , Db7 = Portc.7 , E =
Portc.2 , Rs = Portc.0
Config Lcd = 16 * 2 : Cursor Off

‘——————————————————————————-
‘PENDEFINISIAN PIN MIKRO
‘——————————————————————————-
Config Portd = Output

‘alias logika motor

M1a Alias Portd.0
M1b Alias Portd.1
M2a Alias Portd.2
M2b Alias Portd.3

Config Portb = Input

Portb = 255
‘alias tombol
Sw_ok Alias Pinb.3
Sw_cancel Alias Pinb.2
Sw_down Alias Pinb.1
Sw_up Alias Pinb.0

Config Portc.3 = Output

‘——————————————————————————-
‘DEKLARASI VARIABEL
‘——————————————————————————-
Dim B1 As Bit , B2 As Bit , B3 As Bit , B4 As Bit , B5 As Bit , B6 As Bit , B7 As Bit , B8
As Bit,
Dim S1 As Byte , S2 As Byte , S3 As Byte , S4 As Byte , S5 As Byte , S6 As Byte , S7 As
Byte , S8 As Byte
Dim Adc1 As Integer , Adc2 As Integer , Adc3 As Integer , Adc4 As Integer , Adc5 As
Integer , Adc6 As Integer , Adc7 As Integer , Adc8 As Integer,
Dim S12 As Byte , S123 As Byte , S1234 As Byte , S12345 As Byte , S123456 As Byte ,
S1234567 As Byte , S12345678 As Byte
Dim C As Byte
Dim B As Byte
Dim Sensor As Byte
Dim Konversi_sensor As Byte
Dim Data1 As Byte
Dim Menu As Byte

‘——————————-declarasi variabel——————————
‘variabel eeprom
Dim Kp_eprom As Eram Integer
Dim Ki_eprom As Eram Integer
Dim Kd_eprom As Eram Integer
Dim Ts_eprom As Eram Integer
Dim Sp_kecepatan_eprom As Eram Integer
Dim Up_eprom As Eram Integer
Dim Lp_eprom As Eram Integer
Dim Nos_eprom As Eram Integer
Dim Hold_eprom As Eram Integer

Dim Kp As Integer
Dim Ki As Integer
Dim Kd As Integer
Dim Ts As Integer
Dim Sp_sensor As Integer
Dim Sp_kecepatan As Integer
Dim Up As Integer
Dim Lp As Integer
Dim Nos As Integer
Dim Hold As Integer

Dim Error As Integer

Dim Last_error As Integer
Dim Pv As Integer
Dim P As Integer
Dim Pd As Integer
Dim Pid As Integer
Dim Pwm As Integer
Dim I1 As Integer
Dim I2 As Integer
Dim I3 As Integer
Dim I As Integer

Dim D1 As Integer
Dim D2 As Integer
Dim D3 As Integer
Dim D As Integer

Dim N1 As Integer
Dim N2 As Integer

‘——————————————————————————-
‘DEKLARASI SUBRUTIN
‘——————————————————————————-

Declare Sub Baca_sensor()

Declare Sub Kiri_maju()
Declare Sub Kanan_maju()
Declare Sub Kiri_mundur()
Declare Sub Kanan_mundur()
Declare Sub Bantingkanan()
Declare Sub Bantingkiri()

Portc.3 = 0 ‘lcd on

Cls : Home
Lcd “ADC LINEfollower”
Waitms 500
Lowerline
Lcd “Fahmizal_dte2006″
Waitms 1500

Portc.3 = 1 ‘lcd off

Menu_utama:
Cls
Home : Lcd “‘menu'<<<<^>>>>>”
Lowerline
Lcd “Please choice…”
Do
If Sw_up = 0 Then : Waitms 250 : Menu = 1
End If
If Sw_down = 0 Then : Waitms 250 : Menu = 2
End If

If Menu = 1 Then : Locate 2 , 1 : Lcd “Setting ROBOT…”

If Sw_ok = 0 Then : Waitms 250 : Gosub Setting_pid : End If
End If
If Menu = 2 Then : Locate 2 , 1 : Lcd “Go……..Ready?”
If Sw_ok = 0 Then : Waitms 250 : Gosub Go : End If
End If
Loop

‘——————————-menu Konstanta PID——————————

Setting_pid:
Cls
Menu_kp:
Do

Kp = Kp_eprom
If Sw_up = 0 Then : Incr Kp : Waitms 10
End If
If Sw_down = 0 Then : Decr Kp : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_ki

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_utama
End If

If Kp > 50 Then : Kp = 0 : Waitms 10

End If
If Kp < 0 Then : Kp = 50 : Waitms 10
End If

Home : Lcd “Tuning PID ^–^ “ : Locate 2 , 1 : Lcd “KP:” : Locate 2 , 4 : Lcd ” “:
Locate 2 , 4 : Lcd Kp : Waitms 100

Kp_eprom = Kp
Loop

‘———————————————

Menu_ki:
Do

Ki = Ki_eprom
If Sw_up = 0 Then : Incr Ki : Waitms 10
End If
If Sw_down = 0 Then : Decr Ki : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_kd

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_kp
End If
If Ki > 20 Then : Ki = 0 : Waitms 10
End If
If Ki < 0 Then : Ki = 20 : Waitms 10
End If

Home : Lcd “Tuning PID ^–^ “ : Locate 2 , 1 : Lcd “KI:” : Locate 2 , 4 : Lcd ” “:
Locate 2 , 4 : Lcd Ki : Waitms 100

Ki_eprom = Ki
Loop

‘———————————————

Menu_kd:
Do

Kd = Kd_eprom
If Sw_up = 0 Then : Kd = Kd + 5 : Waitms 10
End If
If Sw_down = 0 Then : Kd = Kd – 5 : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_ts

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_ki
End If

If Kd > 150 Then : Kd = 0 : Waitms 10

End If
If Kd < 0 Then : Kd = 150 : Waitms 10
End If

Home : Lcd “Tuning PID ^–^ “ : Locate 2 , 1 : Lcd “KD:” : Locate 2 , 4 : Lcd ” “:
Locate 2 , 4 : Lcd Kd : Waitms 100

Kd_eprom = Kd

Loop

‘———————————————

Menu_ts:
Do

Ts = Ts_eprom
If Sw_up = 0 Then : Ts = Ts + 5 : Waitms 10
End If
If Sw_down = 0 Then : Ts = Ts – 5 : Waitms 10
End If
If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_sp_kecepatan
End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_kd
End If

If Ts > 20 Then : Ts = 0 : Waitms 10

End If
If Ts < 0 Then : Ts = 20 : Waitms 10
End If

Home : Lcd “TimeSampling(ms)” : Locate 2 , 1 : Lcd “TS:” : Locate 2 , 4 : Lcd ” “:

Locate 2 , 4 : Lcd Ts : Waitms 100

Ts_eprom = Ts

Loop

‘———————————————

Menu_sp_kecepatan:
Do

Sp_kecepatan = Sp_kecepatan_eprom
If Sw_up = 0 Then : Sp_kecepatan = Sp_kecepatan + 50 : Waitms 10
End If
If Sw_down = 0 Then : Sp_kecepatan = Sp_kecepatan – 50 : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_up

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_ts
End If

If Sp_kecepatan > 600 Then : Sp_kecepatan = 400 : Waitms 5

End If
If Sp_kecepatan < 400 Then : Sp_kecepatan = 600 : Waitms 5
End If

Home : Lcd “Set Point ^–^ “ : Locate 2 , 1 : Lcd “kecepatan:” : Locate 2 , 11 : Lcd ” “:
Locate 2 , 11 : Lcd Sp_kecepatan : Waitms 100

Sp_kecepatan_eprom = Sp_kecepatan

Loop

‘———————————————
Menu_up:
Do
Up = Up_eprom
If Sw_up = 0 Then : Up = Up + 50 : Waitms 10
End If
If Sw_down = 0 Then : Up = Up – 50 : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_nos

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_sp_kecepatan
End If

If Up > 1000 Then : Up = 700 : Waitms 10

End If
If Up < 700 Then : Up = 1000 : Waitms 10
End If

Home : Lcd “TOP speed ROBOT “ : Locate 2 , 1 : Lcd “top:” : Locate 2 , 5 : Lcd ” “:
Locate 2 , 5 : Lcd Up : Waitms 100

Up_eprom = Up

Loop

‘———————————————
Menu_nos:
Do

Nos = Nos_eprom
If Sw_up = 0 Then : Nos = Nos + 100 : Waitms 10
End If
If Sw_down = 0 Then : Nos = Nos -100 : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Menu_hold:

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_up
End If

If Nos > 500 Then : Nos = 100 : Waitms 10

End If
If Nos < 100 Then : Nos = 500 : Waitms 10
End If

Home : Lcd “POWER ^–^ ROBOT” : Locate 2 , 1 : Lcd “start:” : Locate 2 , 7 : Lcd ” “
: Locate 2 , 7 : Lcd Nos : Waitms 100

Nos_eprom = Nos

Loop
‘——————————————————————————-
Menu_hold:
Do

Hold = Hold_eprom
If Sw_up = 0 Then : Hold = Hold + 5 : Waitms 10
End If
If Sw_down = 0 Then : Hold = Hold – 5 : Waitms 10
End If

If Sw_ok = 0 Then : Waitms 250 : Gosub Rampung_setting:

End If
If Sw_cancel = 0 Then : Waitms 250 : Gosub Menu_nos
End If

If Hold > 75 Then : Hold = 25 : Waitms 10

End If
If Hold < 25 Then : Hold = 75 : Waitms 10
End If

Home : Lcd “TressHold^SENSOR” : Locate 2 , 1 : Lcd “hold:” : Locate 2 , 6 : Lcd ” “

: Locate 2 , 6 : Lcd Hold : Waitms 100

Hold_eprom = Hold

Loop
‘——————————————————————————-

‘——————————-tampilansaveepprom——————————
Rampung_setting:

Cls
Locate 1 , 1 : Lcd “Write’_to_EEPROM”
Locate 2 , 1 : Lcd “=” : Waitms 200
Locate 2 , 2 : Lcd “=” : Waitms 180
Locate 2 , 3 : Lcd “=” : Waitms 155
Locate 2 , 4 : Lcd “=” : Waitms 125
Locate 2 , 5 : Lcd “=” : Waitms 90
Locate 2 , 6 : Lcd “=” : Waitms 70
Locate 2 , 7 : Lcd “=” : Waitms 50
Locate 2 , 8 : Lcd “=” : Waitms 35
Locate 2 , 9 : Lcd “=” : Waitms 20
Locate 2 , 10 : Lcd “=” : Waitms 15
Locate 2 , 11 : Lcd “=” : Waitms 13
Locate 2 , 12 : Lcd “=” : Waitms 11
Locate 2 , 13 : Lcd “=” : Waitms 9
Locate 2 , 14 : Lcd “=” : Waitms 7
Locate 2 , 15 : Lcd “=” : Waitms 5
Locate 2 , 16 : Lcd “=” : Waitms 300
Locate 2 , 1 : Lcd “writesucsesfully“ : Waitms 500 : Gosub Go:
‘——————————————————————————-
Go:

Kp = Kp_eprom
Ki = Ki_eprom
Kd = Kd_eprom
Ts = Ts_eprom
Sp_kecepatan = Sp_kecepatan_eprom
Up = Up_eprom
Nos = Nos_eprom
Hold = Hold_eprom

Portc.3 = 0 ‘lcd on
Cls
Locate 2 , 5 : Lcd “Ready..!!”
Locate 1 , 8 : Lcd “-“ : Waitms 150
Locate 1 , 8 : Lcd “3” : Waitms 150
Locate 1 , 8 : Lcd “2” : Waitms 150
Locate 1 , 8 : Lcd “1” : Waitms 150
Locate 1 , 8 : Lcd “-“ : Waitms 150
Cls : Locate 2 , 7 : Lcd “GO…” : Waitms 200 : Cls

Do

Portc.3 = 1 ‘lcd off

Call Baca_sensor()

Sensor = Konversi_sensor

If Sensor = &B00000001 Then : Pv = 20 : End If

If Sensor = &B00000010 Then : Pv = 11 : End If
If Sensor = &B00000100 Then : Pv = 5 : End If
If Sensor = &B00001000 Then : Pv = 0 : End If
If Sensor = &B00010000 Then : Pv = 0 : End If
If Sensor = &B00100000 Then : Pv = -5 : End If
If Sensor = &B01000000 Then : Pv = -11 : End If
If Sensor = &B10000000 Then : Pv = -20 : End If

If Sensor = &B00000011 Then : Pv = 16 : End If

If Sensor = &B00000110 Then : Pv = 8 : End If
If Sensor = &B00001100 Then : Pv = 2 : End If
If Sensor = &B00011000 Then : Pv = 0 : End If
If Sensor = &B00110000 Then : Pv = -2 : End If
If Sensor = &B01100000 Then : Pv = -8 : End If
If Sensor = &B11000000 Then : Pv = -16 : End If

If Sensor = &B00000111 Then : Pv = 12 : End If

If Sensor = &B00001110 Then : Pv = 6 : End If
If Sensor = &B00011100 Then : Pv = 3 : End If
If Sensor = &B00111000 Then : Pv = -3 : End If
If Sensor = &B01110000 Then : Pv = -6 : End If
If Sensor = &B11100000 Then : Pv = -12 : End If

If Sensor = &B00001111 Then : Pv = 8 : End If

If Sensor = &B00011110 Then : Pv = 2 : End If
If Sensor = &B00111100 Then : Pv = 0 : End If
If Sensor = &B01111000 Then : Pv = -2 : End If
If Sensor = &B11110000 Then : Pv = -8 : End If

If Sensor = &B00000000 Then

Portc.3 = 0 ‘lcd on
If Pv < -10 Then : Pv = -30 : Nos = Up / 2
End If
If Pv > 10 Then : Pv = 30 : Nos = Up / 2
End If
End If

If Pv < 0 Then
N1 = Up / 2
N2 = Nos / 3
Nos = N1 + N2
End If

If Pv > 0 Then
N1 = Up / 2
N2 = Nos / 3
Nos = N1 + N2
End If

‘setpoint sensor
Sp_sensor = 0
‘nilai error
Error = Sp_sensor – Pv
‘proportional control
P = Kp * Error

‘integrativ control

I1 = Error + Last_error
I2 = I1 / 2
I = Ki * I2

‘derivative control
D1 = Kd * 10
D2 = Error – Last_error
D = D1 * D2

‘error lampau
Last_error = Error
‘proportional-derivative control
Pd = P + D

‘proportional-integrativ-derivative control
Pid = Pd + I

‘===== Hitung Kondisi Pertama=============’sebelah kiri

Pwm = Sp_kecepatan + Pid
If Pwm > 0 Then : Call Kiri_maju() : Locate 2 , 7 : Lcd “F” : End If
If Pwm > Up Then : Pwm = Up : End If
If Pwm < 0 Then : Call Kiri_mundur() : Pwm = 0 – Pwm : Locate 2 , 7 : Lcd “R” : End If
If Pv = 0 Then : Pwm = Nos : If Nos < Up Then : Nos = Nos + 25 : End If : End If
Pwm1a = Pwm

‘=====Hitung Kondisi Kedua===============’sebelah kanan

Pwm = Sp_kecepatan – Pid
If Pwm > 0 Then : Call Kanan_maju() : Locate 2 , 16 : Lcd “F” : End If
If Pwm > Up Then : Pwm = Up : End If
If Pwm < 0 Then : Call Kanan_mundur() : Pwm = 0 – Pwm : Locate 2 , 16 : Lcd “R” : End If
If Pv = 0 Then : Pwm = Nos : If Nos < Up Then : Nos = Nos + 25 : End If : End If
Pwm1b = Pwm

Locate 2 , 1 : Lcd “L:” : Locate 2 , 3 : Lcd ” “ : Locate 2 , 3 : Lcd Pwm1a : Locate 2 , 10 :

Lcd “R:” : Locate 2 , 12 : Lcd ” “ : Locate 2 , 12 : Lcd Pwm1b
Locate 1 , 11 : Lcd “PV:” : Locate 1 , 14 : Lcd ” “ : Locate 1 , 14 : Lcd Pv

‘selang waktu cuplik

Waitms Ts ‘time sampling
Loop
End

Sub Baca_sensor()
Start Adc
Adc1 = Getadc(0) : Adc1 = Adc1 / 5
Adc2 = Getadc(1) : Adc2 = Adc2 / 5
Adc3 = Getadc(2) : Adc3 = Adc3 / 5
Adc4 = Getadc(3) : Adc4 = Adc4 / 5
Adc5 = Getadc(4) : Adc5 = Adc5 / 5
Adc6 = Getadc(5) : Adc6 = Adc6 / 5
Adc7 = Getadc(6) : Adc7 = Adc7 / 5
Adc8 = Getadc(7) : Adc8 = Adc8 / 5
If Adc1 < Hold Then : S1 = &B00000000 : B1 = 0 : End If : If Adc1 > Hold Then : S1 =
&B00000001 : B1 = 1 : End If
If Adc2 < Hold Then : S2 = &B00000000 : B2 = 0 : End If : If Adc2 > Hold Then : S2 =
&B00000010 : B2 = 1 : End If
If Adc3 < Hold Then : S3 = &B00000000 : B3 = 0 : End If : If Adc3 > Hold Then : S3 =
&B00000100 : B3 = 1 : End If
If Adc4 < Hold Then : S4 = &B00000000 : B4 = 0 : End If : If Adc4 > Hold Then : S4 =
&B00001000 : B4 = 1 : End If
If Adc5 < Hold Then : S5 = &B00000000 : B5 = 0 : End If : If Adc5 > Hold Then : S5 =
&B00010000 : B5 = 1 : End If
If Adc6 < Hold Then : S6 = &B00000000 : B6 = 0 : End If : If Adc6 > Hold Then : S6 =
&B00100000 : B6 = 1 : End If
If Adc7 < Hold Then : S7 = &B00000000 : B7 = 0 : End If : If Adc7 > Hold Then : S7 =
&B01000000 : B7 = 1 : End If
If Adc8 < 120 Then : S8 = &B00000000 : B8 = 0 : End If : If Adc8 > 120 Then : S8 =
&B10000000 : B8 = 1 : End If
S12 = S1 Or S2 : S123 = S12 Or S3 : S1234 = S123 Or S4 : S12345 = S1234 Or S5 :
S123456 = S12345 Or S6 : S1234567 = S123456 Or S7 : S12345678 = S1234567 Or S8
Konversi_sensor = S12345678 And &B11111111
Locate 1 , 1 : Lcd “s”
Locate 1 , 2 : Lcd B1
Locate 1 , 3 : Lcd B2
Locate 1 , 4 : Lcd B3
Locate 1 , 5 : Lcd B4
Locate 1 , 6 : Lcd B5
Locate 1 , 7 : Lcd B6
Locate 1 , 8 : Lcd B7
Locate 1 , 9 : Lcd B8
End Sub

Sub Kiri_maju()
Reset M2a
Set M2b
End Sub

Sub Kanan_maju()
Reset M1a
Set M1b
End Sub

Sub Kiri_mundur()
Set M2a
Reset M2b
End Sub

Sub Kanan_mundur()
Set M1a
Reset M1b
End Sub

===============================================================

Dan berikut ini sample coding PID line followerku dengan pemrograman
CODEVISION AVR :

#include<mega8535.h>
#include <delay.h>
#define sensor PINB
//===pwm motor alias
#define motor_ki OCR1A //sip
#define motor_ka OCR1B

#define m1a PORTD.0

#define m1b PORTD.1
#define m2a PORTD.2
#define m2b PORTD.3

void maju ()
{
m1a=1;m1b=0;
m2a=0;m2b=1;
}

void rem_kanan ()
{
m1a=0;m1b=1;
m2a=0;m2b=1;
}

void rem_kiri ()
{
m1a=1;m1b=0;
m2a=1;m2b=0;
}

//===Tombol Yang Digunakan======

#define sw_ok PINC.3
#define sw_cancel PINC.2
#define sw_down PINC.1
#define sw_up PINC.0

#asm
.equ __lcd_port=0x1B ;PORTA
#endasm
#include <lcd.h>
#include <stdio.h>

//====Variabel di eeprom=====
eeprom int Kp = 0;
eeprom int Ki = 0;
eeprom int Kd = 0;
eeprom int Ts= 0;
eeprom int Upper= 0;
eeprom int Lower= 0;
eeprom int Set_point=0;
//====Nilai-nilai eror=======
eeprom int e0= 0;
eeprom int e1 = 0;
eeprom int e2 = 0;
eeprom int e3 = 0;
eeprom int e4 = 0;
eeprom int e5 = 0;
eeprom int e6 = 0;
eeprom int e7 = 0;

int error,error1,nil_pid,pwm,kode;
char lcd_buff[33];

void seting_awal ()
{
set:
Kp=Kp;
if(sw_up==0){Kp++;delay_ms(10);}
if(sw_down==0){Kp=Kp-1;delay_ms(10);}
if(Kp>100){Kp=0;delay_ms(10);}
if(Kp<0){Kp=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“***************”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Nilai Kp:%i”,Kp);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0)
{
delay_ms(150);goto set1;
}
else goto set;
//====================================
set1:
Ki=Ki;
if(sw_up==0) {Ki++;delay_ms(10);}
if(sw_down==0) {Ki=Ki-1;delay_ms(10);}
if(Ki>100){Ki=0;delay_ms(10);}
if(Ki<0) {Ki=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“***************”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Nilai Ki:%i.%i”,Ki/10,Ki%10);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set2;}
if(sw_cancel==0){delay_ms(150);goto set;}
else
goto set1;
//======================================
set2:
Kd=Kd;
if(sw_up==0) {Kd++;delay_ms(10);}
if(sw_down==0) {Kd=Kd-1;delay_ms(10);}
if(Kd>100){Kd=0;delay_ms(10);}
if(Kd<0) {Kd=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“***************”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Nilai Kd:%i”,Kd);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set3;}
if(sw_cancel==0){delay_ms(150);goto set1;}
else
goto set2;
//========================================
set3:
Ts=Ts;
if(sw_up==0) {Ts++;delay_ms(10);}
if(sw_down==0) {Ts=Ts-1;delay_ms(10);}
if(Ts>100){Ts=0;delay_ms(10);}
if(Ts<0) {Ts=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Time Sampling”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Delay:%ims”,Ts);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set4;}
if(sw_cancel==0){delay_ms(150);goto set2;}
else
goto set3;
//=============================================
set4:
Ts=Ts;
if(sw_up==0) {Set_point++;delay_ms(10);}
if(sw_down==0) {Set_point=Set_point-1;delay_ms(10);}
if(Set_point>255){Set_point=0;delay_ms(10);}
if(Set_point<0) {Set_point=255;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Set Point”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Kec:%i”,Set_point);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set5;}
if(sw_cancel==0){delay_ms(150);goto set3;}
else
goto set4;
//=================================================
set5:
Upper=Upper;
if(sw_up==0) {Upper++;delay_ms(10);}
if(sw_down==0) {Upper=Upper-1;delay_ms(10);}
if(Upper>255){Upper=0;delay_ms(10);}
if(Upper<0) {Upper=255;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Limit Speed”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Upper:%i”,Upper);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set6;}
if(sw_cancel==0){delay_ms(150);goto set4;}
else
goto set5;
//====================================================
set6:
Lower=Lower;
if(sw_up==0) {Lower++;delay_ms(10);}
if(sw_down==0) {Lower=Lower-1;delay_ms(10);}
if(Lower>255){Lower=0;delay_ms(10);}
if(Lower<0) {Lower=255;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Limit Speed”);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”Lower:%i”,Lower);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set7;}
if(sw_cancel==0){delay_ms(150);goto set5;}
else
goto set6;

//========Menampilkan Eror-Eror===============
set7:
e0=e0;
if(sw_up==0) {e0++;delay_ms(10);}
if(sw_down==0) {e0=e0-1;delay_ms(10);}
if(e0>100){e0=0;delay_ms(10);}
if(e0<0) {e0=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 0″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e0:%i”,e0);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set8;}
if(sw_cancel==0){delay_ms(150);goto set6;}
else
goto set7;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set8:
e1=e1;
if(sw_up==0) {e1++;delay_ms(10);}
if(sw_down==0) {e1=e1-1;delay_ms(10);}
if(e1>100){e1=0;delay_ms(10);}
if(e1<0) {e1=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 1″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e1:%i”,e1);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set9;}
if(sw_cancel==0){delay_ms(150);goto set7;}
else
goto set8;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set9:
e2=e2;
if(sw_up==0) {e2++;delay_ms(10);}
if(sw_down==0) {e2=e2-1;delay_ms(10);}
if(e2>100){e2=0;delay_ms(10);}
if(e2<0) {e2=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 2″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e2:%i”,e2);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set10;}
if(sw_cancel==0){delay_ms(150);goto set8;}
else
goto set9;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set10:
e3=e3;
if(sw_up==0) {e3++;delay_ms(10);}
if(sw_down==0) {e3=e3-1;delay_ms(10);}
if(e3>100){e3=0;delay_ms(10);}
if(e3<0) {e3=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 3″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e3:%i”,e3);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set11;}
if(sw_cancel==0){delay_ms(150);goto set9;}
else
goto set10;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set11:
e4=e4;
if(sw_up==0) {e4++;delay_ms(10);}
if(sw_down==0) {e4=e4-1;delay_ms(10);}
if(e4>100){e4=0;delay_ms(10);}
if(e4<0) {e4=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 4″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e4:%i”,e4);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set12;}
if(sw_cancel==0){delay_ms(150);goto set10;}
else
goto set11;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set12:
e5=e5;
if(sw_up==0) {e5++;delay_ms(10);}
if(sw_down==0) {e5=e5-1;delay_ms(10);}
if(e5>100){e5=0;delay_ms(10);}
if(e5<0) {e5=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 5″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e5:%i”,e5);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set13;}
if(sw_cancel==0){delay_ms(150);goto set11;}
else
goto set12;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set13:
e6=e6;
if(sw_up==0) {e6++;delay_ms(10);}
if(sw_down==0) {e6=e6-1;delay_ms(10);}
if(e6>100){e6=0;delay_ms(10);}
if(e6<0) {e6=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 6″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e6:%i”,e6);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto set14;}
if(sw_cancel==0){delay_ms(150);goto set12;}
else
goto set13;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
//========Menampilkan Eror-Eror===============
set14:
e7=e7;
if(sw_up==0) {e7++;delay_ms(10);}
if(sw_down==0) {e7=e7-1;delay_ms(10);}
if(e7>100){e7=0;delay_ms(10);}
if(e7<0) {e7=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Error 7″);
lcd_gotoxy(0,1);
sprintf(lcd_buff,”e7:%i”,e7);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto Magelang;}
if(sw_cancel==0){delay_ms(150);goto set13;}
else
goto set14;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
Magelang:
lcd_clear();
lcd_gotoxy(1,0);
lcd_putsf(” Save To EEPROM”);
delay_ms(200);
Kp=Kp;Ki=Ki;Kd=Kd;Ts=Ts;Set_point=Set_point;Lower=Lower;Upper=Upper;
e0=e0;e1=e1;e2=e2;e3=e3;e4=e4;e5=e5;e6=e6;e7=e7;

}
void tampilan_awal()
{
lcd_gotoxy(0,0);
lcd_putsf(” C_Tools__! “);
delay_ms(1000);
lcd_gotoxy(6,1);
lcd_putsf(“Present “);
delay_ms(1000);
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“Fahmizal_DTE_UGM”);
delay_ms(500);
lcd_gotoxy(0,1);
lcd_putsf(” Line Follower “);
delay_ms(1000);
lcd_clear();
}

//=====Perlihatkan Sensor=========
//#define sensor PINA
#define s0 PINB.0
#define s1 PINB.1
#define s2 PINB.2
#define s3 PINB.3
#define s4 PINB.4
#define s5 PINB.5
#define s6 PINB.6
#define s7 PINB.7

void show_sensor()
{
lcd_gotoxy(2,1);
if (s7) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s6) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s5) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s4) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s3) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s2) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s1) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
if (s0) lcd_putchar(‘1’);
else lcd_putchar(‘0’);
}
//=====Tutup Perlihatkan Sensor====
void PID ()
{
//***hitam=mati/0 & putih=nyala/1

//=====sensor mengarah ke Kiri

if (sensor==0b11101110) {error=e0;}
else if (sensor==0b11001110) {error=-e1;}
else if (sensor==0b11011110) {error=-e2;}
else if (sensor==0b10011110) {error=-e3;}
else if (sensor==0b10111110) {error=-e4;}
else if (sensor==0b00111110) {error=-e5;}
else if (sensor==0b01111110) {error=-e6;kode=12;}

//=====sensor mengarah ke Kanan

else if (sensor==0b11101110) {error=e0;}
else if (sensor==0b11100110) {error=e1;}
else if (sensor==0b11110110) {error=e2;}
else if (sensor==0b11110010) {error=e3;}
else if (sensor==0b11111010) {error=e4;}
else if (sensor==0b11111000) {error=e5;}
else if (sensor==0b11111100) {error=e6;kode=24;}

else if (sensor==0b11111110)//di putih semua

{
if (kode==12)
{
error=-e7;
rem_kiri();
delay_ms(20);
}
else if (kode==24)
{
error=e7;
rem_kanan();
delay_ms(20);
}
}

maju();
nil_pid=((Kp*error)+((Ki/10)*(error+error1)*Ts)+((Kd/Ts)*(error-error1)));
error1=error;

//===== Hitung Kondisi Pertama=============

pwm=Set_point-(nil_pid);
if(pwm>Upper){pwm=Upper;}
if(pwm<Lower){pwm=Lower;}
motor_ka=pwm;
//=====Hitung Kondisi Kedua===============
pwm=Set_point+(nil_pid);
if(pwm>Upper){pwm=Upper;}
if(pwm<Lower){pwm=Lower;}
motor_ki=pwm;
//kode=0;
delay_ms(Ts);
}

void show_detail()
{
lcd_gotoxy(0,0);
sprintf(lcd_buff,”e:%i”,error);
lcd_puts(lcd_buff);
lcd_gotoxy(5,0);
sprintf(lcd_buff,”Ki%i”,motor_ki);
lcd_puts(lcd_buff);
lcd_gotoxy(11,0);
sprintf(lcd_buff,”Ka%i”,motor_ka);
lcd_puts(lcd_buff);
}
void inisialisasi_port()
{
//===Seting untuk sensor============
DDRB=0b00000000;
PORTB=0b11111111;
//===Seting untuk fungsi Tombol======
DDRC=0x00;
PORTC=0xff;
//===Seting motor====================
DDRD=0xff;
PORTD=0x00;
//——-inisialisasi PWM—–//
TCCR1A=0xA3;
TCCR1B=0x0B;
TCNT1=0x0000;//PWM 16 bit//
OCR1A=0x3FF;
OCR1B=0x3FF;
TIFR=0;

}
void main(void)
{
inisialisasi_port();
lcd_init(16);
lcd_clear();
tampilan_awal();
seting_awal();
while(1)
{
lcd_clear();
PID();
show_sensor();
kode=0;
show_detail();
delay_ms(Ts);
}
}

https://fahmizaleeits.wordpress.com/2010/08/24/tuning-kontrol-pid-pada-robot-line-
follower/#comment-7582

Pengaturan Kecepatan Motor Dc Dengan

Mikrokontroler [open-loop]
Posted Juli 27, 2010 by Fahmizal in Kuliah Kontrol, Mikrokontroler. Tagged: aplikasi pwm
Atmega 8535, kendali motor dc, kontrol kecepatan motor dc dengan bascom, mengatur duty
cycle, Pengaturan Kecepatan Motor Dc, Pengaturan Kecepatan Motor Dc Berbasis
Atmega8535, Pengaturan Kecepatan Motor Dc Dengan Mikrokontroler, PWM (Pulse Width
Modulation) adalah, PWM Atmega8535, PWM Bascom AVR, PWM berbasis
mikrokontorler, PWM pada motor dc. 85 Komentar

18 Votes

Penggunaan motor DC dewasa ini sudah sangatlah umum, salah satu kelebihan motor DC
adalah relatif gampang didapat dan mudah diatur kecepatan putarnya. Secara umum
pengaturan kecepatan motor DC adalah dengan menggunakan cara analog. Pada artikel kali
ini akan dibahas contoh cara mengatur kecepatan motor DC dengan menggunakan
mikrokontroller.

Mikrokontroler yang digunakan adalah Tipe AVR dari Atmel seperti mikrokontroler Atmega
8535, 16, 32. Informasi kecepatan motor akan ditampilkan pada modul LCD HD4480.
Sedangkan sebagai driver motor menggunakan modul driver motor IC L298.

Cara pengaturan kecepatan yang digunakan adalah dengan menggunakan teknik PWM
(Pulse Width Modulation), salah satu teknik untuk mengatur kecepatan motor DC yang
umum digunakan. Dengan menggunakan PWM kita dapat mengatur kecepatan yang
diinginkan dengan mudah. Teknik PWM untuk pengaturan kecepatan motor adalah,
pengaturan kecepatan motor dengan cara merubah-rubah besarnya duty cycle pulsa. Pulsa
yang yang berubah ubah duty cycle-nya inilah yang menentukan kecepatan motor. Besarnya
amplitudo dan frekuensi pulsa adalah tetap, sedangkan besarnya duty cycle berubah-ubah
sesuai dengan kecepatan yang diinginkan, semakin besar duty cylce maka semakin cepat pula
kecepatan motor, dan sebaliknya semakin kecil duty cycle maka semakin pelan pula
kecepatan motor. Sebagai contoh bentuk pulsa yang dikirimkan adalah seperti pada gambar 1,
pulsa kotak dengan duty cycle pulsa 50%. Sedangkan sebagai contoh bentuk pulsa PWM
adalah seperti pada gambar 2.

Gambar 1

Gambar 2

Seperti pada gambar 1, semakin besar duty cycle pulsa kotak, maka semakin lama pula posisi
logika high. Jika motor diatur agar berjalan ketika diberi logika high, maka jika memberi
pulsa seperti pada gambar 1 diatas, maka motor akan berada pada kondisi “nyala-mati-nyala-
mati” sesuai dengan bentuk pulsa tersesebut. Semakin lama motor berada pada kondisi
“nyala” maka semakin cepat pula kecepatan motor tersebut. Motor akan berputar dengan
kecepatan maksimum jika mendapat pulsa dengan duty cycle 100%. Dengan kata lain motor
mendapat logika high terus menerus.

Dengan mengatur besarnya duty cycle pulsa kotak yang dikirimkan, kita dapat mengatur
banyaknya logika high yang diberikan pada motor, dengan kata lain mengatur lamanya waktu
motor untuk berputar dalam satu periode pulsa. Jika lamanya waktu motor untuk berputar
dalam satu periode pulsa ini berubah maka kecepatan purtaran motor juga akan berubah,
sesuai dengan duty cycle atau waktu motor untuk berputar dalam satu periode pulsa.

Sumber :http://delta-electronic.com/article/wp-content/uploads/2008/09/an0082.pdf

===============================================================

PENGATURAN KECEPATAN MOTOR DC Berbasis Atmega8535

Skema dengan proteus:

Hasil simulasi dengan proteus:

Program Pengaturan Kecepatan Motor DC dengan Bascom AVR

$regfile = “m8535.dat” ‘menggunakan Atmega8535 sebagai

preprosesor

$crystal = 12000000 ‘menggunakan crystal clock 12 MHz

$eeprom ‘menggunakan fasilitas eeprom

Atmega8535

‘—————————inisialisasi lcd————————————

Config Lcdpin = Pin , Db4 = Portc.4 , Db5 = Portc.5 , Db6 = Portc.6 , Db7 = Portc.7 , E =
Portc.2 , Rs = Portc.0

Config Lcd = 16 * 2 : Cursor Off

‘—————————inisialisasi pwm———————————–

Config Timer1 = Pwm , Pwm = 10 , Prescale = 64 , Compare A Pwm = Clear Up , Compare

B Pwm = Clear Up ‘pwm dengan settingan fast pwm 10 bit

‘—————————inisialisasi port——————————–

‘inisialisasi tombol

Config Portb = Input

‘—————————pull up internal——————————–

Portb.0 = 1

Portb.1 = 1

Portb.2 = 1

Portb.3 = 1

Config Portd = Output

‘alias logika motor

M1a Alias Portd.0

M1b Alias Portd.1

M2a Alias Portd.2

M2b Alias Portd.3

‘——————————alias——————————————–

‘alias tombol

Sw_ok Alias Pinb.3

Sw_cancel Alias Pinb.2

Sw_down Alias Pinb.1

Sw_up Alias Pinb.0

‘——————————————————————————-

Dim Pwm As Integer

Dim Pwm_eprom As Eram Integer

Home

Lcd “Fahmizal_dte2006″

Lowerline

Lcd “Cek fungsi PWM”

Wait 1

Do

Pwm = Pwm_eprom

If Sw_up = 0 Then : Incr Pwm : Waitms 10

End If

If Sw_down = 0 Then : Decr Pwm : Waitms 10

End If

If Pwm > 1023 Then : Pwm = 0 : Waitms 10

End If

If Pwm < 0 Then : Pwm = 1023 : Waitms 10

End If

Pwm_eprom = Pwm
Cls

Home

Lcd “tes uji pwm”

Lowerline

Reset M1a

Reset M2a

Set M1b

Set M2b

Pwm1a = Pwm

Pwm1b = Pwm

Lcd “nilai pwm:” ; Pwm1a : Waitms 100

Loop

End

nach berikut hasil video pengaturan sinyal PWM nya ^_^

===============================================================

bacaan terkait di blog ini:

1. mudah-belajar-mikro-dengan-simulasi-program-proteus klik disini

2. aplikasi-pwm-mikrokontroler-atmega8535 klik disini

Aplikasi PWM Mikrokontroler ATmega8535

Posted Mei 1, 2010 by Fahmizal in Mikrokontroler. Tagged: aplikasi pwm Atmega 8535,
program pwm atmega, PWM Atmega8535, PWM Bascom AVR. 31 Komentar
9 Votes

PWM (Pulse Width Modulation) Atmega8535

PWM (Pulse Width Modulation) atau modulasi lebar pulsa adalah salah satu keunggulan
Timer/Counter yangterdapat pada Atmega8535. Ketiga jenis Timer/Counter pada
Atmega8535 dapat menghasilkan pulsa PWM. Pulsa PWM adalah sederetan pulsa yang lebar
pulsanya dapat diatur. Pulsa PWM berfungsi mengatur kecepatan motor DC, mengatur gelap
terang LED dan aplikasi lainnya. PWM adalah Timer mode Output Compare yang canggih.
Mode PWM Timer juga dapat mencacah turun yang berlawanan dengan mode Timer lainnya
yang hanya mencacah naik. Pada mode PWM tersebut, Timer mencacah naik hingga
mencapai nilai TOP, yaitu 0xFF (255) untuk PWM 8 bit dan 0x3FF (1023) untuk PWM 10
bit. Timer/Counter 0 hanya memiliki PWM 8 bit, sedangkan pada Timer/Counter 1 memiliki
9 bit dan PWM 10 bit, dan Timer/Counter 2 memiliki PWM 8 bit.

Pemilihan mode PWM diseting melalui bit COM01 dan bit COM00 pada register TCCR.
Saat COM00 clear dan COM01 set, pin OC0 clear sat timer mencacah diatas Compare
Match dan pin OC0 set saat timer mencacah dibawah Compare Match atau non-inverting
PWM. Kebalikannya, saat COM00 set dan COM01 juga set, maka pin OC0 set saat timer
mencacah dibawah Compare Match atau disebut juga inverting PWM. Agar lebih jelas,
perhatikan gambar berikut.

Pulsa PWM inverting dan non-inverting

Pemrograman PWM dengan BASCOM AVR

Fasilitas timer mikrokontroler digunakan untuk pengaturan PWM. Berikut ini pengujian
fungsionalitas mikrokontroler Atmega 16 dalam membangkitkan PWM. Penggunanan PWM
menggunakan fasilitas overflow pada timer/counter 1.

Listing program untuk mengeluarkan nilai PWM = 0 pada pin OC1A dan OC1B.

Config Timer1 = Pwm , Pwm = 10 , Prescale = 64 , Compare A Pwm = Clear Down ,

Compare B Pwm = Clear Down ‘pwm dengan settingan fast pwm 10 bit, mode inverting

Do

Pwm1a = 0 ‘pin OC1A

Pwm1b = 0 ‘pin OC1B

Loop

End

Gambar Gelombang PWM saat 0%

Listing program untuk mengeluarkan nilai PWM = 512 pada pin OC1A dan OC1B.

Config Timer1 = Pwm , Pwm = 10 , Prescale = 64 , Compare A Pwm = Clear Down ,

Compare B Pwm = Clear Down ‘pwm dengan settingan fast pwm 10 bit, mode inverting

Do

Pwm1a = 512 ‘pin OC1A

Pwm1b = 512 ‘pin OC1B

Loop

End
 Gambar Gelombang PWM saat 50%

nach berikut hasil video pengaturan sinyal PWM nya ^_^

===============================================================

Merancang Rangkaian Sensor Garis

Posted Juli 25, 2010 by Fahmizal in Elektronika, Sensor. Tagged: cara kerja Sensor Garis,
membuat sensor garis, Merancang Rangkaian Sensor Garis, merancang sensor garis,
merancang sensor photo diode, Rangkaian Sensor Garis. 28 Komentar

23 Votes

Sensor garis sering digunakan pada robot line follower (robot pengikut garis), digunakan juga
sebagai pendeteksi objek dengan permukaan bidang pantul yang kontras…. nach pada blog
ini dijelaskan bagaimana cara mendesain sensor garis tersebut menggunakan sensor
photodiode. Selain menggunakan photodiode dapat juga dirancang dengan menggunakan
phototranssistor, infra red, dan masih banyak laennya.

Sensor photodiode adalah salah satu jenis sensor peka cahaya (photodetector). Photodiode
akan mengalirkan arus yang membentuk fungsi linear terhadap intensitas cahaya yang
diterima. Arus ini umumnya teratur terhadap power density (Dp). Perbandingan antara arus
keluaran dengan power density disebut sebagai current responsitivity. Arus yang dimaksud
adalah arus bocor ketika photodiode tersebut disinari dan dalam keadaan dipanjar mundur.

Hubungan antara keluaran sensor photodiode dengan intensitas cahaya yang diterimanya
ketika dipanjar mundur adalah membentuk suatu fungsi yang linier. Hubungan antara
keluaran sensor photodiode dengan intensitas cahaya ditunjukkan pada Gambar berikut.
 Gambar Hubungan keluaran photodiode dengan intensitas cahaya

Mekanisme Perancangan Sensor Garis

LED superbright berfungsi sebagai pengirim cahaya ke garis untuk dipantulkan lalu dibaca
oleh sensor photodiode. Sifat dari warna putih (permukaan terang) yang memantulkan cahaya
dan warna hitam (permukaan gelap) yang tidak memantulkan cahaya digunakan dalam
aplikasi ini. Gambar dibawah ini adalah ilustrasi mekanisme sensor garis.

Gambar Ilustrasi mekanisme sensor garis

Prinsip Kerja Sensor

Pada rancangan sensor photodiode dibawah ini, nilai resistansinya akan berkurang bila
terkena cahaya dan bekerja pada kondisi riverse bias. Untuk pemberi pantulan cahayanya
digunakan LED superbright, komponen ini mempunyai cahaya yang sangat terang, sehingga
cukup untuk mensuplai pantulan cahaya ke photodiode. Berikut ini prinsip dan gambaran
kerja dari sensor photodiode.
 Gambar Sensor photodiode tidak terkena cahaya

Saat photodiode tidak terkena cahaya, maka nilai resistansinya akan besar atau dapat
diasumsikan tak hingga. Sehingga tidak ada arus bocor yang mengalir menuju komparator.

Gambar Sensor photodiode terkena cahaya

Saat photodiode terkena cahaya, maka photodiode akan bersifat sebagai sumber tegangan
dan nilai resistansinya akan menjadi kecil, sehingga akan ada arus bocor yang mengalir ke
komparator.

Nah buat temen2 yang nantinya pengen merancang sensor garis dengan multisensor dapat
menggunakan multiplekser-4051 dan di akses dengan ADC-Multiplekser. info lebih lanjut,
temen2 kunjungi postingan ini :

https://fahmizaleeits.wordpress.com/2010/09/02/robot-line-follower-dengan-multiplekser-
adc/

Simulasi Logika Fuzzy dengan Simulink-Matlab

Posted by Fahmizal in Fuzzy Logic, Kuliah Kontrol. Tagged: Fuzzy dengan Toolbox Matlab,
Simulasi Logika Fuzzy, Simulasi Logika Fuzzy dengan Simulink-Matlab, Simulink Fuzzy. 4
komentar

Belajar logika fuzzy tidak cukup dengan hanya memahami teorinya… temen2 juga dapat
mencobanya dalam simulasi atau aplikasi… nah pada postingan ini, ane mencoba berbagi
pengalaman bagaimana cara mensimulasi logika fuzzy dengan Simulink-Matlab, silakan
temen2 unduh file tutorialnya disini.

Setelah teman2 baca, lihat sample gambar yg ane gunakan saat simulasi logika Fuzzy dengan
Simulink-Matlab:
 FIS editor

 7 Membership error

 7 Membership derror
 5 Membership Speed (PWM)

 Rule Inference using 49 Rules

 Simulink Fuzzy Mobile Robot
ini video hasil simulasi logika fuzzy ane menggunakan simulink-matlab…

dan video berikut aplikasi Fuzzy untuk kontrol suhu, bagus juga buat ditonton…

Semoga informasi ini bermanfaat :)

4 Des

Robot Line Follower dengan Kendali PID-Fuzzy

Posted by Fahmizal in Fuzzy Logic, PID kontrol, Robotika. Tagged: Defuzifikasi adalah,
Diagram Blok Hybrid Kendali PID - Fuzzy, FUUZY control based line follower, FUUZY
control line follower, FUUZY controller implementation on line follower, FUUZY
implementation on line follower, Fuuzy programming for line follower, Fuzzifikasi adalah,
IF……THEN, Inferencing (Ruled Based), kendali Fuzzy, kontrol FUUZY pada line follower,
line follower based FUUZY controller, line follower with Fuuzy control, logika fuzzy,
membership dalam proses cris input, proses defuzzifikasi, proses fuzzifikasi, proses inference
fuuzy, proses rule evaluation, Robot Line Follower dengan Kendali Fuzzy, Robot Line
Follower dengan Kendali Hybrid PID-Fuzzy, robot pengikut garis dengan FUUZY, Rule
Base MacVicar Whelan, setting Fuuzy line follower, sistem pengaturan cerdas, Tahap
Pemodelan dalam logika Fuzzy, tutorial line follower Fuuzy. 63 komentar

Robot Line Follower dengan Kendali PID-Fuzzy

Ane mau… sharing lagi nih ma temen2 tentang LF… mungkin ada yg bosen kok isi blog ini
kebanyakan robot LF aja heheheeehe :-D Ya begitulah kondisinya temen2 ane maniak banget
dengan ni robot LF makanya ane suka ber-eksperiment tentang bagaimana menerapkan
berbagai kendali yg tepat untuk diterapkan di robot LF ini supaya pergerakannya itu halus
cepat dan responsif. Yups ane dah menerapkan kendali PID pada ni robot dan saat ini ane
mencobanya dengan menggabungkannya dengan kendali Fuzzy. Ide itu berawal dari setelah
ane dapat matakuliah sistem pengaturan cerdas di Teknik Elektro ITS. Matakuliah
(walaupun cuma 2 sks) itu saat ane senangi temen2… dimana dosennya mantep banget
(perfect) jelasinnya (terimakasih banyak ya pak) tidak hanya teori tapi praktek juga… so ane
terrapin deh di robot LF ane :D. Nah oleh sebab itu ane coba share ilmu yg sedikit ini kepada
temen2 semua… semoga bermanfaat dan bisa dijadikan referensiya… ^_^
Nah sebelum ane jelasin tentang logika Fuzzy-nya ane kenalkan dahulu ye ma robot LF ane
yang tersisa, maksudnya yang kondisinya masih FIT alias sehat (masih bisa nyala). Ni dia
foto-fotonya:
Temen2 semua dah liatkan robot LF ane yang satu ini… Jelekkan (kurang estetika)…
hehehe :-D itu lah robot ane.. desain mekanik ala kadarnya… menggunakan acrylic sisa dan
PCB bolong sebagai kerangka robotnya… sensornya pun langsung ditanam di PCB bolong
gak pake desain layout langsung solder aja praktis bukan… komposisi gearbox-nya pake
kanibal maenan tank terus ane tempel ke bodi robotnya pake Lem Tembak… itulah senjata
ane gan ^_^ walaupun mekanik robotnya jelek, setelah diberi kontroler yang tepat jalannya
bisa halus lo hehehe :D ini dia salah satu aksi robotnya pada kasus Line Maze Robot.

Nah ni dia spesifikasi lengkap dari robot LF ane :

 Mikrokontroler AVR = ATMega32

 Sensor = LED Super Bright Putih – Photo Dioda (8 di depan, 3 di sayap kiri, 3 di sayap kanan
dan 1 di tengah belakang sebagai kondisi NOS… total pake 15 sensor dengan Konfigurasi
ADC-Multiplekser)
 Motor DC = DVD 6.0 V
 Gear = Kanibal dari maenan Tank
 Battery = LiPo 850mAH / 11,1V
 Driver Motor = L293d
 Dimensi = panjang; 18 cm × lebar; 15 cm
 Bahasa Pemrograman = Bahasa C dengan compiler CodeVision AVR

Selanjutnya untuk penjelasan logika Fuzzy ini temen2 bisa googling di mbah google ato baca
sedikit penjelasnya disini ato sedot ni paper. Berikut ini aturan yang harus temen2 fahami
tentang logika Fuzzy yang ane uraikan sebagai berikut (bila ada kesalahan mohon ane
dikoreksi ya gan ^_^ ).

Tahap Pemodelan dalam logika Fuzzy:

Nah bila kita terapkan dalam pengendalian proses dapat diterapkan seperti blok di bawah ini:

Dari uraian
blok diatas dapat kita fahami bahwa didalam logika Fuzzy terdapat tiga hal terpenting yang
harus temen2 fahami diataranya:

1. Fuzzifikasi adalah proses untuk mengubah variabel non fuzzy (variabel numerik) menjadi
variabel fuzzy (variabel linguistik).
2. Inferencing (Ruled Based) , pada umumnya aturan-aturan fuzzy dinyatakan dalam bentuk
“IF……THEN” yang merupakan inti dari relasi fuzzy.
3. Defuzifikasi adalah proses pengubahan data-data fuzzy tersebut menjadi data-data numerik
yang dapat dikirimkan ke peralatan pengendalian.

Oke deh… segitu aja ya penjelasan dari ane tentang teori logika Fuzzy-nya… selanjutnya ane
jelasin tentang cara pengaplikasiannya pada robot LF… tapi logika Fuzzy yang ane terrapin
pada robot LF ini tidak murni hanya dengan logika Fuzzy saja tapi digabungkan (hybrid)
dengan kendali PID… so judulnya yang lebih tepat adalah Robot Line Follower dengan
Kendali Hybrid PID-Fuzzy.
 Diagram Blok
Hybrid Kendali PID – Fuzzy

Nah untuk penjelasan Kendali PID-nya bisa temen2 lihat postingan ane yg lampau disini.
Dan untuk penjelasan logika Fuzzy-nya ialah sebagai berikut:

Perhatikan step berikut temen2 :

Aplikasi pemrograman logika fuzzy ini ane

terapkan dalam bahasa C (codevisonAVR), ini dia potongan program untuk penentuan
membership pada proses penentuan crisp input dalam proses fuzzikasi-nya. Ane
menggunakan 7 membership dalam proses cris input pada Fuzzifikasi error dan derror-
nya, dengan fungsi keanggotaan segitiga (triangle membership function). Berikut ini
sample code fuzzifikasi-nya:
Proses fuzzifikasi, fungsi keanggotaanya ane aktifkan dengan fungsi keanggotaan segitiga
yang selanjutnya masuk ke proses Rule Base Evaluationnya. Proses Rule Evaluation-nya
mengacu pada tabel MacVicar Whelan dengan menggunakan Mamdani Inference Rule,
berikut ini contoh tabee proses rule evaluationya menggunakan teknik dari MacVicar Whelan
dengan menggunakan 5 membership error dan derror. Untuk case pada robot ini, ane gunakan
7 membership error dan derror.

Nah berikut ini sample codenya untuk Mamdani Inference Rule using MacVicar Whelan
Method:
Dari hasil rule evaluasi ini kita dapatkan hasil kontrol logika fuzzy-nya yang selanjutnya kita
defuzzifikasi yaitu dengan banyak cara (bisa lihat disini sebagai reference) diantaranya yang
paling umum adalah dengan teknik Center of Gravity (COG). Nah untuk case robot ini, ane
gunakan teknik dari Sugeno menggunakan Weighted Average (WA). Berikut ini sample code
defuzzifikasi-nya:

Dari proses defuzzifikasi ini baru lah kita dapatkan sinyal kontrol logika Fuzzy yang akan
kita terapkan pada robot LF nantinya. Nah selajutnya proses pemberian nilai PWM motor
robot LF ane adalah gabungan (hybrid) antara kendali PID dengan logika Fuzzy.
Berikut sample code untuk ditransfer ke aktuator (driver motor robot) dalam bentuk PWM:
Dan ini dia video robot LF ane dengan kendali Kendali PID – Fuzzy…

Semoga informasi ini bermanfaat

ROBOT LINE FOLLOWER dengan Kendali PID

Bergerak smooth-nya robot sangat tergantung dari aksi kontrol robot tersebut, jika hanya
menngunakan kontrol on-offf (diskontinyu) akan sangat berbeda dengan aksi kontrol
kontinyu PID. Kontrol PID saat ini banyak digunakan dalam aksi-aksi di dunia industri dan
juga kontrol robot ^_^

Jika kita berbicara kontrol robot line follower dengan PID maka bukanlah kontrol PID yang
sebenarnya… sebab (kata dosenku) pada robot line follower elemen ukur (sensor) tidak
terdapat pada plant (motor penggerak) dari robot, yang serharusnya ialah sensor terdapat di
plant(motor penggerak), dengan contoh tachometer sebagai sensor pada motor, encoder atau
yang laennya yang terletak pada plant. sedangkan pada robot line follower sensor berupa
pendeteksi garis (tidak terletak pada plant) dan dari hasil kondisi garis tersebut barulah
dikontrol ke motor (plant), namun walaupun begitu kontrol PID masih dapat diterapkan untuk
mengendalikan robot line follower.
Blok aksi kontrol PID:

Formula matematis dari PID:

Dari formula tersebut dapat dirumuskan

menjadi pen-digitalization PID dengan berbagai metode, kalo di kul dengan cara transformasi
Z, ZOH, bilinier transformartion, Eulers method.. wah susah pokoknya…. Sehingga
diperoleh bentuk digital diskritnya menjadi persamaan dibawah ini….

Bentuk kontroler PID diskrit:

Nach…jika kita terapkan dalam bahasa

pemrograman menjadi….

Dimana; Ts ialah time sampling, error ialah nilai kesalahan dan last_error ialah nilai error
sebelumnya.

Berikut ilustrasi penerapan kontrol PID pada robot line follower:

dari blok iliustrasi tersebut dapat q jelasin sebagai berikut:

S1,S2…,S8 merupakan sensor dengan pemberian bobot Present Value (PV) PV=0, PV=-1,
PV= 1 dst….

Deviasi/simpangan antar variabel terukur (PV) dengan nilai acuan (SP) disebut error (galat)

Nach nilai error dari pembacaan sensor ini yang dijadikan aksi perhitungan kendali PID, lalu
nilai perhitungan PID tersebut dijumlahkan dengan setpoint PWM untuk dijadikan sebagai
nilai aktual PWM motor dari robot line follower, berikut formula perhitungan nilai PWM kiri
dan kanan dari robotku:
Untuk dapat lebih mudah memahami algoritma kendali PID robot line follower ku download
diagram alir programnya disini…

Untuk cara tunning kontrol PID dan sample coding (BASCOM AVR dan CODEVISION
AVR) pada robot line follower ku dapat di lihat disini… dan pengen lihat video
robotku disini….dan disana…