laporan 11

ROBOT MONITORING SUHU

KONTROL PC (T-SpayBOT)

ABDUL ROHMAN SAYYID/1211703002

Fisika Sains/III/A

Universitas Islam Negeri Sunan Gunung Djati Bandung

Bandung

INDONESIA

[email protected]

Abstract-Robot is temperature monitoring controls PC (T SpayBOT) basically SyBOT's robot

which is one affiliate among system from ADC what do at o of a censor analogue data with

serial communication two aims by use of USART among one computer with minimum system or

mikrokontroler in one conducts robot power aim be next to be calibrated to get one data which

real time. temperature monitoring robot system t SpyBOT by use of one kontroler of one

computer so we need to activate ADC, PWM, and USART on programs Code Vision AVR. where

on ADC will be made one system calibrates to a temperature, are next will be made one outgoing

data of one temperature goes to PC and system succeeding one from control one robot which

that berbasiskan will one PC.

Key word: Robot, ATmega 16, ADC, Code Vision AVR

Abstrak-Robot monitoring suhu kontrol PC (T-SpayBOT) pada dasarnya robot T-SyBOT yaitu

sebuah gabungan antara sistem dari ADC yang diolah dari suatu data analog sensor dengan

komunikasi serial dua arah dengan menggunakan USART antara sebuah computer dengan

sistem minimum atau mikrokontroler dalam sebuah kendali arah gerak robot yang kemudian

dikalibrasi untuk mendapatkan sebuah data yang real time. robot monitoring suhu sistem T-

SpyBOT dengan menggunakan sebuah kontroler dari sebuah computer sehingga kita perlu

mengaktifkan ADC, PWM, dan USART pada program Code Vision AVR. dimana pada ADC

akan dibuat sebuah sistem kalibrasi terhadap suatu suhu, yang kemudian akan dibuat sebuah

data pengeluaran dari sebuah suhu ke PC dan yang selanjutnya sistem dari control sebuah robot

yang akan berbasiskan sebuah PC.

Kata kunci : Robot, ATmega 16, ADC, Code Vision AVR

1. Pendahuluan

Latarbelakang

Robot adalah sebuah mesin mekanik

yang dapat diarahkan untuk melakukan

bermacam tugas fisik tanpa campur tangan

manusia, baik menggunakan pengawasan

dan kontrol manusia, atau menggunakan

program yang telah didefinisikan

(kecerdasan buatan). Secara ideal robot

dihapkan dapat melihat, mendengar,

menganalisa lingkungannya, dan melakukan

mailto:[email protected]

tugas-tugas yang terprogram. Robot

monitoring suhu kontrol PC (T-SpayBOT)

pada dasarnya robot T-SyBOT yaitu sebuah

gabungan antara sistem dari ADC yang

diolah dari suatu data analog sensor dengan

komunikasi serial dua arah dengan

menggunakan USART antara sebuah

computer dengan sistem minimum

Dasar Teori :

Mikrokontroler adalah sebuah chip

yang berfungsi sebagai pengontrol rangkaian

elektronik dan umunya dapat menyimpan

program didalamnya. Mikrokontroler

umumnya terdiri dari CPU (Central

Processing Unit), memori, I/O tertentu dan

unit pendukung seperti Analog-to-Digital

Converter (ADC) yang sudah terintegrasi di

dalamnya.

Kelebihan utama dari mikrokontroler

ialah tersedianya RAM dan peralatan I/O

pendukung sehingga ukuran board

mikrokontroler menjadi sangat ringkas.

Mikrokontroler ATmega16 ialah

mikrokomputer CMOS 8 bit dengan 16 KB

Flash PEROM (Programmable and

Erasable Only Memory) yang dapat dihapus

dan ditulisi sebanyak 1000 kali.

Mikrokontroler ini diproduksi dengan

menggunakan teknologi high density non-

volatile memory Atmel. Flash PEROM on-

chip tersebut memungkinkan memori

program untuk diprogram ulang dalam

sistem (in-system programming) atau

dengan menggunakan programmer non-

volatile memori konvensional.

Mikrokontroler AVR ATMega16

AVR merupakan seri mikrokontroler CMOS

8-bit buatan Atmel, berbasis arsitektur RISC

(Reduced Instruction Set Computer).

Hampir semua instruksi dieksekusi dalam

satu siklus clock. AVR mempunyai 32

register general-purpose, timer/counter

fleksibel dengan mode compare, interrupt

internal dan eksternal, serial UART,

programmable Watchdog Timer, dan mode

power saving, ADC dan PWM internal.

AVR juga mempunyai In-System

Programmable Flash on-chip yang

mengijinkan memori program untuk

diprogram ulang dalam sistem menggunakan

hubungan serial SPI. ATMega16.

ATMega16 mempunyai throughput

