Membuat dan Merancang Strategi ROBOT SUMO

Membuat dan Merancang Strategi ROBOT SUMO

Oke kali ini kita akan membahas bagaimana cara membuat dan merakit robot sumo sederhana, bagi kalian yang pengen ngebuat robot sumo untuk keperluan tugas ataupun ingin mengikuti kejuaraan, lets chek it out…

sumo-robot-fight

Sebelum memulai merakit robot sumo tentunya kita perlu mengetahui komponen2 penting untuk menyusun sebuah robot sumo yang sederhana ini, langsung saja berikut adalah komponen2 utama yang diperlukan penyusun robot SUMO antara lain :

1. Motor DC -> Motor DC adalah suatu mesin yang berfungsi merubah tenaga listrik arus searah menjadi tenaga gerak, dimana tenaga gerak tersebut berupa putaran motor. Pada prinsipnya mesin listrik dapat berlaku sebagai  motor atau generator. Perbedaan hanya terletak pada konversi dayanya, jika generator merubah daya mekanik menjadi daya listrik sedangkan motor merubah daya listrik menjadi daya mekanik.Sedangkan tipe motor DC yang digunakan dalam pembuatan robot sumo ini  adalah tipe magnet permanen, karena tipe ini lebih mudah dalam pengontrolannya, disamping itu dimensi yang tidak terlalu besar.Motor DC pada saat ini banyak digunakan pada industri yang memerlukan gerakan dengan kepresisian yang sangat tinggi untuk pengaturan kecepatan pada torsi yang konstan. Motor DC berfungsi mengubah tenaga listrik menjadi tenaga mekanis dimana gerak tersebut berupa putaranmotor_dc_800rpm

 

2. Sensor Garis -> Sensor garis atau sensor proximity adalah jenis sensor yang berfungsi mendeteksi warna garis hitam atau putih dengan menggunakan LED sebagai transmitter dan photodioda sebagai receiver. Dengan memanfaatkan IC comparator sebagai pem­banding tegangan, hasil yang berubah-ubah yang diperoleh dari receiver diolah menjadi data digital berupa logika high atau low untuk kemudian diolah di dalam mikrokontroler.garis

3. sensor jarak -> sensor jarak disini digunakan untuk mendeteksi keberadaan musuh, kita bisa menambahkan beberapa sensor jarak untuk memudahkan pendeteksian keberadaan musuh, namun jika mengingikan menambahkan hanya 1 buah sensor jarak maka perlu dilakukan metode “scanning enemy” yang lebih akurat.

untuk sensor jarak yang bisa digunakan ada beberapa jenis namun disini kita bisa menggunakan beberapa jenis sensor jarak yg cukup murah dan cukup akurat antara lain :

a. sensor sharp gp.

sensor sharp GP memiliki karakteristik respon yg cepat, sensor ini memanfaatkan cahaya sebagai media pemantulannya, namun cukup akurat untuk membuat sebuah robot sumo, sensor ini juga termasuk cukup murah untuk yaitu sekitar Rp. 150-170 ribu dipasaran.

sharp-gp2d120xj00f-350.jpg

 

 b.  sensor Ultrasonik.

sensor Ultrasonik disini sebenarnya memiliki banyak tipe namun disini sesnsor yang kita pilih adalah sensor ultrasonik merk PING))) karena memiliki kualitas dan karakteristik yang lebih baik dari sensor ultrasonik yang ada dipasaran, harga dari sensor ini juga relatif murah walaupun lebih mahal jika dibandingkan dengan sensor Sharp GP yaitu berkisar antara Rp. 350-400 ribu di pasaran.

Parallax_Ping_Lo.jpg

c. sensor infrared.

Sensor infrared merupan sensor yg memanfaatkan sinar Infrared sebagai media pantulnya, sensor ini memiliki harga yg relatif lebih murah daripada bebrapa sensor jarak yang beredar dipasaran, yaitu sekitar Rp. 100-120 ribu. namu sensor ini memiliki beberapa kelemahan jika dibandingkan dengan sensor jarak lainnya.

IR Reflection Sensor.jpg

4. Minimum system

Minimum sistem disini berfungsi sebagai otak dari robot sumo itu sendiri, disini kita bisa menggunakan berbagai jenis minimum sistem dengan mebuat sendiri maupun dengan menggunakan modul yang tersedia di pasaran.

Sismin ATMEGA8.jpg

selain menggunakan minisistem rakitan sendiri kita juga bisa menggunakan moduL ARDUINO sebagai otak dari robot sumo, penggunaan arduino menjadi lebih flexibel karena arduino memiliki sifat open source sehingga lebih mudah untuk diaplikasikan untuk membangun sebuah robot.

