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

Hello sahabat anak kendali.

pada kesempatan kali ini saya akan melanjutkan Artikel tentang ATmega16/32 Tutorial Fuzzy Logic Controller dengan CVAVR (Defuzzifikasi).
sebelumnya kita sudah membahas Tutorial Fuzzy dengan Atmega, bagian Fuzifikasi dan Rule, dan di artikel rule termasuk juga inferensi fuzzy.
dan kali ini kita akan melanjutkan Tutorial Fuzzy dengan Atmega16 Atmega32 CVAVR  tahap akhir yaitu Defuzzifikasi.
jika kalian belum membaca Artikel Tutorial Fuzzy Sebelumnya, silahkan di baca dulu Atmega16, Tutorial Fuzzy Logic Controller dengan CVAVR (Rule)

Download File Simulasi Fuzzy dengan Proteus Download

adapaun metode defuzzifikasi yang paling umum adalah Center of Area (COA) dan Mean of Maximum (MOM)

baca juga tentang
Contoh Tutorial Aplikasi Fuzzy logic untuk Kontrol Air Heater CVAVR
adapun persemaan dengan metode COA jika diskrit maka sebagai berikut :

untuk metode COA kontinyu persamaan nya sebagai berikut :

dan untuk metode MOM persamaan nya sebagai berikut :

adapun pada artikel ini saya menggunakan defuzzifikasi dengan metode COA diskrit.
pada bagian Tutorial Fuzzy bagian rule kita sudah mendapatkan nilai untuk masing masing rule nya. jika lupa silahkan di buka lagi halaman  Arduino, Tutorial Fuzzy Logic Controller dengan Arduino (Rule)   sehingga berdasarkan rumus COA diskrit diatas rumus menghitung Defuzifikasi bisa kita tulis sebagai berikut :   Output Defuzifikasi = ((rule1*dingin) + (rule2a*hangat) + (rule2b*hangat) + (rule3*panas)) / (dingin+hangat+hangat+panas)   untuk program lengkapnya Tutorial Fuzzy Logic dengan Arduino 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, outForPWM;

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

// Fuzzyfikasi metode weigt avarage
outForPWM = ((rule1*suhuDingin) + (rule2a*suhuHangat) + (rule2b*suhuHangat) + (rule3*suhuPanas)) / (suhuDingin+suhuHangat+suhuHangat+suhuPanas);
}

void tampil_lcd(){
fuzzy_rule();
ftoa (outForPWM,0,buff);          
      lcd_gotoxy(0,0);
      lcd_putsf("OutFor PWM:");
      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=0xFF;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=0xFF
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 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=0xA1;
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  :");
//      lcd_gotoxy(0,1);
//      lcd_putsf("anakkendali.com");  
//    
//      delay_ms(3000);
        
while (1)
      {
      // Place your code here  
      lcd_clear();
    
      val = read_adc(0);
      suhu =(float)val*500/1023;
      
      tampil_lcd();      
      OCR1A = outForPWM;
      OCR1B = 0;
    
      ftoa(suhu,2,buff);
      lcd_gotoxy(0,1);  
      lcd_putsf("Suhu : ");
      lcd_puts(buff);
      delay_ms(100);
      }
}

hasil nya dapat dilihat pada video di bawah ini :

hasil ini semua berdasarkan himpunan fuzzy yang kita buat, (LihatTutorial Fuzzy Bagian Fuzzifikasi ) jadi silahkan bisa disesuaikan sendiri himpunan fuzzy nya dengan bebas, tidak ada aturan yang pasti, yang terpenting kita punya alasanya, dan saya membuat tutorial ini hanya sebagai contoh, Membuat Pengendali Kipas Angin dengan Logika Fuzzy.   bila ada kekeliruan atau kesalahan silahkan beri saya masukan, karena saya juga masih belajar dan akan terus belajar. ataupun jika ada pertanyaan silahkan tulis semua di komentar. dan jika bermanfaat silahkan di share artikel nya.

keyword :

Tutorial Fuzzy Logic AVR
Tutorial Fuzzy Logic CVAVR
Tutorial Fuzzy Logic Bahasa C
Program Implementasi Fuzzy Mikrokontroler
Aplikasi Fuzzy Logic pada Mikrokontroler