Fundamentals of Wireless Communication

Transcription

1 Communication Technology Laboratory Prof. Dr. H. Bölcskei Sternwartstrasse 7 CH-8092 Zürich Fundamentals of Wireless Communication Homework 5 Solutions Problem 1 Simulation of Error Probability When implementing simulations, it is important to compute only the quantities that are necessary. The simulation you were asked to perform in this homework is on the same level of abstraction as used in class to describe wireless communication systems. Hence, it suffices to consider discretetime systems, with timestep commensurate with the symbol rate. This type of simulation is commonly used to complement theoretical investigations. For real system design, the effects that need to be considered range from impairments of the analog circuits, over synchronization and channel estimation, to finite precision number representation. A simulation taking into account all these points needs to operate at a much higher sampling rate, and thus will consume much more computation time. The starting point, however, is the same the discrete-time symbol-synchronous simulation developed in this homework. To get the comparison between the noncoherent and coherent schemes right, it is important to have the same SNR in both cases. Just considering E s /N 0 is not sufficient, because the symbol duration is different for the two settings, and hence the average signal power is different, too: in the noncoherent case, only every second time slot contains energy, while for coherent detection, energy E s is transmitted in every time slot. Therefore, you need to s symbols with amplitude 2E s in part (i), and with amplitude E s in part (ii). Note furthermore that it is only the ratio E s /N 0 that is important, hence we can normalize the noise power, i.e., N 0 = The noncoherent receiver computes the square of the received signal, and compares the energy in two successive time slots. The decision rule is given in the lecture notes on page 23. The simulation code in the following is written in Matlab, not because it is my favorite programming language, but because it has already a lot of build-in functionality you would need to implement yourself otherwise. The drawback, however, is speed if not done properly, Matlab code can be quite slow. The key is to use vector notation whenever possible, so that fast matrix/vector subroutines can be used. As a rule of thumb, a for loop as the inner loop of your code is suspicious. To allow Matlab to use fast vectorized subroutines 1, the following simulation code always operates on blocks of transmitted symbols instead of treating every symbol separately. I chose a block size of 1000 rather arbitrarily. Other block sizes should work as well, as long as they are not too big (they might not fit into the cache of the CPU), or too small (too many branching instructions need to be processed). The transmitted symbols in the following code are organized in a matrix. All relevant functions, like the random number generators, can return matrices as well, so that all 1 Matlab is designed around the LAPACK numerical algorithms, which in turn build on BLAS (basic linear algebra subroutines), which are often provided as highly optimized libraries by CPU vors. For more information on how to speed up Matlab code, have a look at the online documentation.

2 computations are completely vectorized. If you are not familiar with a particular function used in the code, look for its definition in the online help. function [Pe, SNR] = fading_error_nc(snr_min,snr_max,snr_step,errorcount) % simulates noncoherent detection for orthogonal signaling over a flat % Rayleigh fading channel % The error probability Pe is evaluated using Monte Carlo simulation for % several SNR values between SNR_min and SNR_max, with stepsize SNR_step; % SNR is measured in db. % For each SNR value, as many transmissions are simulated as needed to % obtain at least errorcount errors. blocklength = 1000; counter = 0; for snr = SNR_min:SNR_step:SNR_max counter = counter + 1; snrlin = 10^(snr/10); symbolcount = 0; errors = 0; while errors < errorcount % number of simultaneous transmissions % for matrix indexing % for evey SNR value % linear SNR % number of transmitted symbols % number of errors so far % check number of errors symbolcount = symbolcount + blocklength; % the symbols are the rows of this matrix, each row has exactly one % "0" and one "1" sig = randerr(blocklength,2); % the noise power is normalized to one, hence the signal power is % equal to 2*snrLin, because we need to average over two time slots txsig = sqrt(2*snrlin)*sig; % the channel, normalized to unit power, i.e., no path loss h = sqrt(1/2)*(randn(blocklength, 2)+ i*randn(blocklength,2)); % complex Gaussian noise, unit variance w = 1/sqrt(2)*(randn(blocklength, 2) + i*randn(blocklength,2)); % modulate with the channel, add noise rxsig = h.* txsig + w ; % square law receiver rxstat = abs(rxsig).^2; % the noncoherent detector: check which of the two time slots % contains more energy decision = rxstat(:,1) >= rxstat(:,2); errors = errors + sum(abs(sig(:,1) - decision)); % count errors Pe(counter) = errors / symbolcount; % estimate error probability SNR(counter) = snr; 2. The coherent receiver, under the assumption of perfect channel knowledge, projects the received signal r[m] onto the channel h[m]. It is convenient to normalize the result to 2

