University of Saskatchewan 5-1 EE 392 Electrical Engineering Laboratory III

Transcription

1 University of Saskatchewan 5-1 DSP Safety The voltages used in this experiment are less than 15 V and normally do not present a risk of shock. However, you should always follow safe procedures when working on any electronic circuit. Assemble or modify a circuit with the power off or disconnected. Don t touch different nodes of a live circuit simultaneously, and don t touch the circuit if any part of you is grounded. Don t touch a circuit if you have a cut or sore that might come in contact with a live wire. Check the orientation of polarized capacitors before powering a circuit, and remember that capacitors can store charge after the power is turned off. Never remove a wire from an inductor while current is flowing through it. Components can become hot if a fault develops or even during normal operation so use appropriate caution when touching components. Objectives: In this laboratory, you will develop a digital audio reverberator. In the process, you will study some basic tools of digital signal processing (decimation, FIR filtering, interpolation), design practical algorithms to implement them, and gain experience with the architecture and instruction set of the Blackfin 533 DSP. Equipment: You will need a Blackfin 533 EZ-lite development board (available in the technician s office), a digital spectrum analyzer, an oscilloscope, and a signal generator. To hear the reverberation effect you will need a microphone and speaker. Preparation: You should have completed the introduction to VisualDSP++ exercise that is part of either EE391 or EE362. You should know how to create, add files to, and build a project. You should also review the architecture of the Blackfin 533 DSP; that is you should know the core register sets and what each is typically used for. An acquaintance with the more common instructions and the assembler is very helpful. The relevant documentation can be downloaded from the EE392 website. Since the Blackfin documentation runs to several thousand pages, you are not expected to read it all before the lab. Theory: A reverberation circuit basically adds-in delayed versions of a signal to produce an echo effect. The sound quality achieved through reverberation depends on the number, gains, and lengths of the delays and how the delayed signals are added. A simple and a more sophisticated reverberator are shown in Fig. 1. In the simple reverberator, the output is delayed by N, multiplied by a gain (that should be less than one), and added into the signal. A problem with the simple design is that the response depends on frequency. The more sophisticated design also uses a single delay but produces a flat response and is called an all-pass reverberator. Since the delays can be quite large especially to achieve an echo effect, implementation of the reverberator is aided by first reducing the data rate of the signal through decimation. Decimation consists of two steps, filtering and down-sampling. Down-sampling is simple; to down-sample by a factor of k, one keeps every kth sample and throws the rest away. The data rate is thereby reduced by a factor of k. However there is a down-side to downsampling; the Nyquist frequency is also reduced by a factor of k. If the Nyquist frequency

2 University of Saskatchewan 5-2 Fig. 1 A simple reverberator (left) and an all-pass reverberator (right) for the original sampling rate is f N, then the Nyquist frequency of the down-sampled signal is f N / k. If frequency components above f N / k are present in the signal then they will be aliased below f N / k. Once aliasing occurs, it is impossible to remove through further processing resulting in permanent distortion to the signal. To prevent the aliasing, the signal must first be filtered to remove the frequencies above f N / k. A FIR filter implements the function N"1 # y[n] = c[i] x[n " i] i=0 x[n] is the input stream, and y[n] is the output. N is the number of taps, and for each tap there is a coefficient c. The coefficients are calculated to achieve, in this case, a low-pass filter with the desired cut-off frequency. An implementation of a FIR filter is shown in Fig.2; inserting the filter before the down-sampler forms the decimator (Fig. 3). Once the decimated signal has passed through the reverberator, the data rate needs to be restored to the original value. Increasing the data rate is done using an interpolator. Interpolation consists of two steps: up-sampling and filtering. Up-sampling by k consists of inserting k " 1 samples between every two samples of the input stream. Doing so increases the sample rate by a factor of k. You might think the inserted values should be carefully calculated, perhaps using a linear or spline function. In fact, it doesn t matter what values are inserted since the output needs to be filtered anyway; so it is common practice to insert zeros; this is known as zero stuffing. Up-sampling produces spectral images at multiples of the incoming data rate. A low-pass filter with a cut-off below the Nyquist frequency of the input stream is necessary to remove the unwanted images. A diagram of an interpolator Fig. 2 FIR filter implementation

