APLIKASI PEMBACAAN SUHU LM35 DENGAN PENAMPIL LCD MENGGUNAKAN CODEVISION AVR

Aplikasi pembacaan suhu (monitoring suhu) ini, menggunakan sensor LM35 yang merupakan sebuah sensor suhu dengan harga yang relatif murah dan output nya sudah berupa tegangan yang sudah linear. Menurut datasheet LM35, untuk kenaikan 1 derajat Celcius akan mengakibatkan perubahan 10mV terhadap output tegangannya. Dimana saat suhu 0 Celcius sensor ini mempunyai tegangan offset sebesar 0 V. Disini saya akan melakukan pembacaan suhu dalam satuan derajat Celcius dengan range pengukuran 0-100 Celcius. Sehingga tegangan output dari LM35 adalah 0-1 V. Tegangan output tersebut sudah dapat dibaca oleh mikrokontroler melalui ADC tanpa diperlukan sebuah penguat tegangan. Aplikasi ini telah saya buat dalam bentuk real (sesungguhnya) dan juga saya simulasikan menggunakan Proteus. Schematic LM35 yang kemudian ditampilkan pada LCD dapat dilihat diatas. Sedangkan untuk programnya menggunakan CodeVision AVR, berikut adalah listing program lengkapnya.

intSUHU; chartemp[8]; floatsuhu_celcius; #include<mega16.h> #include<stdlib.h> #include<lcd.h> #include<delay.h> //AlphanumericLCDModulefunctions #asm .equ__lcd_port=0x15;PORTC #endasm #defineADC_VREF_TYPE0x40 //ReadtheADconversionresult unsignedintread_adc(unsignedcharadc_input) { ADMUX=adc_input|(ADC_VREF_TYPE&0xff); //DelayneededforthestabilizationoftheADCinputvoltage delay_us(10); //StarttheADconversion ADCSRA|=0x40; //WaitfortheADconversiontocomplete while((ADCSRA&0x10)==0); ADCSRA|=0x10; returnADCW; } voidmain(void) { //AnalogComparatorinitialization //AnalogComparator:Off //AnalogComparatorInputCapturebyTimer/Counter1:Off ACSR=0x80; SFIOR=0x00; //ADCinitialization //ADCClockfrequency:750.000kHz //ADCVoltageReference:AVCCpin //ADCAutoTriggerSource:None ADMUX=ADC_VREF_TYPE&0xff; ADCSRA=0x84; //LCDmoduleinitialization lcd_init(16); lcd_clear();