mendekati 1 MIPS per MHz membuat

disainer sistem untuk mengoptimasi

konsumsi daya versus kecepatan proses.

Sehingga dengan fasilitas yang lengkap ini,

programmer dan desainer dapat

menggunakannya untuk berbagai aplikasi

sistem elektronika seperti robot, otomasi

industry, peralatan telekomunikasi, dan

berbagai keperluan lain.

AVR memiliki keunggulan dibandingkan

dengan mikrokontroler lain, keunggulan

mikrokontroler AVR yaitu AVR mrmiliki

kecepatan eksekusi program yang lebih

cepat karena sebagian besar instruksi

dieksekusi dalam satu siklus clock, lebih

cepat dibandingkan dengan mikrokontroler

MCS51 yang memiliki arsitektur CISC

(Complex Instruction Set Compute) dimana

mikrokontroler MCS51 membutuhkan 12

siklus clock utnuk mengeksekusi 1 instruksi.

Adapun fitur yang dimiliki Mikrokontroler

AVR ATmega16 adalah sebagai berikut :

1) Frekuensi clock maksimum 16 MHz.

2) Jalur I/O 32 buah, yang terbagi dalam

port A, port B, port C, dan port D.

3) Analog to Digital Converter (ADC) 10

bit sebanyak 8 input.

4) Timer/counter sebanyak 3 buah.

5) CPU 8 bit yang terdiri dari 32 register.

6) Watchdog timer dengan osilator internal.

7) SRAM internal sebesar 1K byte.

8) Memori flash sebesar 16K byte dengan

kemampuan read while write.

9) Interrupt internal maupun eksternal.

10) Port komunikasi SPI (Serial

Pheripheral Interface)

11) EEPROM (Electrically Erasable

Program-mable Read Only Memory) sebesar

512 byte yang dapat diprogram saat operasi.

12) Analog komparator.

13) Komunikasi serial standar USART

dengan kecepaatan maksimal 2,5 Mbps

Fungsi PIN Mikrokontroler AVR

ATmega16

Pin-pin pada ATMega16 dengan

kemasan 40-pin DIP (dual inline package)

Guna memaksimalkan performa, AVR

menggunakan arsitektur Harvard (dengan

memori dan bus terpisah untuk program dan

data). untuk jelasnya dapat dilihat pada

gambar dibawah ini :

ATMega16 mempunyai empat buah port

yang bernama PortA, PortB, PortC, dan

PortD. Keempat port tersebut merupakan

jalur bidirectional dengan pilihan internal

pull-up. Tiap port mempunyai tiga buah

register bit, yaitu DDxn, PORTxn, dan

PINxn. Huruf „x‟mewakili nama huruf dari

port sedangkan huruf „n‟ mewakili nomor

bit. Bit DDxn terdapat pada I/O address

DDRx, bit PORTxn terdapat pada I/O

address PORTx, dan bit PINxn terdapat

pada I/O address PINx. Mikrokontroler

ATmega16 dikemas dalam bentuk DIP 40

pin, 32 kaki diantaranya adalah kaki untuk

keperluan port paralel. Satu port paralel

terdiri dari 8 kaki, dengan demikian 32 kaki

tersebut membentuk 4 buah port paralel,

yang masing-masing dikenal sebagai Port A,

Port B, Port C, dan Port D. Nomor dari

masing-masing jalur(kaki) dari Port paralel

mulai dari 0 sampai 7, jalur (kaki) pertama

Port A disebut sebagai PA.0 dan jalur

terakhir untuk Port D adalah PD.7. untuk

jelasnya dapat dilihat pada gambar dibawah

ini :

2. Tujuan dan Rumusan Masalah

Tujuan :

Dalam percobaan robot monitoring

suhu kontrol PC (T-SpayBOT) yang

bertujuan untuk mengetahui dan memahami

system control digital dengan komunikasi

serial USART antara mikrokontroler dan

komputer serta mampu menampilkan data

real time pada monitor PC dari sensor ADC

robot, mampu memprogram dan membuat

robot digital dengan kontrol keyboard

komputer serta mengetahui aplikasi robot

kontrol digital menggunakan PC.

Rumusan masalah :

Bagaimana cara system control digital

dengan komunikasi serial USART antara

mikrokontroler dan komputer, mampu

menampilkan data real time pada monitor

PC dari sensor ADC robot dan mendesain,

memprogram serta membuat robot digital

dengan control keyboard dan mengetahui

aplikasi robot control digital dengan

menggunakan PC.

Metode Percobaan :

Alat dan bahan:

1. Papan PCB/protoboard

2. Multimeter

3. Osiloskop

4. Sensor suhu LM 35

5. Kabel koneksi

6. Resistor

7. LED

8. Motor DC

9. Spacer

10. Battery 9 volt

11. Modul kit MAX 232 USB

