5650 chapter4. November 6, 2015

Transcription

1 5650 chapter4 November 6, 2015 Contents Sampling Theory 2 Starting Point Lowpass Sampling Theorem Principle Alias Frequency Multirate Sampling Downsample Upsample Sampling Bandpass Signals Probability, Random Variables, & Random Sequences 12 Random Variables Auto and Cross Correlation Quantization 16 In [1]: %pylab inline #%matplotlib qt from future import division # use so 1/2 =, etc. import ssd import scipy.signal as signal from IPython.display import Audio, display from IPython.display import Image, SVG Populating the interactive namespace from numpy and matplotlib In [2]: pylab.rcparams[ savefig.dpi ] = 100 # default 72 #pylab.rcparams[ figure.figsize ] = (6.0, 4.0) # default (6,4) #%config InlineBackend.figure_formats=[ png ] # default for inline viewing #%config InlineBackend.figure_formats=[ svg ] # SVG inline viewing %config InlineBackend.figure_formats=[ pdf ] # render pdf figs for LaTeX 1

2 Sampling Theory Using Python it is easy to investigate, various aspects of sampling theory. In particular sampling theory and quantization can be studied. Starting Point Uniform sampling a continuous-time signal x c (t) using sampling period T Lowpass Sampling Theorem For signal x c (t) bandlimited such that x[n] = x c (nt ) (1) In rad/s: X c (jω) = In Hz: X c (f) = { nonzero, Ω Ω N 0, { otherwise nonzero, f f N 0, otherwise (2) (3) perfect reconstruction of the signal from its samples is possible using a lowpass reconstruction filter, provided you choose f s > 2f N Hz. When sampling is viewed in the frequency domain you get a clear view of how aliasing takes place through the superposition of spectral translates: X s (jω) = 1 T X(e jω ) = 1 T k= k= X c (jω jkω s ) (4) ( X c j ω T j 2πk ) T (5) Python can be used to visualize sampling theory in action. frequency. For starters consider the principle alias Principle Alias Frequency Given the sampling rate the principle alias frequency is given by ( ) f prin = round fin f s f in (6) For example, given an input frequency at 6 Hz and sampling frequency of 10 Hz use the function f prin = ssd.prin alias(f in,fs). In [3]: ssd.prin_alias(6.,10.) Out[3]: 4.0 f s 2

3 Example: Consider a range of f in then you can consider the corresponding principle alias values. In [4]: fs = 44.1 # khz fin = linspace(0,100.,200) fout = ssd.prin_alias(fin,fs) plot(fin,fout) xlabel( Input Frequency (khz) ) ylabel( Output Frequency (khz) ) title(r Principle Alias Frequencies for $f_s = 44.1$ khz ) 25 Principle Alias Frequencies for f s =44.1 khz Output Frequency (khz) Input Frequency (khz) Example Set f s = 20 khz and consider x c (t) = cos(2πf o t) with f 0 equal to 2 khz, 18 khz, and 22 khz. Check the principle alias frequencies: In [5]: ssd.prin_alias(array([2,18, 22]),2) #need to make sure f_in is an ndarray Out[5]: array([ 2., 2., 2.]) You see that all three f 0 values have the same principle alias. Plot the sampled signals to verify they are the same. In [6]: # fs = 20 khz fs = n = arange(0,50) x2 = sin(2*pi*2000/fs*n) x18 = sin(2*pi*18000/fs*n) x22 = sin(2*pi*22000/fs*n) subplot(311) 3

4 stem(n,x2) xlabel(r Index $n$ ) ylabel(r $x_2[n]$ ) title(r Compare $x[n]= x_c(nt)$ for Three $f_0$ Values ) subplot(312) stem(n,x18) xlabel(r Index $n$ ) ylabel(r $x_{18}[n]$ ) subplot(313) stem(n,x22) xlabel(r Index $n$ ) ylabel(r $x_{22}[n]$ ) tight_layout() x 2 [n] x 18 [n] x 22 [n] Compare x[n] =x c (nt) for Three f 0 Values Index n Index n Index n As expected all three waveforms are identical. See what happens if cos() is replaced by sin(). Explain what is happening. Also see notes Chapter 4 Example 4.3. Multirate Sampling Start with a signal having a bandlimited spectrum. Here I have chosen a triangle shape, which is a sinc 2 () in the time domain. In [7]: n = arange(-100,100) x = (sinc(2*pi*n/25.))**2 # create a signal with a triangle shaped spectrum stem(n,x) 4

5 grid() xlim([-20,20]) xlabel( Index n ) ylabel( Amplitude ); Amplitude Index n I now approximate the DTFT using freqz() and plot the magnitude spectrum. In [8]: f = arange(-1.5,1.5,.01) w,x = signal.freqz(x,1,2*pi*f) plot(f,abs(x)) xlabel(r Normalized Frequency $f = \omega/(2\pi)$ ) ylabel(r Spectrum $ X(e^{j 2\pi f/f_s})$ ) 5

6 Spectrum X(e j2πf/f s ) Normalized Frequency f =ω/(2π) Downsample Use the downsample() function in ssd: In [9]: # Downsample the triangle spectrum input by 2 xd = ssd.downsample(x,3) # Create a downsampled times (sequence) axis xd nd = ssd.downsample(n,3)/3 # Plot the result subplot(211) stem(nd,xd) xlim([-10,10]) xlabel(r Index n ) ylabel(r Amplitude of $x_d[n]$ ) title(r Downsample Bandlimited $x[n]$ Using $M=2$ ) # Plot the spectrum subplot(212) w,xd = signal.freqz(xd,1,2*pi*f) plot(f,abs(xd)) xlabel(r Normalized Frequency $f = \omega/(2\pi)$ ) ylabel(r Spectrum $ X_d(e^{j 2\pi f/f_s})$ ) grid() tight_layout() 6

7 Amplitude of x d [n] Spectrum X d (e j2πf/f s ) Downsample Bandlimited x[n] Using M = Index n Normalized Frequency f =ω/(2π) Upsample Use the upsample function in ssd: In [10]: # Upsample x by 2 xu = ssd.upsample(x,2) # Create an upsampled time axis nu = arange(2*n[0],2*n[-1]+2) # Plot the result subplot(211) stem(nu,xu) xlim([-20,20]) ylim([-.05,5]) xlabel( Index n ) ylabel(r Amplitude of $x_u[n]$ ) title(r Upsample Bandlimited $x[n]$ Using $L=2$ ) # Plot the spectrum subplot(212) w,xu = signal.freqz(xu,1,2*pi*f) plot(f,abs(xu)) xlabel(r Normalized Frequency $f = \omega/(2\pi)$ ) ylabel(r Spectrum $ X_u(e^{j 2\pi f/f_s})$ ) tight_layout() 7

8 Amplitude of x u [n] Spectrum X u (e j2πf/f s ) Upsample Bandlimited x[n] Using L = Index n Normalized Frequency f =ω/(2π) Sampling Bandpass Signals When the signal being sampled has a bandpass spectrum, that is the spectrum of the analog signal is zero everywhere except over a band of frequencies not centered on zero Hz, i.e., In rad/s: X c (jω) = In Hz: X c (f) = { nonzero, Ω l Ω Ω h 0, { otherwise nonzero, f l f f h 0, otherwise (7) (8) With the lowpass sampling theorem you have to sample at greater than the highest frequency, i.e., Ω s > 2Ω h rad/s (f s > 2f H Hz). With a bandpass signal it is possible to find lower sampling rates that allow recovery of the original x c (t) using a bandpass reconstruction filter. To explore this using Python the following function(s) allow the spectrum of a sampled bandpass signal to be displayed so you can see what works. Yes, there are papers written on the theory of bandpass sampling. Example 4.12, p. 4 45, of the Chapter 4 notes makes use of bandpass sampling to insure that one of the aliased spectral translates lies at f s /4. The minimum requirement is that the sampling rate must be greater than twice the signal bandwidth. For the bandpass definition above, let B = f h f l then f s > 2B. As you consider f s over the interval 2B < f s < 2f h not all values work. There are subintervals do work. The Python code allows you to explore the possibilities experimentally. In [11]: def BP_spec(f,fs,Ntranslates=10,B=(2,3)): """ Sampled bandpass signal spectrum plot f = frequency axis created using arange fs = sampling frequency 8

9 Ntranslates = the number of spectrum translates to use in the calculation B = (B_lower,B_upper) Mark Wickert March 2015 """ W = B[1]-B[0] X = BP_primP(f-B[0],W)+BP_primN(f+B[0],W) for k in xrange(ntranslates): plot(f,bp_primp(f-b[0]-k*fs,w)+bp_primn(f+b[0]-k*fs,w), b ) plot(f,bp_primp(f-b[0]+k*fs,w)+bp_primn(f+b[0]+k*fs,w), b ) plot(f,x, r ) title(r Sampled Signal Spectrum for $f_s$ = %2.2f % fs) ylabel(r Amplitude ) xlabel(r Frequency ) xlim([-2*b[1],2*b[1]]) def BP_primP(f,W=1): return ssd.tri(f-w,w)*ssd.rect(f-w/2,w) def BP_primN(f,W=1): return ssd.tri(f+w,w)*ssd.rect(f+w/2,w) Example: Consider a bandpass signal nonzero on the interval 8 to 10 Hz. Clearly f l = 8 Hz and f h = 10 Hz. The signal bandwidth is B = 10 8 = 2 Hz. The Python function BP spec uses a right triangle spectral shape where you specify the non-zero spectrm as B = (fl,fh), e.g., here B = (8,10). You can then specify the sampling rate fs and hown many spectral translates you want the function to plot over the interval that f covers by using f = arange(fmin,fmax,step size). Note: The number translates needed for an accurate plot increases as the sampling rate becomes small relative to the required lowpass sampling rate. If you are suspicious that a plot is missing some spectral translates, try increasing Ntranslates. The red spectrum is the original and the blue spectra are translates. Lowpass Sampling In [12]: f = arange(-20,20,.01) BP_spec(f,20,8,(8,10)) 9

10 Sampled Signal Spectrum for f s = 20 Amplitude Frequency No aliasing when choosing f s > 2f h = 20 Hz! Bandpass Sampling or Undersampling In [13]: f = arange(-20,20,.01) BP_spec(f,5,8,(8,10)) 10

11 Sampled Signal Spectrum for f s = 5.00 Amplitude Frequency Notice that f s = 15 > 2B = 4 Hz does indeed work. Try a lower values for f s : In [14]: f = arange(-20,20,.01) BP_spec(f,5.1,8,(8,10)) 11

12 Sampled Signal Spectrum for f s = 5.10 Amplitude Frequency Very nice, choosing f s = 5.1 Hz also works and provides some guardbands around the original red spectra for recovery using a bandpass filter! Probability, Random Variables, & Random Sequences Familiarity with discrete-time random processes is fundamental to understanding quantization noise as well as a few topics from statistical signal processing. The starting point is: A brief review of probability A brief review of random variables An introduction to discrete-time random (stochastic) processes Random Variables Working with random variables is easy when using pylab. In [15]: x1 = rand(100000)-1/2 x2 = 5*rand(100000)+3 In [16]: (var(x1),1/12) Out[16]: ( , ) In [17]: #This some comment subplot(311) hist(x1,50,normed=true); subplot(312) hist(x2,50,normed=true); 12

13 subplot(313) hist(x1+x2,50,normed=true); tight_layout() Auto and Cross Correlation When dealing with random processes (RPs) you frequently deal with the auto- and cross-correlatiuon between RPs. In digital comm.py there is a function xcorr() for estimating the time averaged correlation between two waveforms. """ Signature: dc.xcorr(x1, x2, Nlags) Docstring: r12, k = xcorr(x1,x2,nlags), r12 and k are ndarray s Compute the energy normalized cross correlation between the sequences x1 and x2. If x1 = x2 the cross correlation is the autocorrelation. The number of lags sets how many lags to return centered about zero """ In [18]: import digitalcom as dc Generate some test vectors of white (uncorrelated zero mean) noise and correlated (colored zero mean) noise. x 1 [n] is white noise of variance 1 x 2 [n] is white noise of variance 2 (independent, so also uncorrelated) from x 1 [n] y 1 [n] is a filtered version of x 1 [n] so it is correlated with x 1 [n] 13

14 The filter is defined as H(z) = Note: The filter DC gain is one since H(z = 1) = H(e j0 ) = 1. In [19]: x1 = randn(10000) x2 = randn(10000) y1 = signal.lfilter([1-.8],[1,-.8],x1) 1 a, a = (9) 1 az 1 The cov(x1,x2) function allows you to obtain the variance and covariance of the inputs as a 2D array or matrix C x1x 2 = [ ] σ 2 x1 C x1x 2 C x1x 2 σx 2 2 (10) Note: C x1x 2 = E{(x 1 [n] m x1 )(x 2 [n] m x2 )} which is equivalent to γ x1x 2 [k] at k = 0. In [20]: print( C_x1x2 = ) print(cov(x1,x2)) print( C_x1y1 = ) print(cov(x1,y1)) C x1x2 = [[ ] [ ]] C x1y1 = [[ ] [ ]] In [21]: figure(figsize=(6,5)) r_x1x1,k = dc.xcorr(x1,x1,100) subplot(311) plot(k,abs(r_x1x1)) ylabel(r Scaled $\phi_{x_1 x_2}[k]$ ) grid() r_x1x2,k = dc.xcorr(x1,x2,100) subplot(312) plot(k,abs(r_x1x2)) ylabel(r Scaled $\phi_{x_1 x_2}[k]$ ) ylim([0,1.2]) grid() r_x1y1,k = dc.xcorr(x1,y1,100) subplot(313) plot(k,abs(r_x1y1)) ylabel(r Scaled $\phi_{x_1 y_1}[k]$ ) xlabel(r Lags $k$ ) grid() tight_layout() 14

15 Scaled φ x1 x 2 [k] Scaled φ x1 x 2 [k] Scaled φ x1 y 1 [k] Lags k Note: In the cross correlation of plot 3 above, you expect the plot to represent a scaled version of the time reverse of the system impulse response, h[ k]. If the cross-correlation order is changed to r x1y1,k = dc.xcorr(y1,x1,100), then you expect a scaled estimate of h[n] to be returned. From notes page 4-85 it must be that the function dc.xcorr() has the correlation order reversed internally. The Filter Frequency Response In [22]: f = arange(0,.5,.001) w,h = signal.freqz([1-.8],[1,-.8],2*pi*f) plot(f,20*log10(abs(h))) xlabel(r Normalized Frequency $\omega/(2\pi)$ ) ylabel(r Filter Gain $ H(e^{j\omega{}}) ^2$ in db ) 15

16 0 Filter Gain H(e jω ) 2 in db Normalized Frequency ω/(2π) Quantization To model quantization there is a function in ssd.py called simplequant() """ Signature: ssd.simplequant(x, Btot, Xmax, Limit) Docstring: A simple rounding quantizer for bipolar signals having Btot = B + 1 bits. This function models a quantizer that employs Btot bits that has one of three selectable limiting types: saturation, overflow, and none. The quantizer is bipolar and implements rounding. Parameters x : input signal ndarray to be quantized Btot : total number of bits in the quantizer, e.g. 16 Xmax : quantizer full-scale dynamic range is [-Xmax, Xmax] Limit = Limiting of the form sat, over, none Returns xq : quantized output ndarray Notes The quantization can be formed as e = xq - x 16

17 Examples >>> n = arange(0,10000) >>> x = cos(2*pi*11*n) >>> y = sinusoidawgn(x,90) >>> yq = simplequant(y,12,1, sat ) >>> psd(y,2**10,fs=1); >>> psd(yq,2**10,fs=1) """ Using this function we can visualize the quantization noise on signals in the time domain and the frequency domain. In the case of the additive noise model for quantization error you have so the additive error with rounding is e[n], where ˆx[n] = x[n] + e[n] (11) e[n] U [ 2, ] 2 (12) and = X m /2 B. The quantizer dynamic range is ±X m and the total number of bits is B + 1 with B being effectively the magnitude bits and one sign bit. The assumption is e[n] is a white RP with variance σ 2 e = 2 /12 and autocorrelation sequence φ ee [k] = γ ee [k] = σ 2 eδ[k]. Suppose that X m = 1 and B + 1 = 14 bits. Let the test signal be a sinusoid with amplitude A < 0 to avoid saturation in the quantizer. The theoretical SNR Q is given by SNR Q = σ2 X σ 2 e (13) Here σ 2 x = A 2 /2 and σ 2 e = (X m /2 B ) 2 /12. In [23]: A = B = 14-1 Xm = 1 SNR_Q_dB = 10*log10(A**2/2/((Xm/2**B)**2/12)) print( SNR_Q = %6.2f db % SNR_Q_dB) SNR Q = 83 db In [24]: fs = # Sampling frequency (Hz) f0 = 1205 # Sinusoid frequency (Hz) A = # Sinusoid amplitude n = arange(0,100000) x = A*cos(2*pi*f0/fs*n) y = ssd.sinusoidawgn(x,snr_q_db) # set SNR to SNR_Q yq = ssd.simplequant(y,14,1, sat ) subplot(211) psd(y,2**12,fs=1); # FFT length is 4096 title(r Sinusoid + Noise to Model Quantization ) ylabel(r PSD (db) ) subplot(212) 17

18 psd(yq,2**12,fs=1); # FFT length is 4096 title(r Actual 12-Bit Quantized Sinusoid ) ylabel(r PSD (db) ) tight_layout() PSD (db) PSD (db) Sinusoid + Noise to Model Quantization Frequency Actual 12-Bit Quantized Sinusoid Frequency We see from the above plots that the two plots are very similar. Not also that the difference in db between the spectral peak and the noise floor is greater than SNR Q. This is because the spectrum resolution, which is inversely proportional to the FFT length, factors into the calculation. 18