lcd_gotoxy(0,0); lcd_putsf("ElectrOcOntrOl"); lcd_gotoxy(0,1); lcd_putsf("SENSORSUHULM35"); delay_ms(1000); while(1) { lcd_clear(); SUHU=read_adc(0); suhu_celcius=(float)SUHU*500/1023;//rumusuntukmengubahkedalamderajatcelcius lcd_gotoxy(0,0); lcd_putsf("ElectrOcOntrOl"); ftoa(suhu_celcius,1,temp);//mengubahtipedatafloatketipedataarrayygakanditampilkandiLCD lcd_gotoxy(0,1); lcd_puts(temp); lcd_gotoxy(5,1); lcd_putchar(0xdf);//menampilkankarakterderajat lcd_putsf("C"); delay_ms(500); }; }

LCD DAN KEYPAD

Pada dasarnya keypad yang ada dipasaran baik yang berukuran keypad 33, 34 atau 44, hanya tersusun dari beberapa push button yang dikonfigurasikan antara kolom dengan baris. Sehingga sering disebutjugakeypadmatriksnxm(n=kolomm=baris).Kolomdanbarisininantinyayangdigunakanuntuk pendeteksianpenekanantombol.Berikutadalahkonfigurasidasaruntukkeypad44.

B1, B2, B3 dan B4 merupakan baris ke 1 sampai baris ke 4, sedangkan C1, C2, C3 dan C4 merupakan kolom ke 1 sampai kolom ke 4 keypad. Terlihat jelas betapa sederhananya rangkaian dasar keypad untuk ukuran keypad 44 yang terdiri dari 16 buah push button yang dikonfigurasikan seperti matriks. Saya sendiri membuat keypad menggunakan rangkaian diatas, dikarenakan mahalnya harga keypad. Dipasaran saja keypad 44 bisa seharga Rp. 50.000, sedangkan untuk membuatnya tidak sampai Rp. 10.000. Baiklah kembali lagi kemateri keypad. Sekarang saya punya pertanyaan? Kenapa kita tidak menggunakan push button saja yang disusun seperti biasa, kenapa harus menggunakan keypad matrik. Jawabannya mudah saja, kalo menggunakan susunan seperti biasa maka akan menghabiskan 16 pin mikrokontroler untuk 16 buah tombol. Sedangkan jika dikonfigurasikan seperti diatas hanya menghabiskan 8 pin saja. Jadi lebih ringkas dan irit dalam penggunaan pin mikrokontroler. Sekarang cara untuk mengakses keypad, tapi terlebih dahulu perhatikan gambar berikut.

Sebelumnya kita harus menentukan terlebih dahulu mana yang akan dijadikan input atau output mikrokontroler. Sebagian banyak orang membuat kolom keypad sebagai output mikrokontroler sedangkan baris keypad sebagai input mikrokontroler. Sebenarnya bisa saja kita balik penggunaannya, tetapi agar standar kita ikut saja yang sudah banyak digunakan orang. Cara kerja keypad adalah scanning yaitu mendeteksi terus menerus apakah ada penekanan tombol. Berikut adalah algoritma cara mengakses keypad: Tentukan terlebih dahulu kolom sebagai output dari mikrokontroler sedangkan baris sebagai input kemikrokontroler. Mengacu pada gambar diatas
Langkahpertama(Scanningkolom1PB0) keluarkanoutputkekolom1(PB0) kemudiandeteksipenekananbaris1(PB4) kemudiandeteksipenekananbaris2(PB5) kemudiandeteksipenekananbaris3(PB6) kemudiandeteksipenekananbaris4(PB7) Langkahkedua(Scanningkolom2PB1) keluarkanoutputkekolom2(PB1) kemudiandeteksipenekananbaris1(PB4) kemudiandeteksipenekananbaris2(PB5) kemudiandeteksipenekananbaris3(PB6) kemudiandeteksipenekananbaris4(PB7) Langkahketiga(Scanningkolom3PB2) keluarkanoutputkekolom3(PB2) kemudiandeteksipenekananbaris1(PB4) kemudiandeteksipenekananbaris2(PB5) kemudiandeteksipenekananbaris3(PB6)

kemudiandeteksipenekananbaris4(PB7) Langkahkempat(Scanningkolom4PB3) keluarkanoutputkekolom4(PB3) kemudiandeteksipenekananbaris1(PB4) kemudiandeteksipenekananbaris2(PB5) kemudiandeteksipenekananbaris3(PB6) kemudiandeteksipenekananbaris4(PB7) Untukrealisasiprogramnyadapatdilihatpadalistingprogramdiakhirpostinganini. >>>LCD216<<< Disini saya tidak akan menjelaskan tentang hardware dari LCD, tetapi akan fokus kepada instruksi intruksi yang akan digunakan dalam mengakses LCD. Jika temanteman ingin paham lebih dalam lagi mengenai hardware dan pengalamatan memory LCD, temanteman dapat mendownload datasheet LCD 216 disini. Dibawah ini ada beberapa instruksi yang digunakan untuk mengakses LCD pada compiler CodeVisionAVR: lcd_clear() digunakanuntukmenghapusLCDdanmeletakkankembalikursorkekolom0baris0. lcd_gotoxy(unsignedcharx,unsignerchary) Untukmeletakkankursorkekolomxbarisy.KolomdanbarispadaLCDdimulaidari0,sehinggakolom antara015danbaris01untukLCD216. contoh: lcd_gotoxy(10,1)makaakanmeletakkankursordikolom10danbaris1 lcd_putsf(charflash*str) menampilkankarakterkarakteryangadadimemoriflashpadaalamatyangditunjukolehpointerstrke LCDdenganposisikursorsaatini. contoh: lcd_putsf(Electro_cOntrOl)makaakanmenampilkantulisanElectrocOntrOl lcd_puts(char*str) menampilkankarakteryangadasimemoriRAMpadaalamatyangditunjukolehpointerstrkeLCD denganposisikursorsaatini.

lcd_putchar(charc) digunakanuntukmenampilkankaraktersesuaiisivariabelckeLCDdenganposisikursorsaatini. Untuklebihjelasnyadapattemantemanlihatpadalistingprogram.Berikutadalahschematickeypad danLCDyangdihubungkankemikrokontroler.

#include <mega8535.h> #include <stdlib.h> #include <delay.h> #include <lcd.h> // Alphanumeric LCD Module functions #asm .equ __lcd_port=015 ;PORTC #endasm void tekan_keypad_tampil_lcd() //penekanan keypad kemudian ditampilkan di LCD { PORTB = 0b11111110; delay_ms(30); if (PINB.4 == 0) {lcd_putsf(1); delay_ms(300);} if (PINB.5 == 0) {lcd_putsf(4); delay_ms(300);} if (PINB.6 == 0) {lcd_putsf(7); delay_ms(300);} if (PINB.7 == 0) {lcd_putsf(F); delay_ms(300);} PORTB = 0b11111101; delay_ms(30);

if (PINB.4 == 0) {lcd_putsf(2); delay_ms(300);} if (PINB.5 == 0) {lcd_putsf(5); delay_ms(300);} if (PINB.6 == 0) {lcd_putsf(8); delay_ms(300);} if (PINB.7 == 0) {lcd_putsf(0); delay_ms(300);} PORTB = 0b11111011; delay_ms(30); if (PINB.4 == 0) {lcd_putsf(3); delay_ms(300);} if (PINB.5 == 0) {lcd_putsf(6); delay_ms(300);} if (PINB.6 == 0) {lcd_putsf(9); delay_ms(300);} if (PINB.7 == 0) {lcd_putsf(E); delay_ms(300);} PORTB = 0b11110111; delay_ms(30); if (PINB.4 == 0) {lcd_putsf(A); delay_ms(300);} if (PINB.5 == 0) {lcd_putsf(B); delay_ms(300);} if (PINB.6 == 0) {lcd_putsf(C); delay_ms(300);} if (PINB.7 == 0) {lcd_putsf(D); delay_ms(300);} } void tampil_string() { lcd_gotoxy(0,0); //menempatkan kursor lcd pada baris 0 kolom 0 lcd_putsf(tampilan lcd2x16); //menampilkan tulisan tampilan lcd2x16 lcd_gotoxy(0,1); //menempatkan kursor lcd pada baris 1 kolom 0 lcd_putsf(Elektro-cOntrOl); //menampilkan tulisan ElektrO-cOntrOl } void tampil_variabel() { //sebuah variabel yg akan ditampilkan kedalam LCD harus diubah dahulu kedalam tipe data array //jika variabel bertipe data float maka diubah kedalan array dengan instruksi ftoa //jika variabel bertipe data int maka diubah kedalan array dengan instruksi itoa char temp[6]; int a=500; float b=123.45; itoa(a,temp); lcd_gotoxy(0,0); lcd_puts(temp); ftoa(b,2,temp); //angka 2, banyaknya digit dibelakang koma yg ditampilkan lcd_gotoxy(0,1);

lcd_puts(temp); } void main(void) { PORTB = 0xff; DDRB = 0x0f;//PA0-3 sebagai output, PA4-7 sebagai input while(1) //program utama { //tinggal dilakukan pemanggilan fungsi saja, contoh: tampil_string(); //pemanggilan fungsi tampil_string() }; }

MEMBUAT SINYAL PWM MENGGUNAKAN TIMER AVR

MungkintemantemansemuasudahtaupengertiandariPWM(PulseWidthModulation),jadisayatidak akanmembahasnyalagi.DisinisayaakanmenjelaskanbeberapaistilahyangberhubungandenganPWM sehingga nantinya akan mempermudah temanteman dalam pembuatan sinyal PWM menggunakan TimerpadaAVR.

Gambar diatas merupakan sinyal PWM dengan amplitudo 5 volt. Dari gambar diatas dapat diketahui pengertian dari 1 periode gelombang, yaitu lamanya interval waktu dalam 1 panjang gelombang, gambardiatasmempunyaiperiode10ms.sedangkandutycycle,yaitulamanyapulsahigh(on)selama1 periode, terlihat bahwa lamanya duty cycle 7 ms. Biasanya duty cycle ditulis dalam satuan persentase (%).Jikadarigambardiatasinginmengubahdutycyclekedalampersenyaitu:

Duty cycle = (interval pulsa high dalam 1 periode/periode gelombang)*100% Sehingga gambar diatas mempunyai duty cycle sebesar 70%.

Jika periode suatu gelombang diketahui, maka dapat dihitung berapa frekuensinya, menggunakan: F=1/T F = Frekuensi (Hz) T = Periode (detik) Maka frekuensi dari gambar diatasa adalah F = 1/10 ms= 100 Hz.
UntukmenghasilkansinyalPWMpadaAVRdigunakanfiturtimer.AVRAtmega8535mempunyai3buah timer, tetapi disini saya akan membahas Timer0 dan Timer1 saja yang digunakan untuk membangkitkan sinyal PWM. Pada dasarnya Timer0 dan Timer1 mempunyai 4 buah mode untuk membangkitkan sinyal PWM.Untuklebihjelasnyatemantemanbacadatasheetsaja. Disini saya akan membangkitkan sinyal PWM menggunakan Timer0 dan timer1 dengan menggunakan 2 buah mode saja, yaitu Phase Correct PWM dan Fast PWM. Untuk pengertian dan penjelasan masing masingmodedapatdilihatdidatasheetATmega8535.

 OutputpinPWMpadaAtmega8535terdapatpada2buahpinyaituPD4(OC1B)danPD5(OC1A).

>>>Timer0<<< Mode Phase Correct PWM Foc0 = Fosc/(N*512) D = (OCR0/255)*100% Mode Fast PWM Foc0 = Fosc/(N*256) D = (OCR0/255)*100% Dimana: Foc0 = Frekuensi output OC0 N = Skala clock (mempunyai nilai 1, 8, 64, 256 dan 1024) D = Duty cycle Fosc = Frekuensi clock kristal yang digunakan >>>Timer1<<< Mode Phase Correct PWM Foc1a = Fosc/(2*N*TOP) Foc1b = Fosc/(2*N*TOP) D = (OCR1X/TOP)*100% Mode Fast PWM Foc1a = Fosc/(N*(1+TOP)) Foc1b = Fosc/(N*(1+TOP)) D = (OCR1X/TOP)*100% Dimana: Foc1a = Frekuensi output OC1A Foc1b = Frekuensi output OC1B N = Skala clock (mempunyai nilai 1, 8, 64, 256 dan 1024) D = Duty cycle Fosc = Frekuensi clock kristal yang digunakan TOP = nilai maksimum counter (TCNT1), TOP mempunyai 3 buah nilai untuk kedua mode tersebut yaitu 8 bit (FF), 9 bit (1FF) dan 10 bit (3FF)

Sekarang saya akan membuat aplikasi membangkitkan sinyal PWM dengan periode 20 ms dengan duty cycle 75%, menggunakan Timer1 10 Bit Mode Fast PWM. Dengan menggunakan kristal 12 Mhz, N = 256 dan TOP = 10 bit = 3FF = 1023 Maka akan didapat frekuensi output (Foc1x) sebesar 45,77 Hz atau jika diubah kedalam peroide 21,8 ms 20 ms

UntukDutycycle: D=(OCR1X/TOP)*100% 75%=(OCR1X/1023)*100% OCR1X=767=2FF(dalamhexa)

Untuk membangkitkan periode yang benar-benar presisi pada sinyal PWM sangat sulit sekali karena kita hanya mampu memanipulasinya lewat 3 parameter saja yaitu, frekuensi kristal yang kita gunakan (tidak semua nilai frekuensi kristal ada dipasaran), skala clock atau N (hanya mempunyai nilai 1, 8, 64, 256, 1024) dan TOP (untuk kedua mode diatas mempunyai 3 buah nilai 8, 9 dan 10 bit). Dengan kombinasi ketiga variabel diatas kita harus benar-benar dapat menentukan periode output yang kita inginkan, menurut saya itu sangat sulit sekali. Untuk aplikasi diatas berikut adalah setting untuk CodeVision CodeWizard AVR. Clock Value bernilai 46.875 berasal dari Fosc/N atau 12 MHz/256.

Penjelasan diatas adalah untuk membangkitkan sinyal PWM sesuai dengan output yang kita inginkan, sedikit sulit memang. Tetapi pada dasarnya banyak sekali aplikasi yang menggunakan PWM tanpa harus memperdulikan kepresisian periode output, contohnya pengaturan motor DC. Untuk aplikasi pengaturan motor DC sangat simple sekali programnya. Baiklah sekarang saya akan mengimplementasikan aplikasi pengaturan kecepatan motor DC menggunakan input yang berasal dari potensiometer. Cara kerjanya kecepatan motor DC diatur

oleh potensio yang nilainya didapat dari pembacaan ADC. Untuk PWM nya saya gunakan hasil dari yang diatas (Timer1 10 bit mode Fast PWM). Berikut adalah setting untuk CodeWizard AVR dan schematicnya:

Berikutadalahlistingprogramlengkapnya(sangatsimple):

#include <mega16.h> #include <delay.h> int potensio; #define ADC_VREF_TYPE 000 // 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|=040; // Wait for the AD conversion to complete while ((ADCSRA & 010)==0); ADCSRA|=010; return ADCW; }

void main(void) { // 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=000; DDRD=030; // Timer/Counter 1 initialization // Clock source: System Clock // Clock value: 46.875 kHz // Mode: Ph. correct PWM top=03FFh // OC1A output: Non-Inv. // OC1B output: Non-Inv. // Noise Canceler: Off // Input Capture on Falling Edge // Timer 1 Overflow Interrupt: Off // Input Capture Interrupt: Off // Compare A Match Interrupt: Off // Compare B Match Interrupt: Off TCCR1A=0xA3; TCCR1B=004; TCNT1H=000; TCNT1L=000; ICR1H=000; ICR1L=000; OCR1AH=002; OCR1AL=0xFF; OCR1BH=000; OCR1BL=000; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // ADC initialization // ADC Clock frequency: 750.000 kHz // ADC Voltage Reference: AREF pin

// ADC Auto Trigger Source: None ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=084; while (1) { potensio=read_adc(0);//membaca nilai ADC potensio OCR1A=potensio;//nilai potensio diumpan ke register PWM untuk ngatur kecepatan motor }; }

MENGAKSES MOTOR SERVO

Dipasaran terdapat 2 tipe motor servo yaitu servo standard dan servo rotation (continuous). Dimana biasanya untuk tipe standar hanya dapat melakukan pergerakan sebesar 180 sedangkan untuk tipe continuous dapat melakukan rotasi atau 360. Pada dasarnya motor servo tersusun dari motor DC, rangkaian kontrol, gearbox dan potensiometer. Berikut gambar motor servo beserta komponen internal motor servo.

Terlihat jelas bahwa motor DC yang digunakan sangat kecil (compact) sehingga motor servo memiliki dimensi yang cukup kecil jika dibandingkan dengan motor DC pada umumnya. Rangkaian kontrol pada motor servo digunakan untuk mengontrol motor DC yang ada pada motor servo, dikarenakan untuk mengakses motor servo kita harus memberikan pulsa-pulsa kepada sinyal kontrol tersebut. Gearbox berfungsi untuk meningkatkan torsi dari motor servo, sebernarnya terdapat dua macam bahan penyusun gearbox yang digunakan untuk motor servo yaitu metal gear (biasanya untuk torsi yang sangat besar) dan nylon gear (berwarna putih seperti gambar diatas). Dan potensiometer berfungsi untuk menentukan batas sudut dari putaran servo. Sedangkan sudut dari sumbu motor servo diatur berdasarkan lebar pulsa yang dikirimkan. Dikarenakan bentuknya yang compact motor servo sering digunakan untuk aplikasi robotik, biasa digunakan untuk penggerak kaki dan tangan robot. Servo motor mempunyai 3 buah pin yang terdiri dari VCC, GND dan pin SIGNAL. Berikut adalah konfigurasi pin motor servo berdasarkan merk.

Sekarang saya akan menjelaskan bagaimana cara mengakses motor servo. Secara umum untuk mengakses motor servo tipe standard adalah dengan cara memberikan pulsa high selama 1,5 ms dan mengulangnya setiap 20 ms, maka posisi servo akan berada ditengah atau netral (0). Untuk pulsa 1 ms maka akan bergerak berkebalikan arah jarum jam dengan sudut90. Dan pulsa high selama 2 ms akan bergeraksearahjarumjamsebesar90.Untuklebihjelasnyaperhatikangambarberikut.

Sedangkan untuk servo motor tipe continuous untuk berputar (rotasi) searah jarum jam harus diberi pulsa high selama 1,3 ms. Sedangkan untuk berputar berlawanan arah jarum jam harus diberi logika highselama1,7ms.Jikamotorservocontinousdiberipulsahighselama1,5msmakaakanberhenti.

Catatan: karakteristik lamanya pulsa high yang diberikan untuk mengatur motor servo tergantung dari merk yang digunakan dengan mengacu kepada datasheet. Pin SIGNAL pada motor servo dapat dikoneksikan ke pin mana saja pada mikrokontroler, lihat gambar dibawah. Disini saya akan memberikan contoh program cara mengakses motor servo menggunakan program CodeVision AVR.

Dibawah ini beberapa fungsi program untuk mengakses motor servo standard.
voidgerak90derajat() { PORTD.0=1;//memberikanpulsahigh delay_ms(1);//pulsahighdiberikanselama1ms PORTD.0=0; delay_ms(20) } voidgerak90derajat() { PORTD.0=1;//memberikanpulsahigh delay_ms(2);//pulsahighdiberikanselama2ms PORTD.0=0; delay_ms(20) } voidgerak0derajat() { PORTD.0=1;//memberikanpulsahigh delay_ms(1.5);//pulsahighdiberikanselama1,5ms

PORTD.0=0; delay_ms(20) } Sedangkanuntukmotorservocontinuoustidakjauhberbedasepertimotorservostandard. voidputarsearahjarumjam() { PORTD.0=1;//memberikanpulsahigh delay_ms(1.3);//pulsahighdiberikanselama1,3ms PORTD.0=0; delay_ms(20) } voidputarlawanjarumjam() { PORTD.0=1;//memberikanpulsahigh delay_ms(1.7);//pulsahighdiberikanselama1,7ms PORTD.0=0; delay_ms(20) } voidstop() { PORTD.0=1;//memberikanpulsahigh delay_ms(1.5);//pulsahighdiberikanselama1,5ms PORTD.0=0; delay_ms(20) }

Jika direalisasikan pada program menjadi seperti dibawah ini, disini saya akan mencontohkan motor servo standar bergerak 90.
#include<mega16.h> #include<delay.h> voidmain(void) { PORTD=000; DDRD=001;//portd.0sebagaioutput //AnalogComparatorinitialization //AnalogComparator:Off

//AnalogComparatorInputCapturebyTimer/Counter1:Off ACSR=080; SFIOR=000; while(1) { PORTD.0=1;//memberikanpulsahigh delay_ms(2);//pulsahighdiberikanselama2ms PORTD.0=0; delay_ms(20) }; }

PENGUKURAN KEMIRINGAN MENGGUNAKAN ACCELEROMETER MMA7260 DENGAN CODEVISION AVR TERKALIBRASI

Sensor accelerometer mma7260 buatan Freescale Semiconductor ini mempunyai 6 buah fungsi yaitu untuk mengukur gerakan (movement), getaran (vibration), jatuh (fall), kemiringan (tilt), posisi (positioning)danbenturan(shock).

saya akan jelaskan bagaimana cara mengakses sensor accelerometer mma7260 untuk mengukur kemiringan (tilt measurement) yang ditampilkan pada LCD 216 menggunakan compiler CodeVision AVR. Berikut adalah schematic accelerometer mma7260.

Pada PD.0 dan PD.1 terdapat 2 buah push button yang digunakan untuk melakukan kalibrasi pada accelerometer, dikarenakan output mma7260 masih berupa tegangan analog yang tidak linear. Berikut adalahoutputsensormma7260: gambaroutputmma7260sumbuX,Y,Z

Pada dasarnya model matematis persamaan garis diatas sudah diketahui dengan mengacu pada applicationnoteAN3107MeasuringTiltwithLowgAccelerometers.pdfadalahsebagaiberikut:

Vout=Voffset+((sensitivitas)*1g *sin ) Vout adalah tegangan output accelerometer Voffset adalah VDD/2 atau saat percepatan=0g atau 1,65 Volt dari persamaan diatas dapat dirubah menjadi: Vout=Voffset+S*sin ; S=sensitivitas

Ada beberapa cara metode untuk melakukan pembacaan kemiringan, yaitu: 1. Measuring Tilt Using One Axis; Ax=(Voutx-Voffset)/S; Ax=percepatan sumbu X(gravitasi); = arcsin (Ax); dimana =kemiringan (sudut) 2. Measuring Tilt Using Two Axis Solution; menggunakan sumbu X dan Z. Ax=(Voutx-Voffset)/S; Az=(Voutz-Voffset)/S; =arctan (Ax/Az); dimana =kemiringan (sudut) 3. Measuring Tilt Using Three Axis Solution Ax=(Voutx-Voffset)/S; Az=(Voutz-Voffset)/S;

Ay=(Vouty-Voffset)/S; =arctan(Ax/(Ay+Az)); =arctan(Ay/(Ax+Az)); =arctan((Ax+Ay)/Az); Dimana: Ax = percepatan sumbu X Ay = percepatan sumbu Y Az = percepatan sumbu Z

picth roll yaw

Pada dasarnya jika kita mengacu pada persamaan garis diatas seharusnya kita sudah dapat menghasilkanpembacaankemiringandalamsatuanderajatyangsudahpresisi.Tapidikarenakanadanya beberapakelemahan,yangmerujukpadaapplicationnoteAN3447yaitu: Sources of offset errors can occur device to device based on offset variations from trim errors, mechanical stresses from the package and mounting, shifts due to temperature and due to aging. These variables can all change the offset. This can be very significant for many applications. The offset error alone can affect a tilt reading on a flat surface by as much as 12 degrees. That is an unacceptable error forthisapplication. Untuk menghilangkan ketidaklinearan sensor dan adanya kelemahan seperti yang diatas, maka perlu dilakukan kalibrasi (auto zero) yang mengacu pada application note AN3447 Implementing AutoZero Calibration Technique for Accelerometers.pdf. Pada AN3447 ada beberapa metode untuk melakukan kalibrasidiantaranya: 1.Manual0gX,Y,ZFullRangeCalibration 2.Simple0gX,Y,ZCalibration 3.FreefallCalibration,dan 4.Simple0gX,0gY,+1gZCalibration

Disini saya akan menggunakan metode kedua yaitu Simple 0g X, Y, Z Calibration dengan alasan dapat dilakukan dengan mudah, dengan pengambilan data melalui penekanan tombol (push button). Dimana pada kalibrasi ini data setiap sumbu X, Y dan Z diambil nilai saat 0g (zero gravitation), 1g (earth gravitation atau one gravitation) dan nilai selisih antara 1g dengan 0g (1g-0g atau dengan kata lain adalah Sensitivitas (S)). Berikut adalah cuplikan program pengukuran kemiringan (tilt measurement) mma7260 menggunakan dua buah axis X dan Z (Dual Axis XZ) dengan range pengukuran -180 sampai +180 derajat dan cara kalibrasinya, dengan rata-rata error 0.4 derajat (dalam sudut) pada setiap pengukuran.

voidkalibrasiZ() { if(PIND.0==0&&indeks==3)//kalibrasiZ { g0X=VoutX;//paraleltoearthsurface g0Y=VoutY;//Z_axisisverticalwithZlabelUP g1Z=VoutZ; indeks=2; lcd_clear(); lcd_putsf(prosescal.Z); delay_ms(3000); } } voidkalibrasiX() { if(PIND.0==0&&indeks==2)//kalibrasiX {//X_axisisverticalwithXlabelUP g1X=VoutX; g0Z=VoutZ; indeks=1; lcd_clear(); lcd_putsf(prosescal.X); delay_ms(3000); } } voidkalibrasiY() { if(PIND.0==0&&indeks==1)//kalibrasiY { g1Y=VoutY;//Y_axisisverticalwithYlabelUP indeks=3; lcd_clear(); lcd_putsf(prosescal.Y); delay_ms(3000); } } voidbaca_adc()//bacaadcuntuksumbuXdanZ { VoutX=(float)read_adc(0);//0=sumbuX,1=sumbuY,2=sumbuZ VoutZ=(float)read_adc(2); } voidhitung_accelerometer() { Ax=(float)(VoutXg0X)/(g1Xg0X);//persamaanmenghitungpercepatanX Az=(float)(VoutZg0Z)/(g1Zg0Z);

sudut=atan2(Ax,Az);//persamaanmenghitungsudut,masihdlmradian sudut=(sudut*180)/3.14;//ubahkedlmsudut } voidtampilkan_lcd() { lcd_putsf(sudut=); ftoa(sudut,1,temp);//nampilinnilaisudut lcd_gotoxy(8,0); lcd_puts(temp); }

PENGUKURAN NEGATIVE THEMPERATURE (MINUS) MENGGUNAKAN LM35 DENGAN CODEVISION AVR

Menurut datasheet, LM35 dapat mengukur dengan range 55 sampai 150C dengan akurasi 0,5C. Untuk lebih jelasnya dapat dibaca pada datasheet. Aplikasi ini pun telah saya simulasikan menggunakan software proteus, dan mempunyai hasil yang sangat presisi untuk pembacaannya. Dibawah ini adalah schematicrangkaiannya:

Sedangkanuntuklistingprogramlengkapnyaadalahsebagaiberikut,padaakhirpostinganinisayajuga menyertakanfileprogramdalamcodevisionAVRsertafilesimulasiproteus.

#include <mega16.h> #include <lcd.h> #include <delay.h> #include <stdlib.h> int data1, data2; float suhu_minus; char temp[8]; // Alphanumeric LCD Module functions #asm .equ __lcd_port=015 ;PORTC

#endasm #define ADC_VREF_TYPE 040 // 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|=040; // Wait for the AD conversion to complete while ((ADCSRA & 010)==0); ADCSRA|=010; return ADCW; } void ambil_dataADC() { data1=read_adc(0); data2=read_adc(1); } void hitung_suhu_minus() { suhu_minus=(float)(data1-data2)/2;//rumus mencari suhu minus } void tampil_LDC() { lcd_gotoxy(0,0); lcd_putsf(ElectrO-cOntrOl); ftoa(suhu_minus,1,temp);//float to array lcd_gotoxy(0,1); lcd_puts(temp); lcd_gotoxy(5,1); lcd_putchar(0xdf);//menampilkan karakter derajat lcd_putsf(C); }

void main(void) { // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // ADC initialization // ADC Clock frequency: 750.000 kHz // ADC Voltage Reference: AVCC pin // ADC Auto Trigger Source: None ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=084; // LCD module initialization lcd_init(16); while (1) { ambil_dataADC(); hitung_suhu_minus(); tampil_LDC(); delay_ms(500); }; }

PENGUNCI PINTU (DOOR LOCK) BERPASSWORD MENGGUNAKAN KEYPAD DAN LCD DENGAN CODEVISION AVR

Mungkin teman-teman semua sudah tahu tentang aplikasi yang bernama pengunci pintu (door lock) berpassword, pada aplikasi ini sudah saya realisasikan pada hardware yang sesungguhnya dan berhasil. Kesulitan utama dari aplikasi ini adalah ketika seorang user memasukkan password dengan menggunakan keypad, kita harus dapat menyimpan input yang berasal dari keypad kedalam satu variabel. Misalnya user menekan 6, lalu 2, lalu 0 dan 4 berarti passwornya adalah 6204 (misalkan). Nilai tersebut harus dijadikan dalam 1 variabel yang kemudian akan dibandingkan dengan password yang sebenarnya. Jika user memasukkan password dengan benar maka akan membuka kunci, jika salah maka kunci tidak akan terbuka. Untuk mengatasi masalah tersebut saya menggunakan array untuk mendeteksi berapa kali penekanan keypad dan angka berapa yang akan ditekan. Baiklah disini saya akan menjelaskan algoritma yang saya buat. Jika user menekan 6, lalu 2 lalu 0 dan 4 maka seperti ini logikanya:

Awalnya saya deklarasikan array sebagai berikut: array[10], i=0; saat terjadi penekanan angka 6 maka; i++ (saya increamentkan) jadi i=1 kemudian angka 6 saya simpan pada variabel array[i] jadi array[1]=6 kemudian saat terjadi penekanan angka 2, maka: i++ (saya increamentkan lagi) jadi i=2 kemudian angka 2 saya simpan pada variabel array[i] jadi array[2]=2 kemudian saat terjadi penekanan angka 0, maka: i++ (saya increamentkan lagi) jadi i=3 kemudian angka 0 saya simpan pada variabel array[i] jadi array[3]=0 kemudian saat terjadi penekanan angka 4, maka: i++ (saya increamentkan lagi) jadi i=4 kemudian angka 4 saya simpan pada variabel array[i] jadi array[4]=4 maka didapat array[1]=6, array[2]=2, array[3]=0, array[4]=4 kalo sudah didapat seperti diatas maka kita tinggal kumpulkan dalam satu variabel (nama variabelnya misalkan nilai) caranya: saat i bernilai 1, i=1 kita hitung dengan rumus: nilai=array[1] //jadi nilai=6

saat i bernilai 2, i=2 kita hitung dengan rumus: nilai=(array[1]*10)+array[2] //jadi nilai=62 saat i bernilai 3, i=3 kita hitung dengan rumus: nilai=(array[1]*100)+(array[2]*10)+array[3] //jadi nilai=620 saat i bernilai 4, i=4 kita hitung dengan rumus: nilai=(array[1]*1000)+(array[2]*100)+(array[3]*10)+array[4] //jadi nilai=6204 Sudah mengerti bukan, dari rumus-rumus diatas masih dapat disederhanakan, menjadi: jika nilai=array[i] jika i bernilai (i>=2 dan i<=8) nilai=(nilai*10)+array[i] Banyaknya penekanan tombol saya batasi sampai 8 kali. Sebenarnya saya ingin membuatnya sampai 10 kali tetapi saat saya coba tidak berjalan dengan lancar saat penekanan ke 9 kali. Saya tidak tahu kenapa? Jika teman-teman bisa memecahkannya tolong beri tahu saya! Baiklah kembali lagi ke aplikasi yang akan kita buat. Langsung saja ke cara kerjanya, gambar rangkaiannya bisa anda lihat dibawah ini. Saat pertama kali alat ini saya nyalakan maka dalam keadaan tidak terkunci (unlock), untuk menguncinya (lock) anda harus menekan tombol = (lihat gambar keypad dibawah). Setelah terkunci, jika anda ingin membukanya kembali anda harus memasukkan passwordnya (jika sudah mengetikan password tekan tombol + untuk memasukkannya). Jika benar maka akan membuka kunci, tetapi jika salah kunci tidak akan terbuka. Ketika sudah terbuka maka cara kerjanya kembali lagi ke awal. Sedangkan tombol ON/C saya gunakan untuk menghapus password jika salah dalam pengetikannya. Untuk indikator kuncinya saya menggunakan sebuah LED, jika LED menyala maka dalam keadaan tidak terkunci dan jika mati dalam keadaan terkunci.

i=1

 Berikutadalahlistingprogramlengkapnya: #include<mega16.h> #include<delay.h> #include<stdlib.h> #include<stdio.h> floatnilai=0,password=12345678; chartemp[12],array[10],i=0,indeks=0; //variabelindeksdigunakanuntukmendeteksijikaindeks=0unlock,indeks=1lock //AlphanumericLCDModulefunctions #asm .equ__lcd_port=015;PORTC #endasm #include<lcd.h> voidlock() { while(indeks==0) { lcd_gotoxy(0,0); lcd_putsf(Pleasepress=); lcd_gotoxy(0,1); lcd_putsf(tolock);

PORTB=0b11111011; delay_ms(30); if(PINB.7==0) { indeks=1; PORTD.0=1;//terkunci lcd_clear(); lcd_gotoxy(0,0); lcd_putsf(locked); delay_ms(1000); lcd_clear(); } } } voidenter() { if(nilai==password) { lcd_clear(); lcd_gotoxy(0,0); lcd_putsf(unlocked); delay_ms(1000); i=0;nilai=0; PORTD.0=0;//kunciterbuka indeks=0; } else { lcd_clear(); lcd_gotoxy(0,0); lcd_putsf(wrongpassword); delay_ms(2500); i=0;nilai=0; indeks=1;//karenapasswordsalahjadimasihterkunci } } voidsimpan_dlm_1variabel() { if(i==1){nilai=array[i];} if(i>=2&&i<=8)

{ nilai=(nilai*10)+array[i]; } } voidscanning_keypad()//scanningpendeteksianpenekanankeypad { lcd_gotoxy(0,0); lcd_putsf(enterurpass); PORTB=0b11111110; delay_ms(30); if(PINB.4==0){i++;array[i]=1;simpan_dlm_1variabel();delay_ms(300);} if(PINB.5==0){i++;array[i]=4;simpan_dlm_1variabel();delay_ms(300);} if(PINB.6==0){i++;array[i]=7;simpan_dlm_1variabel();delay_ms(300);} if(PINB.7==0){lcd_clear();i=0;nilai=0;delay_ms(300);} PORTB=0b11111101; delay_ms(30); if(PINB.4==0){i++;array[i]=2;simpan_dlm_1variabel();delay_ms(300);} if(PINB.5==0){i++;array[i]=5;simpan_dlm_1variabel();delay_ms(300);} if(PINB.6==0){i++;array[i]=8;simpan_dlm_1variabel();delay_ms(300);} if(PINB.7==0){i++;array[i]=0;simpan_dlm_1variabel();delay_ms(300);} PORTB=0b11111011; delay_ms(30); if(PINB.4==0){i++;array[i]=3;simpan_dlm_1variabel();delay_ms(300);} if(PINB.5==0){i++;array[i]=6;simpan_dlm_1variabel();delay_ms(300);} if(PINB.6==0){i++;array[i]=9;simpan_dlm_1variabel();delay_ms(300);} if(PINB.7==0){delay_ms(300);} PORTB=0b11110111; delay_ms(30); if(PINB.4==0){delay_ms(300);} if(PINB.5==0){delay_ms(300);} if(PINB.6==0){delay_ms(300);} if(PINB.7==0){enter();delay_ms(300);} } voidtampil_lcd() { if(nilai>0) { ftoa(nilai,0,temp); lcd_gotoxy(0,1); lcd_puts(temp);

} } voidmain(void) { PORTB=0xff; DDRB=0x0f; PORTD=000;//PD0belogikalowataudlmkeadaanunlockawalnya DDRD=001;//PD0sebagaioutput //AnalogComparatorinitialization //AnalogComparator:Off //AnalogComparatorInputCapturebyTimer/Counter1:Off ACSR=080; SFIOR=000; //LCDmoduleinitialization lcd_init(16); lcd_putsf(ElectrOcOntrOl); delay_ms(1500); lcd_clear(); while(1) { lock(); scanning_keypad(); tampil_lcd(); }; }

PROGRAMMENGAKSESSENSORJARAKPING)))PARALLAX MENGGUNAKANCODEVISIONAVR

Sensor jarak ultrasonic Parallax PING))) mampu mengukur jarak dengan teliti dan tanpa kontak antara 2 cm (0.8 inche) sampai 3 meter (3.3 yard). Sangat mudah untuk dikoneksikan dengan mikrokontroler, hanya membutuhkan satu pin I/O. Sensor PING))) berkerja dengan mentransmisikan sebuah ultrasonic burst (diatas batas pendengaran manusia) dan menghasilkan sebuah pulsa output yang berhubungan dengan waktu yang dibutuhkan oleh echo dari burst untuk kembali ke sensor. Dengan mengukur lebar pulsa echo jarak sensor ke target dapat dihitung. Karakteristik * Tegangan suplai : 5VDC * Konsumsi arus : 30 mA typ; 35 mA max * Jarak : 2 cm sampai 3 m (0.8 in sampai 3.3 yrd) * Input Trigger : positive TTL pulse, 2 uS min, 5 s typ * Echo Pulse : positive TTL pulse, 115 uS to 18.5 ms * Echo Hold-off : 750 s from fall of Trigger pulse * Burst Frequency : 40 kHz for 200 s * Burst Indicator LED shows sensor activity * Delay before next measurement : 200 s * Size : 22 mm H x 46 mm W x 16 mm D (0.84 in x 1.8 in x 0.6 in) Berikut adalah program pembacaan jarak (cm) menggunakan sensor ultrasonik PING))) buatan Parallax. Pada program dibawah ini menggunakan frekuensi kristal 4Mhz, dan pin output dari PING))) dihubungkan ke port PB0, LCD pada PC. //Clock frequency : 4.000000 MHz //output sensor PING))) ke PB0 //LCD ke PC #include <mega8535.h> #include <lcd.h> #include <stdio.h> #include <delay.h> // Alphanumeric LCD Module functions #asm .equ __lcd_port=015 ;PORTC #endasm

