Дипломная работа: Синтез гибридной нейронной сети для управления двухмассовой электромеханической системой с зазором. 2003 г

121

bit10,

bit11,

bit12,

bit13;

int nr;

/* *******Ende der Variablendeklaration ******************************** */

/* ********************************************************************* */

/* ********Anlegen der Funktionen ** allgemein ************************ */

float pireg(nr,x,vr,tr,grz,y)

int nr ;

float x,vr,tr,grz,y;

{ p_gr = 0.0; nr = nr + 0; y = 0.0; p1 = x * vr;

if (vari[nr] > grz) p_gr = (vari[nr] - grz) * 10;

if (vari[nr] < (-grz)) p_gr = (vari[nr] + grz) * 10;

if (p_gr < -1000 ) p_gr = -1000;

if (p_gr > 1000 ) p_gr = 1000;

vari2[nr] = vari2[nr] + (p1 - p_gr) * tr ;

vari[nr] = p1 + vari2[nr];

y = vari[nr];

return y;

}

/* der PI-reg Aufruf Variablen 1. lfde Nr.

2. Eingang

3. Verst„rkung

4. Integrationszeitkonstante 2 ms/T

5. Begrenzung des Ausgangswertes

6. leer 0.0 angeben */

float innt(nr,a,t,br)

int nr; float a,t,br;

{

vari[nr] = vari[nr] + ((a + vari2[nr]) * t * 0.5);

vari2[nr] = a;

if (vari[nr] < -br) vari[nr] = -br;

if (vari[nr] > br) vari[nr] = br;

return vari[nr];

}

/* der Aufruf 1. lfd. Nr.

2. Eingang

3. Integrationszeitkonstante

4. Begrenzung */

float zpg(nr,e,a) /* Zweipunktglied */

int nr; float e,a;

{

vari[nr] = 0.0;

if (e < 0.0) vari[nr] = -a;

if (e > 0.0) vari[nr] = a;

return vari[nr];

}

/* der Aufruf 1. lfd. Nr.

2. Eingang

122

3. Stellgr”бe */

float begrz(nr,c,a) /* Begrenzer ausgang,eingang,maxwert */

int nr; float c,a;

{ vari[nr] = c;

if ( c < -a ) vari[nr] = -a;

if ( c > a ) vari[nr] = a;

return vari[nr];

} /* 1. lfd.Nr.

2. Eingang

3. Begrenzung */

float pt1(nr,a,t) /* Verz”gerungsglied 1. Ordng. */

int nr; float a,t;

{

vari[nr] = vari[nr] + ( a - vari[nr]) * t;

return vari[nr];

}

float add(nr,a,b) /* Addierer */

int nr; float a,b;

{ nr = nr + 0;

vari[nr] = a + b;

return vari[nr];

}

float mul(nr,a,b) /* Multiplizierer*/

int nr; float a,b;

{ vari[nr] = a * b;

return vari[nr];

}

float sub(nr,a,b) /* Subtraktion */

int nr; float a,b;

{ vari[nr] = a - b;

return vari[nr];

}

float stbegr(nr,v,t) /* Steilheitsbegrenzer*/

int nr;

float v,t; /* v = Variable t = dif /abtastzeit */

{

vari2[nr] = v;

if (v > vari[nr] + t) vari2[nr] = vari[nr] + t;

if (v < vari[nr] - t) vari2[nr] = vari[nr] - t;

vari[nr] = vari2[nr];

return vari[nr];

}

float z_1(nr,v) /* Speicherung Ѓber eine Abtastperiode */

int nr;

float v;

{

123

vari[nr] = vari1[nr];

vari1[nr] = v;

return vari[nr];

}

/* ******************* Ende der Funktionsfestlegung ******************** */

/* ********************************************************************* */

/* ****************** Initialisierungsroutine ************************** */

void user(void)

{

/*. . . . . . . . V O R E I N S T E L L U N G S W E R T E. . . . . . . */

/* ********** Voreinstellungen der bin„ren Ein - und Ausg„nge ********** */

ds1102_p14_pin_io_init(0x0000402F);/* 0100 0000 0010 1111 = Ausgang */

ds1102_p14_pin_io_clear(0xFFFF);

ds1102_inc_clear_counter(1);

ds1102_inc_clear_counter(2);

/* ....dzr......Der Drehzahlregler ............................... */

DT1 = TCYCLE * 0.000001; /* Umrechnung der Zy.-zeit in sec */

t_1s = dt; /* Zeitkonstante 1 sec */

t_5ms = dt / 0.005;

t_10ms = dt / 0.01;

t_20ms = dt / 0.02;

t_50ms = dt / 0.05;

t_100ms = dt / 0.1;

t_200ms = dt / 0.2;

norm_igr_omega = 20.4797 / dt ; /* Normierwert 1 =>1500 U/min */

/* ************** Ende aller Voreinstellungen ************************** */

}