3 University of Saskatchewan 5-3 Fig. 3 Decimator Fig. 4 Interpolator using an FIR filter is shown in Fig. 4. Procedure: 1. (0.5h) The first step is design. You need to decide on the decimation factor, the decimation filter cut-off frequency, the reverberation delay and gain, and the interpolation filter cut-off frequency. The audio codec on the EZ-lite module samples at 48 KHz. At this sample rate, each second of delay requires storing samples. The Blackfin DSP is capable of buffers that big, but for this design, you are to use buffers of no more than 2000 samples. Decide on a suitable delay and gain that should produce an interesting effect (echo, echo, echo, echo, echo). The reverberation in a small concert hall might be only tens of milliseconds, but for a large venue or in the mountains, the echo might be delayed by half a second to several seconds. Using the maximum delay you feel is needed, calculate the decimation factor needed to stay within the 2000 sample restriction. The decimation factor determines the Nyquist frequency of the down-sampled data stream and hence the filter cut-offs. (Do the calculations in your notebook!) 2. (0.25h) Create the project. Since it is unreasonable to expect you to code the complete program in six hours, a skeleton program is provided. Download the REVERB.zip file from the EE392 website and expand the file. Start the VisualDSP++ IDE, and create a new project in the REVERB folder; the default preferences are acceptable. If you are asked if kernel support should be included, answer no (the kernel is a small operating system supplied by Analog Devices that runs on the Blackfin DSP; the Colonel sells chicken). Add to the project all the *.asm and *.h files. Here is a brief description of what is in each file. startup.asm startup.h main.asm init.asm is mysterious code supplied by Analog Devices; it contains the entry point for the program. Don t touch. is the header file for startup.asm. Don t touch. contains the main routine that is called after the startup code finishes. Look but don t touch. contains a series of subroutines that set the innumerable internal registers that control various aspects of the processor. Don t touch. allocate_globals.h allocates memory for variables and buffers. included in main.asm and nowhere else. globals.h DAG.asm ez_lite.h general.h This header file is contains.extern directives for each global variable. Any file that includes globals.h will have access to all the global variables. contains code that initializes the circular delay buffers. is just some constants related to the development board. contains the constants related to the reverberator and the filters.

4 University of Saskatchewan 5-4 interrupts.asm FIR.asm reverb.asm FIRcoeffs.dat contains the interrupt service routine (ISR) that is called each time the audio codec sends data. All your code goes into the ISR, so you will modify this file quite a bit. contains the subroutine that implements the FIR filter. Putting the FIR code in a separate file makes the ISR a bit neater. contains the subroutine that implements the reverberator. Putting the reverb code in a separate file makes the ISR neater still. is not part of the project but is a text file that contains the FIR filter coefficients. 3. (1h) The complete reverberator will be built in stages. After each stage you will investigate the functioning of the stage with actual signals. The first stage is already done for you. The code, as is, simply passes values straight through the DSP. Whatever signal goes into the left channel 0 ADC comes out the left channel 0 DAC. Build the project and run the program. Make the following measurements. a) Input a sine wave and observe the output. Does the output match the input? If not what is different? Vary the frequency and find the cut-off frequency of the on-board filters. Vary the amplitude and determine the voltage at which clipping occurs. Determine the frequency at which the output is phase-shifted by 2π. b) Input a pulse and observe the output. Calculate the pulse width that produces only a single non-zero sample. Can you observe any output using this pulse width? The output should be the impulse response of the on-board anti-aliasing and reconstruction filters, but it might be too small to measure. Increase the pulse width until a nice pulse appears at the output and measure the time delay. How is the time-delay related to the frequency at which the phase shift is 2π? c) Use the spectrum analyzer to measure the gain response from 0 to 25KHz. Use white noise for the source and average about 1000 spectra. 4. (1.25h) Time to start coding. In the second stage you will program the down-sampler and the up-sampler. Since you need to down-sample and up-sample by the same factor K, it is convenient to program both together. The algorithm is as follows. at each interrupt: load the incoming value into a register (use register R0.H) load decimate_counter subtract one from the counter if (counter > 0) { } else { } output: store counter value in decimate_counter set R0.H to 0 jump to output reset decimate_counter to decimate_by (K) jump to output

