DESAIN PROTEUS and PROGRAM Code Vision A

DESAIN PROTEUS & PROGRAM Code Vision AVR
ROBOT LINE FOLLOWER DIGITAL RA04

Posted on 3/20/2013 06:39:00 PM by Mada Sanjaya Ws
Silahkan download file pdf berikut:

Robot autonomous line follower bolabot
Untuk yang membutuhkan simulasi Robot Line Follower Digital, silahkan download File
berikut:
1. Desain Proteus dan Code Vision AVR Line Follower ATMega 16

2. Desain Proteus dan Code Vision AVR Line Follower ATMega 8
Line follower Robot (Robot Pengikut Garis) adalah robot yang dapat berjalan mengikuti sebuah lintasan, ada yang
menyebutnya dengan Line Tracker, Line Tracer Robot dan sebagainya. Garis yang dimaksud adalah garis berwarna hitam
diatas permukaan berwarna putih atau sebaliknya, ada juga lintasan dengan warna lain dengan permukaan yang kontras
dengan warna garisnya. Ada juga garis yang tak terlihat yang digunakan sebagai lintasan robot, misalnya medan magnet.
Gambar 1. Ilustrasi robot line follower dengan posisi sensor di atas permukaan putih
Seperti layaknya manusia, bagaimana manusia dapat berjalan mengikuti jalan yang ada
tanpa menabrak dan sebagainya, tentunya karena manusia memiliki “mata” sebagai
penginderanya. Begitu juga robot line follower ini, dia memiliki sensor garis yang
berfungsi seperti “mata” pada manusia. Sensor garis ini mendeteksi adanya garis
atau tidak pada permukaan lintasan robot tersebut, dan informasi yang diterima
sensor garis kemudian diteruskan ke prosesor untuk diolah sedemikian rupa dan
akhirnya hasil informasi hasil olahannya akan diteruskan ke penggerak atau motor
agar motor dapat menyesuaikan gerak tubuh robot sesuai garis yang dideteksinya.
Gambar 2. Diagram blok robot line follower

Untuk merangkai rangkaian elektroniknya kita perlu tahu dulu diagram blok sistem
yang akan kita bangun, dengan demikian akan menjadi mudah mengerjakannya. Blok
sistem yang akan kita bagun paling tidak tampak seperti gambar berikut. Sistemnya
terdiri dari sensor garis, rangkaian komparator, sistem minimum AT Mega dan motor
driver.
ROBOT LINE FOLLOWER DIGITAL MIKROKONTROLER ATMEGA 16
Desain berikut menggunakan mikrokontroler ATmega 16, LCD 2x 16, 2 buah sensor
phototransistor
Skema Lengkap Line follower Digital IC Komparator
Pada skema lengkap robot line follower didesain dengan posisi sensor di atas permukaan
putih. Dua buah sistem sensor di pasang pada pin B.0 dan B.1, sedangkan sistem
actuator motor DC dipasang pada Port D.0 dan D.1 untuk motor kiri, D.2 dan D.3
untuk motor kanan. Prinsip kerja robot line follower berikut adalah saat sistem sensor
berada di atas permukaan putih, akan ada pantulan cahaya dari LED yang akan
mengenai sensor cahaya LDR sehingga resistansi sensor LDR berkurang sehingga arus
bergerak melalui LDR. Kondisi tersebut menyebabkan arus output sensor menuju IC
komparator LM 393 menjadi minimum, oleh IC LM 393, arus di non-inverting sehingga
output menuju pin mikrokontroler menjadi LOW (0). Sebaliknya, saat sistem sensor
berada di atas garis hitam, tidak akan ada pantulan cahaya dari LED yang akan
mengenai sensor cahaya LDR sehingga resistansi sensor LDR sangat besar sehingga
arus tidak akan melalui LDR. Kondisi tersebut menyebabkan arus output sensor menuju
IC komparator LM 393 menjadi maksimum, oleh IC LM 393, arus di non-inverting
sehingga output menuju pin mikrokontroler menjadi HIGH (1). Oleh mikrokontroler
data logika pin tersebut kemudian diolah untuk mengerakan motor, motor akan
bergerak jika kedua pin motor tersebut memiliki beda polaritas. Selengkapnya
mengenai logika gerak robot dapat dilihat pada Tabel 1 dan 2.
Tabel 1. Kondisi Gerak Motor dan pengaruh Sensor
Kondisi B.0 = 0 B.0 =1
B.1 = 0 Maju Belok Kiri
B.1 = 1 Belok Kanan Mati
Tabel 2. Kondisi Gerak Motor dan Kondisi Logika Tiap Pin Motor
Kondisi D.0 D.1 D.2 D.3
Maju 0 1 0 1
Belok Kiri 1 0 0 1
Belok Kanan 0 1 1 0
Mati 1 1 1 1
Gambar 3. Skema lengkap robot line follower menggunakan AT Mega 16
PROGRAM ROBOT LINE FOLLOWER DIGITAL ATMEGA 16 MENGGUNAKAN CODE VISION AVR
/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.0 Professional
Automatic Program Generator
© Copyright 1998-2010 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project : Robot Line follower

Version : I
Date : 11/8/2012
Author : Mada Sanjaya WS, Ph.D
Company : Bolabot Techno Robotic School
Comments: www. bolabot. com
Chip type : ATmega16

Program type : Application
AVR Core Clock frequency: 12.000000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 256
*****************************************************/
#include <mega16.h>
# include <delay.h> //tambahan program untuk membuat waktu tunda
// Alphanumeric LCD Module functions

#include <alcd.h>
// Declare your global variables here
void main(void)
{
// Declare your local variables here
// Input/Output Ports initialization

// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTA=0x00;
DDRA=0x00;
// Port B initialization
PORTB=0x00;
DDRB=0x00;
// Port C initialization
PORTC=0x00;
DDRC=0x00;
// Port D initialization
// Func7=In Func6=In Func5=Out Func4=Out Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=0 State4=0 State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x30;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
// Clock value: 11.719 kHz
// Mode: Fast PWM top=0x00FF
// OC1A output: Non-Inv.
// OC1B output: Non-Inv.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0xA1;
TCCR1B=0x0D;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
// Clock value: Timer2 Stopped
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
// External Interrupt(s) initialization

// INT0: Off
// INT1: Off
// INT2: Off
MCUCR=0x00;
MCUCSR=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x00;
// USART initialization
// USART disabled
UCSRB=0x00;
// Analog Comparator initialization

// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
// ADC initialization
// ADC disabled
ADCSRA=0x00;
// SPI initialization
// SPI disabled
SPCR=0x00;
// TWI initialization
// TWI disabled
TWCR=0x00;
// Alphanumeric LCD initialization

// Connections specified in the
// Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu:
// RS - PORTC Bit 0
// RD - PORTC Bit 1
// EN - PORTC Bit 2
// D4 - PORTC Bit 4
// D5 - PORTC Bit 5
// D6 - PORTC Bit 6
// D7 - PORTC Bit 7
// Characters/line: 16
lcd_init(16);
// Tambahan kode mendefinisikan input output

DDRB.0=0; // input sensor kiri
DDRB.1=0; // input sensor kanan
DDRD.0=1; // output motor kiri
DDRD.1=1; // output motor kiri
DDRD.2=1; // output motor kanan
DDRD.3=1; // output motor kanan
// Tambahan kode mendefinisikan kecepatan motor PWM
OCR1A=200;// kecepatan dapat diubah sesuai kebutuhan
OCR1B=200;// kecepatan dapat diubah sesuai kebutuhan
// Tambahan kode mendefinisikan kondisi awal
PORTB.0=1; //sensor kiri
PORTB.1=1; //sensor kanan
PORTD.0=0;
PORTD.1=0;
PORTD.2=0;
PORTD.3=0;
while (1)
{
if (PINB.0==1 & PINB.1==0) // Tambahan kode sensor kiri hitam, kanan putih,
maka belok kiri
{
PORTD.0=1;
PORTD.1=0;
PORTD.2=0;
PORTD.3=1;
lcd_clear ();
lcd_gotoxy(0,0);
lcd_putsf("B0=1 B1=0");
lcd_gotoxy(0,1);
lcd_putsf("BELOK KIRI");
delay_ms(100);
}
else if (PINB.0==0 & PINB.1==1) // Tambahan kode sensor kiri putih, kanan
hitam, maka belok kanan
{
PORTD.0=0;
PORTD.1=1;
PORTD.2=1;
PORTD.3=0;
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_putsf("BELOK KANAN");
delay_ms(100);
}
else if (PINB.0==1 & PINB.1==1) // Tambahan kode sensor kiri hitam, kanan
hitam, maka mati
{
PORTD.0=0;
PORTD.1=0;
PORTD.2=0;
PORTD.3=0;
lcd_clear ();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_putsf("MATI");
delay_ms(100);
}
else // Tambahan kode sensor kiri putih, kanan putih, maka bergerak maju
{
PORTD.0=0;
PORTD.1=1;
PORTD.2=0;
PORTD.3=1;
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_putsf("MAJU");
delay_ms(100);
}
}
}
ROBOT LINE FOLLOWER DIGITAL SEDERHANA DENGAN ATMEGA 8
Jika desain diatas dibuat menggunakan mikrokontroler AT mega 8, maka berikut ini
merupakan desain robot line follower digital menggunakan mikrokontroler ATmega 8,
dan 2 buah sensor phototransistor yang lebih sederhana.
Gambar 4. Skema lengkap robot line follower menggunakan AT Mega 8
PROGRAM ROBOT LINE FOLLOWER DIGITAL ATMEGA 8 MENGGUNAKAN CODE VISION AVR
/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.0 Professional
Automatic Program Generator
© Copyright 1998-2010 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project : Bolabot Line Follower Digital AT Mega 8

