Penerapan JST Pada Sensor Warna

Deskripsi project: Pada project kali ini kita akan mencoba mensimulasikan sebuah aplikasi pengenalan warna pada mikrokontroler menggunakan algoritma “Jaringan Syaraf Tiruan: ’MLP Dengan Algoritma Belajar Propagasi Balik’”. Karena interface sensor warna tidak terdapat di aplikasi Proteus, maka sensor  warna akan kita misalkan dan diganti dengan potensiometer. Dimana setiap potensio meter akan mewakili filter cahaya dari warna utama yaitu RGB (red, green, dan blue). Jadi akan digunakan 3 potensiometer. Proses pembacaan akan menggunakan ADC 8-bit dengan nilai pembacaan sensor warna terendah 0 dan nilai tertinggi 255.
Sekilas tentang JST:

Jaringan saraf tiruan (JST) (Bahasa Inggris: artificial neural network (ANN), atau juga disebut simulated neural network (SNN), atau umumnya hanya disebut neural network (NN)), adalah jaringan dari sekelompok unit pemroses kecil yang dimodelkan berdasarkan jaringan saraf manusia. JST merupakan sistem adaptif yang dapat mengubah strukturnya untuk memecahkan masalah berdasarkan informasi eksternal maupun internal yang mengalir melalui jaringan tersebut.

Secara sederhana, JST adalah sebuah alat pemodelan data statistik non-linier. JST dapat digunakan untuk memodelkan hubungan yang kompleks antara input dan output untuk menemukan pola-pola pada data.

 Sens_JST1
Jaringan saraf tiruan merupakan jaringan dari unit pemroses kecil yang saling terhubung, yang dimodelkan berdasar jaringan saraf (neuron) jaringan saraf.

 

Pengertian Dasar

Tidak ada dua otak manusia yang sama, setiap otak selalu berbeda. Beda dalam ketajaman, ukuran dan pengorganisasiannya. Salah satu cara untuk memahami bagaimana otak bekerja adalah dengan mengumpulkan informasi dari sebanyak mungkin scan otak manusia dan memetakannya. Hal tersebut merupakan upaya untuk menemukan cara kerja rata-rata otak manusia itu. Peta otak manusia diharapkan dapat menjelaskan misteri mengenai bagaimana otak mengendalikan setiap tindak tanduk manusia, mulai dari penggunaan bahasa hingga gerakan.

Walaupun demikian kepastian cara kerja otak manusia masih merupakan suatu misteri. Meski beberapa aspek dari prosesor yang menakjubkan ini telah diketahui tetapi itu tidaklah banyak. Beberapa aspek-aspek tersebut, yaitu :

a. Tiap bagian pada otak manusia memiliki alamat, dalam bentuk formula kimia, dan sistem saraf manusia berusaha untuk mendapatkan alamat yang cocok untuk setiap akson (saraf penghubung) yang dibentuk.

b. Melalui pembelajaran, pengalaman dan interaksi antara sistem maka struktur dari otak itu sendiri akan mengatur fungsi-fungsi dari setiap bagiannya.

c. Axon-axon pada daerah yang berdekatan akan berkembang dan mempunyai bentuk fisik mirip, sehingga terkelompok dengan arsitektur tertentu pada otak.

d. Axon berdasarkan arsitekturnya bertumbuh dalam urutan waktu, dan terhubung pada struktur otak yang berkembang dengan urutan waktu yang sama.

Berdasarkan keempat aspek tersebut di atas dapat ditarik suatu kesimpulan bahwa otak tidak seluruhnya terbentuk oleh proses genetis. Terdapat proses lain yang ikut membentuk fungsi dari bagian-bagian otak, yang pada akhirnya menentukan bagaimana suatu informasi diproses oleh otak.

Elemen yang paling mendasar dari jaringan saraf adalah sel saraf. Sel-sel saraf inilah membentuk bagian kesadaran manusia yang meliputi beberapa kemampuan umum. Pada dasarnya sel saraf biologi menerima masukan dari sumber yang lain dan mengkombinasikannya dengan beberapa cara, melaksanakan suatu operasi yang non-linear untuk mendapatkan hasil dan kemudian mengeluarkan hasil akhir tersebut.

Dalam tubuh manusia terdapat banyak variasi tipe dasar sel saraf, sehingga proses berpikir manusia menjadi sulit untuk direplikasi secara elektrik. Sekalipun demikian, semua sel saraf alami mempunyai empat komponen dasar yang sama. Keempat komponen dasar ini diketahui berdasarkan nama biologinya yaitu, dendrit, soma, akson, dan sinapsis. Dendrit merupakan suatu perluasan dari soma yang menyerupai rambut dan bertindak sebagai saluran masukan. Saluran masukan ini menerima masukan dari sel saraf lainnya melalui sinapsis. Soma dalam hal ini kemudian memproses nilai masukan menjadi sebuah output yang kemudian dikirim ke sel saraf lainnya melalui akson dan sinapsis.

