B M S COLLEGE OF ENGINEERING

(AUTONOMOUS COLLEGE UNDER VTU, BELGAUM)

BANGALORE – 560019

“OPEN-ENDED EXPERIMENTS”
IN
TH
5 SEMESTER
ADVANCED COMMUNICATION LAB (22EC5PCACL)
(PLATFORM-MATLAB)
Submitted in partial fulfilment of the requirements for the Activity plan

BACHELOR OF ENGINEERING

IN

ELECTRONICS AND COMMUNICATION

BY

UTTAM (1BM21EC190)

UNDER THE GUIDANCE OF

Dr. Madhusudhan K N
(Assistant Professor, BMSCE)
Department of Electronics and Communication Engineering
2023-2024
1).Demonstrate sampling,quantization and reconstruction of any given signal.
clc;
close all;
clear all;

% Signal parameters
Fs = 1000; % Sampling frequency (Hz)
t = 0:1/Fs:1; % Time vector from 0 to 1 second with 1/Fs increment
f_original = 5; % Frequency of the original signal (Hz)
original_signal = sin(2*pi*f_original*t); % Original signal (sine wave)

% Plot the original signal

subplot(4, 1, 1);
plot(t, original_signal);
title('Original Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% Sampling
Fs_sampled = 200; % Sampling frequency for the sampled signal (Hz)
t_sampled = 0:1/Fs_sampled:1; % Time vector for sampled signal
sampled_signal = sin(2*pi*f_original*t_sampled); % Sampled signal

% Plot the sampled signal

subplot(4, 1, 2);
stem(t_sampled, sampled_signal);
title('Sampled Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% Quantization
bits = 4; % Number of quantization bits
quantized_signal = quantize(sampled_signal, bits);

% Plot the quantized signal

subplot(4, 1, 3);
stem(t_sampled, quantized_signal);
title('Quantized Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% Reconstruction
reconstructed_signal = interp1(t_sampled, quantized_signal, t, 'linear', 'extrap');

% Plot the reconstructed signal

subplot(4, 1, 4);
plot(t, reconstructed_signal);
title('Reconstructed Signal');
xlabel('Time (s)');
ylabel('Amplitude');
% Function to quantize a signal to the specified number of bits
function quantized_signal = quantize(signal, bits)
% Normalize signal to the range [-1, 1]
normalized_signal = signal / max(abs(signal));

% Quantize the normalized signal

quantized_signal = round((2^(bits-1) - 1) * normalized_signal);
% Scale back to the original range
quantized_signal = quantized_signal / (2^(bits-1) - 1);
end

OUTPUT:

2).Determine PCM/DPCM of any signal or speech compression by digital companding (A

or Mu law)
clc;
clear all;
close all;
% Speech compression using PCM and μ-law companding

% Generate a sample speech-like signal (sine wave)

fs = 3000; % Sampling frequency
t = 0:1/fs:1; % 1 second duration
f = 44; % Frequency of the sine wave (change as needed)
speech_signal = 0.5 * sin(2 * pi * f * t);

% Display the original speech signal

subplot(3,1,1);
plot(t, speech_signal);
title('Original Speech Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% PCM Encoding
bits_per_sample = 8; % Number of bits per sample
speech_max = max(abs(speech_signal));
speech_quantized = speech_signal / speech_max * (2^(bits_per_sample-1) - 1);
speech_quantized = round(speech_quantized);

% μ-law companding
mu = 255; % μ value for μ-law companding
speech_companded = sign(speech_quantized) .* log(1 + mu * abs(speech_quantized) / (1 + mu)) / log(1 + mu);

% PCM Decoding
speech_decompanded = sign(speech_companded) .* ((1 + mu).^abs(speech_companded) - 1) / mu;
speech_reconstructed = speech_decompanded * speech_max;

% Display the compressed signal

subplot(3,1,2);
plot(t, speech_companded);
title('Companded Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% Display the reconstructed signal

subplot(3,1,3);
plot(t, speech_reconstructed);
title('Reconstructed Signal');
xlabel('Time (s)');
ylabel('Amplitude');

% Play the original and reconstructed signals

sound(speech_signal, fs);
pause(2);
sound(speech_reconstructed, fs);

OUTPUT:
3).Demonstarte digital communication system employing BASK,BPSK,QPSK,BFSK
modulation and demodulation scheme you have studied and show the constellation plot/
BER performance/ Plot waveforms.Assume AWGN channel and demodulation.
For BFSK:
clc;
close all;
clear all;
% BFSK Modulation and Demodulation with AWGN Channel

% Parameters
f_mark = 1000; % Frequency for binary 1
f_space = 500; % Frequency for binary 0
T = 1 / 1000; % Symbol duration (1 ms)
A = 1; % Amplitude
SNR_dB = 10; % Signal-to-Noise Ratio in dB

% Simulation parameters
num_bits = 1000; % Number of bits to transmit

% Generate random data (0s and 1s)

data = randi([0, 1], 1, num_bits);

% Modulation
t = 0:T:(num_bits * T - T);
modulated_signal = zeros(size(t));
for i = 1:num_bits
if data(i) == 1
modulated_signal((i-1)*length(T)+1:i*length(T)) = A * cos(2*pi*f_mark*t((i-1)*length(T)
+1:i*length(T)));
else
modulated_signal((i-1)*length(T)+1:i*length(T)) = A * cos(2*pi*f_space*t((i-1)*length(T)
+1:i*length(T)));
end
end

% Add AWGN to the modulated signal

SNR = 10^(SNR_dB/10);
noise_power = A^2 / (2 * SNR);
noisy_signal = awgn(modulated_signal, SNR_dB, 'measured', 'linear');

% Demodulation
demodulated_data = zeros(1, num_bits);
for i = 1:num_bits
mark_amplitude = sum(noisy_signal((i-1)*length(T)+1:i*length(T)) .* cos(2*pi*f_mark*t((i-1)*length(T)
+1:i*length(T))));
space_amplitude = sum(noisy_signal((i-1)*length(T)+1:i*length(T)) .* cos(2*pi*f_space*t((i-1)*length(T)
+1:i*length(T))));

% Decision based on which frequency has higher amplitude

demodulated_data(i) = (mark_amplitude > space_amplitude);
end

% Calculate Bit Error Rate (BER)

ber = sum(data ~= demodulated_data) / num_bits;

% Plot the Modulated and Noisy Signals

figure;

subplot(2, 2, 1);
plot(t, modulated_signal);
title('BFSK Modulated Signal');
xlabel('Time');
ylabel('Amplitude');

subplot(2, 2, 2);
plot(t, noisy_signal);
title('Noisy Signal (AWGN)');
xlabel('Time');
ylabel('Amplitude');

% Constellation Plot
subplot(2, 2, 3);
scatter(real(noisy_signal), imag(noisy_signal));
title('Constellation Plot');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');

% BER Performance
subplot(2, 2, 4);
bar([0, 1], [num_bits - sum(data), sum(data)], 'r');
hold on;
bar([0, 1], [sum(demodulated_data == data), num_bits - sum(demodulated_data == data)], 'b');
title(['Bit Error Rate (BER): ' num2str(ber)]);
xlabel('Transmitted Bit');
ylabel('Number of Bits');
legend('Transmitted', 'Received', 'Location', 'NorthEast');

hold off;
Output:
For BASK:

clc;
close all;
clear all;
% BASK Modulation and Demodulation with AWGN Channel

% Parameters
A1 = 1; % Amplitude for binary 1
A0 = 0; % Amplitude for binary 0
T = 1 / 1000; % Symbol duration (1 ms)
SNR_dB = 10; % Signal-to-Noise Ratio in dB

% Simulation parameters
num_bits = 1000; % Number of bits to transmit

% Generate random data (0s and 1s)

data = randi([0, 1], 1, num_bits);

% Modulation
t = 0:T:(num_bits * T - T);
modulated_signal = zeros(size(t));
for i = 1:num_bits
if data(i) == 1
modulated_signal((i-1)*length(T)+1:i*length(T)) = A1 * square(2*pi*(1/T)*t((i-1)*length(T)
+1:i*length(T)));
else
modulated_signal((i-1)*length(T)+1:i*length(T)) = A0 * square(2*pi*(1/T)*t((i-1)*length(T)
+1:i*length(T)));
end
end

% Add AWGN to the modulated signal

SNR = 10^(SNR_dB/10);
noise_power = A1^2 / (2 * SNR);
noisy_signal = awgn(modulated_signal, SNR_dB, 'measured', 'linear');

% Demodulation
demodulated_data = zeros(1, num_bits);
for i = 1:num_bits
demodulated_data(i) = (sum(noisy_signal((i-1)*length(T)+1:i*length(T))) > 0);
end

% Calculate Bit Error Rate (BER)

ber = sum(data ~= demodulated_data) / num_bits;

% Plot the Modulated and Noisy Signals

figure;

subplot(2, 2, 1);
plot(t, modulated_signal);
title('BASK Modulated Signal');
xlabel('Time');
ylabel('Amplitude');

subplot(2, 2, 2);
plot(t, noisy_signal);
title('Noisy Signal (AWGN)');
xlabel('Time');
ylabel('Amplitude');

% Constellation Plot
subplot(2, 2, 3);
scatter(real(noisy_signal), imag(noisy_signal));
title('Constellation Plot');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');

% BER Performance
subplot(2, 2, 4);
bar([0, 1], [num_bits - sum(data), sum(data)], 'r');
hold on;
bar([0, 1], [sum(demodulated_data == data), num_bits - sum(demodulated_data == data)], 'b');
title(['Bit Error Rate (BER): ' num2str(ber)]);
xlabel('Transmitted Bit');
ylabel('Number of Bits');
legend('Transmitted', 'Received', 'Location', 'NorthEast');

hold off;

OUTPUT:
For QPSK:

clc;
close all;
clear all;
% QPSK Modulation and Demodulation with AWGN Channel

% Parameters
A = 1; % Amplitude for each symbol
T = 1 / 1000; % Symbol duration (1 ms)
SNR_dB = 10; % Signal-to-Noise Ratio in dB

% Simulation parameters
num_bits = 1000; % Number of bits to transmit

% Generate random data (0s and 1s)

data = randi([0, 1], 1, num_bits);

% Convert binary data to QPSK symbols

symbols = 2*data(1:2:end) - 1 + 1i*(2*data(2:2:end) - 1);

% Modulation
t = 0:T:(num_bits/2 * T - T);
modulated_signal = A * symbols;

% Add AWGN to the modulated signal

SNR = 10^(SNR_dB/10);
noise_power = A^2 / (2 * SNR);
noisy_signal = awgn(modulated_signal, SNR_dB, 'measured', 'linear');

% Demodulation
demodulated_symbols = noisy_signal / A;

% Convert symbols back to binary data

demodulated_data = zeros(1, num_bits);
demodulated_data(1:2:end) = real(demodulated_symbols) > 0;
demodulated_data(2:2:end) = imag(demodulated_symbols) > 0;

% Calculate Bit Error Rate (BER)

ber = sum(data ~= demodulated_data) / num_bits;

% Plot the Modulated and Noisy Signals

figure;

subplot(2, 2, 1);
plot(real(modulated_signal), imag(modulated_signal), 'o');
title('QPSK Modulated Signal');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');
axis square;

subplot(2, 2, 2);
plot(real(noisy_signal), imag(noisy_signal), 'o');
title('Noisy Signal (AWGN)');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');
axis square;

% Constellation Plot
subplot(2, 2, 3);
scatter(real(noisy_signal), imag(noisy_signal));
title('Constellation Plot');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');

% BER Performance
subplot(2, 2, 4);
bar([0, 1], [num_bits - sum(data), sum(data)], 'r');
hold on;
bar([0, 1], [sum(demodulated_data == data), num_bits - sum(demodulated_data == data)], 'b');
title(['Bit Error Rate (BER): ' num2str(ber)]);
xlabel('Transmitted Bit');
ylabel('Number of Bits');
legend('Transmitted', 'Received', 'Location', 'NorthEast');

hold off;

OUTPUT:
For BPSK:

clc;
close all;
clear all;
% BPSK Modulation and Demodulation with AWGN Channel

% Parameters
A = 1; % Amplitude for both binary 0 and 1
T = 1 / 1000; % Symbol duration (1 ms)
SNR_dB = 10; % Signal-to-Noise Ratio in dB

% Simulation parameters
num_bits = 1000; % Number of bits to transmit

% Generate random data (0s and 1s)

data = randi([0, 1], 1, num_bits);

% Modulation
t = 0:T:(num_bits * T - T);
modulated_signal = A * cos(2*pi*(1/T)*t + pi*(data-0.5));

% Add AWGN to the modulated signal

SNR = 10^(SNR_dB/10);
noise_power = A^2 / (2 * SNR);
noisy_signal = awgn(modulated_signal, SNR_dB, 'measured', 'linear');

% Demodulation
demodulated_data = (noisy_signal > 0);

% Calculate Bit Error Rate (BER)

ber = sum(data ~= demodulated_data) / num_bits;

% Plot the Modulated and Noisy Signals

figure;

subplot(2, 2, 1);
plot(t, modulated_signal);
title('BPSK Modulated Signal');
xlabel('Time');
ylabel('Amplitude');

subplot(2, 2, 2);
plot(t, noisy_signal);
title('Noisy Signal (AWGN)');
xlabel('Time');
ylabel('Amplitude');

% Constellation Plot
subplot(2, 2, 3);
scatter(real(noisy_signal), imag(noisy_signal));
title('Constellation Plot');
xlabel('In-Phase (I)');
ylabel('Quadrature (Q)');

% BER Performance
subplot(2, 2, 4);
bar([0, 1], [num_bits - sum(data), sum(data)], 'r');
hold on;
bar([0, 1], [sum(demodulated_data == data), num_bits - sum(demodulated_data == data)], 'b');
title(['Bit Error Rate (BER): ' num2str(ber)]);
xlabel('Transmitted Bit');
ylabel('Number of Bits');
legend('Transmitted', 'Received', 'Location', 'NorthEast');

hold off;

OUTPUT:

4).Demonstarte DS OR FH spread spectrum system

clc;
close all;
clear all;

% Spread Spectrum Systems Simulation

% Parameters
fs = 100; % Sampling frequency
T = 1; % Total time duration
fc = 50; % Carrier frequency
SNR_dB = 10; % Signal-to-Noise Ratio in dB
% Generate a binary signal
data = randi([0 1], 1, fs*T);

% Direct Sequence (DS) Spread Spectrum

chipping_code = 2*data - 1; % Convert to bipolar
ds_modulated_signal = kron(chipping_code, ones(1, fs));

% Frequency Hopping (FH) Spread Spectrum

hop_indices = randi([1, fs], 1, fs*T); % Random frequency hopping indices
fh_modulated_signal = zeros(1, fs*T);

for i = 1:length(data)
fh_modulated_signal((i-1)*fs + 1:i*fs) = cos(2*pi*(fc+hop_indices(i))/fs*(1:fs));
end

% Add noise to both signals

noise = randn(1, length(ds_modulated_signal));
SNR_linear = 10^(SNR_dB / 10);
scaled_noise = noise / sqrt(SNR_linear);
ds_received_signal = ds_modulated_signal + scaled_noise;

noise = randn(1, length(fh_modulated_signal));

scaled_noise = noise / sqrt(SNR_linear);
fh_received_signal = fh_modulated_signal + scaled_noise;

% Plotting
figure;

subplot(3,2,1);
plot(data, 'LineWidth', 1.5);
title('Binary Data');

subplot(3,2,2);
plot(ds_modulated_signal, 'r', 'LineWidth', 1.5);
title('DS Modulated Signal');

subplot(3,2,3);
plot(data, 'LineWidth', 1.5);
title('Binary Data');

subplot(3,2,4);
plot(fh_modulated_signal, 'r', 'LineWidth', 1.5);
title('FH Modulated Signal');

subplot(3,2,5);
plot(ds_received_signal, 'g', 'LineWidth', 1.5);
title('DS Received Signal with Noise');

subplot(3,2,6);
plot(fh_received_signal, 'g', 'LineWidth', 1.5);
title('FH Received Signal with Noise');
OUTPUT:

5).Demonstrate Huffman and Shannon Fano coding

Huffman coding:
clc;
clear all;
close all;
probabilities=[1/5 1/5 3/5 2/15 2/15];
probabilities=probabilities/sum(probabilities);

for index=1:length(probabilities)
codewords{index}=[];
set_contents{index}=index;
set_probabilities(index)=probabilities(index);
end

while length(set_contents)>1
[temp,sorted_indices]=sort(set_probabilities);
zero_set=set_contents{sorted_indices(1)};
zero_probability=set_probabilities(sorted_indices(1));

for codeword_index=1:length(zero_set)
codewords{zero_set(codeword_index)}=[codewords{zero_set(codeword_index)},1];
end
one_set=set_contents{sorted_indices(2)};
one_probability=set_probabilities(sorted_indices(2));

for codeword_index=1:length(one_set)
codewords{one_set(codeword_index)}=[codewords{one_set(codeword_index)},0];
end
 set_contents(sorted_indices(1:2))=[];
set_contents{length(set_contents)+1}=[zero_set,one_set];

set_probabilities(sorted_indices(1:2))=[];
set_probabilities(length(set_probabilities)+1)=zero_probability+one_probability;
end

for index=1:length(codewords)
disp([num2str(index),' ',num2str(probabilities(index)),' ',num2str(codewords{index}
(length(codewords{index}):-1:1))])
end

entropy=sum(probabilities.*log2(1./probabilities))

av_length=0
for index=1:length(codewords)
av_length=av_length+probabilities(index)*length(codewords{index});
end

disp(['the symbol entropy is:',num2str(entropy)])

disp(['the average huffman codeword length is:',num2str(av_length)]);
disp(['the efficiency is:',num2str(entropy/av_length)]);

OUTPUT:

1 0.15789 0 0 1
2 0.15789 0 0 0
3 0.47368 1
4 0.10526 0 1 1
5 0.10526 0 1 0

entropy =

2.0353

av_length =

the symbol entropy is:2.0353

the average huffman codeword length is:2.0526
the efficiency is:0.99158

Shannon fano coding:

clc;
clear all;
close all;
m=input('Enter the no. of message ensembles : ');
z=[];
h=0;l=0;
display('Enter the probabilities in descending order');
for i=1:m
fprintf('Ensemble %d\n',i);
p(i)=input('');
end
%Finding each alpha values
a(1)=0;
for j=2:m;
a(j)=a(j-1)+p(j-1);
end
fprintf('\n Alpha Matrix');
display(a);
%Finding each code length
for i=1:m
n(i)= ceil(-1*(log2(p(i))));
end
fprintf('\n Code length matrix');
display(n);
%Computing each code
for i=1:m
int=a(i);
for j=1:n(i)
frac=int*2;
c=floor(frac);
frac=frac-c;
z=[z c];
int=frac;
end
fprintf('Codeword %d',i);
display(z);
z=[];
end
%Computing Avg. Code Length & Entropy
fprintf('Avg. Code Length');
for i=1:m
x=p(i)*n(i);
l=l+x;
x=p(i)*log2(1/p(i));
h=h+x;
end
display(l);
fprintf('Entropy');
display(h);
%Computing Efficiency
fprintf('Efficiency');
display(100*h/l);
fprintf('Redundancy');
display(100-(100*h/l));
INPUT:
Enter the no. of message ensembles :
5
Enter the probabilities in descending order
Ensemble 1
0.5
Ensemble 2
0.5
Ensemble 3
0.4
Ensemble 4
0.3
Ensemble 5
0.2

OUTPUT:
Alpha Matrix
a = 0 0.5000 1.0000 1.4000 1.7000
Code length matrix
n=1 1 2 2 3
Codeword 1
z=0
Codeword 2
z =1
Codeword 3
z =2 0
Codeword 4
z =2 1
Codeword 5
z =3 0 1
Avg. Code Length
l =3
Entropy
h =2.5142
Efficiency 83.8082
Redundancy 16.1918

6) Demonstrate BER performance of digital communication system employing BPSK

