By | 23/10/2018

Hello sahabat Anak Kendali

pada kesempatan kali ini saya akan melanjutkan Tutorial Fuzzy Logic pada Atmega dengan CVAVR. 
sebelumnya kita sudah membuat tutorial Fuzzy juga menggunakan Arduino yang artikelnya bisa dilihat pada laink berikut :
Arduino, Tutorial Fuzzy Logic Controller dengan Arduino (Defuzzifikasi)

sedangkan untuk artikel sebelumnya yang membahas fuzzy logic dengan CVAVR bisa di lihat pada link berikut :
Atmega16/32, Tutorial Fuzzy Logic Controller dengan CVAVR (Fuzzifikasi)

dan sekarang kita akan melanjutkan tutorialnya Fuzzy Logic dengan Atmega16 atau Atmega32 CVAVR untuk bagian Rule.
jadi kita akan menetapkan sebuah rule dari himpunan fuzzy yang sudah kita buat sebelumnya. dan rule nya seperti berikut :

1. Jika Suhu Dingin maka Motor Lambat
2. Jika Suhu Hangat maka Motor Sedang
3. Jika Suhu Panas maka Motor Cepat

bisa dilihat lagi gambar himpunan fuzzy yang sudah di buat pada gambar berikut ini :

Atmega16/32, Tutorial Fuzzy Logic Controller dengan CVAVR (Rule)
Atmega16/32, Tutorial Fuzzy Logic Controller dengan CVAVR (Rule)

dari rule diatas dapat dibuat persamaan nya seperti berikut ini :

// jika suhu dingin maka motor lambat
rule1 = 150 - (suhuDingin*50);
// jika suhu hangat maka motor sedang
rule2a = 100 + (suhuHangat*50);
rule2b = 200 - (suhuHangat*50);
// jika suhu panas maka motor cepat
rule3 = 150 + (suhuPanas*50);

sehingga jika dibuat program seluruhnya FUZZY LOGIC dengan CVAVR sebagai berikut :

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.3 Standard
Automatic Program Generator
© Copyright 1998-2011 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project :
Version :
Date : 9/30/2018
Author : Chaerul Anam
Company : Unisi Robotik
Comments:

Chip type : ATmega32
Program type : Application
AVR Core Clock frequency: 16.000000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 512
*****************************************************/
#include <mega32.h>
#include <delay.h>
#include <stdlib.h>
#include <stdio.h>
// Alphanumeric LCD functions
#include <alcd.h>
#define ADC_VREF_TYPE 0x40
// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}
// Declare your global variables here
char buff[5];
int val;
unsigned char fuzifikasi_suhu_dingin ();
unsigned char fuzifikasi_suhu_hangat ();
unsigned char fuzifikasi_suhu_panas ();
unsigned char fuzifikasi_pwm_lambat ();
unsigned char fuzifikasi_pwm_sedang ();
unsigned char fuzifikasi_pwm_cepat ();
float suhu, pwm;
float suhuDingin, suhuHangat, suhuPanas;
float pwmPelan, pwmSedang, pwmCepat;
float rule1, rule2a, rule2b, rule3;
//fuzifikasi untuk input suhu
unsigned char fuzifikasi_suhu_dingin (){
if (suhu <= 30){suhuDingin = 1;}
if (suhu > 30 && suhu <= 45){suhuDingin = (45-suhu)/15;}
if (suhu >= 45){suhuDingin = 0;}

return suhuDingin;
}
unsigned char fuzifikasi_suhu_hangat (){
if (suhu < 30){suhuHangat = 0;}
if (suhu >= 30 && suhu < 45){suhuHangat = (suhu-30)/15;}
if (suhu >= 45 && suhu <= 60){suhuHangat = (60-suhu)/15;}
if (suhu > 60){suhuHangat = 0;}
return suhuHangat;
}
unsigned char fuzifikasi_suhu_panas (){
if (suhu >= 60){suhuPanas = 1;}
if (suhu >= 45 && suhu < 60){suhuPanas = (suhu-45)/15;}
if (suhu < 45){suhuPanas = 0;}

return suhuPanas;
}
unsigned char fuzifikasi_pwm_lambat (){
if (pwm <= 100){pwmPelan = 1;}
if (pwm > 100 && pwm <= 150){pwmPelan = (150-pwm)/50;}
if (pwm >= 150){pwmPelan = 0;}

return pwmPelan;
}
unsigned char fuzifikasi_pwm_sedang (){
if (pwm < 100){pwmSedang = 0;}
if (pwm >= 100 && pwm < 150){pwmSedang = (pwm-100)/50;}
if (pwm >= 150 && pwm <= 2000){pwmSedang = (200-pwm)/50;}
if (pwm >= 200){pwmSedang = 0;}
return pwmSedang;
}
unsigned char fuzifikasi_pwm_cepat (){
if (pwm > 200){pwmCepat = 1;}
if (pwm >= 150 && pwm < 200){pwmCepat = (pwm-150)/50;}
if (pwm < 100){pwmCepat = 0;}

return pwmCepat;
}
void fuzifikasi(){
fuzifikasi_suhu_dingin ();
fuzifikasi_suhu_hangat ();
fuzifikasi_suhu_panas ();
fuzifikasi_pwm_lambat ();
fuzifikasi_pwm_sedang ();
fuzifikasi_pwm_cepat ();
}
void fuzzy_rule (){
fuzifikasi();
// jika suhu dingin maka motor lambat
rule1 = 150 - (suhuDingin*50);
// jika suhu hangat maka motor sedang
rule2a = 100 + (suhuHangat*50);
rule2b = 200 - (suhuHangat*50);
// jika suhu panas maka motor cepat
rule3 = 150 + (suhuPanas*50);
}
void tampil_lcd(){
lcd_clear();
fuzzy_rule();

ftoa (rule1,0,buff);
lcd_gotoxy(0,0);
lcd_puts(buff);
ftoa (rule2a,0,buff);
lcd_gotoxy(4,0);
lcd_puts(buff);
ftoa (rule2b,0,buff);
lcd_gotoxy(8,0);
lcd_puts(buff);
ftoa (rule3,0,buff);
lcd_gotoxy(12,0);
lcd_puts(buff);
// ftoa (pwmSedang,2,buff);
// lcd_gotoxy(5,1);
// lcd_puts(buff);
// ftoa (pwmCepat,2,buff);
// lcd_gotoxy(10,1);
// lcd_puts(buff);
}
void main(void)
{
// Declare your local variables here
// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTA=0x00;
DDRA=0x00;
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTB=0x00;
DDRB=0x00;
// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0x00;
// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x00;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer1 Stopped
// Mode: Normal top=0xFFFF
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x01;
TCCR1B=0x09;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=0xFF
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
MCUCR=0x00;
MCUCSR=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
// USART initialization
// USART disabled
UCSRB=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
// ADC initialization
// ADC Clock frequency: 1000.000 kHz
// ADC Voltage Reference: AVCC pin
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x84;
// SPI initialization
// SPI disabled
SPCR=0x00;
// TWI initialization
// TWI disabled
TWCR=0x00;
// Alphanumeric LCD initialization
// Connections are specified in the
// Project|Configure|C Compiler|Libraries|Alphanumeric LCD menu:
// RS - PORTC Bit 0
// RD - PORTC Bit 1
// EN - PORTC Bit 2
// D4 - PORTC Bit 4
// D5 - PORTC Bit 5
// D6 - PORTC Bit 6
// D7 - PORTC Bit 7
// Characters/line: 16
lcd_init(16);
lcd_clear();
lcd_gotoxy(0,0);
lcd_putsf("Welcome to :");
lcd_gotoxy(0,1);
lcd_putsf("anakkendali.com");

delay_ms(3000);
while (1)
{
// Place your code here
val = read_adc(0x00);
suhu = 32; // suhu =(float)val*500/1023;

tampil_lcd();

ftoa(suhu,2,buff);
lcd_gotoxy(0,1);
lcd_putsf("Suhu : ");
lcd_puts(buff);
delay_ms(1000);
  }
}

program diatas jika dijalankan maka akan tampil pada LCD nilai pwm masing-masing rule berdasarkan keanggotaan suhu.
saya akan simulasikan menggunakan Proteus di akhir tutorial, jadi silahkan tunggu untuk melihat video hasil pembuatan fuzzy logic dengan CVAVR.

selanjutnya :
Tutorial Fuzzy Logic bagian Defuzifikasi
mungkin cukup ini dulu artikel kali ini, semoga bermanfaat, jangan lupa untuk berkomentar.

Leave a Reply

Your email address will not be published. Required fields are marked *