/* ------------------- Die Programm-Struktur -------------------------*/

/* Unterteilt in: */

/* p14 Einlesen der Eing„nge dSPACE */

/* ********************************************************************** */

isr_t0()

{

/* .......Einlesen der IGR's IGR0 unter Welle IGR1 obere Welle */

ds1102_p14_pin_io_clear(0x0003); /* Analogmultiplexer auf die 4 Buchsen*/

ds1102_p14_pin_io_set(0x0000);

/* Welle oben IGR0 Welle unten IGR2 */

igr1a = igr1; igr2a = igr2; omega1a = omega1; omega2a = omega2;

igr1 = ds1102_inc(1); /* Einlesen IGR 1 */

igr2 = ds1102_inc(2); /* Einlesen IGR 2 */

/* Der DSP Z„hler springt bei љberlauf auf von max pos. auf max. neg. !!*/

if ((abs(igr1 - igr1a)) > 1.99) { omega1 = omega1a;} else

{ omega1 = (((igr1 - igr1a) * norm_igr_omega) + omega1a) * 0.5;}

if ((abs(igr2 - igr2a)) > 1.99) { omega2 = omega2a;} else

{ omega2 = ((-(igr2 - igr2a) * norm_igr_omega) + omega2a) * 0.5;}

service_trace(); /*fuer Win Trace ***/

count1=count_timer(TMR1);

ds1102_ad_start(); /* AD-Wandler Start */

/* .......Einlesen bzw. Ausgabe der 16 Bin„rleitungen.................... */

124

binein = ds1102_p14_pin_io_in() & 0x00ff; /* Lesen der 8 Bit */

/* .......Einlesen der 4 Analogeing„nge und Normierung .................. */

ad1 = ds1102_ad(1) * 1.0;

ad2 = ds1102_ad(2) * 1.0;

ad3 = ds1102_ad(3) * 1.0;

ad4 = ds1102_ad(4) * 1.0;

pt1(254,ad2,t_10ms);

n_last_7welle = 2.2 * vari[254];

pt1(253,ad3,t_10ms);

m_7welle= -1.43*vari[253];

bit15 = (ds1102_p14_pin_io_in() & 0x8000) ?1:0; /* negiert1:0; bit15 */

bit15aa = bit15a; bit15a = bit15;

if ((bit15+bit15aa+bit15a) == 3)

{ i=0;

/* +„+ start der Signalverarbeitung */

n_1soll=0.0; m_last=0.0; coun1++;

if ((coun1>100)&&(coun1<3100)) n_1soll=0.3;/*das ist Zeit arbeiten wsoll */

if ((coun1>1000)&&(coun1<2500)) m_last=0.3;/*das ist Moment Last pro Zeit*/

sub(2,n_1soll,omega2);

mul(3,vari[2],8.0); /* Pregler zum Test*/

da1= 0.66 * vari[3];/* Normierung 6,6V am UR -> 7Nm am Motor =M_nenn */

}

else

{ i++;coun1=0;

/* Regelungsende----Stillsetzen */

sub(2,0.0,omega2);

mul(3,vari[2],2.0); /* Pregler auf n=0 */

da1= 0.66 * vari[3];

if (i>3000){ da1=0.0;} /* nach ca. 3sec da=0 */

}

/* *Anzeige auf GOULD ************************************************** */

da2 = m_last;

da4 = m_7welle;

da3 = omega2;

/* .ana................ANALOGAUSGABE......................................*/

begrz(255,da1,0.999); /* Stellsignal Untermotor an Microverter V*/

ds1102_da(1,vari[255]);

begrz(255,da2,0.999); /* Stellsignal Obermotor an Microverter V*/

ds1102_da(2,vari[255]);

begrz(255,da3,0.999); /* Messkanal1 */

ds1102_da(3,vari[255]);

begrz(255,da4,0.999); /* Messkanal2 */

ds1102_da(4,vari[255]);

/* Ende................ANALOGAUSGABE......................................*/

extime1=time_elapsed(TMR1,count1);

125

end_isr_t0();

}

/* Endes des gesamten zyklischen Regelprogramms ------------------------ */

/* ********************************************************************** */

/* .............. Festlegung der Programmstruktur ...................... */

main()

{

dt = 0.001; /* Abtastzeit */

init();

user();

dp_mem[0].f=0.0;

start_isr_t0(dt);

/* start_isr_t1(0.002); /* Interruptserviceroutine 2 sec */

*error=NO_ERROR;

while(*error == NO_ERROR);

}

/* Ende der Festlegung der Programmstruktur */

/* ********************************************************************** */