//deklarasi PIN I/O PING #define PULSE PORTB.0 #define ECHO PINB.0 #define ARAH DDRB.0 #define OUT 1 #define INP 0 unsigned int ultrasonic() { unsigned int count=0; unsigned int jarak; ARAH=OUT;//mengatur PIN I/O sebagai output PULSE=1;//memberikan tanda ke PING untuk memancarkan ultrasonic burst delay_us(5);//waktu tunggu sebelum pengukuran min. 2us biasanya 5us PULSE=0;//menberikan sinyal low ke PING ARAH=INP;//arah PIN I/O diatur sebagai input PULSE=1;//mengatur PIN I/O sebagai pill-up while (ECHO==0) {};//menunggu sinyal ECHO high while (ECHO==1) { count++; //menghitung lebar sinyal ECHO high } jarak=(unsigned int)(((float)count)/25);//nilai pembagi dikalibrasi sampai sesuai dengan satuan yang diinginkan return(jarak);//mengembalikan jarak ke fungsi ultrasonic dengan tipe data unsigned int } void main(void) { unsigned char kata[16]; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // LCD module initialization lcd_init(16); while (1) {

sprintf(kata, J=%3d cm, ultrasonic());//menyusun karakter ke dalam satu baris dengan menggunakan fungsi sprintf lcd_clear(); lcd_gotoxy(0,0); lcd_puts(kata);//mengirim data ke LCD delay_ms(300); } }

PROGRAM MENGAKSES SENSOR JARAK SHARP GP2D12 MENGGUNAKAN CODEVISION AVR

Pada postingan ini saya akan menjelaskan bagaimana cara mengkalibrasi sensor GP2D12 dan programnya menggunakan CodeVision AVR. Akhirnya saya dapat menyelesaikan kalibrasi sensor Sharp GP2D12, dimana saya sebelumnya hanya mencoba program yang berasal dari beberapa blog.

Dari blog tersebut saya mendapatkan persamaan jarak untuk sensor GP2D12 adalah sebagai berikut. jarak = (1611/data_adc)-3; (tidak saya rekomendasikan untuk range 10-80 cm) Ternyata setelah saya coba hasilnya lumayan baik, tetapi hanya pada range 10-40 cm saja. Dikarenakan saya membutuhkan pembacaan yang presisi dan mempunyai range yang cukup lebar yaitu full range (10-80 cm), maka saya mencoba melakukan kalibrasi sendiri dengan menggunakan metode Trendline (fitur dari MS. Excel). Baiklah dibawah ini beberapa penjelasan singkat tentang sensor Sharp GP2D12. GP2D12 adalah sensor pengukur jarak yang diproduksi oleh Sharp. Sensor ini mengeluarkan sinyal analog dan mampu mengukur jarak pada rentang 10 80 cm. Prinsip kerja sensor inframerah ini dalam mengukur jarak berbeda dengan sensor ultrasonik yang menggunakan waktu pantul gelombang bunyi karena waktu pantul cahaya jelas terlalu singkat untuk dapat diukur. Cahaya inframerah dengan frekuensi 40 kHz dipancarkan dan hasil pantulannya diterima oleh susunan detektor inframerah. Sudut pantulan sinar inframerah akan berubah sesuai jarak sensor dan obyek. Antarmuka sensor GP2D12 dengan AVR sangatlah mudah, namun sayangnya output analog sensor ini sangatlah tidak linier.

Untuk mengatasi masalah ketidaklinearan sensor tersebut disini saya melakukan kalibrasi menggunakan metode Trendline dengan menggunakan MS. Exel. Dari hasil kalibrasi yang saya lakukan dengan menggunakan ADC 8 bit, didapat persamaan jarak untuk sensor GP2D12 adalah:

atau jika direalisasikan ke dalam program CodeVision AVR, menjadi: jarak=(float)((1/((0.04*Vout)-0.006)-0.42));

Nilai dari variabel Vout pada persamaan diatas masih merupakan tegangan keluaran (Volt) sensor GP2D12, sehingga perlu pengubahan dari nilai biner ADC 8 bit ke dalam bentuk tegangan keluaran sensor(Vout)tersebut,caranya:

Vout=read_adc(0); Vout=Vout/51;
BerdasarkandatasheetGP2D12perbandingntegangankeluaransensordenganjarakadalahsebagai berikut:

 Terlihat jelas dari grafik diatas bahwa hubungan antara tegangan keluaran sensor dengan jarak sangat tidaklinear. Tetapi menurut application note sensor GP2D12 mempunyai hubungan yang cukup linear antara tegangan keluaran sensor (Vout) dengan 1/(distance+K), K bernilai 0,42 untuk tipe GP2D12. Berukut adalahgrafikhubungannya:

Sumbu X merupakan output sensor sedangkan sumbu Y adalah 1/(distance+K). Berdasarkan grafik diatas kita sudah dapat menggunakan persamaan metode Trendline yang ada pada MS. Exel. Baiklah berikut adalah beberapa langkah panduan melakukan kalibrasi sensor GP2D12: LANGKAH PERTAMA Teman-teman harus melakukan pengukuran dari 10-80 cm setiap kelipatan 5. Kemudian meRecord setiap tegangan keluarannya. Kemudian berikan nilai untuk X=Vout dan untuk Y=1/(distance+K), K=0,42. Teman-teman dapat menggunakan Voltmeter untuk me-Record tegangan keluaran sensor.
Atau jika temanteman malas menggunakan Voltmeter temanteman dapat melihat tegangan keluarannya menggunakan sebuah program yang difungsikan untuk menghitung tegangan keluran sensoryangkemudianditampilkanpadaLCDmenggunakanmikrokontroler. Berikutadalahhasilyangsayadapatkan: K=0.42

