Robot Obstacle Avoidance Sederhana dengan Bahasa C

Oke kali ini, sharing perihal tugas besar semester 5. Ya walau di jurusan kami periode ini menjadi kegiatan dimana mahasiswa berkutat dengan tugas-tugas yang berkaitan dengan mekatronika+komputasi :D hhe Robot yang dibuat terbilang sangat sederhana, namun pendekatan konsep lah yang lebih penting, jadi dengan konsep dasar yang kuat maka untuk membuat robot dengan karaktersitik dan spesifikasi yang berbeda pun tidak akan jadi masalah. Obstacle Avoidance(waduh dari namanya aja udah gimana gitu) haha. Robot yang dibuat ini dibuat dengan spesifikasi sebagai berikut :
Body :ACRYLIC - Black
Mikrokontroler : ATMEGA 16 ( AVR Series )
Sensor : InfraRed - Distance Sensor ( SHARP manufact - 2D120X )
Gearbox : TAMIYA - Twin gearbox
Roda : TAMIYA
Baterai : 7v ( 800A )
LCD : LCD character 16x2 Blue backlight

Sensor yang digunakan merupakan sensor analaog, karena inframerah pada dasarnya mentranmit kan gelombang IR, dimana akan diterima dalam keadaan analog, nilai yang akan diamati pun akan bersifat kontinyu ( berubah-ubah ), lain halnya dengan sensor jarak yang yang menggunakan gelombang ultrasonik. Dalam keadaan ini pulse yang dihasilkan merupakan digital, dan output yang ditampilkan pun berupa digital. Robot ini diprogram dengan menggunakan bahasa C. Compiler yang digunakan merupakan CV AVR ( Code Vision AVR ). CV AVR merupakan perangkat lunak yang berlisensi, artinya berbayar dan bukan free software atau pun freeware. Jika kita ingin menggunakan perangkat lunak free dapat beralih menggunakan AVRStudio. Compiler ini bersifat free, namun pada versi atas compiler ini telah dipadu padankan dengan IDE Visual Studio. Mengapa CV AVR, yah karena Compiler ini memberikan kemudahan kepada pengguna, karena adanya CODEWIZARD yang mempermudah pemrogram untuk menginisialisasikan pustaka yang ada, tanpa harus menginisialisasikan secara manual. Penggunaan bahasa C sebagai bahasa menengah, dalam artian bahasa ini dapat digunakan untuk mengakses modul dari bahasa mesin. Walaupun selain bahasa C redapat juga processing ( C# ) yang digunakan pada mikrokontroler seperti ARDUINO. Jadi pada dasarnya bagi kalian yang familiar dengan penggunaan library/syntax/prosedur/fungsi tidak akan sulit untuk belajar.
Berikut merupakan algoritma yang akan diterapkan pada robot, terlebih ingat kita juga menggunakan modul LCD, yang artinya pustaka LCD pun akan kita gunakan :D. Karena sensor yang digunakan merupakan sensor analog maka dibutuhkan ADC ( Analog Digital Converter ), Mikrokontroler AVR biasanya telah built-in ADC. ADC ini berada pada PORT A - dengan setiap pin yang dapat dijadikan input. Dari nilai ADC yang dibaca tadilah PWM ( Pulse width Modulation ) ditentukan dengan algoritma sebgai berikut :

Berikut merupakan list-conding robot Avoider Sederhana bserta comment 

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.0 Evaluation
Automatic Program Generator
© Copyright 1998-2010 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : ROBOT AVOIDER SEDERHANA
Version : 
Date    : 12/2/2013
Author  : M. Ridwan Zalbina
Company : - 
Comments: 
ATMEGA 16, IR distance sensor, DC motor, 


Chip type               : ATmega16
Program type            : Application
AVR Core Clock frequency: 8.000000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 256
*****************************************************/

#include 
#include 
// Alphanumeric LCD Module functions
#include  // lcd module library untuk LCD character 16x2 40x2
#include 
#include 
#define ADC_VREF_TYPE 0x60
unsigned char adc_kiri,adc_kanan;

void lcd();   //definisi prosedur untuk menampilkan lcd
void maju();  //definisi prosdur agar PWM kiri kanan maju
void belok_bagus(unsigned char baca); // prosedur belok dengan back rotating padd wheel robot
void belok(); // prosedur belok biasa untuk 1 sensor (defualt bisa kanan dan kiri )
void belok_kanan();//prosedur belok kanan jika menggunakan 2 sensor
void belok_kiri();  //prosedur belok kiri jika menggunakan 2 sensor
void mundur(); // prosedur mundur 
char data[16]; //digunakan untuk membaca adc dan dijadikan char untuk ditampilkan ke lcd *karena kita menggunakan 2 sensor jadi pembacaan adc tidak kita lakukan
int adc; // nilai adc


// Read the 8 most significant bits
// of the AD conversion result
unsigned char 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 ADCH;
}


/* ################################
Dibawah merupakan hasil deklarasi slrh variable lokal dalam 
program utama (main) yang kita generate
dari codewizard
################################# */

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
// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 
// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 
PORTB=0x00;
DDRB=0xFF;

// Port C initialization
// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 
// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 
PORTC=0x00;
DDRC=0xFF;

// Port D initialization
// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 
// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 
PORTD=0x00;
DDRD=0xFF;

