MÃ NGUỒN CÁC CHƯƠNG TRÌN1

Bài tập lớn môn Ănten- Truyền sóng Gv: Thầy Nguyễn Khuyến

MÃ NGUỒN CÁC CHƯƠNG TRÌNH

%-----------------------------------------------------------------------------------------------

% Chương trình chính tính toán.

%----------------------------------------------------------------------------------------

------- global k0 so_chan_tu last lmax chuky alpha hsdh trovao

clc;

disp(‘ THIET KE ANTEN LOGA – CHU KY ’)

% doi tan so ra dang Hz

fmax=600*1e+6; %Hoặc nhập tay fmax=input('Tan so lon nhat (MHz):')

fmin=400*1e+6; %Hoặc nhập tay fmin = input('Tan so nho nhat (MHz):')

F0 = 500*1e+6; %input('Nhap tan so hoat dong giua fmax va fmin(MHz):');

last = 10; %input('Nhap so vong chay: ');

lamda = 3e+8/F0; %Bước sóng hoạt động

k0 = 2*pi/lamda;

so_chan_tu = 6;

lmax = 3e+8/(2*fmin);

No_bit = 10; %input(‘so bit ma hoa: ’);

row = 8; %số anten thử nghiệm

% Những giới hạn của các tham số anten

a0 = 0.85;

b0 = 0.95;

a1 = 10*pi/180; %alpha min = 10o

b1 = 20*pi/180; %alpha max = 20o

gen = 2; %số gen trong 1 nhiễm sắc thể

Thiết kế anten Loga- chu kỳ Page 1 4/11/2023


cell = gen*No_bit; %Kích thước nhiễm sắc thể

muctieu = [];

Gene = round(rand(row,cell));

for ib = 1:last

disp(‘ vong lap thu ’)

ib

for ic = 1:row

cost = Gene(ic,:);

for jb = 1:No_bit

ckkc(1,jb) = cost(1,jb);

goc_d(1,jb) = cost(1,jb+No_bit);

end

%giải mã

chuky = decode(ckkc,No_bit);

alpha = decode(goc_d,No_bit);

%giới hạn các tham số

chuky = a0+chuky*(b0-a0)/(2^No_bit);

alpha = a1+alpha*(b1-a1)/(2^No_bit);

%tính hàm mục tiêu

muctieu(ic,1) = loga(chuky,alpha);

end

muctieu = -muctieu;

[muctieu,ind] = sort(muctieu);



Gene = Gene(ind(1:round(row/2)),:);

%lai ghép

cross = ceil((cell-1)*rand(round(row/2),1));

for ic = 1:2:(round(round(row/2)))

Gene(round(row/2)+ic,1:cross) = Gene(ic,1:cross);

Gene(round(row/2)+ic,cross+1:cell) =

Gene(ic+1,cross+1:cell);

Gene(round(row/2)+ic+1,1:cross) = Gene(ic+1,1:cross);

Gene(round(row/2)+ic+1,cross+1:cell) = Gene(ic,cross+1:cell);

end

if ib ~ = last

%biến dị

ix = ceil(row*rand);

iy = ceil(cell*rand);

Gene(ix,iy) = 1-Gene(ix,iy);

else

% vòng lặp cuối thì không biến dị, cho in các giá trị

cuoicung = Gene(1,:);

for jb = 1:No_bit

ck_cuoicung(1,jb) = cuoicung(1,jb);

goc_cuoicung(1,jb) = cuoicung(1,jb+No_bit);

end

chuky = decode(ck_cuoicung,No_bit);



alpha= decode(goc_cuoicung,No_bit);

chu ky = a0+ chuky*(b0-a0)/(2^No_bit);

alpha= a1+alpha*(b1-a1)/(2^No_bit);

muctieu_cuoicung =

loga(chuky,alpha) chuky

alpha = alpha*180/pi % alpha tính theo độ

trovao

hsdh_dBi = 10*log10(hsdh)/1.6 % tính ra dBi

end

end



%-----------------------------------------------------------------------------------------------

% Phần chương trình tính hàm object (loga.m).

%----------------------------------------------------------------------------------------

------- function out = loga(cky,anpha)

global chky alfa k_cach lmax so_chan_tu x dong L hsdh

trovao chky = cky;

alfa =

anpha;

L = [];

L(so_chan_tu) = lmax; % tính chiều dài các chấn tử.

for n = so_chan_tu-1:-1:1