Penelitian terbaru memberikan bukti lebih lanjut bahwa sel saraf biologi mempunyai struktur yang lebih kompleks dan lebih canggih daripada sel saraf buatan yang kemudian dibentuk menjadi jaringan saraf buatan yang ada sekarang ini. Ilmu biologi menyediakan suatu pemahaman yang lebih baik tentang sel saraf sehingga memberikan keuntungan kepada para perancang jaringan untuk dapat terus meningkatkan sistem jaringan saraf buatan yang ada berdasarkan pada pemahaman terhadap otak biologi.

Sel saraf-sel saraf ini terhubung satu dengan yang lainnya melalui sinapsis. Sel saraf dapat menerima rangsangan berupa sinyal elektrokimiawi dari sel saraf-sel saraf yang lain. Berdasarkan rangsangan tersebut, sel saraf akan mengirimkan sinyal atau tidak berdasarkan kondisi tertentu. Konsep dasar semacam inilah yang ingin dicoba para ahli dalam menciptakan sel tiruan.

(id.wikipedia.org/wiki/Jaringan_saraf_tiruan)

Sekilas Tentang Rangkaian Sensor Warna:

Sensor warna yang digunakan menggunakan rangkaian yang biasa digunakan sebagai sensor line follower yaitu proximity cahaya. Jarak deteksinya tidak bisa jauh hanya beberapa centimeter saja dari objek. Terdiri dari 3 sensor warna untuk mendeteksi 3 warna utama, Red, Green, Blue (RGB) dengan output tegangan analog yang kemudian akan dibaca melalui port ADC mikrokontroler.

Sens_JST7

Prinsip Kerja :
Objek berwarna merah akan lebih banyak memantulkan cahaya warna merah
Objek berwarna hijau akan lebih banyak memantulkan cahaya warna hijau
Objek berwarna biru akan lebih banyak memantulkan cahaya warna biru

A.    JST di Matlab

Kita akan simulasikan di matlab terlebih dahulu dengan input yang dimisalkan dari data berikut data RGB dengan range 0-255. Bukan data ADC yang mungkin terbaca jika menggunakan sensor. Jika real menggunakan sensor, maka data yang dilatihkan data baca dari ADC. Proses JST sendiri terdiri dari 2 tahap: tahap belajar dan tahap uji. Tahap belajar akan menghasilkan W1 dan W2 atau nilai pembobotan. Nilai inilah yang akan kita masukan untuk program di mikrokontroler di CodevisionAVR.Sens_JST2

%program latih
clc
clear all

P = ...
	[255	0	0   ;%P1 merah
	 255 	0	128 ;%P2 merah
	 255	0	255 ;%P3 merah
	 0	0	255 ;%P4 biru
	 0	128	255 ;%P5 biru
	 0	255	255 ;%P6 biru
	 0	255	128 ;%P7 hijau
	 0	255	0   ;%P8 hijau
	 128	255	0  ];%P9 hijau

T = ...
	[1	0	0; 	%1 merah
	 1	0	0;	%2 merah
 	 1	0	0;	%3 merah
	 0	1	0;	%4 biru
	 0	1	0;	%5 biru
	 0	1	0;	%6 biru
 	 0	0	1;	%7 hijau
	 0	0	1;	%8 hijau
	 0	0	1];	%9 hijau

JumPola  = length(P(:,1));	% Jumlah semua pola latih (11)
DimPola  = length(P(1,:));	% Dimensi pola latih (3)
JOneuron = length(T(1,:));	% Jumlah neurons pada Output layer (1)

JHneuron = 9;			% Jumlah neurons pada Hidden layer
LR       = 0.1;			% Learning Rate
Epoch	 = 10000;		% Maksimum iterasi
MaxMSE	 = 10^-5;		% Maksimum MSE

%--------------------------------------------------------------------------
% Bangkitkan Weights antara Input layer dan Hidden layer secara acak
% dalam interval -1 sampai +1. Simpan sebagai W1.
%--------------------------------------------------------------------------
W1 = [];
for ii=1:JHneuron,
	W1 = [W1 ; (rand(1,DimPola)*2-1)];
end
W1 = W1';

%--------------------------------------------------------------------------
% Bangkitkan Weights antara Hidden layer dan Output layer secara acak
% dalam interval -1 sampai +1. Simpan sebagai W2.
%--------------------------------------------------------------------------
W2 = [];
for jj=1:JOneuron,
	W2 = [W2 ; (rand(1,JHneuron)*2-1)];
end
W2 = W2';

MSEepoch = MaxMSE + 1;	% Mean Square Error untuk 1 epoch
MSE = [];		% List MSE untuk seluruh epoch
ee	 = 1;		% Index Epoch