/* LISTENENDE */

126

Приложение Б.

Программа обучения сети ANFIS с помощью обратного распространения ошибки.

Main.m

%Die Funktion der direkten Fehlkalkulation "ANFIS " des Netzes

%Die Funktion der Rechnung und der Ausbildung des Vektores der Parameter der Funktionen

%der Zugeho:rigkeit von der Methode des Gradienten

%Fur das Netz "ANFIS"

% Tsepkovskiy Yuriy Jan 2003 - Febr 2003

%////////// input interface

clear all

load dmatr

close all

disp ('Anfis programmen Ver 1.0 --- Febr 2003');

disp('Trial Versionen');

m=3

epoh=input('epoh =');

msew=0;

h1=2;

h2=1;

d;

[w1,w2,error]=trainin(epoh,msew,d,h1,h2,m);

function [w1,w2,error]=trainin(epoh,msewunch,d,h1,h2,m)

% Tsepkovskiy Yuriy Jan 2003 - Febr 2003

%Die Funktion der Rechnung und der Ausbildung des Vektores der Parameter der Funktionen

%der Zugeho:rigkeit von der Methode des Gradienten

%Fur das Netz "ANFIS"

n=size(d,2)-1; %Die Dimension des Eingangsvektores des Netz

T=size(d,1); %Die Dimension des Eingangsvektores des Netz Nach der Zeit

w1=initalw1(m,n,h1,d); % h - Die Menge der Parameter der Eingangsfunktion

w2=initalw2s0(m,n,h2);

nju=0.5;

fff=T/10;

ep=0;

qqq=1;

while qqq==1

for dddd=1:epoh

ep=ep+1;

%Die Formierung des Vektores der Geschwindigkeit der Ausbildung

nju=nju ;

%Die Berechnung des Mittelwertfehlers zwischen dem Signal des Netzes und das Zweck

for t=1:fff

127

[y , outrules , index, dst , mf ]=anfdirect(d,w1,w2,m ,t);

mse(t)=(y-d(t,n+1)); %[T,1]

mse2(t)=(y-d(t,n+1))*(y-d(t,n+1)); %[T,1]

%Die Berechnung der Vera:nderung des Vektores w2

for r=1:n^m

dedw2t(r,t)= -mse(t)*outrules(r);%[n^m,1]

end

if (t==2)

dedw2=dedw2t(:,t)+dedw2t(:,t-1);

if (t>2)

dedw2=dedw2+dedw2t(:,t);

end

%Die Berechnung der Vera:nderung des Vektores w1

%/////////

Zi=(index*w2)/9; %[9:27]*[27:1] = [9:1] w2'* C'= [1:27] * [27: 9] = [1:9]

l=0;

for i=1:n

for j=1:m

l=l+1;

dedw11t(l,1,t)=-mse(t)*Zi(l)*gauss1dc(w1(l,1),w1(l,2),dst(l));

dedw12t(l,2,t)=-mse(t)*Zi(l)*gauss1dsig(w1(l,1),w1(l,2),dst(l))*dst(l);

end

if (t==2)

dedw11=dedw11t(:,1,t)+dedw11t(:,1,t-1);

dedw12=dedw12t(:,2,t)+dedw12t(:,2,t-1);

if (t>2)

dedw11=dedw11+dedw11t(:,1,t);

dedw12=dedw12+dedw12t(:,2,t);

end;

mse2=mse2' ; % [1,T]

error(ep)=sum(mse2)/(2*fff); % das Vector nach der Epoches

dedw2=dedw2/fff;

deltaw2= nju.*dedw2;

w2=w2+deltaw2;

deltaw11=nju.*dedw11/fff;

deltaw12=nju.*dedw12/fff;

w1(:,1)=w1(:,1)+deltaw11;

w1(:,2)=w1(:,2)+deltaw12;

end

plot(error);grid on ;zoom;

128

qqq=input('Continue ? 1 - yes');

end

disp ('OOuuuKEY!')

function [zo , outrules , index , dst, mf]=anfdirect(d,w1,w2,m,t)

% Tsepkovskiy Yuriy Jan 2003 - Febr 2003

%Die Funktion der direkten Fehlkalkulation "ANFIS " des Netzes

% Anprobieren - Ok

%//////////////////////// input interface

% Eingang matrix variable d

%W1 [m*n,r] Die Matrix der Parameter der Inbetriebnahme

% r die Zahle die Functionen der Parameter

%W2 [n^m,g] Die Matrix der Parameter des Schlusses

% g die Zahle die Functionen der Parameter , g=1 fur Sugeno die Ordnung = 0

% m - Die Zahl der Funktionen auf den Zutritt

%die ZeitIterator ist t !

n=size(d,2)-1;%Die Dimension des Eingangsvektores des Netzes

