Wireless Standards: Key Performance Measurements

Wireless Standards: Key Performance Measurements

Bit Error Rate (BER): A crucial measure of communication system performance, BER is the ratio of erroneous bits received to the total number of bits transmitted1. A low BER indicates a reliable, high-quality link, while a high BER reflects poor performance2. Errors can occur due to noise, interference, fading, or distortion in the communication channel3.

Packet Error Rate (PER): PER is a key indicator of communication quality that measures how many transmitted packets fail to be received correctly4. A high PER often leads to frequent retransmissions and can be caused by interference or poor link conditions5.

Block Error Ratio (BLER): This is the ratio of erroneous blocks received to the total number of blocks transmitted6. A block is considered erroneous if its cyclic redundancy check (CRC) fails7. BLER helps in evaluating system performance under different channel conditions and data rates8.

Throughput: Throughput is the actual rate at which data is successfully transmitted over a channel within a specific time period9. It is a measure of the effective data transfer rate, taking into account factors like network congestion and protocol overhead10.

Capacity: This is a network design requirement that defines the number of devices a wireless network can support simultaneously11. It is based on factors such as the applications used, bandwidth consumption, and the number of available Wi-Fi radios12.

Adjacent Channel Leakage Ratio (ACLR): Also known as Adjacent Channel Power Ratio (ACPR), ACLR quantifies the amount of power that leaks from a desired channel into adjacent channels13. It is expressed as the ratio of power in the desired channel to the power in each adjacent channel14.

Error Vector Magnitude (EVM): EVM is a critical metric that quantifies the difference between an ideal, perfectly modulated signal and the actual, measured signal15. A lower EVM indicates a higher-quality signal.

MATLAB Program and Outputs

The following MATLAB code snippets and their corresponding outputs illustrate how to simulate each of these performance metrics.

BER

This code simulates the Bit Error Rate for a given range of Eb/No values.

Matlab

clc;

clear all;

close all;

numBits = 10000;

EbNo_db = 0:2:20;

ber = zeros(size(EbNo_db));for idx = 1:length(EbNo_db)

EbNo_linear = 10^(EbNo_db(idx)/10);

No = 1/EbNo_linear;

noise_var = No/2;

txBits = randi([0, 1], 1, numBits);

txSymbols = 2*txBits - 1;

noise = sqrt(noise_var)*randn(1, numBits);

rxSymbols = txSymbols + noise;

rxBits = rxSymbols > 0;

numErrors = sum(txBits ~= rxBits);

ber(idx) = numErrors/numBits;end

semilogy(EbNo_db, ber, 'o-');

grid on;

xlabel('EbNo_db');

ylabel('bit error rate');

title('ber vs EbNo');

PER

This script calculates the Packet Error Rate for a QPSK-modulated signal over a range of SNR values.

Matlab

clc;

clear all;

close all;

modulation_order = 4;

num_symbols_per_packet = 100;

num_packets = 1000;

snr_range = -10:1:20;

per_range = zeros(size(snr_range));for snr_idx = 1:length(snr_range)

snr_linear = 10^(snr_range(snr_idx)/10);

packet_errors = 0;

for packet_idx = 1:num_packets

tx_symbols = randi([0, modulation_order-1], 1, num_symbols_per_packet);

tx_signal = qammod(tx_symbols, modulation_order);

noise_power = 1/(2*snr_linear);

noise = sqrt(noise_power) * (randn(size(tx_signal)) + 1i * randn(size(tx_signal)));

rx_signal = tx_signal + noise;

rx_symbols = qamdemod(rx_signal, modulation_order);

if any(tx_symbols ~= rx_symbols)

packet_errors = packet_errors + 1;

end

end

per_range(snr_idx) = packet_errors/num_packets;endfigure;

semilogy(snr_range, per_range);

xlabel('SNR (dB)');

ylabel('Packet Error Rate (PER)');

title('Packet Error Rate (PER) vs SNR for QPSK Modulation');

grid on;

BLER

This program computes the Block Error Ratio versus SNR.

Matlab

clc;

clear all;

close all;

SNRdB = -5:1:15;

numBits = 1000;

BER = zeros(size(SNRdB));

Bler = zeros(size(SNRdB));for snrIdx = 1:length(SNRdB)

SNR = 10^(SNRdB(snrIdx)/10);

numErrors = 0;

numBlocks = 0;

while numErrors < 100 && numBlocks < 1000

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

modulatedData = 2*data - 1;

noise = sqrt(1/(2*SNR)) * randn(1, numBits);

receivedData = modulatedData + noise;

demodulatedData = receivedData > 0;

