Design and Implementation of Efficient Codes for MIMO Wireless

Telecommunication Systems
Hamad El Gibreen, Awadh Abu-Fahesh, Ahmad Al-Issa & Saeed Al-Shehri

MOTIVATION METHODOLOGY EXPERIMENTAL RESULTS

“Zero Forcing Only” Simplification: -1

V-BLAST performance at NT= 2 MR= 2 and at 4 bps/Hz
0
V-BLAST performance at NT= 4 MR= 4 and at 8 bps/Hz
10 10
ZF

Why this Project ? The received signal in a MIMO system is represented by: -2
10 10
-1

 The main objective of this project is to linearly simplify the algorithms of

BER

BER
-3 -2
10 10

general Matlab functions which have been used for MIMO systems
To solve for x , we know that we need to find a matrix which satisfies WH= I . The Zero -4
10 10
-3

Forcing (ZF) linear detector for meeting this constraint is given by:

Why do we need to bother simplifying these functions

-5 -4
10 10
10 15 20 25 30 35 40 10 15 20 25 30 35 40
SNR in dB SNR in dB

when the simulation is already working? So, since we were primarily focusing on 2x2/4x4 implementation, we came up with
Fig. 4: Performance output of 2x2 MIMO System using ZF Only.
Fig. 5: Performance output of 4x4 MIMO System using ZF Only
different methods to simplify this equation
 Implementable code V-BLAST performance at NT= 4 MR= 4 and at 8 bps/Hz V-BLAST performance at NT= 4 MR= 4 and at 8 bps/Hz

to have the final product easily implemented on hardware of the available

-1 -1
10 10

• Using Regular Inverse for 2x2 and 4x4 ZF MIMO:

MIMO system in the department. Here, and since we are working with equal rows/columns matrices, we decided to start out
2x2/4x4 optimization
-2 -2
10
by replacing the generalized inverse with regular inverse
10

it was decided to make the simplification optimized mainly for 2x2 and 4x4
• Using Linear Simplification for 2x2 ZF MIMO:

BER
-3

BER
systems; this was due to the lack of time available to do it for all scenarios in
-3
10 10

addition to the similarity of 2x2/4x4 MIMO to real life situations (4G LTE, WiFi, for us to extract the transmitted symbol x ,we multiply by the inverse of H:
Which, for 2x2 systems, will be equivalently:
-4 -4
10

etc…).
10

 Less memory and processing consumption 10

-5
-5
10

With the developed simplification, implementing it for the available hardware as

10 15 20 25 30 35 40 10 15 20 25 30 35 40
Converting it into linear equations instead of matrix format, along with ignoring the noise: SNR in dB SNR in dB

well as expanding it for other –more complex- systems will save a lot of and
processing time and power. Also, the consumption of memory (RAM and ROM) Fig. 6: Performance output of 4x4 MIMO Fig. 7: Performance output of 4x4 MIMO
• Using Linear Simplifications for 4x4 ZF MIMO: System using ZF-SIC Without ordering System using ZF-SIC With ordering.
in the hardware is also remarkably reduced
This linear simplification can be expanded for 4x4 matrices, we used the regular (linear) V-BLAST performance at NT= 4 MR= 4 and at 8 bps/Hz V-BLAST performance at NT= 4 MR= 4 and at 8 bps/Hz
concept to find the inverse; which can be generally derived as the following: 10
0
10
0

For a 4x4 matrix A and 10

-1
10
-1

the inverse matrix of A are ;

MECHANISMS
-2 -2
10 10

BER

BER
-3 -3
10 10

Zero Forcing With Successive Interference Cancellation: -4 -4

10 10

• ZF-SIC without ordering simplifications for 4x4 MIMO: 10

-5
10
-5

ZF-SIC is an expansion of regular ZF equalizer. So, when looking into the original code of it
10 15 20 25 30 35 40 10 15 20 25 30 35 40
SNR in dB SNR in dB

This project was mainly on 4x4 MIMO systems, and it was mainly focused
on:
• Linear simplification of Zero Forcing (ZF) algorithms for 2x2 and 4x4
MIMO systems.
there are minor improvements over the “ZF Only” one. The original code is shown below.
Fig.8: Performance output of 4x4 MIMO System
• ZF-SIC With Ordering Simplifications for 4x4 MIMO: using different signal detection schemes (original code)
Fig.9: Performance of 4x4 MIMO System using
different signal detection schemes (simplified code)
Using this method, we can find out the transmit symbol (after multiplication with the
channel) which came at higher power at the receiver. Therefore, there are slight
differences between this approach and the previous one.
function function

• Linear simplification of V-BLAST (ZF-SIC) without optimal ordering

FUTURE WORK
BE=ZFBLASTNoOrder(r,H,SignalSet,Modulation,Input, BE=ZFBLASTOrder(r,H,SignalSet,Modulation,Input,BitMapping,SimTy
BitMapping,SimType) pe)

algorithms for 4x4 MIMO systems. %%% V-Blast Detector With ZF without Ordering %%% V-Blast Detector With ZF without Ordering

• Linear simplification of V-BLAST (ZF-SIC) with optimal ordering global NTx MRx qset global NTx MRx qset

algorithms for 4x4 MIMO systems. G=ZFInvers(H); G=ZFInvers(H);

• Performance comparisons between the developed simplifications and the

HH=H; HH=H;

original code, in addition to performance comparisons between the

for ii=1:NTx %%%%% try to convert this into
linear equations
%kk=TrackOrder(G);%% kk will have the decoding order of V-Blast Inserting our simplified implementation code into the available MIMO
different simplified techniques. w=G(1,:);
BE=0;
hardware in the department successfully
for ii=1:NTx
y=w*r; %% Interfernce Nulling
k(ii)=MinNorm(G);
Simulating it in real time and compare these results to our simulated ones
a(ii)=Detector(y,SignalSet,1); %% detection
w=G(k(ii),:);  out that other scenarios can be simplified linearly for the available
r=r-H(:,ii)*SignalSet(a(ii)); %%Interfernece
Cancellation y=w*r; %% Interfernce Nulling hardware implementation (1x4, 2x4, 3x4 MIMO and vice versa).
HH(:,1)=[]; a(ii)=Detector(y,SignalSet,1); %% detection

% HH(:,1)=zeros(MRx,1); BE=BE+BECalculator(Input(k(ii)),a(ii),BitMapping);%%%
Calculat the Bit Errors
G=ZFInvers(HH);
switch SimType
end
case 1
BE=BECalculator(Input,a,BitMapping);%%% Calculat
the Bit Errors if BE>0

switch SimType BE=1;

case 1 return;

if BE>0 end
Figure1: General MIMO System case 2
BE=1; %FER counter
Diagram
end end

case 2 r=r-HH(:,k(ii))*SignalSet(a(ii)); %%Interfernece

Cancellation
end
HH(:,k(ii))=[]; %% remove the kth culomn
Figure 2: original code of Figure 3: orginial code of
Input(k(ii))=[]; %% remove theZFBLAST with
kth symbol order
ZFBLASTNoOrder function function
%HH(:,k)=zeros(MRx,1);