jarak 10 15 20 25 30 35 40 45 50 55 60 65 70

X=Vout (Volt) Y=1/(distance+k) 2.4 1.8 1.4 1.1 1 0.86 0.78 0.7 0.63 0.6 0.55 0.5 0.48 0.09596929 0.064850843 0.048971596 0.039339103 0.03287311 0.028232637 0.024740228 0.022016733 0.019833399 0.018044027 0.016550811 0.015285845 0.014200511

75 80

0.43 0.41

0.013259082 0.012434718

LANGKAH KEDUA Setelah mendapatkan nilai X dan Y untuk tabel diatas, plot tabel tersebut kedalam grafik pada MS. Exel dengan type grafik XY scatter. Maka akan muncul grafik seperti GAMBAR 2 seperti diatas. Kemudian klik pada grafik dan pilih menu trendline di MS. Exel, caranya LAYOUT ANALYSIS TRENDLINE MORE TRENDLINE OPTIONS sesuaikan dengan gambar berikut. Kemudian CLOSE.

Makaakanmuncultrendlinepersamaansepertigambardibawahini:

Akhirnya sekarang kita dapat persamaan trendline nya yaitu Y=0.04X-0.006 LANGKAH KETIGA (TERAKHIR) Langkah terakhir ini digunakan untuk mendapatkan persamaan akhir yang akan dipakai pada program untuk menghitung jarak dari sensor Sharp GP2D12. Caranya: X=Vout Y=1/(distance+K) K=0.42 Disubtitusikan ke persamaan trendline yaitu: Y=0.04X-0.006 Menjadi: 1/(distance+0.42)=(0.04*Vout)-0.006 Sehingga: distance=((1/((0.04*Vout)-0.006)-0.42)) Atau dalam program menggunakan CodeVision menjadi: jarak=(float)((1/((0.04*Vout)-0.006)-0.42)); Nilai dari Vout masih merupakan tegangan keluaran sensor GP2D12, sehingga perlu pengubahan dari nilai biner ADC 8 bit ke dalam bentuk tegangan keluaran sensor (Vout) tersebut, caranya: Vout=read_adc(0); Vout=Vout/51;
BerikutadalahlistingprogramlengkapGP2D12,denganoutputsensorGP2D12masukkePA0:

//output sensor ke PA0

#include <mega16.h> #include <lcd.h> #include <stdlib.h> #include <delay.h> int baca_adc; float jarak, vo; char temp[6]; // Alphanumeric LCD Module functions #asm .equ __lcd_port=015 ;PORTC #endasm #define ADC_VREF_TYPE 060 // 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|=040; // Wait for the AD conversion to complete while ((ADCSRA & 010)==0); ADCSRA|=010; return ADCH; } void baca_sensor() { baca_adc=read_adc(0); vo= (float)baca_adc/51; } void gp2d12() { jarak=(float)((1/((0.04*vo)-0.006)-0.42)); }

void tampil_lcd()//menampilkan jarak ke LCD { lcd_clear(); lcd_putsf(ElectO-cOntrOl); ftoa(jarak,1,temp);//menampilkan nilai jarak yg sesungguhnya lcd_gotoxy(0,1); lcd_puts(temp); lcd_gotoxy(4,1); lcd_putsf(cm); ftoa(vo,2,temp); //menampilkan nilai dari Vout (tegangan keluaran sensor) lcd_gotoxy(9,1); lcd_puts(temp); delay_ms(2000); } void main(void) { // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // ADC initialization // ADC Clock frequency: 750.000 kHz // ADC Voltage Reference: AVCC pin // ADC Auto Trigger Source: None // Only the 8 most significant bits of // the AD conversion result are used ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=084; // LCD module initialization lcd_init(16); while (1) { baca_sensor(); gp2d12(); tampil_lcd();

}; }
CATATAN: sebenarnya temanteman sudah bisa langsung menggunakan program diatas, tetapi dikarenakan karakteristik setiap sensor dengan tipe yang sama bisa saja berbeda, maka saya merekomendasikanuntukmelakukankalibrasiterlebihdahulu.

SCIENTIFIC CALCULATOR MENGGUNAKAN CODEVISION AVR

Saya menemukan aplikasi scientific calculator ini di situs www.avrprojects.info, aplikasi ini merupakan sebuah kalkulator dengan menggunakan keypad dan ditampilkan pada LCD. Cukup menarik, dan ternyata sudah disimulasikan menggunakan software Proteus dan berhasil, algoritma programnya pun cukupbaikdanefisien.Berikutadalahschematicrangkaiannyasedangkanuntuklistingprogramlengkap dapatdidownloaddiakhirartikelini.

/* Todownloadotherfreeprojectsvisitwww.electrocontrol.wordpress.com */ #include<mega16.h> #include<delay.h> #include<lcd.h>

#include<stdlib.h> #include<math.h> #asm .equ__lcd_port=0x18 #endasm //############################################# intkey(void); float_Main(void); voidMohandes(void); voidMohasebe(void); voidAlamat(int,int); floatEmoji(int); //############################################# floata=0,b=0,c=0,q,t; inti; chary=0,lcd[25],z; //############################################# voidmain(void){ DDRB=0x0F; DDRC=0x07; DDRD=0x0F; lcd_init(16);

while(1){ _Main(); } } //############################################################# float_Main(void){ intLoop=1; y=key(); if(y==15){a=0;b=0;c=0;lcd_clear();return0;} if(y<10){ a=(a*10)+y; itoa(y,lcd); lcd_puts(lcd); delay_ms(50); } if(y>9&&y<16){ if(y==15){a=0;b=0;c=0;lcd_clear();return0;} z=y; Alamat(y,1); while(Loop){ y=key(); if(y==15){a=0;b=0;c=0;lcd_clear();return0;}

if(y<10){ b=(b*10)+y; itoa(y,lcd); lcd_puts(lcd); delay_ms(50); }elseif(y==14){ lcd_putchar('='); Mohasebe(); y=0; Loop=0; } } } if(y>15){ lcd_clear(); a=0;b=0;c=0; Alamat(y,2); z=y; Loop=1; while(Loop){ y=key(); if(y==15){a=0;b=0;c=0;lcd_clear();return0;} if(y<10){ a=(a*10)+y; itoa(y,lcd);

lcd_puts(lcd); delay_ms(50); }elseif(y==14){ lcd_putchar('='); Mohandes(); } Loop=1; } } return0; } //########################################################## voidMohasebe(void){ if(z==10)c=a/b; if(z==11)c=a*b; if(z==12)c=ab; if(z==13)c=a+b; ftoa(c,3,lcd); lcd_puts(lcd); delay_ms(100); } //######################################################### floatEmoji(intrr){ q=1; for(i=0;i<rr;i++)q=q*2.71728;

returnq; }

//######################################################### voidMohandes(void){ t=(3.1415926535897932384626433832795/180)*a; if(z==16)c=sin(t); if(z==17)c=cos(t); if(z==18)c=tan(t); if(z==19)c=1/tan(t); if(z==20)c=asin(t); if(z==21)c=acos(t); if(z==22)c=log(a); if(z==23)c=sqrt(a); if(z==24)c=Emoji(a); ftoa(c,3,lcd); lcd_puts(lcd); delay_ms(100); } //######################################################### voidAlamat(intMoji,intHalat){ if(Halat==1){ if(Moji==10)lcd_putchar('/'); if(Moji==11)lcd_putchar('*'); if(Moji==12)lcd_putchar(''); if(Moji==13)lcd_putchar('+');

delay_ms(100); } if(Halat==2){ if(Moji==16)lcd_putsf("Sin"); if(Moji==17)lcd_putsf("Cos"); if(Moji==18)lcd_putsf("Tan"); if(Moji==19)lcd_putsf("Cot"); if(Moji==20)lcd_putsf("aSin"); if(Moji==21)lcd_putsf("aCos"); if(Moji==22)lcd_putsf("Log"); if(Moji==23)lcd_putsf("Sqrt"); if(Moji==24)lcd_putsf("exp"); delay_ms(100); } } //######################################################### intkey(void){ charKEY=1; while(KEY){ PORTD.0=1; PORTD.1=0; PORTD.2=0; PORTD.3=0;

if(PIND.4==1){return7;KEY=0;delay_ms(50);} if(PIND.5==1){return8;KEY=0;delay_ms(50);} if(PIND.6==1){return9;KEY=0;delay_ms(50);} if(PIND.7==1){return10;KEY=0;delay_ms(50);} //========================================== PORTD.0=0; PORTD.1=1; PORTD.2=0; PORTD.3=0; if(PIND.4==1){return4;KEY=0;} if(PIND.5==1){return5;KEY=0;} if(PIND.6==1){return6;KEY=0;} if(PIND.7==1){return11;KEY=0;} //========================================== PORTD.0=0; PORTD.1=0; PORTD.2=1; PORTD.3=0; if(PIND.4==1){return1;KEY=0;} if(PIND.5==1){return2;KEY=0;} if(PIND.6==1){return3;KEY=0;} if(PIND.7==1){return12;KEY=0;} //========================================== PORTD.0=0; PORTD.1=0;

PORTD.2=0; PORTD.3=1; if(PIND.4==1){return15;KEY=0;} if(PIND.5==1){return0;KEY=0;} if(PIND.6==1){return14;KEY=0;} if(PIND.7==1){return13;KEY=0;} //============================================================================= PORTC.0=1; PORTC.1=0; PORTC.2=0; if(PINC.5==1){return16;KEY=0;} if(PINC.6==1){return17;KEY=0;} if(PINC.7==1){return18;KEY=0;} //===================================================== PORTC.0=0; PORTC.1=1; PORTC.2=0; if(PINC.5==1){return19;KEY=0;} if(PINC.6==1){return20;KEY=0;} if(PINC.7==1){return21;KEY=0;} //===================================================== PORTC.0=0; PORTC.1=0; PORTC.2=1;

if(PINC.5==1){return22;KEY=0;} if(PINC.6==1){return23;KEY=0;} if(PINC.7==1){return24;KEY=0;} KEY=1; } } //############################################################

SIMPLE STOPWATCH MENGGUNAKAN MIKROKONTROLER DENGAN CODEVISION AVR

Aplikasi ini merupakan sebuah stopwatch sederhana yang dapat menghitung sampai satuan waktu terkecil yaitu 1/100 detik atau 10 ms. Untuk membangkitkan timer 10 ms saya menggunakan fitur timer0 mikrokontroler AVR. Untuk lebih jelas mengenai fitur timer AVR silakan baca postingan saya mengenaitutorialTimerdanCounterAVR. Padaaplikasiiniterdapat3buahtombol(push button)yang terdiri daritombolSTART,STOPdanRESET. Tombol START digunakan untuk memulai stopwatch, STOP digunakan untuk memberhentikan stowatch dantombolRESETuntukmereset(mensetulangkembalinilaistopwatch). Saya juga menyertakan program dalam file CodeVision AVR dan file simulasi proteus pada akhir artikel ini.Berikutadalahschematikrangkaiannya.

unsigned char count, temp[16], indeks=0, detik=0, menit=0, jam=0; #include <mega16.h> #include <stdio.h> #include <stdlib.h> // Alphanumeric LCD Module functions #asm .equ __lcd_port=015 ;PORTC #endasm #include <lcd.h> // Timer 0 overflow interrupt service routine interrupt [TIM0_OVF] void timer0_ovf_isr(void) { // Reinitialize Timer 0 value TCNT0=0x8A; count++; } void hitung_waktu() { if (count>=100) { lcd_clear(); detik++; count=0; } if (detik>=60) { menit++; detik=0; } if (menit>=60) { jam++; menit=0; } } void detek_tombol()