% /////////////////Direkt Arbeits netz

% Die Berichnung der Ausgange der Schicht der Functionen mf

l=0;

for i=1:n

for h=1:m

l=l+1;

% mf=[n,m]

mf(i,h)=gauss1(w1(l,1),w1(l,2),d(t,i));

dst(l)=d(t,i); % difiniren Eingang Vectores fur nntrain.m Func

end

% mf - ist die String

% Die Berichtung der Ausgange die Regeln der Schicht

[outrules, index]=rules(mf,m,n);

% [1,n^m]

outrules=outrules';

%[n^m,1]

S=1/sum(outrules);

outrules=outrules*S;

% Die Berechnung der linearen Kombination der Ausgange der Regeln

zi=multel(outrules,w2); %die String

%[n^m,1]

% output netz

zo=sum(zi)*S;

function g=gauss1( c , sigma, x)

%function memberschip fur anfis neuronale netz

129

% IESY, tsepkovsky yuriy, febr 2003

% gaussmf memberschip function

% Anprobieren - OK

g= exp(-(x-c)*(x-c)/(2*sigma*sigma));

function f=gauss1dc(c,sigma,x)

f=(x-c)/sigma^2*exp(-1/2*(x-c)^2/sigma^2);

function f=gauss1df(c,sigma,x)

f= -exp(-1/2*(x-c)^2/sigma^2)*(x-c)/sigma^2;

function f=gauss1dsig(c,sigma,x)

f= (x-c)^2/sigma^3*exp(-1/2*(x-c)^2/sigma^2);

function F=initalw1s0(m,n,h,d)

% Die Funktion des Initializationes der Matrix der Parameter der Inbetriebnahme W1[m*n,h]

% h - Die Menge der Parameter der Eingangsfunktion

% F=rand(m*n,h); %Das gleichma:ssige Gesetz der Einteilung der zufa:lligen Za:hle

%////////////////////////////////////***************************

% Die Bestimmung des Bereiches der Verдnderung des Eingangsvektores d (t,n)

k=0;

minid=min(d)%[1:n]

maxid=max(d)%[1:n]

diap=maxid-minid;% [1:n]

for i=1:m

for j=1:n

k=k+1;

F(k,1)=(diap(j)/n *j)/1;

F(k,2)=1;

end

disp('inital w1');

function F=initalw2s0(m,n,h)

% Die Funktion des Initializationes der Matrix der Parameter der Inbetriebnahme W1[m*n,h]

% h - Die Menge der Parameter der Eingangsfunktion

% F=rand(n^m,h); %Das gleichma:ssige Gesetz der Einteilung der zufa:lligen Za:hle

for i=1:n^m

F(i,h)=1;

end

function F=multel(a,b)

%Die Funktion bis die elemente Multiplikation der Matrizen

%Die Matrizen sollen des identischen Umfanges sein , a[m,n] , b[m,n]

130

% Anprobieren - OK

[m,n]=size(a); %m - die Zaile

[m1,n1]=size(b); % n - die Spalte

%Die Bearbeitung der Fehler

if (n1~=n)

disp('Sie haben den Feler mit matrix gro:sse in function multel , die Zaile');

keyboard;

end

if (m1~=m)

disp('Sie haben den Feler mit matrix gro:sse in function multel , die Spalte');

keyboard;

end

%Den Ko:rper der Funktion

for i=1:m

for j=1:n

F(i,j)=a(i,j)*b(i,j);

end

function [F , nn]=rules(mf,m,n)

% IESY, tsepkovsky yuriy, febr 2003

% Die Funktion des Kombinierens der Signale der Schicht der Funktionen

%der Zugeho:rigkeit und die Zusammenstellung des Vektores der Beschlusse, nach der Regel

"and" oder den Minimum

% Modifizirung die Functionen fur die Ausbildung die neuronale Netz.

% !!!!!!! Es funktionieren fur 5 und mehr die Parameter nicht

k=0; % Hauptiterator

% n -Die Zahl der Zutritte des Netzes

% m - Die Zahl der Funktionen auf den Zutritt

nn=zeros(n,m);

switch n

case {1}

for i=1:m

k=k+1;

F(k)=min(mf(1,i));

% Die Erhaltung des Indexes der minimalen Komponente des Vektores mf

nn(1,i)=1;

end

case {2}

for i=1:m

for j=1:m

k=k+1;

F(k)=min([mf(1,i);mf(2,j)]);

% Die Erhaltung des Indexes der minimalen Komponente des Vektores mf

if (mf(1,i)<mf(2,j))

nn(1,i)=1;

else

Дипломная работа: Синтез гибридной нейронной сети для управления двухмассовой электромеханической системой с зазором. 2003 г

Подождите немного. Документ загружается.