Version : I
Date : 3/3/2013
Author : Mada Sanjaya WS, Ph.D
Company : Bolabot Techno Robotic Institute
Comments: Semangat!!
Chip type : ATmega8

Program type : Application
AVR Core Clock frequency: 12.000000 MHz
Memory model : Small
External RAM size :0
Data Stack size : 256
*****************************************************/
#include <mega8.h>
// Declare your global variables here
void main(void)
{
// Declare your local variables here
// Input/Output Ports initialization

// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=0 State1=0 State0=T
PORTB=0x00;
DDRB=0x06;
// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0x00;
// Port D initialization
PORTD=0x00;
DDRD=0x00;
// Clock value: Timer 0 Stopped
TCCR0=0x00;
TCNT0=0x00;
// Clock value: 11.719 kHz
// Mode: Fast PWM top=0x00FF
// OC1A output: Non-Inv.
// OC1B output: Non-Inv.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0xA1;
TCCR1B=0x0D;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
// Clock value: Timer2 Stopped
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
// External Interrupt(s) initialization

// INT0: Off
// INT1: Off
MCUCR=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x00;
// USART initialization
// USART disabled
UCSRB=0x00;
// Analog Comparator initialization

// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
// ADC initialization
// ADC disabled
ADCSRA=0x00;
// SPI initialization
// SPI disabled
SPCR=0x00;
// TWI initialization
// TWI disabled
TWCR=0x00;
DDRD.5=1; // ke motor
DDRB.0=1; // ke motor
DDRC.4=0; // input sensor

DDRC.3=0; // input sensor
PORTD.5=1;
PORTD.6=1;
PORTD.7=1;
PORTB.0=1;
OCR1A=150; // kecepatan motor dapat diatur sesuai kebutuhan

OCR1B=150; // kecepatan motor dapat diatur sesuai kebutuhan
while (1)
{
if (PINC.3==1 & PINC.4==0 )
{
PORTD.5=1;
PORTD.6=0;
PORTD.7=0;
PORTB.0=1;
}
else if (PINC.3==0 & PINC.4==1)
{
PORTD.5=0;
PORTD.6=1;
PORTD.7=1;
PORTB.0=0;
}
else
{
PORTD.5=1;
PORTD.6=0;
PORTD.7=1;
PORTB.0=0;
}
}
}
Berikut adalah video robot line follower digital sederhana karya Profesor
Bolabot menggunakan ATMega 8 dan 2 sensor cahaya Phototransistor
Membuat Robot Line Follower Dengan AVR ATMega8535
Tuesday, October 2nd, 2012 - Microcontroller
Robot line follower atau robot line tracert merupakan robot pengikut garis yang dapat bergerak atau berjalan
mengikuti suatu lintasan hitam diatas background putih atau sebaliknya. Untuk membuat rangkaian robot line
follower dapat menggunakanmicrocontroller. salah satu microcontroller yang dapat digunakan untuk
membuat rangkaian robot line follower adalah AVR ATMega8535. “Robot Line Follower” merupakan robot yang di
desain untuk mengikuti jejak (bisa garis bisa garis putus2 atau bahkan titik titik). Membuat Robot Line
Follower menggunakan prosesor mikrokontroler AVR ATMega 8535 sangat mungkin dan sangat bisa diandalkan.
Karena dalam desain suatu Robot Line Follower perlu kita pikirkan bahwa jejak yang akan di ikuti atau langkah2 yang
akan dilakukan Robot Line Follower terhadap track atau lintasan yang di lewati Robot Line Follower tersebut. Dan dari
kebutuhan Robot Line Follower tersebut feature2 yang dimiliki oleh mikrokontroler AVR ATMega 8535 sangat
mencukupi dan memenuhi kebutuhan dari Robot Line Follower.
Blok Diagram Robot Line Follower Dengan AVR ATMega8535
Fungsi Bagian Blok Diagram Robot Line Follower Dengan AVR ATMega 8535
 Sensor pada Robot Line Follower dapat menggunakan foto dioda atau foto transistor, bagian ini berfungsi
mendeteksi keberadaan lintasan track.
 Keypad, Bagian ini berupa tombol yang berfungsi untuk start/stop Robot Line Follower dan sebagai pemilih
konfigurasi seting Robot Line Follower terhadap medan yang di akan di lalui.
 Display, merupakan bagian yang berfungsi untuk menampilkan pilihan seting dan hasil seting (cukup itu saja
yg perlu di tampilan) bagian ini bisa menggunakan LCD atau penampil 7 segmen.
 Driver Motor, bagian ini berupa rangkaian H Bridge driver motor DC. Bagian ini yang mengendalikan putaran
motor secara langsung. Bagian ini merupakan interface anatara mikrokontroler AVR ATMega dengan motor
DC. Saya suka menggunakan IC keluarga L298 untuk driver motor.
 Mikrokontroler AVR ATMega8535, bagian ini merupakan bagian yang menentukan kemana robot akan di
bawa berdasarkan data dari sensor. Bagian ini yang mengatur langkah2 Robot Line Follower dalam
menaklukan lintasan.
Blok diagram rangkaian robot line follower diatas merupakan gambaran umum dari pembuatan robot line follower yang
dapat dipilih program kerja yang akan dijalankan olehrobot line follower tersebut. Dengan keypad tersebut dapat
dimasukan seting kecepatan, program jalannya robot dan laiannya.
Share Membuat Robot Line Follower Dengan AVR ATMega8535
Membuat Robot Line Follower dengan Mikrokontroler

Posted Mei 1, 2010 by Fahmizal in Robotika. Tagged: ATmega 8535 pada line follower, digital line follower, line follower berbasis
mikrokontroler, line follower dengan ATmega 8535, line follower dengan mikrokontroler Atmega 8535, line follower digital, Membuat Robot Line
Follower dengan Mikrokontroler, membuat robot line follower mikro, mendesain robot line follower mikro, merancang robot line follower
mikro, pemrograman line follower, rangkaian line follower mikrokontroler, rangkaian robot line follower dengan mikrokontroler. 82 Komentar
Membuat Robot Line Follower dengan Mikrokontroler