{ if (PINA.0==0 && (indeks==0 || indeks==2))//start timer { indeks=1; TIMSK=001;//memulai timer lcd_clear(); } if (PINA.1==0 && indeks==1)//stop timer { indeks=2; TIMSK=000;//menstop timer lcd_clear(); } if (PINA.2==0 && indeks==2)//reset timer { indeks=0;//semua data direset count=0; detik=0; menit=0; jam=0; lcd_clear(); } } void tampil_lcd() { lcd_gotoxy(0,0); sprintf(temp,Timer %d:%d:%d:%d,jam,menit,detik,count); lcd_puts(temp);//tampilkan waktu di LCD baris pertama if (indeks==0) { lcd_gotoxy(0,1); lcd_putsf(START); } if (indeks==1) { lcd_gotoxy(0,1); lcd_putsf(STOP); } if (indeks==2)

{ lcd_gotoxy(0,1); lcd_putsf(START } } void main(void) { PORTA=0x0f; DDRA=000;

RESET);

// Timer/Counter 0 initialization // Clock source: System Clock // Clock value: 11.719 kHz // Mode: Normal top=FFh // OC0 output: Disconnected TCCR0=005; TCNT0=0x8A; OCR0=000; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // LCD module initialization lcd_init(16); // Global enable interrupts #asm(sei) while (1) { detek_tombol(); hitung_waktu(); tampil_lcd(); }; }

MENGAKSES MODUL SENSOR GYROSCOPE LISY300 TERKALIBRASI MENGGUNAKAN CODEVISION AVR

[OVERVIEW] Sensor gyroscope yang saya gunakan ini adalah sebuah modul yang terdiri dari sensor Gyroscope LISY300AL dan ADC serial ADC101S021 yang dikeluarkan oleh PARALLAX Inc. Pada modul ini pun telah dilengkapi dengan regulator tegangan 3.3 V sebagai supply nya. Modul Sensor Gyroscope LISY300AL dapat mendeteksi kecepatan sudut (angular rate) satu axis, yaitu sumbu Z (yaw). Dan mampu membaca sampai 300/s full scale.

[PROTOKOL KOMUNIKASI] Pada dasarnya output dari sensor Gyroscope LISY300AL adalah berupa tegangan analog, tetapi oleh PARALLAX Inc, output dari sensor Gyroscope tersebut dibaca menggunakan ADC serial. Sehingga untuk mengakses modul ini kita harus menggunakan protokol kumunikasi SPI (Serial Peripheral Interface). Berikut adalah timing diagram cara mengakses Modul Sensor Gyroscope LISY300AL (ADC serial ADC101S021).

Pada dasarnya untuk dapat mengakses Modul Sensor Gyroscope LISY300AL ini, sebenarnya kita hanya harus tau cara mengakses ADC serial ADC101S021, dikarenakan Sensor Gyroscope itu sendiri dibaca oleh ADC serial ADC101S021. Dari gambar diatas terlihat bahwa terdapat 3 jalur untuk mengakses ADC serial ADC101S021 yaitu CS, SCLK dan SDATA. CS digunakan untuk meng-enable ADC serial ADC101S021 agar dapat diakses, harus beri logika LOW. SCLK digunakan sebagai serial clock, dimana semua aplikasi yang berkomunikasi secara serial membutuhkan clock untuk mengaksesnya, maksimal kecepatan clock untuk mengakses ADC serial ADC101S021 adalah 4MHz. Sedangkan SDATA adalah jalur data serial yang berasal dari ADC serial ADC101S021. Data yang berasal dari ADC serial ADC101S021 mempunyai 15 bit data. Yaitu 3 bit 0 (LOW) awal, 10 bit data ADC dan 2 bit 0 (LOW) akhir. Dimana 10 bit data ADC dimulai dari MSB dan diakhiri oleh LSB. [SENSITIVITAS] Dan sensor Gyroscope LISY300AL, mempunyai sensitivitas 3.3 mV//s. Dimana ADC serial ADC101S021 mempunyai pembacaan data 10 bit (0-1023 atau sebanyak 1024 step) dengan perkiraan 3.22 mV/step. Sehingga setiap perubahan setiap step adalah perubahan 1 derajat. [ZERO RATE LEVEL] Sebenarnya sensor Gyroscope LISY300AL sudah terkalibrasi dari pabriknya. Yaitu dengan supply tegangan 3.3 V akan menghasilkan zero rate level 1.65 V (tegangan offset atau Voffset). Nilai zero rate level ini terjadi ketika Gyroscope tidak melakukan kecepatan sudut (angular rate), atau sensor Gyroscope dalam keadaan diam. Atau dengan kata lain jika dibaca menggunakan ADC 10 bit, dengan range input ADC 0-3.3 V, maka didapat nilai ADC sebesar 512 untuk zero rate level (tidak terjadi percepatan sudut atau dalam keadaan diam). Jika sumbu Z bergerak searah jarum jam, maka nilai ADC akan berkurang (dibawah nilai zero rate levelnya), Jika bergerak berlawanan arah jarum jam maka nilai ADC akan bertambah (diatas zero rate levelnya). Tetapi menurut datasheet Gyroscope LISY300AL: Zero-rate level describes the actual output signal if there is no angular rate present. For a 3.3 V powered sensor the absolute zero-rate output is ideally 1.65 V. Zero-rate level of precise MEMS sensors is, to some extent, a result of stress to the sensor and therefore zero-rate level can slightly change after mounting the sensor onto a printed circuit board or after exposing it to extensive mechanical stress. This value changes very little over temperature and also very little over time. [KALIBRASI] Karena alasan diatas, maka terjadi penyimpangan untuk nilai zero rate levelnya, yaitu maksimal sekitar 51224. Oleh karena itu harus dilakukan cara untuk dapat menentukan nilai zero rate level melalui kalibrasi.

Pada dasarnya nilai zero rate level sudah bisa kita tentukan sendiri, yaitu saat tidak terjadi kecepatan sudut (angular rate) atau gyroscope dalam keadaan diam. Sebagai contoh ketika saya baca keluaran Modul Sensor Gyroscope LISY300AL muncul nilai 511, 509, 504, 513 (berubahubah). Dari data tersebut bisa saja saya mengambil kesimpulan jika nilai zero rate levelnya adalah 507 (nilai tengahnya). Pertanyaannya, mengapa nilainya tidak diam/statis? Jawabannya adalah sensor gyroscope bersifar dinamis, dimana sensor gyroscope mempunyai nilai saat terjadi kecepatan sudut (angular rate). Sedangkan saat diam (tidak terjadi angular rate) maka nilainya adalah sama dengan zero rate level. Lalu nilainya yang berubah-ubah dikarenakan gyroscope mempunyai efek drift saat kondisi diam (nilainya tidak cenderung kembali ke nilai zero rate level). Hal ini adalah kebalikan dari sensor accelerometer, dimana sensor accelerometer bersifat statis. Oleh karena itu mengapa pada banyak aplikasi selalu menggabungkan dua buah sensor tersebut (gyroscope dan accelerometer).
Baiklah, berikut adalah cara melakukan kalibrasinya. Cara ini saya dapat dari program demo yang diberikanolehPARALLAXInc.

center (saya gunakan untuk mengganti istilah zero data_gyro (hasil pembacaan ADC dari gyroscope melalui komunikasi SPI) center(n)=(center(n-1)+data_gyro(n))/ banyaknya n

rate

level)

Dimana: n = sampling center(n-1) = 0 (bernilai nol pada awalnya) Semakin banyak n (sampling) maka semakin baik untuk mendapatkan nilai zero rate levelnya. Kalibrasi ini dilakukan hanya 1 kali pada awal program saja. [MENGAKSES ADC SERIAL ADC101S021 ATAU SPI] Untuk mengakses ADC serial ini menggunakan protokol komunikasi SPI dan saya menggunakan bahasa C dengan compiler CodeVision AVR untuk memprogramnya. Pada dasarnya compiler CodeVision AVR telah mempunyai library bawaan untuk mengakses SPI, tapi sayangnya library tersebut hanya untuk mengakses 8 bit data saja (aplikasi ini datanya 15 bit). Oleh karena itu saya membuat sebuah fungsi sendiri untuk mengaksesnya. Untuk listing program lengkap dan schematic rangkaiannya dapat dilihat dibawah ini.

#include<mega16.h> #include<delay.h> #include<stdlib.h> charj=1,i=1,k=1,data[16],temp[16]; unsignedintdata_gyro; floatcenter=0,sudut; #asm .equ__lcd_port=015;PORTC #endasm #include<lcd.h> voidbaca_gyro() { data_gyro=0; if(i==16){i=1;} if(j==16){j=1;} PORTB.4=1;//cshigh delay_us(100); PORTB.4=0;//cslow,enableserialtransfer\___ for(i=1;i<16;i++) { PORTB.7=1;//sclkhigh delay_us(1); PORTB.7=0;//sclklow\___ delay_us(1); if(PINB.6==1){data[j]=1;}//mengambildataperbitdariMISO elsedata[j]=0; j++; } //perhitungandataADC10bit,3bitzeroleadingdan2bitzerotrailertidakdihitung //data[1]sampaidata[3]adalahbitleadingdandata[14]sampaidata[15]adalahbittrailer data_gyro=((data[4]*512)+(data[5]*256)+(data[6]*128)+(data[7]*64)+(data[8]*32)+(data[9]*16)+(data[ 10]*8)+(data[11]*4)+(data[12]*2)+(data[13]*1)); } voidkalibrasi_gyro()

{ for(k=1;k<10;k++) { baca_gyro(); center=center+data_gyro; lcd_gotoxy(0,0); lcd_putsf(CALIBRATING); lcd_gotoxy(0,1); ftoa(center,1,temp); lcd_puts(temp); delay_ms(200); } center=center/10; } voidsudut_gyro() { sudut=data_gyrocenter; sudut=sudut*1; } voidtampil_LCD() { lcd_clear(); itoa(data_gyro,temp); lcd_puts(temp); lcd_gotoxy(0,1); ftoa(center,1,temp); lcd_puts(temp); lcd_gotoxy(8,1); ftoa(sudut,1,temp); lcd_puts(temp); } voidmain(void) { PORTB=0xff; DDRB=090;//pb7danpb4output,sisanyainput //AnalogComparatorinitialization //AnalogComparator:Off //AnalogComparatorInputCapturebyTimer/Counter1:Off

ACSR=080; SFIOR=000; //LCDmoduleinitialization lcd_init(16); kalibrasi_gyro(); while(1) { baca_gyro(); sudut_gyro(); tampil_LCD(); delay_ms(100); }; }

Mengukur tinggi level air dengan sensor

Banyak permukaan untuk macam air, membuat cara pada semacam air dengan air Untuk posisi yang sensor adalah pada prinsipnya permukaan diketahui. air dengan dapat mengukur posisi mengukur ketinggian tinggi selisih ketinggian selisih pelampung maksimal dengan dapat akan pengukur tetap digunakan dicontohkan ketinggian telah untuk kali air ini yaitu mengukur cara yang dengan nilainya antara maka antara sensor air akan jarak dengan pasti pada posisi sensor dengan ketinggian digunakan menggunakan dengan batas tinggi tinggi pasti, air. tinggi maksimal jarak, posisi diukur. batas pelampung pelampung. dengan maka 1: contoh (T) = pada 100cm, sensor cahaya infra gambar dan 1, misalkan antara jarak maka Untuk tabung air tinggi tinggi akan maksimum maksimum dipergunakan diberi gangguan tertutup, juga ini turun dengan air permukaan dengan air posisi jarak posisi yang pada permukaan

aplikasi

yang

pelampung dan sensor pengukur jarak. Cara ini dapat digunakan jika ukuran tinggi maksimal misalnya Pada air maksimal permukaan karena dengan Sehingga maksimal adalah Jika permukaan dan diketahui tandon ketinggian pelampung ketinggian digunakan

pengukur dengan

selisih

ketinggian posisi

antara

permukaan

ketinggian pelampung adalah sama dengan jarak antara batas maksimal permukaan air pelampung menempatkan air, maka selisih tersebut sensor yang air nilai jarak yang pengukur terukur tetap dan selisih maksimum antara dengan ketinggian dengan air nilai sama

ketinggian adalah dengan

ketinggian

ketinggian

maksimum

nilainya,

maka

mengurangkan gambar Seperti adalah

ketinggian

pelampung,

ketinggian air dapat diketahui. Untuk memperjelas sebagai contoh adalah seperti pada

pelampung adalah (t) = 30cm, maka tinggi permukaan air adalah (tair) =T t =100 30=70cm. metode pemantul dan lubang semacam ketinggian sebuah Karena cahaya pengukur infra merah pada sebagai air. Dari merah, sensor. sebuah tempat agar menggunakan lapisan maka dengan berfungsi sebagai sebuah sebagai pelampung pantulan pelampung yang

mengurangi silinder Tabung naik maka

sensor pada

ditempatkan dasarnya

masuk. bergerak diatas

tempat sensor

pelampung pengukur

dapat

mengikuti hanya dapat

perubahan diukur.

permukaan

penjelasan jarak

menggunakan

maka

ketinggian

Sensor Detector, dengan kecil, satu jarak.

pengukur yaitu cara sehingga bentuk

jarak modul

yang sensor yang modul

digunakan pendeteksi relatif sensor pada Object

adalah benda

modul

sensor

InfraRed infra yang

Object merah. cukup Salah

dengan dan

menggunakan ukuran

Modul ini menggunakan rangkaian sensor yang telah berbentuk modul jadi siap pakai, penggunaan dapat aplikasi yang sensor jarak dari mudah dan ini mempunyai untuk sebagai pengukur modul dengan didepan kemudian dapat Object menghemat tempat praktis adalah untuk modul digunakan. sensor

pengukur air ini

Modul-modul adalah diukur aplikasi mengukur dilakukan Jarak besarnya tinggi output Nilai seperti terukur. diatur Untuk Sebagai substractor, referensi tegangan Amp ini obyek modul adalah ini

digunakan InfrRed antara

aplikasi Detector,

ketinggian modul Prinsip yaitu hasil dengan Output

OP-01, sensor. sensor dari

ADC0809, kerja dari

modul DST-52 dan modul LCD. Seperti yang telah dijelsakan diatas, jarak yang akan obyek (pelampung) obyek tersebut, sensor InfraRed oleh adalah berapa mendeteksi jauh jarak keberadaan obyek untuk dengan pada sensor pelampung, pengukuran air. sensor pada sekali. adalah yang yang dahulu kalibrasi. OP-01. sebagai tegangan Kemudian ini dapat mengukur dari

penghitungan (pelampung) output yang tegangan

mendapatkan

posisi dihitung Detector.

ketinggian

adalah berupa tegangan DC. Semakin dekat jarak obyek dengan sensor maka semakin pula tegangan akan terdapat besarnya ke input dikeluarkan secara 2 output output sensor. Besarnya setiap jarak yaitu jarak tegangan 32ms obyek grafik obyek sensor perubahan yang diperbarui pada terus-menerus terhadap grafik sensor kira-kira perubahan sensor, dengan ke sensor modul sebagai menggunakan rangkaian dikurangkan mencapai 0 level output pada Op 0. sensor.

tegangan

sensor output tersebut nya

gambar

respon sesuai

menunjukkan diumpankan

tegangan sensor nol modul

Tegangan tegangan pengaturan pengatur dimana sampai

output offset

diumpankan output dan diperkuat penguatan sensor titik

ADC0809. terlebih proses modul Amp dengan

Sebelum

ADC, offset offset

tegangan dan dari

tersebut

tegangan tegangan tegangan tegangan

menggunakan substractor

output output

pada untuk

Pengurangan

dimaksudkan penguat

mengkalibrasi Tingkat

tegangan dari output rangkaian substracktor ini diperkuat menggunakan rangkaian Op sebagai non-inverting. penguatan rangkaian diatur sesuai dengan kebutuhan, pada aplikasi kali ini tingkat penguatan yang dipakai

adalah pengatur seperti Setelah berguna modul

1x.

Contoh

gambar offset

rangkaian penguat

cara

menghubungkan 3 diumpankan digital. yang setiap terjadi sensor Dari (pelampung) terjadi ke

sensor

dengan dan

rangkaian adalah 4. yang dapat maka input 1 bit. gambar output adalah: desimal

tegangan output untuk

dan

dengan

menggunakan

modul modul biner adalah perubahan data grafik

OP-01 ADC0809 hasil sensor 5VDC pada pada sensor sebesar Misalnya

pada sensor diperkuat, jarak mengkonversi inilah, tegangan sebesar maka ADC,

gambar kemudian ke obyek ADC Jadi output dengan analog referensi 0,0196V. pada

output

konversi

ADC0809 Karena ADC sebesar data adalah

terhadap

diketahui. resolusi ADC Dari 2, dari Hasil Tegangan Jika 20cm. DST-52, Sesuai dapat (t) maksimum

digunakan perubahan dengan dapat tegangan = x

0.0196V obyek

digital jarak

output

kemudian 0x49H,

disesuaikan maka 0x49H

maka

(pelampung) bernilai

diketahui. output 73 0,019V

ADC

adalah Konversi Output

ADC: Sensor sensor modul diatas, air contoh : telah

73 diketahui ini jarak diketahui, sesuai maksimal ini

= maka ke

1,387V sesuai modul air. air air

tegangan Hasil

output dari

sebesar1,387V, kemudian tinggi antara maka dengan

dengan grafik pada gambar 1, jarak obyek (pelampung) terhadap sensor adalah sekitar konversi untuk dengan dengan dihitung. ADC0809 jika telah diatas, diumpankan permukaan tinggi ketinggian gambar air permukaan permukaan 1, dari jika proses permukaan pada menghitung

penjelasan Seperti

dengan (T)

pengukuran diketahui jarak antara batas tinggi maksimum (sensor) dengan pelampung adalah sebesar Hasil 20cm, dan ketinggian air dari permukaan dasar adalah 100cm, maka ketinggian permukaan air dari dasar (tair) adalah tair=T-t=10020=80cm. LCD. potongan Pertama-tama dengan adalah program memberi alamat 1 modul modul 4. ADC ADC, memberi baris perintah menulis dalam data data hal perhitungan ketinggian data kemudian ditampilkan adalah pada seperti modul pada 1. mulai 0800H, lalu dengan proses seperti data konversi, alamat pada diambil data yaitu data eksternal dengan Contoh program pengambilan modul ADC0809

program diperintahkan ke ini untuk memori adalah

potongan dengan adalah

Kemudian

menunggu dari

proses

konversi,

perintah

membaca

memori

eksternal

alamat

alamat Setelah pada menjadi tersebut sesuai pada dengan tair=T-t Seperti

ADC. data contoh data telah dengan

Data

hasil

konversi dilanjutkan program 2.

kemudian dengan Data dahulu, seperti kemudian 5.

disimpan 1 proses

pada

Accumulator, baris tinggi

seperti air, data 4.

pada 8. seperti

potongan diperoleh potongan jarak nilai

program hasil

penghitungan ADC isi ini Untuk

konversi

kemudian tersebut baris jarak, sensor

dirubah jarak dibaca Hasil seperti dengan air rumus:

sensor konversi

dengan ADC,

pelampung. baru pada

memudahkan, tabel 2 variabel jarak perhitungan program

ditabelkan jarak program

terlebih tersebut 2

kemudian potongan pada

pembacaan pelampung

tabel

disimpan Kemudian adalah

potongan

baris

setelah proses

diketahui,

maka

selanjutnya

tinggi

pada

potongan lalu nilai

program Accumulator

baris tersebut

dan

8,

nilai

T nilai

disimpan yang

pada

Accumulator,

dikurangi

dengan

disimpan

pada variabel JARAK, yaitu nilai t, hasil pengurangan ini adalah nilai ketinggian air yang diukur (tair), dan disimpan pada Accumulator. Nilai ketinggian air ini kemudian disimpan pada variabel TINGGIAIR dan kemudian ditampilkan pada modul LCD.

PROGRAMMENGAKSESSENSORJARAKPING)))PARALLAX MENGGUNAKANCODEVISIONAVR