ARDUINO_NANO_03.png 5. driver Motor.

driver motor disini sangant berperan penting untuk mengendalikan kecepatan motor DC yang akan dipakai untuk membangun ROBOT SUMO ini karena robot akan mudah keluar lintasan ketika kecepatan dari motor tidak dapat diatur. disini driver motor yang kita gunakan adalah seri L298N karena lebih mudah didapatkan di pasaran danjuga mudah untuk diakses.

2

nahh, setelah membahas komponen utama yang diperlukan untuk membangun robot sumo itu sendiri kita juga membutuhkan beberapa komponen tambahan antara lain seperti dibawah ini :

    • mekanik berupa Frame, dan roda
    • catu daya
    • komponen2 pasif seperti resistor, kapasitor, kabel jumper, dll.

tahap selanjutnya adalah bagaimana membangun robot sumo itu sendiri sehingga dapat bekerja dengan baik, let’s chek it out !!

-> Konfigurasi Sistem

Secara umum konfigurasi sistem dari Robot Sumo ini terdiri dari input, kontroler dan output. Dari sisi masukan (input) terdiri dari sensor inframerah, kontroler yang digunakan adalah mikrokontroller AVR ATMega328, dan pada sisi keluaran (output) digunakan driver motor.

1

Pada robot sumo, hal sangat di perlukan adalah teknik pergerakan yang baik pada robot, yang paling utama adalah dapat bertahan ketika di serang dan menyerang lawan. sehingga untuk menerapkan teknik tersebut   diperlukan stategi sebagaimana dijelaskan pada gambar di bawah ini:

2.png

Sedangkan penjelasan mekanisme gerak Robot Sumo dapat di jelaskan pada  table di bawah ini:

3

4

Setelah menyiapkan semua komponen utama dan melakukan perancangan system hardware, tentunya kita membutuhkan strategi untuk bertanding yang baik, berikut kita akan membahas beberapa strategi bertanding dalam robot sumo.

-> perancangan strategi pertandingan :

Pada pengujian sistem secara keseluruhan ini akan diuji bagaimana sensor bekerja bila ada halangan didepan robot. Pada gambar berikut menunjukkan pergerakan robot bila ada halangan didepan kiri robot.

15.png

Bila robot mendeteksi halangan berada disebelah kanan maka robot akan bergerak kekanan.

Robot mendeteksi adanya halangan yang berada didepan atau bisa dikatakan juga bahwa kedua sensor yang berada dibagian depan robot mendeteksi adanya halangan maka robot akan bergerak maju dengan cepat hingga mendorongnya keluar arena.

16.png

Tabel berikut menunjukkan sensor yang aktif dan tindakan yang harus dilakukan Robot Sumo.

Tabel. Pergerakan Robot Sumo ketika ada lawan :

17.png

Jika halangan masih berada didalam range pendeteksian sensor, maka halangan tersebut masih dapat terdeteksi, namun jika halangan sudah berada diluar range pendeteksian sensor maka halangan tidak dapat terdeteksi.

Dengan menggunakan dua sensor yang berada dibagian depan robot, maka robot dapat mendeteksi dimana halangan tersebut berada. Apabila sensor yang terletak sebelah kiri yang mendeteksi adanya suatu halangan maka robot akan bergerak kekiri, begitu juga bila sensor yang terletak disebelah kanan robot mendeteksi adanya halangan maka robot akan bergerak kekanan. Apabila halangan yang berada disebelah kanan maupun kiri robot terdeteksi maka robot akan bergerak tidak terlalu cepat untuk mendekati halangan tersebut, namun bila robot mendeteksi bahwa halangan sudah berada didepan robot (kedua sensor mendeteksi adanya halangan) maka robot akan bergerak cepat kemudian mendorongnya hingga keluar arena. Apabila robot lawan berada disebelah kanan maupun disebelah kiri maka hanya diikuti (tidak diserang), robot lawan akan diserang ketika robot lawan berada tepat didepan.

18.png

Apabila robot diserang dari sebelah kanan smaka robot akan menghindar dengan bergerak maju kemudian bergerak kekanan. Sedangkan apabila robot diserang dari sebelah kiri maka robot juga akan menjauh dari serangan lawan dengan bergerak maju kemudian bergerak ke kekiri seperti yang ditunjukkan oleh gambar diatas.

19

Namun bila robot diserang dari belakang maka robot akan bergerak maju kemudian robot tersebut berputar.