// 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;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 31.250 kHz
// Mode: Ph. correct 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=0x04;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=0xFF
// OC2 output: Disconnected
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 Clock frequency: 1000.000 kHz
// ADC Voltage Reference: AVCC pin
// ADC Auto Trigger Source: ADC Stopped
// Only the 8 most significant bits of
// the AD conversion result are used
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x83;

// 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 - PORTB Bit 0
// RD - PORTB Bit 1
// EN - PORTB Bit 2
// D4 - PORTB Bit 4
// D5 - PORTB Bit 5
// D6 - PORTB Bit 6
// D7 - PORTB Bit 7
// Characters/line: 16
lcd_init(16);



/*Dibawah merupakan infinite loop dengan while (infinite loop selain dengan while dapat menggunakan for tanpa parameter :) 
*/
while (1)
      {    
      /*
      if(read_adc(0)>=30)
      { //kondisikan apabila nilai ADC lebih dari 40 maka roda kiri berputar (belok)   
      belok_kiri();
      }    
      else  
      maju(); // kondisi default apabila kondisi berikut tak terpenuhi robot akan maju
      lcd();
      // tampilkan ADC VALUE pada lcd
      //contoh program kedua     
      */
        
      
       adc_kiri=read_adc(2); //lokal variable untuk membaca adc motor kiri PADA PORTA pin2 pada SISTEM MINIMUM         
       adc_kanan=read_adc(0); //lokal variable untuk membaca adc motor kanan pada PORTA  pin0 pada SISTEM MINIMUM    
       
       if((adc_kanan>=34) && (adc_kiri<=37)) //jika sensor kanan lebih dekat maka belok kiri, 37 merupakan nilai adc yang terbaca dengan jarak sepanjang 19-21cm
       {
             belok_kiri();   
             delay_ms(200);
       }
       else
       if((adc_kanan<=37) && (adc_kiri>=34)) //jika sensor kiri lebih dekat maka belok kanan, 37 merupakan nilai adc yang terbaca dengan jarak sepanjang 19-21cm
       {
            belok_kanan();  
            delay_ms(200);
       } 
       else
       if((adc_kanan>=37) && (adc_kiri>=37)) //jika kedua duanya memiliki jarak deteksi yang lebih besar maka motor DC kedua arah akan mundur 
       {
            mundur();     
       }    
       
       else   
       maju();  //defualt maka robot akan maju    
       lcd();
    
}
}


/*
void lcd()  // prosedur lcd untuk menampilkan adc (tidak dipakai ) :D
{
    
    lcd_gotoxy(0,0);       
    lcd_puts("ROBOT AVOIDER");
    lcd_gotoxy(0,1); 
    lcd_puts("SK11 KELOMPOK-3"); 
    //variable char data[16];
       
    lcd_gotoxy(0,0);
    lcd_puts("SK11 - KELOMPOK3");
    adc=read_adc(0);
    lcd_gotoxy(0,1);
    sprintf(data,"NILAI ADC = %i",adc);
    lcd_puts(data);       
    delay_ms(100);
    lcd_clear();    
}
*/

void lcd()   //fungsi/prosedur lcd yang digunakan
{
lcd_gotoxy(0,0);
lcd_puts("Sistem  Komputer");
lcd_gotoxy(0,1);
lcd_puts("  Kel-3-SK2011 ");  
delay_ms(200);
}


void maju()//prosedur maju
{
        //prosedur maju set full PWM untuk kedua motor kanan dan kiri
        PORTD.2 =1; //roda kiri
        PORTD.3 =0; //roda kiri
        PORTD.6 =1; //roda kanan
        PORTD.7 =0; //roda kanan   
        OCR1A = 255; //pwm kanan
        OCR1B = 255; //pwm kiri     

}

void mundur()//prosdur mundur
{
        PORTD.2 = 0; //roda kiri
        PORTD.3 = 1; //roda kiri
        PORTD.6 = 0; //roda kanan
        PORTD.7 = 1; //roda kanan   
        OCR1A = 255; //pwm kanan
        OCR1B = 255; //pwm kiri    

}
void belok()  // prosedur belok biasa
{
        PORTD.2 = 1; //kiri
        PORTD.3 = 0; //kiri
        PORTD.6 = 1; //kanan
        PORTD.7 = 0; //kanan   
        OCR1A = 255; //pwm kanan
        OCR1B = 0; //pwm kiri   
        delay_ms(500); 
}

void belok_bagus(unsigned char baca) // prosedur belok dengan roda kanan berputar dari belakang dan roda kiri maju (tidak kita pakai )
{      
        //gunakan variabel baca untuk membaca nilai dari adc 
        baca=read_adc(0);
        PORTD.2 = 0; //kiri
        PORTD.3 = 1; //kiri
        PORTD.6 = 1; //kanan
        PORTD.7 = 0; //kanan
        OCR1A = 255; //pwm roda kiri
        OCR1B = 255;// pwm roda kanan
}

void belok_kanan() //prosedur belok kanan (analogikan PWM nya)
{
PORTD.2 = 1;
PORTD.3 = 0;
PORTD.6 = 1;
PORTD.7 = 0;
OCR1A = 0;  //pwm roda kiri
OCR1B = 255 ; //pwm roda kanan
delay_ms(100);
}

void belok_kiri() //prosedur belok kiri (analogikan PWM  nya )
{
PORTD.2 = 1;
PORTD.3 = 0;
PORTD.6 = 1;
PORTD.7 = 0;
OCR1A = 255;  //pwm roda kiri
OCR1B = 0; //pwm roda kanan
delay_ms(100);
}
</div>