modulation scheme with (a) Block coding scheme OR (b) Convolution. assume AWGN
channel.

Block coding scheme:

clc;
close all;
clear all;
%% Parameters
N = 10^4; % Number of bits (reduced for demonstration)
EbN0dB = 0:1:10; % Eb/N0 range in dB
EbN0 = 10.^(EbN0dB/10); % Eb/N0 in linear scale
nBitsPerSymbol = 1; % For BPSK
codeRate = 1/2; % Coding rate (for repetition code)

%% Initialization
ber = zeros(size(EbN0));

%% Simulation
for idx = 1:length(EbN0)
% Generate random bits
txBits = randi([0,1], 1, N);

% BPSK modulation
txSymbols = 1 - 2*txBits; % Mapping 0 to 1 and 1 to -1

% Block coding (Repetition code)

odedSymbols = kron(txBits, ones(1, 1/codeRate));

% Adding noise
noise = sqrt(1/(2*codeRate*EbN0(idx))) * randn(1, length(codedSymbols));
rxSymbols = codedSymbols + noise;

% Demodulation
rxBits = rxSymbols < 0; % Decision rule for BPSK

% Decoding (for repetition code)

decodedBits = sum(reshape(rxBits, 2, [])).' > 1; % Reshape into 2 rows, column count determined
automatically

