Experiment 4

Please note the correction in III.4, you are supposed to use a time scale of 0.05 ms, and not 0.05 s as mentioned earlier.

Objective: Generating bandpass WGN and studying the effect of AWGN on DSB-SC AM.

Description: In this experiment you will generate bandpass white Gaussian noise using two different methods. Then, you will see the effect of this noise on a DSB-SC system.

Instructions

• I. Initialization: Copy the initialization files for the experiment into your Matlab working directory. Note that the initialization files have changed

  The following constants should be set by the startup file. Use who in the matlab workspace to check if the constants are all there. Some additional constants may also be set, but you may ignore them. Set the simulation time to T_SIM and the sample time to T_SAMPLE in the simulink models you construct.

  • F_CARR = 2*pi*5e05 ----------Carrier Frequency, rad/sec
  • T_PERIOD = 2*pi/F_CARR ------Time period of carrier
  • T_SAMPLE = T_PERIOD/4.01 ----Sampling period used in Simulink
  • T_SIM = 0.002 s ---------- --Total simulation time
  • BW_MESSAGE = 2*pi*2e04 ------Message Bandwidth.
  • F_CUTOFF = BW_MESSAGE -------Cutoff frequency of lowpass Butterworth filter
  • N_0 = 0.01 ---------------------Power of noise

• II. Generating bandpass white noise
  1. Use the ece359lib/White Noise block to generate zero mean white gaussian noise. The noise power spectral density is already set to N_0/2. Pass this noise through the ece359lib/Band Pass filter block (bandwidth=2F_CUTOFF, and center frequency F_CARR). The resulting signal is the bandpass noise n1 (t).
  2. Use the HF scope and 359 PSD blocks from ece359lib to observe the time and frequency domain characteristics of n1 (t). The HF scope works in the same way as in the previous experiments (help available here).
  3. Print the PSD of n1 (t).

• III. Componentwise generation of bandpass noise
  (This part will use many blocks, so try and space blocks close together)
  1. Generate two lowpass noise processes n_s, n_c(t) using the ece359lib/White Noise and ece359lib/low pass filter blocks. To make the two processes independent, change the random number generator seed in one of the blocks.
  2. Produce the signal
     
     n2(t) = n_s(t) sin(w0 t) + n_c(t) cos(w0 t).
     
     Here w0 refers to the carrier frequency F_CARR. (You are free to use multipliers and sine and cosine generators )
     
     
  3. Use the HF scope to see the lowpass signals n_c(t), n_s(t) and also the bandpass signals n2(t), n_c(t) cos(w0 t), n_s(t) sin(w0 t). Save all these signals in the workspace using the save to workspace option of scope.
  4. Use the subplot function of matlab to plot the three bandpass signals above on the same figure (use subplot(3,1,row_number)). On this scale, it is difficult to observe the difference between the sine and cosine components.
     On a separate figure with an enlarged time scale, plot on the same axis (overlap the plots using hold on, and make one of the plots to be a dotted line) the two signals n_c(t) cos(w0 t), n_s(t) sin(w0 t). Your entire time scale should be no more than 0.05 ms. This plot shows how the two components of noise differ.
  5. Use the ece359lib/359 PSD block to plot the PSD of n2(t).

  IV. DSB-SC performance in bandpass noise
  (We will use DSB-SC system as in simulink #2.)

  1. Construct a DSB-SC transmitter/receiver. Let the message signal m(t) be a sinusoid of frequency BW_MESSAGE/2 and amplitude 100. The modulating waveform is a cosine wave with zero phase shift, frequency F_CARR and amplitude 1. For the low pass filter at the receiver, use ece359lib/DSB-Low Pass block.
  2. We will add noise to the modulated signal s(t) of DSB-SC and observe the result at the demodulator. Suppose you used variable name n2 to save the bandpass noise in part III. Now use the ece359lib/From Workspace block to input this signal into simulink.
  3. To measure the noise level of the demodulated signal, we will need to resort to some indirect methods. Pass the source signal m(t) through the same lowpass filter that you used in the demodulator. This gives us a version of the source signal delayed by the same amount as the demodulated signal. Call this signal m1(t).
  4. Multiply the demodulated signal by 2 and call the resulting signal v(t). Subtract the signal m1(t) from it. Call the resulting signal n_r(t).

     n_r(t) = v(t) - m1(t)

     Save n_r(t) to the workspace using the scope.

  5. Use subplot to plot both n_c(t) and n_r(t) on the same figure. Compare the shape of the two signals.