Jika beberapa artikel yang lalu q bercerita tentang Robot Line Follower Analog, maka kali ini pengen bercerita tentang
line follower digital,… yups kali ini q pengen memberikan artikel tentang cara membuat robot line follower dengan
mikrokontroler… semoga bermanfaat…ya…ok :D
Nah jika pada artikel robot line follower analog, kita gak perlu mikirin yang namanya software… tapi kali ini berbeda…
temen-temen semua dituntut untuk dapat menggunakan software dalam pengoperasian robot… tapi bagi yang belum
paham software gak perlu khawatir,… tenang ja,.. dunia lum kiamat… kalian masih dapat mempelajarinya hehehee … :)
Hmmm software apa ja sich yang digunakan pada robot line follower dengan mikrokontroler?
Yang pertama ialah software pemrograman bahasanya,…. ada banyak bahasa yang dapat digunakan
diantaranya assembly (angel tenan….) pascal( rodok angel…) C (rodok gampang…)BASIC (gampang buanget…).
Ada banyak bahasa yang apat digunakan, mulai dari bahasa yang susah dan mudah, nach dengan adanya bahasa yang
mudah lebih baik kita pelajari dulu yang mudah-mudah (kayak ngerjain soal ujian)…, seperti bahasa BASIC dan C.
Kalian dapat mempelajari bahasa basic dan c dari buku yang beredar…. banyak banget dipasaran,… oiya di blog ini juga
terdapat penjelasan tentang cara mempelajari mikrokontroler Atmega8535, nach disitu q udah berusaha menge-share
semua tentang bahasa basic dari awal….hingga tak berakhir…
Yang kedua ialah software downloader mikro, maksudnya ialah suatu perangkat lunak yang berfungsi memasukkan
program ke dalam mikrokontroler tersebut…. nach Cuma dua software ini untuk merancang robot line follower
mikrokontroler… guampangkan….
Nach perhatikan blok sistem dari robot line follower mikrokontroler dibawah ini:
Dengan mengacu kepada blok diagram sistem, terdiri dari bagian masukan, bagian kendali, bagian keluaran dan bagian
catu daya (baterai). Pada bagian masukan berupa delapan buah sensor photodiode dengan untai pengkondisi sinyal
berupa komparator (IC LM324) dan tombolkeypad yang berfungsi untuk memasukan data pengendali robot, contoh
dengan kendali PID,Hybrid PID-Fuzzy dan lain sebagainya. Pada bagian keluaran berupa penampil LCD 2*16
dandriver motor (IC L293D) sebagai aktuator (penggerak) robot.
Gambaran Umum Sistem
Cara kerja dari sistem robot line follower secara umumialah dimulai dari pembacaan lintasan atau garis oleh
sensor photodiode berserta LED superbright yang mana intensitas pantulan sinar LEDsuperbright akan berbeda jika
terkena bidang pantul yang gelap dengan bidang pantul yang lebih terang, dari perbedaan inilah dimanfaatkan sebagai
pendeteksi lintasan atau garis dan selanjutnya diteruskan pada rangkaian untai pengkondisi sinyal (komparator).
Rangkaian komparator (IC LM324) berfungsi untuk membandingkan nilai yang dibaca sensor photodiode dengan nilai
referensi komparator sehingga perbedaan terlihat sangat kontras saat sensor photodiodemendeteksi objek pantul gelap
maupun terang. Hasil keluaran komparator kemudian diteruskan dan diproses oleh rangkaian pengendali utama yakni
IC mikrokontroler Atmega16. Pada bagian kendali utama inilah semua logika pembacaan sensor yang telah
dikondisikan oleh komparator diproses.
Bagian mikrokontroler ini terdiri dari dua masukan dan dua keluaran. Pada bagian masukan berupa sensor dengan
untai komparator dan keypad kendali yang berfungsi untuk mengatur algoritma kendali yang akan digunakan pada
robot line follower. Pada bagian keluaran berupadisplay (penampil) dengan
menggunakan LCD dan PWM mikrokontroler Atmega16 yang diteruskan ke driver motor (IC l293D) untuk
mengendalikan motor kiri dan kanan dari robot line follower.
Untuk skematic rangkaiannya dapat didownload disini
Untuk contoh program dalam bentuk bahasa BASIC dengan editor BASCOM-AVR dapat didownload disini dan bahasa
C dengan editor CodeVision-AVR disana.
Semoga bermanfat :)
Nach ni dia galery foto robot LINE FOLLOWER ku…. ( tapi ini udah tinggal kenangan, robotnya dah dipreteli ma anak2
mikro club dte UGM :D )
nach ni dia kalo pengen liat video robotku klik disini…. dan disana…
sistem pergerakan robot

ROBOT LINE FOLLOWER dengan Kendali PID
Posted Mei 8, 2010 by Fahmizal in PID kontrol, Robotika. Tagged: Kendali PID pada line follower, kendali pid robot pengikut garis, kontrol line
tracer pid, kontrol PID pada line follower, line follower based PID controller, line follower berbasis kendali PID, line follower berbasis kontroler
PID, line follower berbasis PID, line follower dengan pid, line follower with pid control, line tracer pid, membuat robot line follower mikro, PID
control based line follower, PID control line follower, PID controller implementation on line follower, PID implementation on line follower, pid
programming for line follower, PID robot Pengikut Garis, Robot line follower dengan kendali PID, robot pengikut garis dengan PID,setting pid line
follower, tutorial line follower pid. 82 Komentar
57 Votes
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 kontinyuPID. 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 errorsebelumnya.
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…
Dan berikut aplikasi kontroler PID pada Robot-Wall Follower ato yg lebih dikenal dengan robot telusur dinding:
Semoga bermanfaat :D
===============================================================
bacaan terkait di blog ini:
1. tuning-kontrol-pid-pada-robot-line-follower klik disini
2. robot line follower dengan multiplekser-ADC klik disini
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. 87 Komentar
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 kecilduty 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 denganduty 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
===============================================================
TUNING KONTROLER PID Pada Robot Line Follower