while(ee <= Epoch) & (MSEepoch > MaxMSE)
	MSEepoch = 0;
	for pp=1:JumPola,
		CP = P(pp,:);	% Current Pattern
		CT = T(pp,:);	% Current Target

		%-----------------------------------------------------------
		% Perhitungan Maju untuk mendapatkan Output, Error, dan MSE
		%-----------------------------------------------------------
		A1=[];
		for ii=1:JHneuron,
			v  = CP*W1(:,ii);
			A1 = [A1 1/(1+exp(-v))];
		end
		A2=[];
		for jj=1:JOneuron,
			v  = A1*W2(:,jj);
			A2 = [A2 1/(1+exp(-v))];
		end
		Error = CT - A2;

		for kk=1:length(Error),
			MSEepoch = MSEepoch + Error(kk)^2;
		end
		%-----------------------------------------------------------
		% Perhitungan Mundur untuk meng-update W1 dan W2
		%-----------------------------------------------------------
		for kk=1:JOneuron,
			D2(kk) = A2(kk) * (1-A2(kk)) * Error(kk);
		end
		dW2 = [];
		for jj=1:JHneuron,
			for kk=1:JOneuron,
				delta2(kk) = LR * D2(kk) * A1(jj);
			end
			dW2 = [dW2 ; delta2];
		end
		for jj=1:JHneuron,
			D1(jj) = A1 * (1-A1)' * D2 * W2(jj,:)';
		end
		dW1 = [];
		for ii=1:DimPola,
			for jj=1:JHneuron,
				delta1(jj) = LR * D1(jj) * CP(ii);
			end
			dW1 = [dW1 ; delta1];
		end
		W1 = W1 + dW1;	% W1 baru
		W2 = W2 + dW2;	% W2 baru
	end
	MSE = [MSE (MSEepoch/JumPola)];
	ee  = ee + 1;
end
plot(MSE);
xlabel('Epoch')
ylabel('MSE')

%program uji
TestSet = ...
	[255 0 255];

Kelas = [];

JumPola = length(TestSet(:,1));
JumBenar = 0;
for pp=1:JumPola,
	CP = TestSet(pp,:);
	A1 = [];
	for ii=1:JHneuron,
		v  = CP*W1(:,ii);
		A1 = [A1 1/(1+exp(-v))];
	end
	A2 = [];
	for jj=1:JOneuron,
		v  = A1*W2(:,jj);
		A2 = [A2 1/(1+exp(-v))];
	end

	%----------------------------------------
	% Pemetaan A2 menjadi kelas keputusan
	% Jika A2 < 0.5 maka Kelas = 0
	%----------------------------------------
	for jj=1:JOneuron,
		if A2(jj) < 0.5,
			Kelas(jj) = 0;
		else
			Kelas(jj) = 1;
		end
    end
end
Kelas

W1
W2
A1
A2

B.    Membuat Rangkaian Simulasi JST di Proteus

Potensiometer adalah untuk memisalkan output dari sensor warna.

Sens_JST3

C.     Membuat Program di CodevisionAVR

Buatlah project baru dengan mengaktifkan ADC 8-bit, Voltage ADC reference dari AVCC, dan LCD di PB. Setelah dibuat project baru, masukan file library wangready_JST.c dengan cara klik configure.

Sens_JST4

Lalu browse file wangready_JST.c dan klik OK.

Sens_JST5

Setelah itu kembali ke layar pemrograman. Buka file (double klik di jendela navigator) dan lakukan pengaturan di file wangready_JST.c . Masukan data-data hasil dari latih JST yang sudah dilakukan di matlab. Masukan nilai JOneuron dan JHneuron serta masukan pula nilai W1  dan W2 (pembobotan) sehingga seperti berikut.