L(n) = L(n+1)*chky;

end

x(1) = (L(1)/2)/tan(alfa); % tính tọa độ

for n = 2:so_chan_tu

x(n) = x(n-1)/chky;

end


for m =

1:so_chan_tu

if n ~ = m

k_cach(n,m) = abs(x(n)-x(m));

else k_cach(n,m) = 0;



end

end

end

bk = 4e-3;

% Dẫn nạp các đoạn fiđe giữa các chấn tử liên tiếp

y = zeros(2,2,so_chan_tu+1);

for k =

2:so_chan_tu+

1 for n = 1:2

for m = 1:2

y(n,m,k) = DanNap(n,m,k);

end

end

end

% Trở kháng riêng và trở kháng tương hỗ.

z = zeros(so_chan_tu,so_chan_tu);


for m = 1:so_chan_tu+1

if m = =

so_chan_tu+1

z(n,m) = 0;

elseif n = = m

z(n,m) = tk_rieng(bk,L(n));



else

z(n,m) = trk_th(L(n),L(m),k_cach(n,m));

end

end

end

% tính các hệ số của ma trận

V0 = 1;

a = zeros(so_chan_tu);


for m = 1:so_chan_tu

thstg = z(n,m)*(y(1,1,m+1)+y(2,2,m)+y(2,1,m+1)*z(n,m+1));

if n = = m

thstg = thstg+1;

end

if m = = 1

a(n,m) = thstg;

else

a(n,m) = thstg+y(1,2,m)*z(n,m-1);

end

end

b(n) = z(n,1)*y(2,1,2)*V0;

end



%Giải hệ điện áp trên các chấn tử.

v = a\b';

% Dong dien:

v(so_chan_tu+1) = 0;


v_thstg = y(1,1,n+1)*v(n)+y(1,2,n+1)*v(n+1)+y(2,2,n)*v(n);

if n = = 1

dong(n) = v_thstg+y(2,1,n);

else

dong(n) = v_thstg+y(2,1,n)*v(n-1);

end

end

% Trở kháng vào của anten

trovao = v(1)/dong(1);

t1 = dblquad('bf_hfh',0,pi,0,2*pi);

hsdh = 4*pi/t1;

object = 30*hsdh;%-abs(75-real(trovao));

out = object;



%-----------------------------------------------------------------------------------------------

% Tổng bình phương hai hàm phương hướng (bf_hfh.m).

%----------------------------------------------------------------------------------------

------- function out = bf_hfh(goc1,goc2)

global so_chan_tu k0 L

dong x goc1 =

0:0.15:2*pi;

tong1 = 0;

goc2 = 0:0.15:2*pi;

tong2 = 0;

for m =

1:so_chan_tu

dau =

cos(m*pi);

t_g1 = (1-cos(k0*L(m)/2))./sin(k0*L(m)/2);

e_mu1 = exp(i*k0*x(m)*cos(goc1));

tong1 = tong1+dau.*dong(m).*t_g1.*e_mu1;

t_g2 = (cos((k0*L(m)/2)*sin(goc2))-cos(k0*L(m)/2))/sin(k0*L(m)/2);

e_mu2 = exp(i*k0*x(m)*cos(goc2));

tong2 = tong2+dau.*dong(m).*t_g2.*e_mu2;

end



hfh_h = abs(tong1)/abs(tong1(1));

hfh_e = abs(tong2)/abs(tong2(1));

out = (sqr(hfh_h)+sqr(hfh_e)).*sin(goc1);



%-----------------------------------------------------------------------------------------------

% Trở kháng tương hỗ (trk_th.m).

%----------------------------------------------------------------------------------------

------- function out = trk_th(l01,l02,kc)

global kcach l1

l2 k0 l1 = l01;

12 = 102;

kcach = kc;

t1 = -30*quad('ham_tk1',-

l2/2,l2/2); t2 = -

30*quad('ham_tk2',-l2/2,l2/2);

out = t1+j*t2;



%-----------------------------------------------------------------------------------------------

% hai file ham_tk1.m và ham_tk2.m:

%----------------------------------------------------------------------------------------

------- function out = ham_tk1(t)

global kcach k0 l1 l2

R = sqrt(kcach^2 + t.^2);

r1 = sqrt(kcach^2 + (t+l1/2).^2);

r2 = sqrt(kcach^2 + (t-l1/2).^2);