20

Apabila robot diserang oleh robot lawan dari sisi belakang, samping kiri dan kanan, maka robot tersebut akan menghindar dengan menjauh dari robot lawan. Tabel berikut menunjukkan pergerakan dari Robot Sumo ketika diserang oleh robot lawan dari sebelah kiri, kanan, dan belakang.

Tabel. Pergerakan Robot Sumo Menghindar dari Serangan Lawan

21.png

Untuk pergerakan robot sumo dalam mendeteksi adanya garis maka robot tersebut akan bergerak. sensor garis yang terletak disebelah kiri robot mendeteksi adanya garis, maka robot akan bergerak seperti yg ditunjukan oleh tabel diatas. Robot tersebut bergerak mundur kemudian robot tersebut berputar serong kekanan kemudian kembali ke tengah arena.

22.png

Table Pergerakan Robot Sumo Ketika Mendeteksi Garis

27.png

Jadi bila robot mendeteksi adanya garis maka robot akan bergerak sejauh mungkin agar robot tidak keluar arena. Sensor garis ini berfungsi sebagai prioritas utama dari sensor-sensor yang lainnya. Apabila sensor lain mendeteksi adanya halangan maka robot akan bergerak menghindar, namun apabila sensor lain mendeteksi adanya halangan dan pada saat yang sama sensor garis mendeksi adanya garis maka robot diperintahkan untuk menghindar dari garis terlebih dahulu. Karena posisi yang paling utama adalah bertahan di atas arena.

-> Perancangan dan Pembuatan Perangkat Lunak 

Sistem perangkat lunak pada proyek akhir ini adalah mengaktifkan sensor dan menggerakkan motor dengan menggunakan CodeVision AVR. Flowchart sistem ditunjukkan pada gambar berikut :

14.png

disini saya ingin berbagi sedikit source code program menggunakan CVAVR, jika teman2 berminat untuk mengembangkan program ini, berikut adalah source code program robot sumo yg telah saya bangun dengan menggunakan mikrokontroller AT-MEGA 8 :

/*****************************************************
Project : SUMO ROBOT
Version : 0.1
Date : 25/07/2016
Author : HENDRIL SATRIAN PURNAMA
Company : RELif-line
Comments: Bismillah !!!

Chip type : ATmega8
Program type : Application
AVR Core Clock frequency: 16,000000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 256
*****************************************************/

#include <mega8.h>
#include <stdio.h>
#include <delay.h>
#include <alcd.h>

#define kiju OCR1B
#define kidur PORTB.0
#define kadur PORTB.3
#define kaju OCR1A

#define led_lcd PORTD.3

#define ADC_VREF_TYPE 0x40

// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}

// Declare your global variables here
int line1, line2, line3, line4;
int sharp;
unsigned char buff[33];
void motor(int pwmkiri,int pwmkanan)
{

if (pwmkiri>255)pwmkiri=255;
if (pwmkiri<-255)pwmkiri=(-255);
if (pwmkanan>255)pwmkanan=255;
if (pwmkanan<-255)pwmkanan=(-255);

if (pwmkanan<0) {
kadur=1;
kaju=255+pwmkanan;
}

if (pwmkiri<0){
kidur=1;
kiju=255+pwmkiri;
}

if (pwmkanan>=0){
kadur=0;
kaju=pwmkanan;
}

if (pwmkiri>=0){
kidur=0;
kiju=pwmkiri;
}
}

void maju()
{
lcd_gotoxy(0,1);
lcd_putsf(” Maju+ “);
motor(200,200);
}

void stop()
{
lcd_gotoxy(0,1);
lcd_putsf(” Stop+ “);
motor(0,0);
}

void mundur()
{
lcd_gotoxy(0,1);
lcd_putsf(” mundur “);
motor(-100,-100);
}

void kanan()
{
lcd_gotoxy(0,1);
lcd_putsf(” kanan+ “);
motor(100, -50);
}

void kiri()
{
lcd_gotoxy(0,1);
lcd_putsf(” kiri+ “);
motor(-50, 100);
}

void pwm_on()
{
TCCR1A=0xA1;
TCCR1B=0x03;
}

void pwm_off()
{
TCCR1A=0x00;
TCCR1B=0x00;
}

void test_motor()
{
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(“TEST MOTOR : “);
maju(); delay_ms(2000); stop(); delay_ms(1000);
mundur(); delay_ms(2000); stop(); delay_ms(1000);
kanan(); delay_ms(2000); stop(); delay_ms(1000);
kiri(); delay_ms(2000); stop(); delay_ms(1000);
}