5 University of Saskatchewan 5-5 output R0.H to DAC Follow through the algorithm, and notice that for the first K " 1 interrupts, zeros are output (this part is the zero stuffing up-sampler). But on the Kth interrupt, the value from the ADC is allowed to fall through to the output (this part is the down-sampler). Open the file interrupts.asm in the IDE. The interrupt service routine is the only subroutine in the file. Find the section titled left channel 0. Notice there are a lot of comments but little code. Your job is to insert the code; the comments are there to guide you. Some items are already done for you. The value from the ADC is loaded into R0.H. decimate_counter is a global variable that is allocated in allocate_globals.h. The constant K is called decimate_by and is defined in general.h; you should set this constant to the value you determined in step 1. Further down, just before right channel 0, is code that sends R0.H to the DAC. Code the rest of the algorithm; it helps to insert the instructions in front of the appropriate comments. Once the algorithm is complete, build the project and run the program. Then make the following measurements. a) Input a sine wave at a frequency well below the Nyquist frequency of the down-sampled data rate. Observe the output on the oscilloscope and the spectrum analyzer. Notice the spectral images of the input frequency caused by the up-sampling. b) Increase the frequency to greater than the Nyquist frequency and observe the spectrum. Notice the aliased peak below the Nyquist frequency caused by the down-sampling. c) Input a pulse as in part 3b and compare the output to what was observed before. 5. (1.5h) Add a filter. In the next stage, you will add the FIR filter to make the decimator. The code for the filter is contained in the file FIR.asm; open this file and read the description of the subroutine. Most of the code has been written for you with the exception of the loop that actually calculates the filter s output value. In that part of the code, you will use three features of the DSP that separate it from an ordinary microprocessor, namely zero-overhead looping, automatic circular buffers, and a dedicated multiply-andaccumulate. The algorithm is as follows: set up a zero-overhead loop to execute N " 1 times (where N is the number of taps) { } load the coefficient c[i] in R1.L and post-decrement the pointer load x[n " i] into R1.H and post-increment the circular buffer index register multiply and add to the accumulator A1 (a single instruction) load the final coefficient c[0] in R1.L load x[n] in R1.H and post-increment the circular buffer index register multiply and add to the accumulator; round, saturate and transfer the value to R0.H Remarkably, the last step is accomplished with a single instruction; another feature of this DSP. Circular buffers are extremely useful for implementing delays. Essentially a circular buffer is a buffer (an array of values in memory) that has an index (a pointer to a value in the buffer) that returns to the start of the buffer whenever it goes past the end. Incrementing the index loops through the buffer over and over. Implementing a circular buffer on a

6 University of Saskatchewan 5-6 conventional microprocessor requires continually comparing the index to the end of the buffer and subtracting the length of the buffer when the index goes past the end. All that is taken care of automatically by a unit of the Blackfin DSP called the Data Address Generator (DAG). The Blackfin DSP contains four circular buffers; each one is controlled by a set of three registers: the base register Bx that points to the start of the buffer, the length register Lx which stores the length of the buffer in bytes, and the index register Ix which is used to access locations in the buffer. The delayed input values for the FIR filter are stored in circular buffer 0 which uses B0, L0, and I0. The memory for the buffer is allocated in allocate_globals.h using the constant FIR_buf_length that is defined in general.h. B0, L0, and I0 are initialized by the subroutine Init_DAG in the file DAG.asm. Complete the FIR16 subroutine by implementing the above algorithm (the missing part requires just nine instructions). Now return to the interrupt service routine. You need to insert the single instruction that stores the values from the ADC into the circular buffer. Only a single instruction is needed because the store instruction also updates the index register, and the DAG unit takes care of maintaining the index register within the circular buffer. The next step is to do the filtering. Where should the call to FIR16 be placed? Figure 3 shows the filter before the down-sampler. However, the down-sampler throws most of the values away, and it makes no sense to calculate the output of the filter if the value is never used. So FIR16 should be called only when decimate_counter reaches 0. The proper place to put the call is after the label process_data. You need to setup the registers properly as described in the comments in FIR.asm. B0, L0, and I0 are already setup but P2 needs to be loaded with the number of coefficients (numfirtaps defined in general.h) and P3 needs to point to the table of coefficients (FIR_coeff from allocate_globals.h). Now you can call FIR16. The filtered value is returned in R0.H. The coefficients are loaded into memory automatically by the assembler from the file FIRcoeffs.dat. The final step is to calculate the coefficients and put them in FIRcoeffs.dat. Filter design is a complicated but important part of digital signal processing. Fortunately, MATLAB toolbox routines do all of the tedious calculations. Open MATLAB, and type help fir1. fir1(n, W) is a routine to calculate FIR coefficients using the window method. Notice that the routine requires two arguments: the order of the filter N (uses N+1 coefficients) and the cut-off frequency W. You should start with a filter of order 30; if time permits, you might want to try out different numbers of coefficients. The cut-off frequency is given as a fraction of the Nyquist frequency; use the value you calculated in step one. Issue the command B = fir1(n, W) and then the command B. You should now have a list of coefficients that you can highlight and copy. Back in VisualDSP++, open the file FIRcoeffs.dat and paste-in the values. With a bit of luck, the filter should now working. Open the file general.h and change decimate_by to 1; with this value the down-sampler and up-sampler are effectively removed. Rebuild your project and run the program. Make the following measurements. a) Input a sine wave. Vary the frequency and find the cut-off frequency of the FIR filter. b) Use the spectrum analyzer to measure the response of the FIR filter. In MATLAB, calculate the theoretical response using freqz(b) and compare to the measured response.