Sensor jarak ultrasonic Parallax PING))) mampu mengukur jarak dengan teliti dan tanpa kontak antara 2 cm (0.8 inche) sampai 3 meter (3.3 yard). Sangat mudah untuk dikoneksikan dengan mikrokontroler, hanya membutuhkan satu pin I/O. Sensor PING))) berkerja dengan mentransmisikan sebuah ultrasonic burst (diatas batas pendengaran manusia) dan menghasilkan sebuah pulsa output yang berhubungan dengan waktu yang dibutuhkan oleh echo dari burst untuk kembali ke sensor. Dengan mengukur lebar pulsa echo jarak sensor ke target dapat dihitung. Karakteristik * Tegangan suplai : 5VDC * Konsumsi arus : 30 mA typ; 35 mA max * Jarak : 2 cm sampai 3 m (0.8 in sampai 3.3 yrd) * Input Trigger : positive TTL pulse, 2 uS min, 5 s typ * Echo Pulse : positive TTL pulse, 115 uS to 18.5 ms * Echo Hold-off : 750 s from fall of Trigger pulse * Burst Frequency : 40 kHz for 200 s * Burst Indicator LED shows sensor activity * Delay before next measurement : 200 s * Size : 22 mm H x 46 mm W x 16 mm D (0.84 in x 1.8 in x 0.6 in) Berikut adalah program pembacaan jarak (cm) menggunakan sensor ultrasonik PING))) buatan Parallax. Pada program dibawah ini menggunakan frekuensi kristal 4Mhz, dan pin output dari PING))) dihubungkan ke port PB0, LCD pada PC. Sebelumnya saya minta maaf tidak menampilkan rangkaiannya, karena tidak ada library untuk komponen PING))). //Clock frequency : 4.000000 MHz //output sensor PING))) ke PB0 //LCD ke PC #include <mega8535.h> #include <lcd.h> #include <stdio.h> #include <delay.h> // Alphanumeric LCD Module functions #asm

.equ __lcd_port=015 ;PORTC #endasm //deklarasi PIN I/O PING #define PULSE PORTB.0 #define ECHO PINB.0 #define ARAH DDRB.0 #define OUT 1 #define INP 0 unsigned int ultrasonic() { unsigned int count=0; unsigned int jarak; ARAH=OUT;//mengatur PIN I/O sebagai output PULSE=1;//memberikan tanda ke PING untuk memancarkan ultrasonic burst delay_us(5);//waktu tunggu sebelum pengukuran min. 2us biasanya 5us PULSE=0;//menberikan sinyal low ke PING ARAH=INP;//arah PIN I/O diatur sebagai input PULSE=1;//mengatur PIN I/O sebagai pill-up while (ECHO==0) {};//menunggu sinyal ECHO high while (ECHO==1) { count++; //menghitung lebar sinyal ECHO high } jarak=(unsigned int)(((float)count)/25);//nilai pembagi dikalibrasi sampai sesuai dengan satuan yang diinginkan return(jarak);//mengembalikan jarak ke fungsi ultrasonic dengan tipe data unsigned int } void main(void) { unsigned char kata[16]; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=080; SFIOR=000; // LCD module initialization lcd_init(16);