% Truncate decodedBits to match the length of txBits

decodedBits = decodedBits(1:N).';

% Debugging: Check lengths of decodedBits and txBits

disp(['Length of decodedBits: ', num2str(length(decodedBits))]);
disp(['Length of txBits: ', num2str(length(txBits))]);

% Calculate BER using only N bits

ber(idx) = sum(decodedBits ~= txBits) / N;
end

%% Plotting
semilogy(EbN0dB, ber, 'bo-');
grid on;
xlabel('Eb/N0 (dB)');
ylabel('Bit Error Rate (BER)');
title('BER Performance of BPSK with Repetition Coding (1/2)');

OUTPUT:
Length of decodedBits: 10000
Length of txBits: 10000
Convolution method:
clc;
close all;
clear all;
%% Parameters
N = 10^6; % Number of bits
EbN0dB = 0:1:10; % Eb/N0 range in dB
EbN0 = 10.^(EbN0dB/10); % Eb/N0 in linear scale
nBitsPerSymbol = 1; % For BPSK
constraintLength = 7; % Constraint length of the convolutional code
codeRate = 1/2; % Coding rate (for convolutional code)

%% Initialization
ber = zeros(size(EbN0));

%% Convolutional Encoder
trellis = poly2trellis(constraintLength, [171 133]); % Define the convolutional code
convEncoder = comm.ConvolutionalEncoder(trellis); % Create a convolutional encoder object