7 University of Saskatchewan 5-7 Now set decimate_by back to its previous value. program. Then make the following measurements. Rebuild your project and run the a) Input a sine wave at a frequency well below the Nyquist frequency of the down-sampled data rate. Observe the output on the oscilloscope and the spectrum analyzer. Notice that the spectral images of the input frequency caused by the up-sampling are still present. b) Increase the frequency to greater than the Nyquist frequency and observe the spectrum. Notice that the FIR filter eliminates the aliasing. 6. (0.5h) Add another filter. In the next stage, you will add the FIR filter after the upsampler to make the interpolator. Since the up-sampler uses the same K as the downsampler, you can use the same filter. Open the file interrupts.asm and find the location for the interpolator. To use the filter, the up-sampled data stream needs to be stored in a circular buffer. Memory has already been allocated in allocate_globals.h and the DAG 2 registers have already been initialized in DAG.asm. All you have to do is store register R0.H (which contains the up-sampled data) in the location pointed to by I2 and postincrement I2. Now setup the registers for the FIR16 call. One immediate problem is that FIR16 expects the circular buffer to use the DAG 0 registers. The easiest thing to do is push B0, L0, and I0 onto the stack and then move B2 into B0, L2 into L0, and I2 into I0. Then setup P2 and P3 as you did before and call FIR16. After the call, restore B0, L0, and I0 from the stack. Rebuild the project. Run the program and verify that your interpolator is now working. a) Input a sine wave at a frequency well below the Nyquist frequency of the down-sampled data rate. Observe the output on the oscilloscope and the spectrum analyzer. Notice that the spectral images of the input frequency caused by the up-sampling are gone. b) Increase the frequency to greater than the Nyquist frequency and observe the spectrum. Notice that the FIR filters now suppress the output signal. 7. (1h) Add the reverberator. Open the file reverb.asm. Read the comments and implement the simple reverberator of Fig. 1 so that the subroutine works as described. Finally, open interrupts.asm and find the place to add the reverberator, just after the decimator filter. We need yet another circular buffer for the reverberator delay. DAG 1 is already set up for this purpose and all you need to do is store the output of the decimator s filter using I1 and post-increment I1 (a single instruction). Then load R0.L with reverb_gain and P1 with reverb_delay and call reverb1. Build your project and run the program. The reverberation effect is best seen on the oscilloscope using a pulsed input. But it is optimal to just listen to it using a microphone and a speaker. Change the values of reverb_delay and reverb_gain and see what effects you can produce. Each change will require a rebuild.