numErrors = numErrors + sum(demodulatedData);

numBlocks = numBlocks + 1;

end

BER(snrIdx) = numErrors / (numBits * numBlocks);

Bler(snrIdx) = numErrors > 0;endfigure;

semilogy(SNRdB, Bler, 'bo-');

xlabel('SNR (dB)');

ylabel('Block Error Rate (BLER)');

title('Block Error Rate vs SNR');

grid on;

Throughput

This code calculates and plots throughput as a function of Eb/No.

Matlab

clc;

clear all;

close all;

bandwidth = 10e6;

modulation_order = 4;

EbNo_dB = 0:2:20;

EbNo = 10.^(EbNo_dB/10);

Es = 2*(modulation_order / log2(modulation_order));

Eb = Es/log2(modulation_order);

C = bandwidth*log2(1+EbNo);

throughput = C / bandwidth;figure;

semilogy(EbNo_dB, throughput, 'b.-');

grid on;

xlabel('Eb/No (dB)');

ylabel('Throughput (bps/Hz)');

title('Throughput Performance');

Capacity

This script simulates the channel capacity for a QPSK modulation scheme over a range of SNR values.

Matlab

clc;

clear all;

close all;

modulation_order = 4;

channel_bandwidth = 10e6;

snr_range = -10:1:20;

capacity_range = zeros(size(snr_range));for i = 1:length(snr_range)

snr_linear = 10^(snr_range(i)/10);

capacity_range(i) = channel_bandwidth * log2(1 + snr_linear);endfigure;plot(snr_range, capacity_range/1e6);

xlabel('SNR (dB)');

ylabel('Capacity (Mbps)');

title('Capacity vs SNR for QPSK Modulation');

grid on;

ACLR

This program simulates and calculates the Adjacent Channel Leakage Ratio.

Matlab

clc;

clear all;

close all;

modulation_order = 4;

num_symbols = 10000;

sampling_rate = 10e6;

tx_symbols = randi([0, modulation_order-1], 1, num_symbols);

tx_signal = qammod(tx_symbols, modulation_order);

noise_power = 0.01;

noise = sqrt(noise_power) * (randn(size(tx_signal)) + 1i*randn(size(tx_signal)));

rx_signal = tx_signal + noise;

N = length(rx_signal);

fft_rx = fftshift(fft(rx_signal, N))/N;

freq_range = linspace(-sampling_rate/2, sampling_rate/2, N);

central_channel_idx = N/2;

adjacent_channel_idx = round(N/4);

acpr = 20*log10(abs(fft_rx(adjacent_channel_idx)) / max(abs(fft_rx)));disp(['Adjacent Channel Power Ratio (ACPR): ' num2str(acpr) ' dB']);figure; subplot(2, 1, 1);plot(freq_range, 10*log10(abs(fft_rx).^2));

xlabel('Frequency (Hz)');

ylabel('Power Spectral Density (dB/Hz)');

title('Received Signal Spectrum');

EVM

This code calculates the Error Vector Magnitude and plots the constellation and error diagrams.

Matlab

clc;

clear all;

close all;

modulation_order = 4;

num_symbols = 10000;

tx_symbols = randi([0, modulation_order-1], 1, num_symbols);

tx_signal = qammod(tx_symbols, modulation_order);

noise_power = 0.01;

noise = sqrt(noise_power) * (randn(size(tx_signal)) + 1i * randn(size(tx_signal)));

rx_signal = tx_signal + noise;

ev = tx_signal - rx_signal;

evm = norm(ev) / norm(tx_signal);disp(['Error Vector Magnitude (EVM): ' num2str(evm)]);figure;

subplot(1, 2, 1);scatter(real(rx_signal), imag(rx_signal), 'b.');hold on; scatter(real(tx_signal), imag(tx_signal), 'ro');

xlabel('In-Phase');

ylabel('Quadrature');

title('Received Constellation Diagram');legend('Received', 'Ideal');

subplot(1, 2, 2);scatter(real(ev), imag(ev), 'g.');

xlabel('In-Phase Error');

ylabel('Quadrature Error');

title('Error Vector Magnitude (EVM)');

Procedure and Result

The general procedure for running these simulations is as follows:

Start MATLAB16.

Open a new M-file (script)17.

Type the program code18.

Save the file in the current directory19.

Run (execute) the program20.

View the output in the Command Window or Figure Window21.

Stop or close the program22.

The result is that the performance measurements such as BER, PER, BLER, throughput, capacity, ACLR, and EVM for 4G and 5G wireless standards were successfully analyzed using MATLAB23.

CHANGE FONT COLOUR TO WHITE EXCEPT CODE