3 obtain h[m] r[m] h[m] = h[m] s[m] + h[m] w[m]. (1.1) h[m] The noise term in (1.1) is still circularly symmetric complex Gaussian with unit variance, because w[m] is simply rotated by a random amount. As the transmitted signal is real, we do not need to consider the imaginary part of the noise, so that for simulation purposes it is sufficient to consider real additive Gaussian noise of variance 1/2, according to our normalization. Note, however, that I still generate a circularly symmetric complex Gaussian channel, and subsequently compute the absolute value in the code below, instead of generating Rayleigh-distributed random variables right from the start. The reason is that the Rayleigh random number generator, as implemented in the Statistics Toolbox in Matlab, is quite slow. function [Pe, SNR] = fading_error_c(snr_min,snr_max,snr_step,errorcount) % simulates coherent detection for BPSK signaling over a flat Rayleigh % fading channel % The error probability Pe is evaluated using Monte Carlo simulation for % each SNR point between SNR_min and SNR_max, with stepsize SNR_step, % where SNR is measured in db. % For each SNR value, as many transmissions are simulated as needed to % obtain at least errorcount errors. blocklength = 1000; counter = 0; % number of simultaneous transmissions % for matrix indexing for snr = SNR_min:SNR_step:SNR_max % for evey SNR value counter = counter + 1; snrlin = 10^(snr/10); % linear SNR symbolcount = 0; % number of transmitted symbols errors = 0; % number of errors so far while errors < errorcount % check number of errors symbolcount = symbolcount + blocklength; % this row vector contains the message to be transmitted sig = randerr(1, blocklength, blocklength/2); % the symbols are antipodal, the noise power is normalized % to one, hence the signal power is equal to snrlin. txsig = sqrt(snrlin) * (2*sig - ones(1,blocklength)); % the channel h = 1/sqrt(2)*(randn(1, blocklength) + i*randn(1,blocklength)); % real noise n = 1/sqrt(2)*randn(1, blocklength); % the received signal after projection and taking the real part rxsig = abs(h).*txsig + n; % threshold detection around 0 decision = rxsig >= zeros(1, blocklength); errors = errors + sum(abs(sig - decision)); % count errors 3

4 Pe(counter) = errors / symbolcount; SNR(counter) = snr; % estimate error probability The simulation results are as expected and follow the analytical curves closely. The analytical error probabilities are given in the lecture notes as 1 P e,nc = 2(1 + snr), (1.2) P e,c = 1 ( ) snr 1, (1.3) snr ( ) P e,aw GN = Q 2snr. (1.4) Error Probability flat Rayleigh fading, noncoherent orthogonal modulation flat Rayleigh fading, coherent BPSK 10-5 BPSK over AWGN SNR (db) Figure 1.1: Error probabilities for signaling over a flat Rayleigh fading channel and an AWGN channel The above comparison is not completely fair, because we are comparing the error probability of two signaling schemes with different rates one bit per time slot for coherent BPSK and half a 4

5 bit per time slot for noncoherent orthogonal modulation. What is happening from a fundamental point of view is that we are using two different codes, i.e., we use to different ways of mapping the message to be transmitted into points in signal space. A fair comparison would use equal rate codes with equal blocklengths. However, there are good codes and bad codes; for a really fair comparison, we would need to compute the error probability for the respectively best codes with given blocklength and rate, a task which is quite difficult in general. However, we will see later on in the course how to characterize the ultimate performance limits of communication systems in terms of the capacity of the channel. The capacity characterizes the maximum rate achievable over a given channel with the best possible code, and for arbitrarily small error probability. Problem 2 Chain Rule for Entropy Note: We did not mark the base of the logarithms in this solution, as it is irrelevant in the derivation, as long as all bases are the same. Only the resulting numerical quantity will change according to the base. Logarithms to base 2 will yield the result in binary digits (bits), while natural logarithms will result in natural units (nats). The joint mutual information H(X, Y ) and the conditional mutual information H(Y X) both contain a summation over the elements of both the alphabets X and Y. A promising approach to combine the summations is thus to reformulate the problem to proof H(X) = H(X, Y ) H(Y X). The right hand side is H(X, Y ) H(Y X) = f X,Y (x, y) log f X,Y (x, y) + f X,Y (x, y) log f Y X (y x) = ( ) f X,Y (x, y) log f X,Y (x, y) log f Y X (y x) = f X,Y (x, y) log f X,Y (x, y) f Y X (y x) = f X,Y (x, y) log f X (x) }{{} f X (x) = f X (x) log f X (x) x X = H(X), where we used that f Y X (y x) = f X,Y (x, y)/f X (x). 5