interfacing

12. Mikrokontroler ATmega 16

13. Motor driver L293D

14. Modul kit downloader

15. Software Proteus

16. Software Code Vision AVR

17. Toolkit elektronika

18. CPU

Prosedur percobaan

Gambar 2.1

Gambar 2.2

Pada percobaan robot monitoring

suhu kontrol PC (T-SpayBOT) hal pertama

yang harus dilakukan yaitu mendesain dan

pembuatan interfacing data suhu ke

komputer yaitu yang pertama mendesain

rangaian desain seperti pada gambar 2.1

menggunakan software proteus dan setelah

itu kita membuat program menggunakan

code vision AVR untuk menampilkan data

sensor ADC ke monitor PC setelah program

yang dibuat sudah benar, kemudian program

diisikan kedalam mikrokontroler yang

berada pada desain proteus. Dan setelah

program diisikan kedalam desain proteus,

kemudian diuji actual T-SpyBOT. Setelah

itu membuat desain rangkaian pada proteus

seperti gambar 2.2 dan setelah itu kita

membuat program menggunakan code

vision AVR untuk memprogram gerak robot

setelah program yang dibuat sudah benar,

kemudian program diisikan kedalam

mikrokontroler yang berada pada desain

proteus. Dan setelah program diisikan

kedalam desain proteus, kemudian diuji

actual T-SpyBOT.

Solusi dari Permasalahan

Data dan Analisis :

Diagram Alir

Pada percobaan robot monitoring

suhu kontrol PC (T-SpayBOT) dimana kita

akan membuat sebuah robot monitoring

yang akan mengirimkan sebuah data

realtime sensor dengan control robot berada

pada keyboard PC. Pada dasarnya sebuah

konsepan dari robot T-SpayBOT yaitu

sebuah gabungan antara ADC yang diolah

dari suatu data analog sensor dengan

komunikasi serial dua arah dengan


computer dengan sistem minimum atau

mikrokontroler dalam sebuah kendali arah

gerak robot. Adapun syarat – syarat untuk

membuat suatu robot monitoring suhu

sistem T-SpyBOT dengan menggunakan

sebuah kontroler dari sebuah computer kita

perlu mengaktifkan ADC, PWM, dan

USART pada program Code Vision AVR.

dimana pada ADC akan dibuat sebuah

sistem kalibrasi terhadap suatu suhu, yang

kemudian akan dibuat sebuah data

pengeluaran dari sebuah suhu ke PC dan

yang selanjutnya sistem dari control sebuah

robot yang berbasiskan sebuah PC. Setelah

melakukan sebuah kalibrasi sensor suhu

dam menampilkannya secara real time

dikomputer maka kita bisa menggunkannya

dengan mengatur atau memprogram sebuah

sensor suhu pada saat kondisi tertentu akan

dapat menggerakan sebuah motor.

3. Kesimpulan

Pada percobaan robot monitoring suhu

kontrol PC (T-SpayBOT) dapat disimpulkan

bahwa Pada dasarnya robot T-SyBOT yaitu

sebuah gabungan antara sistem dari ADC

yang diolah dari suatu data analog sensor

dengan komunikasi serial dua arah dengan


computer dengan sistem minimum atau

mikrokontroler dalam sebuah kendali arah

gerak robot yang kemudian dikalibrasi untuk

mendapatkan sebuah data yang real time.

References:

[1] Sanjaya, M. “Modul membuat robot itu

Asyik” Bolabot Techno Robotic School,

Bandung, 2012

[2] Malvino.”prinsip-prinsip elektronika I”

Erlangga, Jakarta,1994

[3] Andrianto, H. “ Pemrograman

mikrokontroler AVR ATmega 16

menggunakan bahasa C (Code Vision

AVR)”. Penerbit Informatika, Bandung,

2008.

Lampiran 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 :

Version :

Date : 29/12/2012

Author :

Company :

Comments:

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 <stdio.h>

#include <delay.h>

#ifndef RXB8

#define RXB8 1

#endif

#ifndef TXB8

#define TXB8 0

#endif

#ifndef UPE

#define UPE 2

#endif

#ifndef DOR

#define DOR 3

#endif

#ifndef FE

#define FE 4

#endif

#ifndef UDRE

#define UDRE 5

#endif

#ifndef RXC

#define RXC 7

#endif

#define FRAMING_ERROR (1<<FE)

#define PARITY_ERROR (1<<UPE)

#define DATA_OVERRUN (1<<DOR)

#define DATA_REGISTER_EMPTY (1<<UDRE)

#define RX_COMPLETE (1<<RXC)

// USART Receiver buffer

#define RX_BUFFER_SIZE 8

char rx_buffer[RX_BUFFER_SIZE];

#if RX_BUFFER_SIZE <= 256