/****************************************************
Implementasi Jaringan Syaraf Tiruan
Multi Layer Perceptron Dengan Algoritma Belajar Propagasi Balik
wangready.wordpress.com
*****************************************************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
// Declare your global variables here
#define JHneuron_val 9
#define JOneuron_val 3
int CP[JOneuron_val];
unsigned char JHneuron = JHneuron_val;
unsigned char JOneuron = JOneuron_val;
unsigned char kelas[JOneuron_val];
float W1[JOneuron_val][JHneuron_val] = {{-0.0552,    0.2011,   -0.0775,   -0.2480,    0.0759,   -0.6707,    2.7798,    0.3610,   -0.2911},
                                        {7.2505,     2.3445,    0.4637,   -2.1228,   -3.8145,   -0.3211,    4.3576,   -2.4067,   -0.6085},
                                        {1.4586,    -1.5528,   -0.7996,   -0.8682,    0.4503,   -0.1916,   -0.7845,    0.2793,   -0.5579}};
float W2[JHneuron_val][JOneuron_val]=  {{-8.8792,    8.8622,   -2.1603},
                                        {-1.7257,    0.2986,    0.8022},
                                        {-0.8877,   -7.1093,    7.0267},
                                        { 0.8346,   -0.5394,   -0.5260},
                                        { 2.9642,   -3.0433,   -4.9297},
                                        {-0.9731,   -0.2062,   -0.4736},
                                        { 5.9101,   -5.9067,   -1.8619},
                                        { 3.0977,   -3.0036,   -3.7159},
                                        { 0.7786,    0.5356,    0.2736}};
float A1[JHneuron_val];
float A2[JOneuron_val];
float v=0;
void run_JST()
{
unsigned int i,j,jj;
                //CP = TestSet(pp,:)
                //A1 = [];
                //for ii=1:JHneuron,
                for(i=0;i<JHneuron;i++)
                {
                v=0;
                        //v = CP*W1(:,ii);
                        for(j=0;j<JOneuron;j++)
                        {
                                v += ((float)CP[j])*W1[j][i];
                        }
                        //A1= [A1 1/(1+exp(-v))];
                        A1[i] = 1/(1+(exp(-v)));
                //end
                }
                //A2 = [];
                //for jj=1:JOneuron,
                for(jj = 0;jj<JOneuron;jj++)
                {
                v=0;
                        //v = A1*W2(:,jj);
                        for(j=0;j<JHneuron;j++)
                        {
                                v += A1[j]*W2[j][jj];
                        }
                        //A2= [A2 1/(1+exp(-v))];
                        A2[jj] = 1/(1+(exp(-v)));
                //end
                }
                //%===================================================
                //%pemetaan A2 menjadi kelas keputusan
                //%jika A2 < 0.5 maka kelas = 0
                //%===================================================
                //for jj=1:JOneuron,
                for(jj = 0;jj<JOneuron;jj++)
                {
                        //if A2(jj) < 0.5,
                        if(A2[jj] < 0.5)
                        {
                                //Kelas = 0;
                                kelas[jj] = 0;
                        }
                        //else
                        else
                        {
                                //Kelas = 1;
                                kelas[jj] = 1;
                        //end
                        }
                }
}

Jika sudah, kita kembali ke file program utama dan ketikan program berikut.

/*****************************************************
Chip type           : ATmega8535
Program type        : Application
Clock frequency     : 16.000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size     : 128
*****************************************************/

#include <mega8535.h>
#include <delay.h>
#include <stdio.h>
#include "wangready_JST.c"

// Alphanumeric LCD Module functions
#asm
   .equ __lcd_port=0x18 ;PORTB
#endasm
#include <lcd.h>

#define ADC_VREF_TYPE 0x60

// 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);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCH;
}

// Declare your global variables here
unsigned char data_adc[3], kata[16],flash *warna;
void main(void)
{
// Declare your local variables here
unsigned int i;
// 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=FFh
// OC0 output: Disconnected
TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// 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=0x00;
TCCR1B=0x00;
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: Timer 2 Stopped
// Mode: Normal top=FFh
// 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;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;

// ADC initialization
// ADC Clock frequency: 1000.000 kHz
// ADC Voltage Reference: AVCC pin
// ADC High Speed Mode: Off
// ADC Auto Trigger Source: None
// Only the 8 most significant bits of
// the AD conversion result are used
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x84;
SFIOR&=0xEF;

// LCD module initialization
lcd_init(16);

lcd_gotoxy(0,0);
lcd_putsf("APLIKASI JST");
//delay_ms(1000);
while (1)
      {
      // Place your code here
        lcd_clear();
        lcd_gotoxy(0,0);
        for(i=0;i<3;i++)
                data_adc[i] = read_adc(i);
        sprintf(kata,"%d=%d=%d",data_adc[0],data_adc[1],data_adc[2]);
        lcd_puts(kata);

        for(i=0;i<3;i++)
                CP[i] = data_adc[i];
        run_JST();

        if     ((kelas[0]==1)&&(kelas[1]==0)&&(kelas[2]==0))
                warna = "merah";
        else if((kelas[0]==0)&&(kelas[1]==1)&&(kelas[2]==0))
                warna = "biru";
        else if((kelas[0]==0)&&(kelas[1]==0)&&(kelas[2]==1))
                warna = "hijau";

        lcd_gotoxy(0,1);
        sprintf(kata,"%d=%d=%d ",kelas[0],kelas[1],kelas[2]);
        lcd_puts(kata);
        lcd_putsf(warna);

        delay_ms(1000);
      };
}

D.    Simulasi

Jika semua tahap sudah selesai dilakukan maka simulasikan. Simulasi menunjukan nilai yang benar.

Sens_JST6

2 Responses to Penerapan JST Pada Sensor Warna

  1. damar says:

    gan ada project yang diatas kga gan… ?
    klo ada ane mnta gan buat referensi saja gan…

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.