void check_sensor()
{
led_lcd=1;
line1=read_adc(0);
line2=read_adc(1);
line3=read_adc(2);
line4=read_adc(3);
sharp=read_adc(4);
sprintf(buff,”%3d %3d %3d %3d”,line1, line2, line3, line4);
lcd_gotoxy(0,0);
lcd_puts(buff);
sprintf(buff,”sharp : %3d “,sharp);
lcd_gotoxy(0,1);
lcd_puts(buff);
delay_ms(100);
}

void run()
{
line1=read_adc(1);
line2=read_adc(2);
line3=read_adc(3);
line4=read_adc(4);
sharp=read_adc(0);

/*
if(sharp>=90)
{
motor(-180,-180); delay_ms(250);
motor(180,0); delay_ms(500);
}

else if(sharp<90)
{
motor(180,180);
}
*/

if(line1>=70&&line2>=70&&line3>=70&&line4>=70)
{
if(sharp>=75&&sharp<=200)
{
lcd_clear();
led_lcd=0;
lcd_gotoxy(0,0);
lcd_putsf(“ENEMY DETECTED”);
lcd_gotoxy(0,1);
sprintf(buff,”sharp : %3d “,sharp);
lcd_puts(buff);
motor(180,180);
delay_ms(25);
//delay_ms(30);
}
if(sharp>=200)
{
lcd_clear();
led_lcd=0;
lcd_gotoxy(0,0);
lcd_putsf(“ENEMY DETECTED”);
lcd_gotoxy(0,1);
sprintf(buff,”sharp : %3d “,sharp);
lcd_puts(buff);
motor(255,255);
//delay_ms(30);
}
else
{
lcd_clear();
led_lcd=1;
lcd_gotoxy(0,0);
lcd_putsf(“SCANNING ENEMY”);
motor(15,120);
//delay_ms(30);
}
}
else if(line1<70||line2<70)//line depan
{
led_lcd=0;
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(” LINE DETECTED “);
//motor(0,0); delay_ms(25);
motor(-180,-180); delay_ms(350);
//motor(150,-170); delay_ms(600);
}
else if(line4<70||line3<70)//line belakang
{
led_lcd=0;
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf(” LINE DETECTED “);
//motor(0,0); delay_ms(50);
motor(180,180); delay_ms(300);
}

}

void main(void)
{
// Declare your local variables here

PORTB=0x00;
DDRB=0x0F;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0xFF;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
TCCR0=0x00;
TCNT0=0x00;

TCCR1A=0xA1;
TCCR1B=0x05;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

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 Clock frequency: 500,000 kHz
// ADC Voltage Reference: AVCC pin
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x85;

// SPI initialization
// SPI disabled
SPCR=0x00;

// TWI initialization
// TWI disabled
TWCR=0x00;

lcd_init(16);
pwm_off();
lcd_clear();
led_lcd=1;
lcd_gotoxy(0,0);
lcd_putsf(” BISMILLAH !!! “);
delay_ms(5000); //5000
lcd_clear();
led_lcd=0;
pwm_on();

while (1)
{
// Place your code here
//test_motor();
run();
//check_sensor();
}
}

source code program robot sumo diatas harus menyesuaikan dengan hardware yang teman-teman pakai, oleh karena itu source code tersebut tidak bisa langsung diterapkan pada hardware yg telah teman2 rancang, jika kalian menginginkan konfigurasi harware dan full source code program sumo diatas teman2 bisa menghubungi penulis melalui email : lfriyan220@gmail.com.

sedikit bonus berikut saya berikan sedikit video yang menampilkan beberapa contoh strategi yang bias diterapkan pada robot sumo yang kita buat

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

setelah membahas semua masalah diatas tentunya teman2 pasti bingung dengan desain dari robot sumo yang ingin di bangun, tapi jangan khawatir karena untuk referensi desain robot sumo sangan banyak sekali, teman2 hanya perlu search di mbah google dengan kata kunci “design robot sumo” atau “robot sumo” , nanti langsung keluar deh tuh bentuk2 robot sumo yang teman2 inginkan.

so.. mungkin sekian dulu tulisan yg sudah panjang lebar ini, semoga bermanfaat bagi teman2 yang ingin mendalami materi tentang robotika, ataupun bagi teman2 yang sedang mempersiapkan untuk mengikuti lomba robot sumo, intinya tetap berkarya dan jangan pernah menyerah untuk menjadi yang terbaik…..!!!

Sumber: https://relifline.wordpress.com

Tinggalkan Balasan

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