%% Viterbi Decoder
vitDecoder = comm.ViterbiDecoder(trellis, 'InputFormat', 'Hard'); % Create a Viterbi decoder object

%% Simulation
for idx = 1:length(EbN0)
% Generate random bits
txBits = randi([0,1], 1, N);
% Convolutional encoding
codedBits = convEncoder(txBits.');
% BPSK modulation
txSymbols = 1 - 2*codedBits; % Mapping 0 to 1 and 1 to -1
% Adding noise
noiseVar = 1 / (2*codeRate*EbN0(idx)); % Noise variance
noise = sqrt(noiseVar) * randn(size(txSymbols));
rxSymbols = txSymbols + noise;
% Demodulation
rxBits = rxSymbols < 0; % Decision rule for BPSK

% Convert rxBits to ufix(1) data type

rxBits = fi(rxBits, 0, 1, 0); % Cast to ufix(1) data type

% Reshape rxBits to process each channel separately

rxBits = reshape(rxBits, [], size(txBits, 1)); % Reshape to have one channel per column

% Viterbi decoding
decodedBits = [];
for i = 1:size(rxBits, 2)
decodedBits = [decodedBits; vitDecoder(rxBits(:, i)).']; % Decode each channel separately
end

% Reshape decodedBits to match the size of transmitted bits

decodedBits = decodedBits(:).';

% Calculating BER
ber(idx) = sum(decodedBits ~= txBits) / N;
end

%% Plotting
semilogy(EbN0dB, ber, 'bo-');
grid on;
xlabel('Eb/N0 (dB)');
ylabel('Bit Error Rate (BER)');
title('BER Performance of BPSK with Convolutional Coding');

OUTPUT:
7) Plot the radiation plot of microstrip antenna using antenna design tool box

Fig(2):Radiation Pattern

Fig(3): S Parameter Plot