while (1) { sprintf(kata, J=%3d cm, ultrasonic());//menyusun karakter ke dalam satu baris dengan menggunakan fungsi sprintf lcd_clear(); lcd_gotoxy(0,0); lcd_puts(kata);//mengirim data ke LCD delay_ms(300); } }

SISTEMDRAINASEOTOMATISBERBASISMIKROKONTROLER ATMEGA8535(ContohJurnalIlmiah)
SISTEM DRAINASE OTOMATIS BERBASIS MIKROKONTROLER ATMEGA8535 PI. Sistem Komputer. Fakultas Ilmu Komputer dan Teknologi Informasi. Universitas Gunadarma, 2011 https://brian_dendiatama@gunadarma.ac.id Oleh : Brian Dendiatama Abstrak Kata Kunci : Mikrokontroler, Drainase, Sensor Air, LCD. Sistem drainase merupakan salah satu cara pembuangan air yang berlebihan pada suatu tempat atau kawasan. Secara umum, sistem drainase didefinisikan sebagai serangkaian bangunan air yang berfungsi untuk mengurangi atau membuang kelebihan air dari suatu kawasan atau lahan, sehingga dapat difungsikan secara optimal. Pada dasarnya rangkaian ini dirancang guna untuk membuang air yang berlebihan pada suatu tempat atau kawasan yang daerah resapan airnya kurang bagus bahkan tidak adanya sistem resapan air yang tertata dengan baik dan benar. Oleh karena itu, dirancang sebuah alat yang berjudul Sistem Drainase Otomatis Berbasis Mikrokontroler ATMega8535 yang difungsikan sebagai media resapan air yang terdiri dari sensor air yang akan membuat aksi pada rangkaian pompa air sebagai alat untuk membuang air melalui pipa atau selang yang terhubung pada pompa air dan hasilnya atau output akan ditampilkan pada display LCD sesuai dengan level air yang mengenai sensor air tersebut dan juga akan di tampilkan pada lampu indikator yang tersusun sesuai dengan kondisi sensor air, serta akan menginformasikan dalam bentuk gelombang suara yang dihasilkan oleh buzzer yang terhubung pada rangkaian Sistem Drainase Otomatis Berbasis Mikrokontroler ATMega8535 ini. 1. PENDAHULUAN 1.1 Latar Belakang Sistem drainase merupakan salah satu cara pembuangan air yang berlebihan pada suatu tempat atau kawasan. Secara umum, sistem drainase didefinisikan sebagai serangkaian bangunan air yang berfungsi untuk mengurangi atau membuang kelebihan air dari suatu kawasan atau lahan, sehingga dapat difungsikan secara optimal. Dari sudut pandang lain, sistem drainase adalah salah satu unsur dari prasarana umum yang dibutuhkan oleh masyarakat kota dalam rangka menuju kehidupan kota yang aman, nyaman, bersih, dan sehat. Prasarana drainase berfungsi mengalirkan air ke tempat pembuangan air atau resapan air, selain itu juga berfungsi sebagai pengendali kebutuhan air dengan tindakan untuk memperbaiki daerah rawan banjir atau daerah genangan air yang secara berlebihan. Sistem drainase juga dirancang sebagai suatu sistem guna membantu memenuhi kebutuhan masyarakat akan terbatasnya dari masalah banjir yang menggangu aktifitas dan rutinitas

masyarakat kota sehari-harinya. Sistem drainase juga merupakan komponen penting dalam perancangan kota (perancangan infrastruktur khususnya). 1.2 Batasan Masalah Pada masalah ini akan disajikan solusi penanggulangan dini dan sistem drainase secara otomatis dengan sistem pembuangan air. Akan dilakukan perancangan alat yang berjudul Sistem Drainase Berbasis Mikrokontroler ATMega8535. 1.3 Tujuan Penulisan Adapun tujuan dari suatu perancangan rangkaian sistem drainase atau pembuangan air otomatis berbasis mikrokontroler ATMega8535 dengan tampilan LCD, yaitu yang pertama adalah untuk mengurangi atau membuang air yang berlebihan dari suatu kawasan atau lahan yang memaksimalkan fungsionalnya. yang kedua yaitu mengontrol ketinggian air banjir atau penanggulangan dini terhadap masalah banjir yang sering dihadapi masyarakat perkotaan terutama daerah rawan banjir. 1.4 Metode Penulisan Dalam penulisan ini menggunakan metode penulisan dari berbagai sumber diantaranya dengan menggunakan metode Studi Pustaka dan Studi Lapangan. Pada metode studi pustaka dilakukan dengan cara mengambil data dari berbagai sumber internet dan buku yang dijadikan pedoman dalam penulisan ini. Selain itu menggunakan metode studi lapangan yang dilakukan dengan cara mencari data dan pengamatan terhadap rangkaian atau alat yang dibuat secara langsung, agar data yang diperoleh dapat seakurat mungkin. 2. LANDASAN TEORI 2.1 Mikrokontroler AVR ATMega8535 Mikrokontroler sebagai sebuah one chip solution pada dasarnya adalah rangkaian terintregrasi (Integrated Circuit- IC) yang telah mengandung secara lengkap berbagai komponen pembentuk sebuah komputer. Berbeda dengan penggunaan mikroprosesor yang masih memerlukan komponen luar tambahan seperti RAM, ROM, Timer, dan sebagainya untuk sistem mikrokontroler, tambahan komponen diatas secara praktis hampir tidak dibutuhkan lagi. Hal ini disebabkan semua komponen penting tersebut telah ditanam bersama dengan sistem prosesor ke dalam IC tunggal mikrokontroler bersangkutan. Dengan alasan itu sistem mikrokontroler dikenal juga dengan istilah populer the real Computer On a Chip-komputer utuh dalam keping tunggal, sedangkan sistem mikroprosesor dikenal dengan istilah yang lebih terbatas yaitu Computer on a Chip-komputer dalam keping tunggal. Dengan berbagai macam kelebihan yang dimiliki, dewasa ini mikrokontroler AVR 8 bit produk perusahaan Atmel adalah salah satu mikrokontroler yang banyak merebut minat kalangan profesional dan juga cocok dijadikan sarana berlatih bagi para pemula. Hal ini selain karena

ragam fitur yang ditawarkan, juga disebabkan kemudahan untuk memperoleh mikrokontroler tersebut (berikut papan pengembangnya) di pasaran dengan harga yang relatif murah. Secara histories mikrokontroler seri AVR pertama kali diperkenalkan ke pasaran sekitar tahun 1997 oleh perusahaan Atmel, yaitu sebuah perusahaan yang sangat terkenal dengan produk mikrokontroler seri AT89S51/52-nya yang sampai sekarang masih banyak digunakan di lapangan. Tidak seperti mikrokontroler seri AT89S51/52 yang masih mempertahankan arsitektur dan set instruksi dasar mikrokontroler 8031 dari perusahaan INTEL. Mikrokontroler AVR ini diklaim memiliki arsitektur dan set instruksi yang benar-benar baru dan berbeda dengan arsitektur mikrokontroler sebelumnya yang diproduksi oleh perusahaan tersebut. Tetapi walaupun demikian, bagi para programmer yang sebelumnya telah terbiasa dengan mikrokontroler seri AT89S51/52, dan berencana untuk beralih ke mikrokontroler AVR, maka secara teknis tidak akan banyak kesulitan yang berarti, hal ini dikarenakan selain konsep dan istilah-istilah dasarnya hampir sama, pemrograman level assembler-nya pun relative tidak jauh berbeda. Berdasarkan arsitekturnya, AVR merupakan mikrokontroler RISC (Reduce Instruction Set Computer) dengan lebar bus data 8 bit. Berbeda dengan sistem AT89S51/52 yang memiliki frekuensi kerja seperduabelas kali frekuensi oscilator, frekuensi kerja mikrokontroler AVR ini pada dasarnya sama dengan frekuensi oscilator, sehingga hal tersebut menyebabkan kecepatan kerja AVR untuk frekuensi oscilator yang sama, akan dua belas kali lebih cepat dibandingkan dengan mikrokontroler keluarga AT89S51/52. Dengan instruksi yang sangat variatif (mirip dengan sistem CISC-Complex Instruction Set Computer) serta jumlah register serbaguna (general purpose Register) sebanyak 32 buah yang semuanya terhubung secara langsung ke ALU (Arithmetic Logic Unit), kecepatan operasi mikrokontroler AVR ini dapat mencapai 16 MIPS (enam belas juta instruksi per detik) sebuah kecepatan yang sangat tinggi untuk ukuran mikrokontroler 8 bit yang ada di pasaran sampai saat ini. Untuk memenuhi kebutuhan dan aplikasi industri yang sangat beragam, mikrokontroler keluarga AVR ini muncul di pasaran dengan tiga seri utama: tinyAVR, ClasicAVR (AVR), megaAVR. Berikut ini beberapa seri yang dapat anda jumpai di pasaran : ATtiny13, AT90S2313, ATmega103, ATtiny22, AT90S2323 ATmega128, ATtiny22L AT90S2333 ATmega16, ATtiny2313 AT90S4414 ATmega162, ATtiny2313V AT90S4433 ATmega168, ATtiny26 AT90S8515 ATmega8535. Keseluruhan seri AVR ini pada dasarnya memiliki organisasi memori dan set instruksi yang sama (sehingga dengan demikian jika telah mahir menggunakan salah satu seri AVR, untuk beralih ke seri yang lain akan relatif mudah). Perbedaan antara tinyAVR, AVR dan megaAVR pada kenyataannya hanya merefleksikan tambahan-tambahan fitur yang ditawarkannya saja (misal adanya tambahan ADC internal pada seri AVR tertentu, jumlah Port I/O serta memori yang berbeda, dan sebagainya). Diantara ketiganya, megaAVR umumnya memiliki fitur yang paling lengkap, disusul oleh AVR, dan terakhir tinyAVR. Untuk memberi gambaran yang lebih jelas. berikut memperlihatkan perbedaan ketiga seri AVR ditinjau dari jumlah memori yang dimilikinya.

Pengisian memory Flash dengan menggunakan saluran SPI ini dapat dilakukan bahkan ketika chip AVR telah terpasang pada sistem akhir (end system), sehingga dengan demikian pemrogramannya sangat fleksibel dan tidak merepotkan pengguna (secara praktis metoda ini dikenal dengan istilah ISP (In System Programming) sedangkan perangkat lunaknya dinamakan (In System Programmer). Untuk penyimpanan data, mikrokontroler AVR menyediakan dua jenis memori yang berbeda : EEPROM (Electrically Erasable Programmable Read Only Memory) dan SRAM (Static Random Access memory). EEPROM umumnya digunakan untuk menyimpan data-data program yang bersifat permanen, sedangkan SRAM digunakan untuk menyimpan data variabel yang dimungkinkan berubah setiap saatnya. Kapasitas simpan data kedua memori ini bervariasi tergantung pada jenis AVR-nya. Untuk seri AVR yang tidak memiliki SRAM, penyimpanan data variabel dapat dilakukan pada register serbaguna yang terdapat pada CPU mikrokontroler tersebut. Selain seri-seri diatas yang sifatnya lebih umum, perusahaan Atmel juga memproduksi beberapa jenis mikrokontroler AVR untuk tujuan yang lebih khusus dan terbatas, seperti seri AT86RF401 yang khusus digunakan untuk aplikasi wireless remote control dengan menggunakan gelombang radio (RF), seri AT90SC yang khusus digunakan untuk peralatan sistem- sistem keamanan kartu SIM GSM,pembayaran via internet, dan lain sebagainya.Pada rangkaian ini menggunakan mikrokontroler AVR ATMega8535, dengan penjelasan sebagai berikut :

Gambar 2.1 Konfigurasi Pin Pada Mikrokontroler ATMega8535

Gambar 2.2 Bentuk Fisik Mikrokontroler ATMega8535 2.2 Sistem Minimum DT-AVR Low Cost Micro System

DT-AVR Low Cost Micro System merupakan modul single chip mikrokontroler ATmega8535 dengan Kbyte Flash Memory, 512 byte SRAM, dan 512 byte EEPROM. DT-AVR Low Cost Micro System juga memiliki ADC hingga 8 channel single-ended A/D converter dengan resolusi 10 bit.

Fitur-fitur ATmega8535 DT-AVR Low Cost Micro System, dua 8-bit timer/counter, satu 16-bit timer/counter, dan Real Time Counter, 4 channel PWM, Two- wire Serial Interface Programmable Serial USART Universal Synchronous and Asynchronous serial Receiver and Transmitter), master/slave SPI Serial Interface, Programmable Watchdog Timer, On-chip Analog Comparator, Internal Calibrated RC Oscillator. Spesifikasi DT-AVR Low Cost Micro System adalah mendukung varian AVR 40 pin antara lain: AT90S8535, ATmega8535L, ATmega16(L), ATmega8515(L), AT90S8515, dan ATmega162(L) (seri AVR yang tidak memiliki ADC membutuhkan converter socket), memiliki fasilitas In- System Programming untuk IC yang mendukung, dilengkapi LED Programming Indicator, memiliki hingga 35 pin jalur input/output, lengkap dengan osilator 4 MHZ dan memiliki kemampuan komunikasi Serial UART RS-232 yang sudah disempurnakan, lengkap dengan rangkaian reset, tombol manual reset, dan brown-out detector dengan menggunakan tegangan input 9 - 12 VDC dan memiliki tegangan output 5 VDC. Perlengkapan DT-AVR Low Cost Micro System, 1 bh Board DT-AVR Low Cost Micro System, 1 set Kabel Serial, 1 CD/DVD berisi CodeVisionAVR versi demo serta kumpulan produk Innovative Eledctronics yang lain, 1 buah converter socket untuk seri AVR tanpa internal ADC dan semuanya itu dikemas dalam plastik yang menarik. 2.3 DI-Smart LCD 162 Board

Deskripsi DI-Smart LCD16X2 Display adalah modul tampilan LCD 162 karakter yang siap untuk digunakan.

Aplikasi pada rangkaian adalah sebagai tampilan (display) untuk menampilkan karakter-karakter yang diperlukan dalam suatu sistem seperti jumlah suatu variabel, tampilan indikator kejadian, atau bisa juga untuk estetika.

Spesifikasi LCD dengan jumlah karakter yang dapat ditampilakan adalah 32 karakter dalam 2 baris x 16 kolom, koneksi pengendalian yang digunakan adalah 4 BIT DATA INTERFACE, telah dilengkapi pengendali CONTRAST dan BRIGHTNESS, telah disediakan kabel IDC-10 sehingga dapat langsung dihubungkan dengan DI- Smart AVR System. 2.4 Sensor Air

Sensor air adalah suatu indikator pada suatu rangkaian yang menandakan bahwa rangkaian itu terkena air atau tidaknya. Konsep yang digunakan pada sensor air yaitu dengan menggunakan sebuah papan PCB yang dibuat garis zig-zag dan dihubungkan dengan kabel sebagai konduktor. Sebagaimana sifat air sebagai konduktor atau penghantar arus listrik.

2.5

Bahasa Pemrograman C untuk AVR

Dalam perancangan alat ini dibuat sebuah pemrograman agar alat dapat dikendalikan dan beroperasi sesuai dengan yang diharapkan. Bahasa pemrograman yang dipakai pada rancangan alat ini adalah bahasa pemrograman C. Akar dan asal dari bahasa pengaturcaraan C (C language) adalah bahasa BCPL yang dikembangkan oleh Martin Richards pada tahun 1967. Bahasa ini memberikan idea pada Ken Thompson yang kemudian mengembangkan bahasa yang disebut dengan panggilan B pada tahun 1970. Perkembangan selanjutnya dari bahasa B adalah bahasa C yang ditulis oleh Dennis Ritchie sekitar tahun 1970-an di Bell Telephone Laboratories Inc. (sekarang adalah AT&T Bell Laboratories). Bahasa C pertama kali digunakan adalah pada komputer Digital Equipment Corporation PDP-11 yang menggunakan sepenuhnya sistem pengoperasian UNIX. Standard bahasa C (Ansi C) yang asli adalah standard dari UNIX. Sistem operasi, kompiler C dan seluruh program aplikasi UNIX yang esensial ditulis dalam bahasa C. Kepopularan bahasa C membuatkan setiap versi dari bahasa ini banyak dibuat untuk komputer jenis mikro. ANSI (American National Standard Institutes) membentuk suatu komite (ANSI Committee X3J11) pada tahun 1983 yang kemudian menetapkan standard ANSI untuk bahasa C. Standard ANSI ini didasarkan kepada standard UNIX yang diperluas. CodeVision AVR merupakan software untuk membuat code program microcontroller AVR. Kebanyakan programmer memakai software ini karena fasilitas-fasilitas yang disediakan CodeVision AVR sangatlah memudahkan bagi programmer dalam membuat code. HP InfoTech menyajikan versi baru (lebih dari 9500 pengguna terdaftar) yang paling populer C Compiler komersial untuk Atmel AVR. Bahasa C luas digunakan untuk pemrograman berbagai jenis perangkat, termasuk mikrokontroler. Bahasa ini sudah merupakan high level language, dimana memudahkan programmer menuangkan algoritmanya. Untuk mengetahui dasar bahasa C dapat dipelajari sebagai berikut. Struktur penulisan program :

#include < [library1.h] > // Opsional #include < [library2.h] > // Opsional #define [nama1] [nilai] ; // Opsional #define [nama2] [nilai] ; // Opsional [global variables] // Opsional [functions] // Opsional void main(void) // Program Utama { [Deklarasi local variable/constant] [Isi Program Utama] } Preprocessor #include Biasanya digunakan untuk menyertakan file header (.h) atau file library. File include berguna untuk memberitahu compiler agar membaca file yang di include-kan lebih dahulu agar mengenali definisi-definisi yang digunakan adalah program sehingga tidak dianggap error. Cara penulisan: #include <> untuk lokasi standar file yang telah disetting oleh tools biasanya pada folder include atau folder direktori compiler. Tabel 2.3 Tabel Tipe Data

Deklarasi variabel dan konstanta pada bahasa C yaitu: variabel adalah memori penyimpanan data yang nilainya dapat diubah, penulisan: [tipe data] [nama] = [nilai]. Konstanta adalah memori penyimpanan data yang nilainya tidak dapat diubah, penulisan: const [nama] = [nilai]. Global variabel/konstanta yang dapat diakses di seluruh bagian program. Lokal variabel/konstanta yang hanya dapat diakses oleh fungsi tempat dideklarasikannya. Statement adalah setiap operasi dalam pemrograman, harus diakhiri dengan [ ; ] atau [ } ]. Statement tidak akan dieksekusi bila diawali dengan tanda [ // ] untuk satu baris. Lebih dari 1 baris gunakan pasangan [/* ] dan [ */ ]. Statement yang tidak dieksekusi disebut juga comments / komentar.

Contoh: suhu=adc/255*100; //contoh rumus perhitungan suhu Function adalah bagian program yang dapat dipanggil oleh program utama. Penulisan : [tipe data hasil] [nama function]([tipe data input 1],[tipe data input 2]) { [statement] ; } Conditional statement dan looping if else : digunakan untuk penyeleksian kondisi if ( [persyaratan] ) { [statement1]; [statement2]; } else { [statement3]; [statement4]; } for : digunakan untuk looping dengan jumlah yang sudah diketahui for ( [nilai awal] ; [persyaratan] ; [operasi nilai] ) { [statement1]; [statement2]; } while : digunakan untuk looping jika dan salama memenuhi syarat tertentu while ( [persyaratan] ) { [statement1]; [statement2]; } do while : digunakan untuk looping jika dan salama memenuhi syarat tertentu, namun minimal 1 kali do { [statement1];

[statement2]; } while ( [persyaratan] ) switch case : digunakan untuk menguji satu variabel dengan banyak kondisi switch ( [nama variabel] ) { case [nilai1]: [statement]; break; Operator relasional (perbandingan), operator ini berfungsi untuk menguji benar atau tidaknya hubungan dua operand, jika hubunganya benar maka akan menghasilkan 1 dan jika salah akan menghasilkan 0. Tabel 2.4 Operasi Relasional (Perbandingan)

Contoh : If (x==5) {x++;); // x akan dinaikan jika x berisi 5. If (x!=5) {x++;); // x akan dinaikan jika x bukan berisi 5. If (x>5) {x++;); // x akan dinaikan jika x berisi lebih besar dari 5. If (x<5) {x++;); // x akan dinaikan jika x berisi lebih kecil dari 5. If (x>=5) {x++;); // x akan dinaikan jika x berisi lebih besar atau sama dengan 5. If (x<=5) {x++;); // x akan dinaikan jika x berisi lebih kecil atau sama dengan 5.

3. PERANCANGAN DAN IMPLEMENTASI 3.1 Gambaran Umum Pada dasarnya rangkaian ini dirancang guna untuk membuang air yang berlebihan pada suatu tempat atau kawasan yang daerah resapan airnya kurang bagus bahkan tidak adanya sistem resapan air yang tertata dengan baik dan benar. Oleh karena itu, dirancang sebuah alat yang berjudul Sistem Drainase Otomatis Berbasis Mikrokontroler ATMega8535 yang

difungsikan sebagai media resapan air yang terdiri dari sensor air yang akan membuat aksi pada rangkaian pompa air sebagai alat untuk membuang air melalui pipa atau selang yang terhubung pada pompa air tersebut dan hasilnya atau output akan ditampilkan pada display LCD. 3.2 Analisa Rangkaian Secara Diagram Blok

Gambar 3.1 Blok Diagram Rangkaian 3.2.1 Blok Input Pada blok diagram mendapat sumber daya yang dihasilkan oleh aktifator yang menyuplay sumber tegangan kedalam blok input, blok proses dan blok output. Dalam diagram blok input terdiri dari otomatis dan manual, dimana kondisi otomatis dipengaruhi inputan dari air yang mengenai sensor air pada rangkaian, sedangkan kondisi manual dipengaruhi inputan dari saklar dan push on yang akan berfungsi apabila ditekan dan air mengenai sensor air.

Gambar Sensor Air Pada dasarnya air bersifat penghantar arus atau konduktor yang baik dan mempunyai elektrolit yang dapat mengantar arus. Dan inputan pada blok input akan mengirimkan data ke dalam mikrokontroler ATMega8535. 3.2.2 Blok Proses

Selanjutnya pada blok proses, akan memproses inputan yang berasal dari sensor air dan diolah oleh mikrokontroler ATMega8535 sebagai pusat kontrol secara keseluruhan.

Dalam mikrokontroler ATMega8535 akan mengolah data pada program CAVR yang dihasilkan oleh port-port yang terhubung pada sensor air. Dan data yang sudah diolah oleh program akan dikirim ke dalam blok output. 3.2.3 Blok Output Dan pada blok output, akan dihasilkan keluaran berupa tampilan pada LCD sebagai display informasi yang dapat dibaca oleh manusia.

LED sebagai keluaran indikator yang terdiri dari warna hijau dalam keadaan aman dan normal, warna putih keadaan siaga 1, warna biru dalam keadaan siaga 2, warna kuning dalam keadaan waspada, dan warna merah dalam keadaan awas serta suara yang dihasilkan oleh buzzer sebagai informasi yang disampaikan oleh alat agar dapat didengar oleh manusia, dan pompa air berfungsi untuk membuang air pada tempat air resapan.

3.3 Analisa Software 3.3.1 Diagram Alur (flowchart)

Flowchart dijelaskan bahwa pada saat kondisi mulai apakah saklar dalam kondisi on atau off, jika off maka akan ke kondisi manual dimana harus menekan tombol push on terlebih dahulu dan program akan melakukan inisialisasi, jika tombol push on tidak ditekan maka program akan selesai. Sedangkan pada saat saklar dalam kondisi on maka akan inisialisasi port yang digunakan pada program. Setelah selesai inisialisasi port yang digunakan baik sebagai input atau output, maka kondisi selanjutnya adalah default dimana semua sensor tidak terkena air sehingga tidak ada yang menyala baik LED maupun pompa air. Setelah kondisi default ada kondisi dimana sensor 1 terkena air dengan data FE (1111-1110) dan akan menghasilkan output berupa status normal, lampu LED hijau dalam kondisi on, jika sensor 1 tidak terkena air maka akan ke kondisi penekanan pada push on. Setelah air mengalir dan mengenai sensor 1, 2 dengan data FC (1111-1100) dan akan menghasilkan output berupa status siaga 1, lampu LED putih, dan pompa air on, jika air tidak mengenai sensor 1, 2 maka akan kembali ke kondisi sensor 1 dengan data FE (11111110) dan pompa air off. Air terus mengalir dan mengenai sensor 1, 2, 3 dengan data F8 (1111-1000) dan akan menghasilkan output berupa status siaga 2, lampu LED biru, dan pompa air on, jika air tidak mengenai sensor 1, 2, 3 maka akan kembali ke kondisi sensor 1 dengan data FE (1111-1110) dan pompa air off. Selanjutnya air terus mengalir dan mengenai sensor 1, 2, 3, 4 dengan data F0 (1111-0000) dan akan menghasilkan output berupa status waspada, lampu LED kuning, dan pompa air on, jika air tidak mengenai sensor 1, 2, 3, 4 maka akan kembali ke kondisi sensor 1 dengan data FE (1111-1110) dan pompa air off. Dan air terus mengalir mengenai sensor 1, 2, 3, 4, 5 dengan data E0 (1110-0000) dan akan menghasilkan output berupa staus awas, lampu LED merah, Buzzer dan pompa air dalam kondisi on, jika air tidak mengenai sensor 1, 2, 3, 4, 5 maka akan kembali ke kondisi sensor 1

dengan data FE (1111-1110) dan pompa air off. Dan jika ingin kembali ke kondisi default maka saklar dikondisikan dalam keadaan off dan menekan terus tombol push on untuk mengaktifkan pompa air dan membuang air ke selang pembuangan hingga batas bawah pompa air menyerap air. 4. HASIL UJI COBA ALAT 4.1 Cara Kerja Alat

Suplay minimal yang digunakan agar chip dapat bekerja adalah (kurang lebih) 5V. Agar tegangan stabil, digunakan IC Regulator 7805 sehingga input tegangan yang diijinkan untuk rangkaian adalah antara 6 - 12V. Range tegangan tersebut akan dikonversi oleh 7805 sebagai tegangan VCC sebesar 5V. Sebagai pengaman, dapat ditambahkan juga dioda 1A (misal 1N4001) agar rangkaian tetap aman apabila dalam memasang suplay dari luar terbalik (optional). Selain itu dapat tambahkan kapasitor (elco) minimal sebesar 100 uF/16V untuk mencegah reset yang diakibatkan oleh suplay yang kurang stabil. Setelah saklar (switch) pada rangkaian dalam keadaan hidup, maka akan dialiri air pada bak resapan air, sehingga sensor akan terkena air. Pada rangkaian ini port yang digunakan atau dipakai adalah portA.0, portA.1, portA.2, portA.3, dan portA.4 untuk sensor air, portB.1 untuk pompa air, portC diguanakan untuk display LCD, sedangkan portD digunakan untuk LED indikator serta buzzer untuk menghasilkan gelombang suara. Saat sensor air yang terhubung pada portA.0 terkena air maka akan mengirim data ke mikrokontroler dengan logika aktif low (aktif jika nilainya 0) dan akan menampilkan ke LCD bahwa keadaan lingkungan dalam status normal, LED yang menyala warna hijau serta pompa aquarium pada portB.1 dalam keadaan Off atau tidak menyala. Lalu saat sensor air yang terhubung pada portA.0, portA.1 terkena air maka akan mengirimkan data ke mikrokontroler dengan logika aktif low (aktif jika nilainya nol) dan akan menampilkan ke LCD bahwa keadaan lingkungan dalam keadaan siaga 1 dan LED warna putih menyala serta pompa air dalam kondisi On dan membuang air ke pipa pembuangan. Selanjutnya, saat sensor air yang terhubung pada portA.0, portA.1, portA.2 terkena air maka akan mengirimkan data ke mikrokontroler dengan logika aktif low (aktif jika

nilainya nol) dan akan menampilkan ke LCD bahwa keadaan dalam keadaan siaga 2 dan LED warna biru menyala, serta pompa air dalam keadaan On untuk terus membuang air ke dalam tempat pembuangan lewat pipa yang dipasang pada pompa air tersebut. Saat sensor air yang terhubung pada portA.0, portA.1, portA.2, portA.3 terkena air, maka LCD akan menampilkan bahwa keadaan dalam keadaan waspada dan LED warna kuning akan menyala, serta pompa air dalam keadaan on dan terus membuang air kedalam bak pembuangan air. Dan saat sensor air yang terhubung pada portA.0, portA.1, portA.2, portA.3, portA.4 terkena air, maka LCD akan menampilkan bahwa keadaan dalam keadaan awas dan buzzer akan bunyi, serta pompa air akan terus membuang air sampai air pada batas aman. Dan jika ingin kembali ke kondisi default, maka saklar dalam kondisi off dan tekan push on hingga air pada batas bawah pompa air. Setelah keadaan air surut, dari kondisi awas sampai ke kondisi normal maka akan tampil pada LCD bahwa keadaan lingkungan dalam keadaan aman dan LED warna hijau menyala, serta pompa air akan off kembali.

Sensor air merupakan suatu rangkaian yang terdiri dari + (positif) dan (negatif) atau vcc dan ground, saat sensor terkena oleh air maka akan terhubung antara vcc dan ground. Sensor air ini terhubung dengan port pada mikrokontroler ATMega8535 di portA.0, portA.1, portA.2, portA.3, dan portA.4 sebagai masukan yang akan mempengaruhi proses dan menghasilkan output yang ditentukan.

Pada rangkaian relay ini menggunakan relay 5 Volt, saat portB.1 berlogika 0, maka kondisi pada T1 dalam keadaan cut-off karena pada kaki basis lebih kecil dari kaki emitor, sehingga arus dari kolektor tidak dapat mengalir ke emitor dan kondisi pada T2 dalam keadaan saturasi karena tegangan pada kaki basis lebih besar dari tegangan pada kaki emitor, sehingga arus dapat mengalir dari kaki kolektor ke emitor dengan indikator L1 menyala dan pompa air dalam keadaan on. Sedangkan kondisi pada saat portB.1 berlogika 1, maka kondisi pada T1 dalam keadaan saturasi karena tegangan pada kaki basis lebih besar dari tegangan pada kaki emitor, sehingga arus dapat mengalir dari kaki kolektor ke emitor dengan indikator L2 menyala dan

kondisi pada T2 dalam keadaan cut-off karena pada kaki basis lebih kecil dari kaki emitor, sehingga arus dari kolektor tidak dapat mengalir ke emitor dan pompa air dalam keadaan off. 4.2 Pengujian Alat Berdsarkan Kondisi Saat dilakukan pengujian alat dan pengambilan data pengamatan terhadap rancangan yang dibuat maka di dapat hasil yang dapat dilihat atau dapat di amati bahwa alat dalam kondisi berjalan dengan baik dan sesuai dengan alur program yang dibuat. Data saat sensor tidak terkena air (default) :

Tabel 4.1 Data Pengamatan Ke-satu Data saat sensor 1 terkena air : Tabel 4.2 Data Pengamatan Ke-dua

Data saat sensor 1 & 2 terkena air : Tabel 4.3 Data Pengamatan Ke-tiga

Data sensor 1, 2, & 3 terkena air : Tabel 4.4 Data Pengamatan Ke-empat

Data saat sensor 1, 2, 3, & 4 terkena air : Tabel 4.5 Data Pengamatan Ke-lima

Data saat sensor 1, 2, 3, 4, & 5 terkena air : Tabel 4.6 Data Pengamatan Ke-enam

Data saat manual (kondisi push on): Tabel 4.7 Data Pengamatan Ke-tujuh

5. PENUTUP 5.1 Kesimpulan Dari hasil perancangan dan pengamatan data yang diperoleh saat melakukan pengujian alat didapat bahwa rangkaian ini bekerja sesuai dengan program yang dibuat dan melakukan fungsifungsi dari masing- masing komponen bekerja dengan optimal. Dan rancangan alat ini dapat berfungsi sebagai resapan air atau pembuangan air yang berlebihan pada suatu kawasan, serta penanggulangan dini terhadap terjadinya banjir, karena alat ini dirancang pada saat sensor 2 terkena air pompa air langsung membuang air yang ada pada rangkaian hal ini berfungsi bila pada saat air yang ada lebih banyak (air bah) sehingga air terus dibuang sampai air tidak lagi mengenai sensor sama sekali. Kelebihan dari rancangan alat yang dibuat ini yang mampu mengatasi permasalahan sistem pembuangan air yang kurang baik pada suatu kawasan, karena konsep dari sistem drainase atau resapan air. Adapun kekurangan dari alat yang dirancang adalah sensor air yang digunakan, sebab dalam konduktor yang digunakan adalah media air tanah yang kadar elektrolitnya sangat sedikit, sehingga proses koduktor kurang bagus. 5.2 Saran

Saran yang dapat disampaikan dalam perancangan alat ini adalah dengan adanya konsep yang matang dan melihat kondisi lingkungan sekitar. Untuk perancangan selanjunya pada rangkaian ini dengan menambahkan ruang aliran atau pembuangan air yang lebih besar. Dapat ditambahkan aplikasi dengan menggunakan program pemantau sistem drainase secara online. Dengan adanya penambahan sesnsor untuk mengukur ketinggian air, sehingga dapat berfungsi secara optimal dan pengiriman data seakurat mungkin.

REALISASI HIGH PASS FILTER PADA DISKRET PROGRAMMING

High Pass Filter digunakan untuk melewatkan frekuensi tinggi. Batasan frekuensi yang akan dilewatkan disebutfrekuensicutoff,dimanapersamaandarifrekuensicutoffadalah:

PersamaandiskretdaripenurunanHighPassFilteradalah:

Hasil dari pengujian dengan menggunakan High Pass Filter yang telah saya lakukan dapat dilihat pada gambardibawahini.

sinyalmasukanyangakandiHighPassFilter.

Gambar diatas adalah sinyal masukan yang akan saya lewatkan frekuensi tingginya. Jika saya ingin melewatkan frekuensi diatas 0,5 Hz (batasan frekuensi atau frekuensi cut off = 0,5 Hz), maka hasilnya akansepertigambardibawahini.

gariswarnahitamadalahsinyalmasukan,gariswarnakuningadalahsinyalhasilHighPassFilter.

Dari hasil kedua gambar diatas sinyal keluaran dari High Pass Filter (garis warna kuning) hanya melewatkan frekuensi diatas frekuensi cut off yang bernilai 0,5 Hz. Jika frekuensi dibawah 0,5 Hz, maka sinyal tersebut tidak akan dilewatkan atau nilainya sama dengan nol. Untuk dapat merealisasikan ke dalam bahasa pemrograman, maka kita dituntut terlebih dahulu untuk merancang batasan frekuensi yang akan dilewatkan (frekuensi cut off). Pada persamaan diskret dari penurunan High Pass Filter, terdapat sebuah variabel bernama koefisien filter (a), variabel inilah yang akan menentukan nilai dari frekuensi cut off. Pengujian diatas saya menggunakan frekuensi cut off sebesar 0,5 Hz, maka untuk menentukan nilai koefisien filter (a), sebagai berikut: frekuensi cut off = 0,5 Hz.

dt adalah waktu sampling yang digunakan untuk mengeksekusi instruksi High Pass Filter pada program, waktu sampling yang saya gunakan adalah 10 ms atau 0,01 detik. Sehingga realisasi persamaan Low Pass Filter kedalam bahasa pemrograman menjadi:

/***************************************************** Chiptype:ATmega8535 Programtype:Application AVRCoreClockfrequency:12.000000MHz Memorymodel:Small ExternalRAMsize:0 DataStacksize:128 *****************************************************/ floathigh_pass,a=0.97; intambil_sinyal,ambil_sinyal_sblmnya=0; chartemp_serial[8]; #include<mega8535.h> #include<delay.h> #include<stdlib.h> #include<stdio.h> //Timer0overflowinterruptserviceroutine //Interuptakandieksekusisesuaiwaktusampling10msatau0.01detik

interrupt[TIM0_OVF]voidtimer0_ovf_isr(void) { //ReinitializeTimer0value TCNT0=0x8A; //AlgoritmaLowPassFilter high_pass=(float)(a*high_pass)+(a*(ambil_sinyalambil_sinyal_sblmnya)); //y(i)=a*y(i1)+a*(x(i)x(i1) //rekursifmasukansinyal ambil_sinyal_sblmnya=ambil_sinyal; } #defineADC_VREF_TYPE0x00 //ReadtheADconversionresult unsignedintread_adc(unsignedcharadc_input) { ADMUX=adc_input|(ADC_VREF_TYPE&0xff); //DelayneededforthestabilizationoftheADCinputvoltage delay_us(10); //StarttheADconversion ADCSRA|=0x40; //WaitfortheADconversiontocomplete while((ADCSRA&0x10)==0); ADCSRA|=0x10; returnADCW; } //untukmengirimdatakePC,agardapatdiplotkegrafik voidkirim_data_ke_PC() { putchar('a');//headerdatapertama itoa(ambil_sinyal,temp_serial); puts(temp_serial); putchar('b');//headerdatapertama ftoa(high_pass,1,temp_serial); puts(temp_serial); }

voidmain(void) { //Timer/Counter0initialization //Clocksource:SystemClock //Clockvalue:11.719kHz //Mode:Normaltop=FFh //OC0output:Disconnected TCCR0=0x05; TCNT0=0x8A; OCR0=0x00; //Timer(s)/Counter(s)Interrupt(s)initialization TIMSK=0x01; //USARTinitialization //CommunicationParameters:8Data,1Stop,NoParity //USARTReceiver:On //USARTTransmitter:On //USARTMode:Asynchronous //USARTBaudRate:9600 UCSRA=0x00; UCSRB=0x18; UCSRC=0x86; UBRRH=0x00; UBRRL=0x4D; //AnalogComparatorinitialization //AnalogComparator:Off //AnalogComparatorInputCapturebyTimer/Counter1:Off ACSR=0x80; SFIOR=0x00; //ADCinitialization //ADCClockfrequency:750.000kHz //ADCVoltageReference:AREFpin //ADCHighSpeedMode:Off //ADCAutoTriggerSource:None ADMUX=ADC_VREF_TYPE&0xff; ADCSRA=0x84; SFIOR&=0xEF; //Globalenableinterrupts

#asm("sei") while(1) { ambil_sinyal=read_adc(0); kirim_data_ke_PC(); }; }

REALISASI LOW PASS FILTER PADA DISKRET PROGRAMMING

LowPassFilterdigunakanuntukmelewatkanfrekuensirendah.Batasanfrekuensiyangakandilewatkan disebutfrekuensicutoff,dimanapersamaandarifrekuensicutoffadalah:

PersamaandiskretdaripenurunanLowPassFilteradalah:

HasildaripengujiandenganmenggunakanLowPassFilteryangtelahsayalakukandapatdilihatpada gambardibawahini.

sinyal berfrekuensi tinggi yang akan di Low Pass Filter.

Gambardiatasmerupakansinyalyangberfrekuensitinggiyangterdiridarinoise.Sinyalyangsebenarnya seharusnyaselalubernilai0dantidakmemilikifrekuensi(sepertisinyalDCdengannilai0).Tetapisinyal tersebutmempunyainilaiyangberubahubahdanberfrekuensitinggi,halinidikarenakanadanyanoise padasinyaltersebut.Jikasayainginmelewatkanfrekuensidibawah0,5Hz(batasanfrekuensiatau frekuensicutoff=0,5Hz),makahasilnyaakansepertigambardibawahini.

Dari hasil kedua gambar diatas sinyal keluaran dari Low Pass Filter (garis warna hijau) hanya melewatkan frekuensi dibawah frekuensi cut off yang bernilai 0,5 Hz. Untuk dapat merealisasikan ke dalam bahasa pemrograman, maka kita dituntut terlebih dahulu untuk merancang batasan frekuensi yang akan dilewatkan (frekuensi cut off). Pada persamaan diskret dari penurunan Low Pass Filter, terdapat sebuah variabel bernama koefisien filter (a), variabel inilah yang akan menentukan nilai dari frekuensi cut off. Pengujian diatas saya menggunakan frekuensi cut off sebesar 0,5 Hz, maka untuk menentukan nilai koefisien filter (a), sebagai berikut: frekuensi cut off = 0,5 Hz.

dt adalah waktu sampling yang digunakan untuk mengeksekusi instruksi Low Pass Filter pada program, waktu sampling yang saya gunakan adalah 10 ms atau 0,01 detik. Sehingga realisasi persamaan Low Pass Filter kedalam bahasa pemrograman menjadi:

/***************************************************** Chip type : ATmega8535 Program type : Application AVR Core Clock frequency: 12.000000 MHz Memory model : Small External RAM size :0 Data Stack size : 128 *****************************************************/ float low_pass, a=0.97; int ambil_sinyal; char temp_serial[8]; #include <mega8535.h> #include <delay.h> #include <stdlib.h> #include <stdio.h> // Timer 0 overflow interrupt service routine

// Interupt akan dieksekusi sesuai waktu sampling 10 ms atau 0.01 detik interrupt [TIM0_OVF] void timer0_ovf_isr(void) { // Reinitialize Timer 0 value TCNT0=0x8A; //Algoritma Low Pass Filter low_pass=(float)(a*low_pass)+((1-a)*ambil_sinyal); // y(i) = a* y(i-1) + (1-a)* x(i) } #define ADC_VREF_TYPE 0x00 // 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; }

//untuk mengirim data ke PC, agar dapat diplot ke grafik void kirim_data_ke_PC() { putchar('a');//header data pertama itoa(ambil_sinyal,temp_serial); puts(temp_serial); putchar('b');//header data kedua ftoa(low_pass,1,temp_serial); puts(temp_serial); } void main(void) {

// Timer/Counter 0 initialization // Clock source: System Clock // Clock value: 11.719 kHz // Mode: Normal top=FFh // OC0 output: Disconnected TCCR0=0x05; TCNT0=0x8A; OCR0=0x00; // Timer(s)/Counter(s) Interrupt(s) initialization TIMSK=0x01; // 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=0x18; 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: AREF pin // ADC High Speed Mode: Off // ADC Auto Trigger Source: None ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=0x84; SFIOR&=0xEF; // Global enable interrupts

#asm("sei") while (1) { ambil_sinyal=read_adc(0);//sinyal masukan dibaca dari ADC kirim_data_ke_PC(); }; }