Posted Agustus 24, 2010 by Fahmizal in PID kontrol, Robotika. Tagged: Controller PID on Line Follower, line follower based PID controller, line
follower berbasis kendali PID, line follower berbasis kontroler PID, line follower berbasis PID,nilai pid line follower, parameter PID, parameter PID
controller, PID control based line follower, PID controller implementation on line follower, PID Controller in Robot, PID implementation on line
follower, pid pada line follower, pid programming for line follower, program PID pada line follower, setting pid line follower, TUNING KONTROL
PID Pada Robot Line Follower, tuning PID controller, tunning nilai PID. 83 Komentar
41 Votes
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 ituatau variabel terukur yang di umpan balikan oleh senso
r (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) pembacaansensor 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 aktualpembacaan. 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
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
untukmengakumulasi 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
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 , 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
Cls
Locate 2 , 5 : Lcd “Ready..!!”
Locate 1 , 8 : Lcd “-“ : Waitms 150
Locate 1 , 8 : Lcd “3” : 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 = &B00100000 Then : Pv = -5 : End If
If Sensor = &B00000000 Then
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
If Adc1 < Hold Then : S1 = &B00000000 : B1 = 0 : End If : If Adc1 > Hold Then : S1 = &B00000001 : B1 = 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
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 pemrogramanCODEVISION 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_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);
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);
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);
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);
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);
else
goto set7;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set8:
e1=e1;
if(e1>100){e1=0;delay_ms(10);}
if(e1<0) {e1=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set8;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set9:
e2=e2;
if(e2>100){e2=0;delay_ms(10);}
if(e2<0) {e2=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set9;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set10:
e3=e3;
if(e3>100){e3=0;delay_ms(10);}
if(e3<0) {e3=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set10;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set11:
e4=e4;
if(e4>100){e4=0;delay_ms(10);}
if(e4<0) {e4=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set11;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set12:
e5=e5;
if(e5>100){e5=0;delay_ms(10);}
if(e5<0) {e5=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set12;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set13:
e6=e6;
if(e6>100){e6=0;delay_ms(10);}
if(e6<0) {e6=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
else
goto set13;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
set14:
e7=e7;
if(e7>100){e7=0;delay_ms(10);}
if(e7<0) {e7=100;delay_ms(10);}
lcd_clear();
lcd_gotoxy(0,0);
lcd_gotoxy(0,1);
lcd_puts(lcd_buff);
delay_ms(100);
if(sw_ok==0) {delay_ms(150);goto Magelang;}
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’);
}
//=====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==0b01111110) {error=-e6;kode=12;}
//=====sensor mengarah ke Kanan
else if (sensor==0b11101110) {error=e0;}
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);
}
}
Nach ni dia hasil tunning pid pada robotku disini….dan disana…
Dan berikut aplikasi kontroler PID pada Robot-Wall Follower ato yg lebih dikenal dengan robot telusur dinding:
Blok sensor
Robot Line Follower dengan Multiplekser-ADC
Posted September 2, 2010 by Fahmizal in Robotika. Tagged: ADC line follower dengan multiplekser, line follower dengan multiplekser, line
follower dengan multiplekser 4051, line follower dengan multiplekser 4067, line tracer dengan multiplekser, membuat multiplekser ADC robot line
follower, merancang robot line follower dengan ADC, merancang sensor LF dengan multiplekser, multiplekser 4051, multiplekser 4067, program
line follower dengan multiplekser,program multiplekser pada line follower, sensor garis dengan multiplekser. 45 Komentar
14 Votes
Robot Line Follower dengan Multiplekser-ADC

wah…gak bosen-bosen nich buat share tentang robot line follower…coz ane mang maniak banget nich dengan ni
robot…kali ini ane mau ngeshare sedikit tentang merancang robot line follower dengan ADC dan ter-
multipleks…tujuannya kita dapat merancang sensor lebih banyak…jika pada awalnya kita memanfaatkan fungsi porta
mikrokontroler AVR sebagai I/O nach kali ini kita manfaatkan keistimewaan porta tersebut yaitu ADC (analog digital
converter)…dengan menggunakan ADC maka isyarat analog dari sensor dapat kita olah tanpa bantuan komparator
lagi…selain itu dengan penggunaaan ADC dapat menghemat komponen elektronika yang digunakan pada robot hanya
saja jika menggunakan ADC kita harus dilebih menguasai pemrograman untuk mengolah proses perkonversian ADC
tersebut…tapi tenang aja gak susah kok…di blog ane dah da cara mengolah ADC dan merancang multiplekser dengan IC
4051 tapi itu pemrogramannya pake Bascom AVR… menurut ane justru lebih gampang lo dari pada CodeVision AVR…
Nach ni dia pengalaman ane merancang sensor line follower sebanyak 16 buah…ilustrasi perancangan sensornya
perhatikan blok diagram berikut:
Dengan banyaknya sensor dampaknya logika pembacaan garis (mapping sensor terhadap garis akan semakin banyak)
maka dari itu akan banyak kondisi yang dapat di mapping oleh sensor jadi kalo da garis perempatan, pertigaan dapat
dengan mudah di mapping…dan memudahkan kita dalam merancang algoritma pemrograman.
nach ni dia video pada robotku disini….dan disana…
===============================================================
kalo mau liat artikel tentang:
1. robot-line-follower-dengan-kendali-pid klik disini
2. tuning-kontrol-pid-pada-robot-line-follower klik disini
3. merancang-multiplekser-adc klik disini
MAKALAH ROBOT LINE

FOLOWER
( ROBOT PENGIKUT GARIS )
Nama : Is Candra Rame

Kelas : XI EA
No : 14
SMK NEGERI TEMBARAK
Alamat : jln.Mantenan, Greges Tembarak Temanggung 56261. Telp : 0293-4903350
E-mail : smktembarak@yahoo.co.id. Web : www.smkntembarak.sch.id
ABSTRAK
Dalam makalah ini akan dibahas mengenai robot Line Follower. Robot ini merupakan
salah satu bentuk robot beroda yang memiliki komponen utama diantaranya, seperti resistor,
dioda, transistor, Led yang dirangkai untuk menghasilkan jenis kendaraan yang berjalan
secara otomatis dengan kecepatan tertentu mengikuti garis.
Di dalam rangkaian Line Follower terdapat 3 bagian utama, yaitu bagian sensor,
komparator dan driver. Untuk bagian sensor digunakan photodioda sebagai sensor cahaya,
sedangkan komparatornya menggunakan IC LM 324 sebagai pembanding tegangan dan
untuk drivernya digunakan 2 buah motor sebagai penggerak rodanya.
Hasil uji coba rangkaian Line Follower ini menunjukkan performa yang mampu
berjalan di beberapa medan, diantaranya medan lurus, belok, naik, dan menurun.
Kata kunci : Robot pengikut garis ( Line Follower )
KATA PENGANTAR
Puji syukur saya panjatkan ke hadirat Allah SWT Tuhan Yang Maha Esa, berkat rahmat
dan karunia-Nya, saya atas nama: Is candra Rame dari kelas XI EA dapat menyelesaikan
makalah dengan judul “LINE FOLOWER”, yang telah dipelajari disemester ketiga pada
program Studi mulok produktif jurusan Teknik Elektronika industri. Tidak lupa kami ucapkan
terima kasih kepada semua pihak yang telah membantu kami baik langsung maupun tidak
langsung.
Saya menyadari bahwa dalam pembuatan makalah ini masih banyak kekurangan, oleh
sebab itu saya t mengharapkan kritik dan saran yang membangun. Dan semoga makalah ini
bermanfaat .
Amin.
Tembarak,13 desember 2013
( Is Candra.R. )
DAFTAR ISI
Abstrak ....................................................................i
Kata Pengantar.............................................................ii
Daftar Isi.................................................................. iii
Daftar Gambar.............................................................iv
Daftar Tabel...............................................................vi
BAB I : PENDAHULUAN
.......................................................... 1
1.1. Latar Belakang
1.2. Rumusan Masalah....................................................... 1
1.3. Tujuan Masalah......................................................... 1
1.4. Batasan Masalah......................................................... 1
1.5. Ruang Lingkup.......................................................... 1
BAB II : LANDASAN TEORI

2.1. Motor DC dan IC L293D ................................................. 2
2.2. Sensor Optocaupler....................................................... 3
2.3Relay..................................................................... 4
2.4 Komponen-komponen Line Follower....................................... 4
 Resistor............................................................... 4
 Transistor............................................................ 4
 LED................................................................. 5
 Photo Dioda......................................................... 5
 IC.................................................................... 5
 Motor Penggerak (Dinamo) ........................................... 6
BAB III : PEMBAHASAN

3.1. Perancangan Alat......................................................... 7
3.2. Rangkaian Line Follower................................................. 8
.................................................. 8
3.3. Cara kerja Line Follower
 Prinsip kerja sensor.................................................... 8
 Prinsip kerja komparator............................................... 10
 Prinsip kerja Drivemator................................................ 11

3.4.
Control ................................................................... 11
3.5. Cara kerja robot pengikut garis............................................. 11
3.6. Uji coba Line Follower.................................................... 13
3.7. Komponen yang dibutuhkan............................................... 14
3.8. Program Pada Mikrokontroler............................................... 14
BAB IV : PENUTUP
4.1. Kesimpulan ................................................................15
4.2.
Saran ......................................................................15
Daftar
Pustaka...............................................................15
DAFTAR GAMBAR
Gambar 1. Konfigurasi Pin Mikrokontroler
AT89S51 .................................... 2
Gambar 2. Konfigurasi Motor
DC ..................................................... 3
Gambar 3. Konfigurasi IC
L293D ..................................................... 3
Gambar 4. Konfigurasi
Sensor Optocoupler ............................................ 3
Gambar 5. Konfigurasi
Relay ......................................................... 4
Gambar 6. Blok Diagram
Rangkaian .................................................. 7
Gambar 7. Rangkaian
Keseluruhan ................................................... 7
Gambar 8. Layout
Utama ............................................................
Gambar 9. Layout
Sensor ............................................................
Gambar 10. Ilustrasi Kerja
Sensor ..................................................... 9
Gambar 11. Letak Pemasangan
Sensor ................................................. 10
Gambar 12. Prinsip Kerja
Sensor ...................................................... 10
Gambar 13. Rangkaian
Sensor ........................................................ 12
Gambar 14. Robot Pengikut
Garis ..................................................... 12
Gambar 2.1. Simbol
Resistor .......................................................... 4
Gambar 2.2. Garis warna
Resistor ..................................................... 4
Gambar 2.3. Bentuk
Transistor ........................................................ 4
Gambar 2.4. Simbol
Transsistor ....................................................... 4
Gambar 2.5. Simbol
LED ............................................................. 5
Gambar 2.6. LED dan
Superbright ..................................................... 5
Gambar 2.7. Simbol photo
Dioda ...................................................... 5
Gambar 2.8. photo
Dioda ............................................................. 5
Gambar 2.9.
IC...................................................................... 6
Gambar 2.10. Op-AMP dalam rangkaian
IC............................................. 6
Gambar 2.11.
Motor ................................................................. 6
Gambar 3.1. Rangkaian line
follower ................................................... 8
Gambar 3.2. Rangkaian
sensor ......................................................... 9
Gambar 3.3. Rangkaian tidak terkena
cahaya ............................................ 9
Gambar 3.4. Rangkaian terkena
cahaya ................................................ 9
komparator ................................................... 10
driver ........................................................ 11
Gambar 3.7. Medan
lurus ............................................................ 13
Gambar 3.8. Medan
naik ............................................................. 13
Gambar 3.9. Medan
turun ............................................................ 13
Gambar 3.10. Medan
blok ............................................................ 13
Gambar 3.11. Medan
kombinasi ....................................................... 13
DAFTAR TABEL
Tabel 1. Daftar
Komponen ........................................................ 7
Tabel 2. Penggunaan Port Mikrokontroler
AT89S51 ................................ 11
Tabel 3. Hasil Analisa Kerja Robot Pengikut
Garis .................................. 12
BAB I
I. PENDAHULUAN
I.1. Latar Belakang
Perkembangan teknologi elektronika saat ini sudah sedemikian pesatnya yang kadang-
kadang berawal dari rangkaian-rangkaian sederhana yang biasa kita jumpai dalam buku-
buku hobby elektronika. Aplikasi dari Line Follower biasanya digunakan sebagai motor
mainan anak-anak dan juga sebagai sarana transportasi di area pabrik.. Jadi dalam makalah
ini akan dijelaskan rangkaian elektronika dari Line Follower beserta cara kerjanya.
I.2. Rumusan masalah

Berdasarkan latar belakang di atas, maka disusun rumusan masalah sebagai berikut :
1. Komponen apa saja yang diperlukan dalam pembuatan Line Follower.
2. Bagaimana prinsip kerja pada Line Follower r.
3. Bagaimana cara membuat rangkaian Line Follower.
I.3. Tujuan dan Manfaat
 Mengetahui komponen-komponen elektonika yang menjadi fungsi-fungsinya sehingga dapat
mengaplikasikannya dalam bentuk sebuah rangkaian.
 Mengetahui dan memahami sistem dan cara kerja Line Follower dengan segala kendala.
 Mengetahui bagaimana cara membuat rangkaian robot Line Follower.
 Mahasiswa mampu merancang dan mengimplementasikan suatu robot pengikut garis dengan
menggunakan mikrokontroler AT89S51 dan sensor optocoupler..
 Mahasiswa dapat memahami prinsip kerja robot pengikut garis berbasis mikrokontroler
AT89S51.
I.4 Batasan Masalah

Dalam penyusunan makalah ini kami hanya membatasi materi mengenai :
1. Fungsi tiap komponen dalam rangkaian Line Follower yang terdiri dari rangkaian sensor,
komparator, dan driver.
2. Prinsip kerja dari Line Follower.
1.5. Ruang Lingkup

Ruang lingkup pembuatan makalah ini, yaitu: pengenalan akan mekanisme dalam
pembuatan robot pengikut garis, komponen-komponen yang digunakan, fungsi dan cara
kerja sensor optocoupler, pengenalan akan IC mikrokontroler AT89S51, prinsip dan cara
kerja robot pengikut garis.
BAB II
DASAR TEORI
Robot pengikut garis merupakan robot yang bergerak secara otomatis mengikuti suatu
garis pandu yang telah ditentukan. Dalam perancangan dan implementasinya, masalah-
masalah yang harus dipecahkan adalah sistem penglihatan robot, arsitektur perangkat keras
yang meliputi perangkat elektronik dan mekanik, dan organisasi perangkat lunak untuk basis
pengetahuan dan pengendalian secara waktu nyata.
Untuk pembuatan robot pengikut garis berbasis mikrokontroler AT89S51 menggunakan
beberapa komponen antara lain:
 Mikrokontroler AT89S51
Mikrokontroler AT89S51 merupakan suatu komponen elektronika yang di dalamnya terdapat
rangkaian mikroprosesor, memori (RAM/ROM) dan I/O, rangkaian tersebut terdapat dalam
level chip atau biasa disebut single chip microcomputer. Pada mikrokontroler sudah terdapat
komponen-komponen mikroprosesor, dengan bus-bus internal yang saling berhubungan.
Komponen-komponen tersebut adalah RAM, ROM, Timer, I/O pararel dan serial, serta
interrupt control. Adapun keunggulan dari mikrokontroler adalah adanya system interupsi.
Mikrokontroler digunakan untuk keperluan control, atau kendali, biasa disebut dengan MCS,
dan yang digunakan dalam robot pengikut garis.
Mikrokontroler AT89S51 mempunyai 40 kaki, 32 kaki diantaranya digunakan sebagai port
pararel. Satu Port pararel terdiri 8 kaki, dengan demikian 32 kaki tersebut membentuk 4
buah Port pararel, yang masing-masing dikenal sebagai Port 0, Port 1, Port 2, dan Port 3.
Nomor dari masing-masing jalur (kaki) dari Port pararel mulai dari 0 sampai 7, jalur (kaki)
pertama Port 0 disebut sebagai P0.0 dan jalur terakhir untuk Port 3 adalah P3.7 (Gambar 1).
Gambar 1. Konfigurasi Pin Mikrokontroler AT89S51
2.1. Motor DC dan IC L293D

Motor DC adalah motor yang biasa digunakan pada perangkat elektronika dalam hal ini
motor digunakan untuk menggerakan roda. Motor dapat bergerak kearah kanan dan kearah
kiri jika motor DC dapat instruksi dari IC L293D. Konfigurasi motor DC dapat dilihat pada
Gambar 2.
Gambar 2. Konfigurasi Motor DC

Motor driver merupakan suatu rangkaian yang mengatur kerja motor atau biasa dikatakan
sebagai suatu rangkaian penggerak motor sehingga motor tersebut bekerja atau beroperasi
sesuai dengan apa yang kita kehendaki. Pada saat motor ini beroperasi atau bekerja
biasanya terjadi induksi yang mengakibatkan tegangan menjadi sangat tinggi, sehingga
diperlukan suatu rangkaian motor driver yang mengatur motor agar pada saat motor
tersebut beroperasi dia tidak akan mengakibatkan gangguan kepada rangkaian-rangkaian
lain yang berhubungan dengan motor.
Pada pembuatan alat ini kami menggunakan IC L293D sebagai motor driver. IC L293D
mempunyai empat pin input dan empat pin output, dapat dilihat pada Gambar 3. IC L293D
merupakan rangkaian penyangga (buffer) pada system digital yang dapat mempertahankan
jumlah tegangan maupun arus sehingga dapat menggerakkan motor DC dengan stabil
tanpa mempengaruhi rangkaian lainnya.
Gambar 3. Konfigurasi IC L293D
2.2. Sensor Optocoupler

Sensor optocoupler tersusun atas LED inframerah sebagai transmitter dan photodioda
sebagai receiver (Gambar 4). LED inframerah adalah dioda yang dapat memancarkan
cahaya dengan panjang gelombang lebih panjang dari cahaya yang dapat dilihat, tetapi
lebih pendek dari gelombang radio apabila LED inframerah tersebut dialiri arus. LED
digunakan untuk memantulkan cahaya antara cahaya cerah dan gelap ke
photodioda.Photodioda adalah sebuah dioda semikonduktor yang berfungsi sebagai sensor
cahaya. Photodioda memiliki hambatan yang sangat tinggi pada saat dibias mundur.
Hambatan ini akan berkurang ketika photodioda disinari cahaya dengan panjang gelombang
yang tepat. Sehingga photodioda dapat digunakan sebagai detektor cahaya dengan
memonitoring arus yang mengalir melaluinya.
Gambar 4. Konfigurasi Sensor Optocoupler
2.3. Relay
Prinsip kerja pada relay adalah pada saat kumparan dialiri arus, maka akan menimbulkan
magnet pada intinya, dengan adanya magnet pada intinya maka jangkar atau angker akan
tertarik oleh inti. Dengan ditariknya jangkar oleh inti maka kontak-kontak relay berubah
posisi dan menyebabkan relay akan terhubung (Gambar 5).
Gambar 5. Konfigurasi Relay
2.4. Komponen-komponen Line Follower

Komponen-komponen pada rangkaian Line Follower terdiri dari :
A. Resistor
Penggunaan resistor dalam rangkaian berfungsi sebagai penghambatarus listrik,
memperkecil arus dan membagi arus listrik dalam suatu rangkaian. Satuan yang dipakai
untuk menentukan besar kecilnya nilai resistor adalah Ohm atau disingkat dengan Ω
(Omega).
Gambar 2.1. Simbol resistor
Gambar 2.2. Garis warna resistor
B. Transistor
Transistor adalah suatu bahan yang dapat merubah bahan yang tidak dapat
menghantarkan arus listrik menjadi bahan penghantar atau setengah menghantar arus
listrik. Sifat ini disebut bahan semikonduktor.
Gambar 2.3. Bentuk transistor
( PNP )
( NPN )
Gambar 2.4. Simbol transistor
Cara kerja transistor :
 Untuk NPN, jika ada arus yang mengalir dari basis menuju emitor maka akan ada arus
yang mengalir dari collector menuju emitor.
 Untuk PNP, jika ada arus yang mengalir dari emitor menuju basis maka akan ada arus
yang mengalir dari emitor menuju collector.
B = Ic / Ib, dimana Ic >> Ib
Dimana, B : besar penguatan
Ic : arus collector
Ib : arus basis
C. LED (Light Emiting Diode) dan LED Superbright

LED biasa berfungsi sebagai lampu indikator pada saat sensor bekerja, dan bekerja pada
bias forward. LED Superbright berfungsi sebagai pengirim cahaya ke garis untuk dibaca
sensor. Kerjanya ketika sumber tegangan masuk pada battery on, maka arus masuk
sehinnga Led superbrigth menyala dengan terang yang kemudian dibiaskan pada
photodioda.
Gambar 2.5 Simbol Led
Gambar 2.6 Led dan Superbright
D. Photo Dioda
Photo dioda berfungsi sebagai sensor cahaya. Cara pemasangannya dengan LED indikator
yaitu terbalik. Bekerja pada bias reverse.
Gambar 2.7. Simbol photo dioda
Gambar 2.8. Photo dioda
E. IC (Integrated Circuit)
Komponen IC memilki bentuk fisik kecil, terbuat dari bahan Silikon dan berwarna
hitam. Komponen IC memiliki banyak kaki dan pada umumnya jumlah kakinya sangat
tergantung dari banyaknya komponen yang membentuk komponen IC tersebut. Letak kaki-
kaki disusun dalam bentuk dua baris atau Dual In Line (DIL).
IC yang digunakan adalah IC LM 324. IC disini digunakan sebagai komparator. Yaitu
membandingkan antara tegangan input dari sensor dengan tegangan input dari variable
resistor. Pulsa outputnya adalah high sehingga tidak diperlikan adanya pull-up pada
rangkaian output.
Gambar 2.9. IC
Gambar 2.10. Op-Amp dalam rangkaian IC
F. Motor Penggerak (Dinamo)

Motor adalah komponen yang mengubah energi listrik menjadi energi mekanik, dalam kasus
perancangan robot, umumnya digunakan motor DC, karena jenis motor tersebut mudah
untuk dikendalikan.
Kecepatan yang dihasilkan oleh motor DC berbanding lurus dengan potensial yang
diberikan. Untuk membalik arah putarnya cukup membalik polaritas yang diberikan.
Gambar 2.11. Motor
BAB III
III. PEMBAHASAN
3.1. Perancangan Alat
Dalam perancangan robot pengikut garis, terdapat masukan berupa sensor cahaya yang
diproses oleh mikrokontroler AT89S51 dan menghasilkan keluaran motor DC seperti
Gambar 6.
Gambar 6. Blok Diagram Rangkaian
Secara keseluruhan robot pengikut garis dirancang dengan

menggunakan hardware(masukan berupa sensor dan keluaran berupa motor DC)
dan software (kendali mikrokontroler). Masukan pada alat ini berupa sensor yang
menghasilkan dua kondisi yaitu high dan low. Setelah masukan diproses maka keluaran
motor DC akan aktif. Rangkaian keseluruhan dari perancangan digambarkan pada Gambar
7.
Gambar 7. Rangkaian Keseluruhan
Komponen-komponen yang digunakan adalah sebagai berikut:

Komponen utama Komponen Sensor
Nama Komponen Unit Nama Komponen Unit
Optocoupler/sensor
IC Regulator 7805 1 2
J4209-01
Elco 1000µF/16V 1 Resistor 100Ω (R3) 2
Resistor 1KΩ (R1) 1 Resistor 47KΩ (R4) 2
Led 1 Transistor C5343 2
IC L293D + Socket 1
IC AT89S51 + Socket 1
X-Tal 11 Mhz 1
Kondensator Keramik
2
33pF/22pF
Elco 10µF/16V 1
Resistor 4K7Ω (R2) 1
Relay 6V 2
Saklar 1
Tabel 1. Daftar Komponen
3.2. Rangkaian Line Follower
Dari beberapa komponen diatas, maka dihasilkan sebuah rangkaian Line Follower.
Rangkaian Line Follower terdiri dari tiga bagian
utama, yaitu rangkaian sensor, rangkaian komparator (pembanding) dan rangkaian driver.
Gambar 3.1. Rangkaian Line Follower
3.3. Cara Kerja Line Follower

Cara kerja dari rangkaian-rangkaian tersebut adalah sebagai berikut :
A. Prinsip Kerja Sensor
Sensor yang digunakan terdiri dari photo dioda. Sensor ini nilai resistansinya akan
berkurang bila terkena cahaya dan bekerja pada kondisi riverse bias. Untuk sensor
cahayanya digunakan LED Superbright, komponen ini mempunyai cahaya yang sangat
terang, sehingga cukup untuk mensuplai cahaya ke photo dioda.
Gambar 3.2. Rangkaian sensor
Cara kerjanya :
Gambar 3.3. Sensor tidak terkena cahaya

Jika photo dioda tidak terkena cahaya, maka nilai resistansinya akan besar atau dapat kita
asumsikan tak hingga. Sehingga arus yang mengalir pada komparator sangat kecil atau
dapat diasumsikan dengan logika 0.
Gambar 3.4. Sensor terkena cahaya

Jika photo dioda terkena cahaya, maka photo dioda akan bersifat sebagai sumber tegangan
dan nilai resistansinya akan menjadi kecil, sehingga akan ada arus yang mengalir ke
komparator dan berlogika 1.
Sensor, dapat dianalogikan sebagai ‘mata’ sebuah robot yang berfungsi untuk ‘membaca’
garis hitam dari track robot. Sehingga robot mampu mengetahui kapan dia akan berbelok ke
kiri, kapan dia berbelok ke kanan dan kapan dia berjalan lurus (Gambar 10). Dimana sensor
sebelah kiri mengendalikan motor sebelah kanan, begitu sebaliknya sensor sebelah kanan
mengendalikan motor sebelah kiri. Sensor yang digunakan adalah sensor optocoupler yang
dipasang di bagian depan bawah robot (Gambar 11), sehingga mampu mengetahui garis
gelap dari latar belakang terang.
Gambar 8. Ilustrasi Kerja Sensor
Gambar 9. Letak Pemasangan Sensor

Prinsip kerja dari sensor tersebut sederhana, ketika transmitter (infrared) memancarkan
cahaya ke bidang berwarna putih, cahaya akan dipantulkan hampir semuanya oleh bidang
berwarna putih tersebut. Sebaliknya, ketika transmitter memancarkan cahaya ke bidang
berwarna gelap atau hitam, maka cahaya akan banyak diserap oleh bidang gelap tersebut,
sehingga cahaya yang masuk ke receiver tinggal sedikit (Gambar 12).
Gambar10. Prinsip Kerja Sensor
B. Prinsip Kerja Komparator

Komparator pada rangaian ini menggunakan IC LM 324 yang didalamnya berisi rangkaian
Op Amp digunakan untuk membandingkan input dari sensor. Dimana input akan
dibandingkan dari Op Amp IC LM 324 yang output berpulsa high. Sehingga tidak perlu
adanya pull up pada outputnya. IC ini dapat bekerja pad range 3 volt sampai 30 volt dan
dapat bekerja dengan normal mulai tegangan 6 volt.
Dalam rangkaian ini juga terdapat 4 LED, yang berfungsi sebagai indikator. Untuk mengatur
tagangan pada pembanding, disambungkan Variable Resistor (VR) diantara kedua OP Amp
IC LM 324.
Gambar 3.5. Rangkaian komparator
► Jika tidak ada arus yang mengalir dari rangkaian sensor ke rangkaian ini maka tegangan
masukan untuk rangkaian ini adalah 0 Volt, akibatnya pada IC 1 tegangan di terminal (+) > (-
), maka LED-A on, sedangkan pada IC 2 sebaliknya LED-B off.
► Jika ada arus yang mengalir dari rangkaian sensor ke rangkaian ini maka tegangan
masukan untuk rangkaian ini mendekati Vcc, akibatnya pada IC 2 tegangan di terminal (+) <
(-), maka LED-B on, sedangkan pada IC 1 sebaliknya maka LED-A off.
Kondisi antara titik A dan b akan selalu keterbalikan.
C. Prinsip Kerja Driver Motor

Driver adalah rangkaian yang tersusun dari transistor yang digunakan untuk menggerakkan
motor DC. Dimana komponen utamanya adalah transistor yang dipasang sesuai
karakteristiknya.
Gambar 3.6. Rangkaian driver

Pada saat input A berlogika 1, maka ada arus yang mengalir pada rangkaian,
akibatnya transistor 1 dan 4 on karena basis terbias, sehingga motor berputar. Sehingga
saat input A berlogika 1 maka input B akan berlogika 0, jadi transistor 2 dan 3 akan off.
Pada saat input B berlogika 1, maka ada arus yang mengalir pada rangkaian,
akibatnya transistor 2 dan 3 on karena basis terbias, sehingga motor berputar tapi dengan
arah yang berlawanan.
3.4. Control
Blok control ini merupakan jantung rangkaian sebagai pengontrol utama dari keseluruhan
rangkaian, dimana sebagai pengontrol digunakan IC mikrokontroler AT89S51. Pada
perancangan alat ini digunakakan P1.0, P1.1, P1.3, P1.4, P1.5, dan P1.6. Untuk lebih
jelasnya penggunaan port mikrokontroler AT89S51 terlihat seperti Tabel 1.
Port Penggunaan
P1.0 Input Sensor 1
P1.1 Input Sensor 2
P1.3 IC L293D (In 4)
P1.4 IC L293D (In 3)
P1.5 IC L293D (In 2)
P1.6 IC L293D (In 1)
Tabel 2. Penggunaan Port Mikrokontroler AT89S51
3.5. Cara Kerja Robot Pengikut Garis

Sistem robot pengikut garis yang dirancang mengacu pada sistem robot bergerak otonom,
seperti digambarkan dalam blok diagram rangkaian yang ditunjukkan pada Gambar 7.
Parameter yang ingin diamati oleh robot adalah keberadaan garis pandu melalui sensor
(Gambar 14) dan menghasilkan sinyal digital. Sinyal digital tersebut kemudian dikirim ke IC
mikrokontroler AT89S51 melalui port-port (P1.0 dan P1.1) untuk diolah berdasarkan basis
pengetahuan yang diprogram dalam mikrokontroler sehingga dihasilkan perintah aksi
(output) yang harus dilakukan. Perintah ini kemudian diteruskan melalui port-port (P1.3,
P1.4, P1.5 dan P1.6) ke IC L293D sebagai rangkaian pengendali motor dengan melalui
relay sehingga akhirnya bagian aktuasi yang berupa motor DC bergerak sesuai dengan
perintah. Dengan demikian pergerakan robot diharapkan dapat mengikuti garis sesuai
dengan misi yang diembannya.
Berikut di bawah ini adalah tabel hasil analisa kerja robot pengikut garis saat dijalankan
pada
lintasan Sensor Motor Kondisi
garis Kanan Kiri Kanan Kiri Robot
hitam/gela Hitam Hitam Berputar Berputar Jalan Lurus
p dengan
Hitam Putih Diam Berputar Belok Kanan
latar
Putih Putih Berputar Berputar Jalan Lurus
belakang
Putih Hitam Berputar Diam Belok Kiri
putih/teran
g:
Tabel 3. Hasil Analisa Kerja Robot Pengikut Garis
Gambar 11. Rangkaian Sensor
Gambar 12. Robot Pengikut Garis

3.6. Uji Coba Line Follower
Hasil uji coba Line Follower ini menunjukkan mampu berjalan di beberapa medan,
dintaranya medan lurus, belok, naik, dan menurun.
► Hasil : 3 detik jarak =100 cm

Gambar 3.7. Medan lurus
Gambar 3.8. Medan naik
Gambar 3.9. Medan turun
Gambar 3.10. Medan belok
Gambar 3.11. Medan kombinasi

3.7.Komponen Yang Dibutuhkan
Dalam pembuatan rangkaian Line Follower ini dibutuhkan beberapa komponen-komponen
elektronika, yaitu sebagai berikut :
Komponen Jumlah
(buah)
1. IC LM 324 1
2. Resistor 33 KΩ 2
3. Resistor 10 KΩ 4
4. Resistor 560 Ω 10
5. Transistor (TR) 9013 8
6. Variable Resistor (VR) 2
7. LED Indikator 4
8. LED Superbright 2
9. Photodioda 2
10. Motor 3 Volt 2
11. PCB Metrik 1
12. Baterai 1
13. Saklar Togle 1
3.8. Program Pada Mikrokontroler

Setelah merealisasikan rangkaian perangkat keras, maka langkah selanjutnya adalah
membuat program untuk menjalankan alat tersebut. Karena sebuah mikrokontroler tidak
akan bekerja bila tidak diberikan program kepadanya. Program tersebut memberitahukan
mikrokontroler apa yang harus dilakukan. Program untukmikrokontroler AT89S51 ini dibuat
menggunakan bahasa assembler ASM51. Sesudah di-compile menjadi file hexa
(*.hex), program ini kemudian di-download ke
dalammikrokontroler menggunakan mikrokontroler programmer.
Listing programnya adalah sebagai berikut :
BAB IV
PENUTUP
Line Follower r adalah suatu robot rangkaian elektronik yang tersusun dari beberapa
komponen-komponen elektronik. Dalam Line Follower terdapat 3 bagian rangkaian utama,
yaitu ; rangkaian sensor (menggunakan photo dioda sebagai sensor cahaya), komparator
(menggunakan IC LM 324 sebagai pembanding suatu tegangan) dan driver (digunakan
sebagai penggerak roda).
Hasil uji coba Line Follower ini menunjukkan mampu berjalan di beberapa medan,
dintaranya medan lurus, belok, naik, dan menurun.
4.1. KESIMPULAN
Pengujian robot pengikut garis dilakukan diatas garis gelap/hitam dengan latar belakang
terang/putih.
 Dari hasil pengujian terlihat bahwa robot pengikut garis yang dibuat telah mampu
mengikuti garis yang ditentukan. Akan tetapi robot tidak mampu mengikuti garis dengan
belokkan yang tajam.
 Robot pengikut garis akan berjalan lurus pada saat kedua sensor berada di atas
garis gelap/hitam, dan juga pada saat kedua sensor berada di atas area terang/putih. Dan
robot pengikut garis akan berbelok ke kanan pada saat sensor kanan berada di atas garis
gelap/hitam dan sensor kiri berada di atas area terang/putih. Begitupun sebaliknya robot
pengikut garis akan berbelok ke kiri pada saat sensor kiri berada di atas garis gelap/hitam
dan sensor kanan berada di atas area terang/putih.
 Kecepatan robot dalam mengikuti garis dipengaruhi oleh bentuk lintasan garis dan
tegangan motor DC sebagai penggerak.
 Mikrokontroler AT89C51 dapat digunakan sebagai pengendali robot pengikut garis
dengan unjuk kerja yang baik.
 Sensor optocoupler dapat digunakan untuk mendeteksi perbedaan warna
berdasarkan tingkat penyerapan warna bahan dengan unjuk kerja yang baik.
4.2. Saran
Berikut ini adalah beberapa tambahan yang diperlukan dalam meningkatkan kemampuan
robot pengikut garis:
 Robot pengikut garis yang kami buat tidak bisa berhenti secara otomatis untuk itu
bisa dimodifikasi dengan menuliskan program stop pada listing program.
 Robot tidak mampu mengikuti garis dengan tikungan yang tajam, dikarenakan dari
bentuk mekanisme robot yang kurang sempurna, juga karena kesensitifan sensor masih
kurang, maka sebaiknya dibuat mekanisme yang fleksibel terhadap tikungan yang tajam,
juga dengan menambahkan sensor sehingga akan lebih sensitif
 V. DAFTAR PUSTAKA
 Dedy Rusmadi, Aneka Rangkaian Elektronika Alarm dan Bel Listrik, Pioner Jaya, Bandung,
2005.
 Politeknik Elektronika Negeri Surabaya, Pelatihan Line Tracer, ITS, 2006.
 http://www.te.ugm.ac.id/~bsutopo/stevanus.pdf
 http://papers.gunadarma.ac.id/index.php/industry/article/view/563/524
 http://www.gunadarma.ac.id/library/articles/graduate/industrial-technology/2
Ø010/Artikel_10405805.pdf
https://fahmizaleeits.wordpress.com/2010/07/27/pengaturan-kecepatan-motor-dc-dengan-mikrokontroler/
https://fahmizaleeits.wordpress.com/2010/09/02/robot-line-follower-dengan-multiplekser-adc/
https://fahmizaleeits.wordpress.com/2010/05/08/robot-line-follower-dengan-kendali-pid/
https://fahmizaleeits.wordpress.com/2010/05/01/membuat-robot-line-follower-mikro/
http://e-belajarelektronika.com/membuat-robot-line-follower-dengan-avr-atmega8535/
http://profesorbolabot.blogspot.co.id/2013/03/desain-proteus-program-cv-avr-robot.html
https://fahmizaleeits.wordpress.com/2010/08/24/tuning-kontrol-pid-pada-robot-line-follower/

Bahasa

DESAIN PROTEUS and PROGRAM Code Vision A

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

DESAIN PROTEUS and PROGRAM Code Vision A

Judul Asli:

Diunggah oleh

Hak Cipta:

Format Tersedia

DESAIN PROTEUS & PROGRAM Code Vision AVR

ROBOT LINE FOLLOWER DIGITAL RA04

Silahkan download file pdf berikut:

1. Desain Proteus dan Code Vision AVR Line Follower ATMega 16

Gambar 2. Diagram blok robot line follower

ROBOT LINE FOLLOWER DIGITAL MIKROKONTROLER ATMEGA 16

Skema Lengkap Line follower Digital IC Komparator

Tabel 1. Kondisi Gerak Motor dan pengaruh Sensor

Kondisi B.0 = 0 B.0 =1

B.1 = 0 Maju Belok Kiri

B.1 = 1 Belok Kanan Mati

Kondisi D.0 D.1 D.2 D.3

Project : Robot Line follower

Chip type : ATmega16

// Alphanumeric LCD Module functions

// Declare your global variables here

// Input/Output Ports initialization

// External Interrupt(s) initialization

// Timer(s)/Counter(s) Interrupt(s) initialization

// Analog Comparator initialization

// Alphanumeric LCD initialization

// Tambahan kode mendefinisikan input output

Gambar 4. Skema lengkap robot line follower menggunakan AT Mega 8

Project : Bolabot Line Follower Digital AT Mega 8

Chip type : ATmega8

// Declare your global variables here

// Input/Output Ports initialization

// External Interrupt(s) initialization

// Timer(s)/Counter(s) Interrupt(s) initialization

// Analog Comparator initialization

DDRC.4=0; // input sensor

OCR1A=150; // kecepatan motor dapat diatur sesuai kebutuhan

Membuat Robot Line Follower dengan Mikrokontroler

Membuat Robot Line Follower dengan Mikrokontroler

sistem pergerakan robot

ROBOT LINE FOLLOWER dengan Kendali PID

Formula matematis dari PID:

Dari formula tersebut dapat dirumuskan menjadi pen-

Nach…jika kita terapkan dalam bahasa pemrograman

dari blok iliustrasi tersebut dapat q jelasin sebagai berikut:

Program Pengaturan Kecepatan Motor DC dengan Bascom AVR

TUNING KONTROLER PID Pada Robot Line Follower

TUNING KONTROLER PID LINE FOLLOWER

Dari blok diagram diatas dapat q jelasin sebagai berikut

Dari blok iliustrasi tersebut dapat q jelasin sebagai berikut:

Simulasi PID Parameter : klik here

Robot Line Follower dengan Multiplekser-ADC

MAKALAH ROBOT LINE

Nama : Is Candra Rame

Tembarak,13 desember 2013

Daftar Isi.................................................................. iii

1.2. Rumusan Masalah....................................................... 1

1.3. Tujuan Masalah......................................................... 1

1.4. Batasan Masalah......................................................... 1

1.5. Ruang Lingkup.......................................................... 1

BAB II : LANDASAN TEORI

2.4 Komponen-komponen Line Follower....................................... 4

BAB III : PEMBAHASAN

 Prinsip kerja sensor.................................................... 8

 Prinsip kerja komparator............................................... 10

 Prinsip kerja Drivemator................................................ 11