out = (2*sin(k0*R)*cos(k0*l1/2)/R-sin(k0*r1)/r1-sin(k0*r2)/r2)*

*sin(k0*(l2/2-abs(t)))/(sin(k0*l1/2)*sin(k0*l2/2));

%----------------------------------------------------------------------------------------

------- function out = ham_tk2(t)

global kcach k0 l1 l2

R = sqrt(kcach^2 + t.^2);

r1 = sqrt(kcach^2 + (t+l1/2).^2);

r2 = sqrt(kcach^2 + (t-l1/2).^2);

out = (2*cos(k0*R)*cos(k0*l1/2)/R-cos(k0*r1)/r1-cos(k0*r2)/r2)*

*sin(k0*(l2/2-abs(t)))/(sin(k0*l1/2)*sin(k0*l2/2));



%-----------------------------------------------------------------------------------------------

% Trở kháng riêng (trk_rieng.m).

%----------------------------------------------------------------------------------------

------- function out = tk_rieng(bk,l)

format long e;

global M h k0 te_ta an_pha

M = 8; %Số vòng lặp

h = 1/M;

te_ta = k0*l/2;

an_pha = 2*bk/l;

% Gán các hệ số của ma trận R (n x m)

for i = 1:M

for j = 1:M

a(i,j) = complex(R_thuc(i,j-1),R_ao(i,j-1));

end

b(i) = complex(sin(i*te_ta*h),0);

end

% Giải hệ phức

x = a\b';

he_so = complex(0,20*h);

out = he_so/x(1);



%-----------------------------------------------------------------------------------------------

% Hàm hệ số ma trận

function R_thuc = R_thuc(m,n);

global M h k0 te_ta an_pha

tam1 = 0;

tam2 = 0;

for i = 0:M

tam1 = tam1+s(i)*(1/Can(i,n)+1/Can(i,-n));

tam2 = tam2+2*s(i)/Can(i,0);

end;

r1 = cos(te_ta*Can(n,-m))/Can(n,-m);

r2 = cos(te_ta*Can(n,m))/Can(n,m);

r3 = 2*cos(te_ta*m*h)*cos(te_ta*Can(n,0))/Can(n,0);

r4 = s(n)*(r1+r2-r3);

r5 = (3/h)*log(((1-n*h+sqrt(sqr(an_pha)+sqr(1-n*h)))*

*(1+n*h+sqrt(sqr(an_pha)+sqr(1+n*h))))/sqr(an_pha));

r6 = cos(te_ta*an_pha)*(r5-tam1);

r7 = cos(te_ta*an_pha)*cos(te_ta*m*h)*

*((6/h)*log((1+sqrt(1+sqr(an_pha)))/an_pha)-tam2);

if m = = n

tam = r4+r6;

else tam = r4;

end

if n = = 0



R_thuc =

tam-r7; else

R_thuc =

tam; end

% phần

ảo

function R_ao = R_ao(m,n);

global te_ta an_pha h

r1 = sin(te_ta*Can(n,-m))/Can(n,-

m);

r2 = sin(te_ta*Can(n,m))/Can(n,m);

r3 = 2*cos(te_ta*m*h)*sin(te_ta*Can(n,0))/Can(n,0);

r =

s(n)*(r1+r2-

r3); R_ao = -

r;

%-----------------------------------------------------------------------

------- function can = Can(n,m);

global h an_pha

can = sqrt(sqr(an_pha)+h*h*sqr(n+m));

%------------------------------------------------------------------------------

% Hàm trọng số Simpson

function s = s(n);

if n = = 0|n = = 8 s = 1;



elseif rem(n,2) = = 0 s = 2;

else s = 4;

end



%-----------------------------------------------------------------------------------------------

% Dẫn nạp (DanNap.m).

%----------------------------------------------------------------------------------------

------- function out = DanNap(n1,m1,kc)

global k0 so_chan_tu x

k_cach format short e;

TKS = 120*pi;

k1 = kc;

if k1 = =

so_chan_tu+1

out = 0;

elseif

k1== 1

if n1 =

= m1

out = coth(i*k0*x(1))/TKS;

else

out = -csch(i*k0*x(1))/TKS;

end

elseif n1 = = m1

out = coth(i*k0*k_cach(k1,k1-1))/TKS;

else

out = -csch(i*k0*k_cach(k1,k1-1))/TKS;

end



%-----------------------------------------------------------------------------------------------


Documents

MÃ NGUỒN CÁC CHƯƠNG TRÌN1