unsigned char rx_wr_index,rx_rd_index,rx_counter;

#else

unsigned int rx_wr_index,rx_rd_index,rx_counter;

#endif

// This flag is set on USART Receiver buffer overflow

bit rx_buffer_overflow;

// USART Receiver interrupt service routine

interrupt [USART_RXC] void usart_rx_isr(void)

{

char status,data;

status=UCSRA;

data=UDR;

if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)

{

rx_buffer[rx_wr_index++]=data;

#if RX_BUFFER_SIZE == 256

// special case for receiver buffer size=256

if (++rx_counter == 0)

{

#else

if (rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;

if (++rx_counter == RX_BUFFER_SIZE)

{

rx_counter=0;

#endif

rx_buffer_overflow=1;

}

}

}

#ifndef _DEBUG_TERMINAL_IO_

// Get a character from the USART Receiver buffer

#define _ALTERNATE_GETCHAR_

#pragma used+

char getchar(void)

{

char data;

while (rx_counter==0);

data=rx_buffer[rx_rd_index++];

#if RX_BUFFER_SIZE != 256

if (rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;

#endif

#asm("cli")

--rx_counter;

#asm("sei")

return data;

}

#pragma used-

#endif

// USART Transmitter buffer

#define TX_BUFFER_SIZE 8

char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE <= 256

unsigned char tx_wr_index,tx_rd_index,tx_counter;

#else

unsigned int tx_wr_index,tx_rd_index,tx_counter;

#endif

// USART Transmitter interrupt service routine

interrupt [USART_TXC] void usart_tx_isr(void)

{

if (tx_counter)

{

--tx_counter;

UDR=tx_buffer[tx_rd_index++];

#if TX_BUFFER_SIZE != 256

if (tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;

#endif

}

}

#ifndef _DEBUG_TERMINAL_IO_

// Write a character to the USART Transmitter buffer

#define _ALTERNATE_PUTCHAR_

#pragma used+

void putchar(char c)

{

while (tx_counter == TX_BUFFER_SIZE);

#asm("cli")

if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))

{

tx_buffer[tx_wr_index++]=c;

#if TX_BUFFER_SIZE != 256

if (tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;

#endif

++tx_counter;

}

else

UDR=c;

#asm("sei")

}

#pragma used-

#endif

// Standard Input/Output functions

#include <stdio.h>

#define FIRST_ADC_INPUT 0

#define LAST_ADC_INPUT 0

unsigned char adc_data[LAST_ADC_INPUT-FIRST_ADC_INPUT+1];

#define ADC_VREF_TYPE 0x60

// ADC interrupt service routine

// with auto input scanning

interrupt [ADC_INT] void adc_isr(void)

{

static unsigned char input_index=0;

// Read the 8 most significant bits

// of the AD conversion result

adc_data[input_index]=ADCH;

// Select next ADC input

if (++input_index > (LAST_ADC_INPUT-FIRST_ADC_INPUT))

input_index=0;

ADMUX=(FIRST_ADC_INPUT | (ADC_VREF_TYPE & 0xff))+input_index;

// Delay needed for the stabilization of the ADC input voltage

delay_us(10);

// Start the AD conversion

ADCSRA|=0x40;

}

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



PORTD=0x00;

DDRD=0x00;

// 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: Timer1 Stopped

// Mode: Normal top=0xFFFF

// OC1A output: Discon.

// OC1B output: Discon.

// 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=0x00;

TCCR1B=0x00;

TCNT1H=0x00;

TCNT1L=0x00;

ICR1H=0x00;

ICR1L=0x00;

OCR1AH=0x00;

OCR1AL=0x00;

OCR1BH=0x00;

OCR1BL=0x00;



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

// Communication Parameters: 8 Data, 1 Stop, No Parity

// USART Receiver: On

// USART Transmitter: On

// USART Mode: Asynchronous

// USART Baud Rate: 9600

UCSRA=0x00;

UCSRB=0xD8;

UCSRC=0x86;

UBRRH=0x00;

UBRRL=0x4D;

// Analog Comparator initialization

// Analog Comparator: Off

// Analog Comparator Input Capture by Timer/Counter 1: Off

ACSR=0x80;

SFIOR=0x00;

// ADC initialization

// ADC Clock frequency: 750,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=FIRST_ADC_INPUT | (ADC_VREF_TYPE & 0xff);

ADCSRA=0xCC;

// SPI initialization

// SPI disabled

SPCR=0x00;

// TWI initialization

// TWI disabled

TWCR=0x00;

// Global enable interrupts

#asm("sei")

printf ("WELCOME TO OMEN TECHNO ROBOTIKA SCHOOL");

while (1)

{

lm35=0.0196*adc_data[0]*100;

printf("\n suhu:%d",lm35);

delay_ms(200);

}

}

laporan 11

Documents