Digital Signal Processing Laboratory Work S Laboratory Exercises with TMS320C6711 DSK

Transcription

1 Digital Signal Processing Laboratory Work 52145S Laboratory Exercises with TMS320C6711 DSK Miguel Bordallo University of Oulu Department of Electrical and Information Engineering Information Processing Laboratory December 3, 2009

2 Contents Contents Contents 1. Introduction General Information Development Environment Before You Begin Exercise Assignments Compilation and Execution Signal Generation Fast Fourier Transform Interpolation and Decimation A. Bit Reversal for FFT 20 B. The Overlap-Save Algorithm: An Example 21 C. Debugging on Workstations 23 C.1. Functions in the code template C.2. Debugging with Electric Fence D. Debugging Techniques 26 E. Tips 2 2

3 1 INTRODUCTION 1. Introduction 1.1. General Information Welcome to the Digital Signal Processing (DSP) Laboratory course! consists one exercise, and the assistant will be: The course 1. TMS320C67x exercise (Miguel Bordallo, TS317) This handout will contain the exercise instructions for the TMS320C67x exercise. When the exercise is completed, you will receive 3.5 credit points (2 credit units). The completed answers and all code written should be returned on paper to the corresponding assistant. For inquiries, you should also primarily contact the appropriate assistant. No grades will be given: each returned exercise will be either accepted or rejected. If an exercise is rejected, the assistant will give instructions which will help you to correct the answers or programs. There is no final exam in the course, but when returning the exercise work, be prepared to answer to a few oral questions. If you are an exchange student and need an international ECTS grade, you must ask for it when returning the work. If you are planning to graduate soon after completing the course, you should mention about it to the assistant. Otherwise the completion mark will be given within three weeks. In the beginning of the course, there is a voluntary initial lecture, where some general topics will be discussed and you will have a chance to register for the course. The course can be carried out either alone or in groups of maximum of two students. Each group should carry out the exercises theirself. The assistants will give advises on request. Copying code or answers from other groups is definitely prohibited, and will lead to penalties! Before starting the work each group must register by adding the member names to the registration list. After the initial lecture the list will be placed into the course material shelf in the third floor of Tietotalo building. You will get several parameters from the registration which you must use when making some of the exercises. Write them down here for the C67x-part: Parameter name Symbol Value Block length N 1 Filter length N 2 Interpolation factor F 3

4 1.2 Development Environment 1 INTRODUCTION Write the parameters also on the front page of the answer sheet. These instructions will be also placed into the shelf and they can be borrowed for copying. Only the first three parameters are needed for this exercise. You will need a key and an access permission for entering the development class room TS139. If you have the key for other student facilities, you can request the access permission personally from course assistants. You may create a temporary working directory into the development computers; however, it must be deleted after use! Always make backups e.g. on floppy disks. The development computer disks may be cleared without notice in advance. The finished exercise work should be returned before May 30, The returned report must contain answers for all questions, denoted as Qx.y in these instructions, and all written code in appendices. Additionally, you must demonstrate in the laboratory class that your program is working. If you are unable to finish the work in time, you should ask for additional time. During the C67x exercise, you will learn the following topics: Generation of sine signals using IIR filters Decimation Interpolation Implementation of a fast Fourier transform (FFT) DSP architecture and DSP-assembly coding Frame based filtering You should write the code for all exercises using the C-language, unless specifically required otherwise Development Environment TMS320C67x is Texas Instruments family of floating point digital signal processors. It is downward compatible with the TMS320C62x fixed point family, and has a Very Long Instruction Word (VLIW) -like architecture, developed by Texas Instruments and called VelociTI. Each 256-bit wide Instruction Fetch Packet (IFP) can contain up to simple 32-bit RISC (Reduced Instruction Set Computer) instructions, whose execution is started simultaneously at the same clock cycle. The instructions are pipelined: new instructions can be dispatched before earlier instructions have finished. There are special instructions for loading and storing data from and to memory; all arithmetic instructions can use directly only built-in registers. The instructions have flexible addressing modes: register direct, register indirect, and base+index modes are supported. Additionally, the index register can be post- or preincremented or decremented. There are two register sets, which both have sixteen 32-bit registers, 4

5 1.3 Before You Begin 1 INTRODUCTION or in total 32 registers. Two 32-bit registers can be combined into one 64-bit floating point or a 40-bit fixed point register. The DSP has plenty of computing resources: there are two multipliers and six arithmetic-logical units (ALUs). The TMS320C6711 DSP is attached to the DSP Starter Kit (DSK) where it is clocked at 150 MHz rate. The DSK contains power supply, 16 megabytes of SDRAM, 12 kilobytes of flash ROM, programmable LEDs, line in and speaker connectors, a codec containing 16-bit D/A and A/D converters, and finally a parallel port interface to the PC. The code development can be made with Code Composer Studio (CCS), which is an integrated development environment (IDE) containing code editor, C compiler, assembler, linker, debugger, and other utilities. The Code Composer Studio contains a firmware kernel called DSP/BIOS, which provides basic runtime services for scheduling tasks running on the DSP. The codec in the DSK uses direct memory access (DMA) to store sampled data into DSK memory and to play back sound from memory buffers. When a DMA transfer has completed collecting samples into a buffer and completed playing back a buffer, an interrupt is generated and the DMA is programmed to transfer the next buffer. Thus, the application will receive whole frames at once, and does not need to take care of collecting single samples. The code template (dsp_lab) used in this course includes a working program that records sound from the computer music player and plays it back into connected speakers. The same template can be also ran at workstation/pc computer (for example in the computers in class room TS13), in which case the sound is read from and written to a file and the created file is played back after the program execution. There are two C67x and two C55x platforms available, and they are located in room TS Before You Begin You can also take a look at these documents for more information: Official course information: kurssit/52145s.shtml Course homepage: courses/52145s/ TMS320C6000 Technical Brief: psheets/spru197d/spru197d.pdf Texas Instruments manuals: psheets/man_dsp.htm TMS320C6000 Programmer s Guide: psheets/spru19g/spru19g.pdf 5

6 1.3 Before You Begin 1 INTRODUCTION TMS320C6000 Optimizing C Compiler User s Guide: http: //focus.ti.com/general/docs/lit/getliterature.tsp? literaturenumber=spru17l&filetype=pdf TMS320C6000 CPU and Instruction Set Reference Guide: ti.com/sc/psheets/spru19f/spru19f.pdf Berkeley Design Technology, Inc. processor overviews: bdti.com/procsum/tic67xx.htm DSP Village Home: B. Champagne & F. Labeau (2003) Discrete Time Signal Processing Course Notes: html Nasser Kehtarnavaz & Burc Simsek (2000) C6x-Based Digital Signal Processing. Prentice Hall, New Jersey, 164 pp. Brian W. Kernighan & Dennis M. Ritchie (19) The C Programming Language, 2nd edition Introduction to C programming: research/tklab/courses/521419a/c_intro.html Electric Fence: efence.php You may use any published information for completing the work. In any case, you must always reference the original source if you directly cite some material (either text or code). You may discuss with other student groups about your problems, but you must write all code yourself! 6

7 2 EXERCISE ASSIGNMENTS 2. Exercise Assignments 2.1. Compilation and Execution Create a working directory for yourself under C:\students: 1. Double click on My Computer -icon with mouse. 2. Type C:\students to the address bar. 3. Select File New Folder. 4. Give an unique directory name for your project. You should use only letters a z and numbers 0 9 in filenames. 5. Close the window. Download and extract the exercise template as follows: 1. Start Mozilla Firefox by double clicking its icon on the desktop. 2. Enter URL courses/52145s/dsp_lab.zip. 3. Select Open with and 7-Zip.zip. Click OK. 4. Choose Edit Select All in the 7-Zip File Manager window and click on Extract. 5. Enter the full path to your project directory, for example C:\students\myproject. 6. Close the window and exit Firefox. Then you are ready to compile and execute the program. First turn on the DSK card and speakers, start Code Composer Studio, and open your new project: 1. Double click on the CCStudio 3.1 icon on the desktop. 2. Choose Project Open..., type C:\students\myproject (or whatever is your project directory) into the File name field, and press Enter. 3. Click on dsp_lab.pjt and click on Open. 4. If you get error dialogs saying CRegistryInfo::GetSABiosRegKey() could not find BIOS registry entries or The project you are opening is based upon an older CDB configuration file which must be converted to the new TConf Script (TCF) format, ignore the messages and click OK. 7

8 2.1 Compilation and Execution 2 EXERCISE ASSIGNMENTS 5. Compile the project by choosing Project Rebuild All. You may get some warnings, but there should be zero errors. In this case the project was built successfully. 6. Connect the CCS to the DSK by selecting Debug Connect. 7. Load the compiled program into the DSK by choosing File Load Program... and go to directory C:\students\myproject\Debug.. Click on dsp_lab.out and click on Open. 9. If you get error dialog window Data verification failed at address..., do this: a) Click Cancel to close the dialog and then click on OK to close the next dialog complaining A data verification error occurred, file load failed. b) Click on Debug Disconnect. c) Turn off and again on the power from the DSK card. d) Open the transparent lid on top of the DSK and press the round white button denoted as Reset. e) Go to step Finally, you may run the program by selecting Debug Run. The program should be now running and replaying all sound coming from the PC to the loudspeakers. You can not hear anything before playing some music: 1. Double click on foobar2000 icon on the desktop. 2. Choose Playlist Open. 3. Go to directory C:\music and select some ogg file to play. 4. Select Order: Repeat. The music will have rather poor quality, because the sampling rate is only 000 Hz. If you are having problems in compiling or running the program, check from Project Build Options that Compiler Basic Build Options are as follows: Target Version: 671x Generate Debug Info: Full Symbolic Debug Opt Speed vs Size: Speed Most Critical Opt Level: None Program Level Opt: None Also check that the cable from computer sound card is connected to the DSK line input and that the DSK output is connected to the loudspeakers, and the speakers are turned on. The DSK collects the samples from the A/D converter until a complete frame is ready. After that a software interrupt is generated, and the frame is delivered to

9 2.1 Compilation and Execution 2 EXERCISE ASSIGNMENTS the frame_full() function in file dsp_lab.c. To change the frame size, you must modify the file dsp_lab.c and change the parameter in the init_audio() function call inside the main() function. The function call argument specifies the buffer size in samples. Then you must rebuild the project and load the new program into the DSK. Q2.1 How many samples long the frame is by default? What is the frequency of the software interrupt, and how can you calculate it? With a sampling rate of 000Hz, what is the highest frequency that we can hear from the speakers? After you have tested that the program works, stop it by choosing Debug Halt. You can also compile, run, and stop the program by clicking on the corresponding icons at the left edge of the CCS window. You can use Code Composer Studio for developing your code, but because the code is ran on the DSP, it is difficult to debug: small bugs can crash the whole DSK and recovery will be difficult. You should instead download the exercise template package to UNIX workstation and develop and debug the code there as long as possible. Only when your code appears to be working properly, port it from the workstation to the DSP. The computer should have GNU C Compiler and GNU Make installed (the department Sun workstations eg. in class room TS13 are adequately equipped). You can run the program on UNIX as follows: 1. Open a terminal window with UNIX command line. 2. Create yourself a project directory: mkdir myproject; cd myproject 3. Download the template code: wget research/tklab/courses/52145s/dsp_lab.zip. 4. Extract it: unzip dsp_lab.zip. 5. Compile the program by running GNU make: gmake. 6. Run the program by typing gmake test. This command runs the audio program which reads the test song audio_in_be.raw (or audio_in_le.raw) and writes audio_out.raw. The resulting sound file is also played if the program sox is installed. You can use any text editor, for example nedit, for editing the files. See Appendix C for more information on using the functions in dsp_lab template. 9

10 2.2 Signal Generation 2 EXERCISE ASSIGNMENTS 2.2. Signal Generation An unit impulse { 1, when n = 0 x(n) = 0, when n 0 contains equally much energy at all frequencies. If we can design a filter, which allows exactly one frequency to pass and stops all other frequencies, and filter the unit impulse with this filter, we get an output signal which is pure sine wave at the pass frequency. This is possible to achieve using infinite impulse response (IIR) filters. Realizable IIR filters are characterized by the following recursive equation: y(n) = N k=0 Transfer function of the IIR filter is b k x(n k) H(z) = M k=1 N b k z k k=0 (1) a k y(n k) (2) (3) 1+ M a k z k k=1 An IIR filter, which passes only one frequency, has the following coefficients: b 1 = gsin(2π f/f s ) (4) a 0 = 1 (5) a 1 = 2cos(2π f/f s ) (6) a 2 = 1 (7) where g = filter gain, f = filter pass frequency, and F s = sampling frequency. All other b n and a n, which are not shown, are zero. Q2.2 Implement an IIR filter that produces a sinewave. Add the generated signal to the sound stream. Generate the sinewave at 300 Hz. Code the function in a way that the frequency and the sampling rate of the generated signal can be easily changed. Remember from the previous section that signal processing is performed using frames: the frame_full() function is called each time when a new frame fills, and it must process all samples in a frame. This is shown in Figure 1. The easiest way is to modify the sine_gen() function in the template code to calculate the sine samples with the IIR filter instead of calling sinf() function. The sine_gen() function should return next sample of the sinewave each time it is called. Write a 10

11 2.3 Fast Fourier Transform 2 EXERCISE ASSIGNMENTS loop that goes over all samples in a received frame, adds sine samples to them, and writes the result into the output frame. You can edit dsp_lab.c file with the CCS by double clicking at Projects dsp_lab.pjt dsp_lab.c. You should also select DSP/BIOS Message Log which opens a panel displaying any messages from the running program 1. If you wish to debug the program using CCS, choose View Watch Window, where you can add variables to see their value. Then use single step and step over commands to execute the program line by line. As a result, you should hear an additional sound in the music coming from the loudspeakers. Q2.2 Modify the function now in a way that several frequencies can be generatd. The function now should alternate amont three frequencies from time to time. Make the function generate a sine on 300Hz during about one second, then a sine on 1000Hz for another second, then a sine on 5000Hz and back to 300Hz. As a result, you should here different pitches of beeping alternating in time in the music coming from the loudspekers. frame_full(buffer_size, src_sample, dst_sample) buffer_size samples Input frame src_sample Output frame dst_sample + sine_gen() Figure 1: Implementation of a Sine Generator Fast Fourier Transform Filtering is often performed using finite impulse response (FIR) filters. That corresponds to the convolution of the signal and the filter coefficients. However, a long 1 Currently there is a problem with this. If you get an error dialog saying Unknown error, the Message Log is not available. We try to solve the problem. 11

12 2.3 Fast Fourier Transform 2 EXERCISE ASSIGNMENTS filter requires much computation. How could we perform the filtering with less operations? According to the convolution theorem, convolution of two signals (the actual signal and the filter) corresponds to multiplication of the Fourier transformed signals. Using the Fourier transform, the computation requirements can be lowered: the filter coefficients are transformed, the signal to be filtered is transformed, the transformed sequences are multiplied together element-by-element, and finally the result is inverse transformed. Mathematically, the convolution can be represented as y(t) = x(t) c(t) () where x(t) is the original signal, as a function of time, y(t) is the filtered signal, and c(t) are the filter coefficients. The operation denotes convolution. By applying the Fourier transform and the convolution theorem, we get Y( f) = X( f)c( f) (9) where f is frequency and Y( f), X( f), and C( f) are Fourier transforms of y(t), x(t), and c(t), correspondingly. The Fourier transform is defined by N 1 X( f) = t=0 x(t)w t f (10) where W = e 2πi/N, i 2 = 1 and N is the transform length. However, by applying directly Formula (10), the computation does not diminish, because the actual transform will need more operations than the original time-domain convolution. There are many fast Fourier transform (FFT) algorithms. The decimation-infrequency (DIF) radix-2 algorithm flowchart is shown in Figure 2. When the transform is made with a FFT, the total amount of computation, including transforms and multiplications, can be less than with a direct time-domain convolution. Study the FFT flowchart and a single butterfly (Figure 3) of the radix-2 algorithm: it will help implementing the FFT. A typical implementation of the FFT contains three nested loops: examine the function fft() which is included with the template code. After the FFT has been performed, the data must be permuted into correct order, as explained in Appendix A. Outermost loop will loop over all the stages, shown horizontally in Figure 2. In this 32-point example, there are log 2 32 = 5 stages. The middle loop will count the number of butterfly groups. In the figure, there is one butterfly group in the first stage and 16 butterfly groups in the last stage. After each stage, the number of butterfly groups is doubled. The innermost loop loops over individual butterflies in a single butterfly group. After each stage, the number of butterflies in a single group is halved. Initially there are 16 butterflies per group, but in the last stage, there is just one butterfly in each butterfly group. Note that the figure represents only a 32-point transform: you need to use a longer transform, so the numbers will be different. 12

13 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS The inverse Fourier transform is defined by y(t) = 1 N N 1 Y(f)W t f. (11) f=0 This is almost same as the transform, but the exponent sign is negated and the result is multiplied by 1 N. The FFT can be used for computing also the inverse transform by replacing W by W 1 in Figure 3 and multiplying the result by 1 N. Q2.3 Implement the fast Fourier transform and the inverse transform using radix-2 decimation in frequency or the radix-2 decimation in time algorithm. Use transform length N 1, which you obtained in the registration. Remember to use binary shifts to calculate powers of 2. Change the compiler optimization levels. How many clock cycles the transforms need at each level? How many milliseconds? How many transforms can you perform between two successive audio frames? To verify that the FFT routine is working correctly, transform some known sequence (e.g. 1,2,3,... ) and compare the transform result to the correct result (you can compute the correct result with Matlab). You must implement the FFT by completing the code template. Therefore, you can not use directly FFT code from books or Internet, but you can look at them for helping your implementation work Interpolation and Decimation Interpolation means rising sampling frequency by an integer factor; in decimation the sampling frequency is lowered by an integer factor. In interpolation, rising the sampling frequency by F times is achieved by adding F 1 zero samples after each original sample. In decimation by factor F, one sample out of a group of F samples is saved and all other samples are discarded. Without proper filtering, interpolation and decimation will create aliasing or undesired frequencies, which will degrade the signal quality. This is shown in Figure 4. Therefore, antialiasing filters should be used to prevent this. After interpolation, the signal should be filtered with a low-pass filter which removes undesired high frequencies. When performing decimation, the filtering is done before dropping out samples and it should discard those high-frequencies, that can not be represented in the signal after the decimation. The convolution given in Equation (9) is cyclic, but we want to perform linear convolution of a long signal and a short filter. To achieve this, one can use the overlapsave algorithm. The principle is shown in Figure 5: the original signal is divided into blocks of N 1 samples. The filter with length N 2 is zero-padded to N 1 coefficients. Both are transformed, multiplied elementwise, and the result inverse transformed. 13

14 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS Stage 0 Stage 1 Group of butterflies Stage 4 Figure 2: 32-point decimation in time radix-2 fast Fourier transform algorithm flowchart. The resulting block contains N 2 1 samples of aliased signal due to cyclic convolution, but the last N 1 N samples correspond to linear convolution. For long signal, there should be one output sample for each input sample, and therefore the blocks in the input signal must overlap by N 2 1 samples. 14

15 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS a a+b b n ( a b)w n Figure 3: Butterfly of the radix-2 FFT. Energy Original signal F s / 2 Nyquist frequency F s Frequency Interpolation Decimation Energy Energy Aliasing Undesired frequencies Original signal Undesired frequencies F s / 2 Nyquist frequency F s Frequency Original signal F s / 2 F s Nyquist frequency Frequency Figure 4: Interpolation and decimation without filtering. Q2.4A Interpolate the sound signal coming from the sound card from 000 Hz to F khz (you obtained the interpolation factor F in the course registration). Modify the sine signal generation routine to generate the sine signal at sampling rate of F khz, and add the generated signal to the sound signal at the higher sampling rate. Then decimate the sound back to 000 Hz, so that it can be transmitted to the loudspeakers. Implement the filters necessary for interpolation and decimation using the fast Fourier transform with N 1 -point transform length and the overlap-save method. Use N 2 coefficients in the filters. For what sampling frequency the filters are designed, and what are the stopband and passband frequencies? Attatch the code/method that you used to get the coefficients (e. g. Matlab code) What frame length you decided to use, and why? How many FFT and IFFT operations are needed for each frame? How many clock cycles are needed per frame? 15

16 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS N 1 N 2 Block from signal Filter 0 FFT FFT Elementwise multiplications IFFT Aliased Filtered signal N 1 N 2 +1 ADC Figure 5: Overlap-save principle. Interpolate Decimate + khz F khz F khz khz DAC sine_gen() F khz Figure 6: Signal flowpath. The signal flowpath is presented in Figure 6, in which the signal comes from the A/D converter (ADC) and the processed signal goes to loudspeakers through the D/A converter (DAC). Remember again, that the operations are frame-based and must be performed to complete frames. Compute the filter coefficients with the optimal equiripple (Remez) method, or any other equivalent one. Use a suitable transition bandwidth, for example a few kilohertz. Appendix B gives an example which you can use as a guideline for implementing the overlap-save algorithm. Before writing any code, you should draw a 16

17 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS figure of your plan on paper (similar to Fig. 7). If you are unsure, it is recommended that you show the figure to the assistant and ask for acceptance before beginning implementation work. You must verify that your program is fast enough to process the incoming audio frames in real-time on the DSP. If the FFT function is too slow, you must optimize it. For example, the coefficients (powers of W) required in the FFT algorithm can be computed in the beginning of the program and stored into an array. The same can be done for the permuted indices. This will speed up the execution. However, before doing difficult optimizations, increase the compiler optimization level. Q2.4B In order to test the code, try first with all the filter coefficients equal to i in the frequency domain (Pass-all filter). What happens when the the generated signal frequency is 5000Hz instead of 300Hz or 1000Hz? What do you hear from the loudspeakers? Why do you hear it? (Remember that the sampling rate is now khz). Try then with the coefficients previously calculated in Matlab? What happens now? This exercise is a synthetic example, and in practice some things would be implemented differently. Q2.4C In the previous system, there were two input signals at different sampling rates combined into one signal. The necessary filters had 65 coefficients or less. How would you modify the system to combine two arbitrary signals at the given sampling rates more efficiently? How the filter operation could be made more efficient? How many clock cycles a time domain filtering would approximately take per frame? Assume that a MAC (multiply-accumulation) operation can be done in one clock cycle. Would it be possible to remove the filter after interpolation of before decimation? If so, why? 2.5 Interfacing Assembly Routines Many tasks can be done by using only the C language, without any knowledge about assembly. Modern C compilers can efficiently optimize wide variety of codes. However, knowledge of processor hardware and assembly will help writing C code which the compiler can easily optimize. There are also some operations, which can not be represented efficiently in C and writing directly assembly is necessary to achieve sufficient performance. 17

18 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS Q2.4 Write an assembly function to multiply two complex numbers (represented as a pair of single precision float-type values) and return the result. Code first a version with no pipelined input, where the instructions wait (add NOPs) for the previous one to complete. The function must be callable from C language. Explain how the function works including the effect of each instruction. Test the function and compute the times. The DSP board includes a lot of resources for computation. Several aritmetic units and multipliers can be used at the same time, pipelining the instructions and/or dispatching them at the same time. Q2.4 Specify now in your assembly function, different multiplication and aritmetic units and paralellize some instructions using the pipeline operator. Try to dispatch at the same time the operations that use different units. Be careful on waiting for the needed results before dispatching operations that need a result from a previous operation. Does the assembly routine improve the program speed compared to if it would have been written in C and compiled at high optimization level? What are the main reasons for the speed difference? Show in a table the computation times of the C multiplication with several optimization levels and the times of the two versions of the assembly function. The DSP programming tools include assembly optimizer which can rearrange instructions in linear assembly source code and fill automatically instruction delay slots. Do not use linear assembly in this exercise. You should insert your assembly code into file multiply.s62 in function multiply_asm, which is already included in the project. Note that you can not do this exercise with PC or workstation, as they have completely different assembly language compared to DSPs. The guidebook TMS320C6000 CPU and Instruction Set Reference Guide describes the necessary assembly instructions in Chapters 3 and 4. You must also take the instruction delay slots into account. Chapter in TMS320C6000 Optimizing Compiler User s Guide describes the interface between C and assembly. Pay special attention to code examples. To compare the speed between the assembly and the corresponding C code, you can use the complex multiplication function multiply_c() which is included in the given code template. Write a loop to multiply complex numbers a few thousand times and measure the loop execution time. The easiest method for measuring clock cycles is to use the debugger breakpoints and to select Profile Clock Enable and Profile Clock View from the Code Composer menu. You can use Mixed Source/Assembly mode to view the assembly code generated by the C compiler to compare it to the hand-written version (click mouse rightmost button on top of the 1

19 2.4 Interpolation and Decimation 2 EXERCISE ASSIGNMENTS code window, after the program has been loaded to the DSK). Also use register window to watch their values by selecting View CPU Registers Core Registers from the CCS menu. Click with the mouse rightmost button on the register display and select View Float from the menu. Q2.4 Integrate the Assembly multiplication in your previous code as a sustitute for multiply_c function. Re run the whole filtering code with the new assembly function 19

20 A BIT REVERSAL FOR FFT A. Bit Reversal for FFT The input data sequence is given in an array (or two arrays, for real and imaginary part) for the fast Fourier transform. The contents of this array must be permuted after FFT to obtain the correct result. The index to the array requires log 2 N 1 bits where N 1 is the FFT and array length. Each value in the array is swapped with another value, whose location is obtained by bit reversing the bits of the first value index. For example, the index into a 32-point transform array can be represented in five bits. The index 5 is in binary. When bit-reversed, it will become 10100, which is 20 in decimal. Thus, the values in indices 5 and 20 must be swapped. With longer transforms, there are more bits in the indices. Also, it must be taken care that each pair in the input array is swapped only once; if a pair would be swapped twice, the values would be in the original order after the permutation. The array can be permuted with the following pseudocode: loop for all locations in the data array let index be the current location let reversed_index be the corresponding location obtained with bit-reversal if the values in locations index and reversed_index have not yet been swapped, swap them now end of loop It is simple to check whether a value pair has been already swapped by comparing index and reversed_index. Alternatively two arrays can be used and the values copied from the first array into the second. In this case no check needs to be made. The bit reversal of an index can be represented with a pseudocode as follows: let index be the index which is to be bit-reversed set reversed_index to zero loop for all bits to reverse if the least significant bit in index is one, set the least significant bit in reversed_index to one shift index right by one bit position shift reversed_index left by one bit position end of loop 20

21 B THE OVERLAP-SAVE ALGORITHM: AN EXAMPLE B. The Overlap-Save Algorithm: An Example The DSP/BIOS gathers a sequence of incoming samples into frames. When a new frame is filled, the frame_full() function in called and the new frame is given to it as a parameter. The function must then process this frame and generate the next frame for output. For the question Q2.4A you have to interpolate, filter, add sine, filter again, and decimate the signal, where the filters are implemented with the overlap-save method. If the parameters were N 1 = 32 (block and FFT length), N 2 = 17 (filter length), and F = 2 (decimation factor), one possible implementation is shown in Figure 7. In this example both the input and output frame lengths are set to 16 samples. buffer1[16] src_sample[16] interpolated[32] 2 Original signal (new frame) fft_buffer[32] fft_buffer[32] buffer1[16] Filter blocks with FFT filtered1[32] Interpolated and filtered Add sine + buffer2[16] with_sine[32] fft_buffer[32] fft_buffer[32] buffer2[16] Filter blocks with FFT filtered2[32] 2 dst_sample[16] Filtered for decimation Final decimated signal (frame to output) Figure 7: Example of the overlap-save algorithm. Let us assume that the incoming signal is in array src_sample[16] (where the number in brackets denotes the array length in samples) when a new frame arrives and the audio() function is called. This array is interpolated by adding a zero after each sample and storing the result into another array interpolated[32]. This array is divided into blocks, which are filtered with the FFT. The blocks overlap with 16 samples. Since the incoming frames in src_sample[16] array never overlap, some of the blocks, which are transformed, must be obtained from two consecutive frames. Thus, the array buffer1[16] is necessary for storing the last 16 interpolated samples from the previous frame. The first block to be transformed with the FFT overlaps with the last 16 samples of the interpolated array from the previous frame and the first 16 samples from the newest frame. Therefore, the last 16 samples from the array must be saved into the array buffer1, from which they are read during the next frame. The samples to be transformed are copied into buffer fft_buffer[32]. This array is transformed and elements are then multiplied with the coefficients of the 21

22 B THE OVERLAP-SAVE ALGORITHM: AN EXAMPLE transformed filter. After inverse transform, the last 16 samples of the buffer hold the filtered samples. During each frame, two blocks are filtered, requiring two FFTs and two inverse FFTs (the filter can be transformed only once in the beginning of the program). In total, 32 filtered samples are obtained, which are copied into the array filtered1[32]. Only a single array needs to be allocated for the FFT, because the same array can be reused for all blocks. Next, the sine signal is added into the samples in the filtered1 array and the result is stored into array with_sine[32] (see also Figure 1). Since the sine signal might cause aliasing after decimation, the samples in the array have to be filtered. This is performed similarly as after the interpolation. In this case the samples from the previous frame are stored into array called buffer2[16]. The same fft_buffer can be again used. Two more FFTs and inverse FFTs are required, or in total per frame. The filtered samples, after each inverse FFT has been computed, are collected into filtered2[32] array, from which they are decimated into array dst_sample[16] by copying only every other sample. dst_sample[16] contains the final resulting samples, which are transmitted from the audio() function. When designing your algorithm, it is recommended that you first draw a sketch on paper, similar to the Figure 7. Try finding a frame length that is reasonably small and which makes the overall algorithm simple. You should initialize all necessary buffers with zeros in the beginning of the program (in the example, buffer1 and buffer2 would need to be initialized). There are several possible solutions, and the example given in this appendix is only for assistance. You are free to implement your algorithm in a different way, as long as it still uses the overlap-save method. 22

23 C DEBUGGING ON WORKSTATIONS C. Debugging on Workstations Developing and testing code on workstation computers instead of digital signal processors is usually easier, because workstations have better development tools and memory protection to aid debugging. Also, the number of DSK cards in the laboratory is limited, and it might be easier to find available UNIX workstations without the DSK. Developing DSP/BIOS code on UNIX workstations is made easier with the dsp_lab library ( S/dsp_lab.zip). It reads audio signal from a file on hard disk and writes the processed sound into another file. The library emulates some basic DSP/BIOS functions and datatypes which are necessary for completing the exercise work. The package also contains a test song and sine sounds at various frequencies. However, the final testing of the program has to be done on the DSP to ensure that the real-time and memory requirements are fulfilled and that the assembly functions are working. C.1. Functions in the code template CFG_TESTRUNS When running the program on workstation/pc, this macro defines how many frames are generated. Larger value processes longer piece of music, but execution time increases. This macro can be configured by modifying file device_fileio.c. COPY_BUFFER(src, src_start, dst, dst_start, len) This macro copies len values from the array src to array dst. The starting locations in the array are given by src_start and dst_start. If src or dst are arrays (and not just pointers to arrays), bounds checking is made. ZERO_BUFFER(dst, dst_start, len) This macro sets len values to zero in the dst array. If dst is an array (and not just a pointer to array), bounds checking is made. void init_audio(int bufsize) Initializes the A/D and D/A conversions and begins collecting samples into frames. After this function has been called, frame_full() will be called when the first frame is full. bufsize denotes the number of samples per frame. void halt_on_error(char *msg,...) Displays error message and halts program. When using the DSP, you should enable Message Log from the DSP/BIOS menu in the CCS to see any error messages. void switch_led(int state) Turns LED on (if state is nonzero) or off (if state is zero) on the DSP card. Can be used for debugging. When running on workstation/pc, turning LED on will print string <*> and turning it off will print <.>. 23

24 C.2 Debugging with Electric Fence C DEBUGGING ON WORKSTATIONS unsigned char *get_bitstring(int x, int b) Converts x into a bit string and returns the character string. b is the number of bits in the string. void cmul_c(float ar, float ai, float br, float bi, float *cr, float *ci) Multiply two complex numbers and return the result. ar and ai are real and imaginary parts of the first number, respectively, and br and bi are the parts of the second number. The result is written to variables pointed to by cr and ci. void fft_check_init(int length) Initializes FFT bug-checking function. Should be called in the beginning of the FFT-function. length is the FFT length. void fft_check_butterfly(int stage, int group, int bfly, int ai, int bi, int n) Checks if the calculated values are correct for the counters, array indices, and the W power. This function must be called each time inside the innermost loop, which calculates the butterfly. If some the values are incorrect, an error message is displayed and the program is halted. Use this function only for debugging because it is very slow. void slow_fft(float *src_re, float *src_im, float *dst_re, float *dst_im, int n) Perform an n-point Fourier transform. The input data real part is read from array pointed to be src_re, imaginary part is read from src_im. The transformed sequence is stored into arrays pointed to by dst_re and dst_im pointers. This function can not be used with the DSP (only on workstation). It is very slow and intended only for debugging. void slow_ifft(float *src_re, float *src_im, float *dst_re, float *dst_im, int n) Perform an n-point inverse Fourier transform. Similar to function slow_fft(), see above. C.2. Debugging with Electric Fence Many errors lead to accessing arrays beyond the end. Consider the following example: int i, my_array[10]; for (i=0; i<=10; i++) my_array[i] = 0; The loop writes one value beyond the end of the array, and as a result memory gets corrupted which may lead to odd behaviour. Electric Fence is a library which uses memory protection hardware to detect immediately bad memory accesses, including even reads. The library replaces malloc() function with its own version, which protects the memory after the allocated memory region. To detect the bad memory access in the above code, the array must be allocated with malloc(): 24

25 C.2 Debugging with Electric Fence C DEBUGGING ON WORKSTATIONS int i, *my_array; my_array = malloc(sizeof(*my_array) * 10); for (i=0; i<=10; i++) my_array[i] = 0; When this code is compiled, linked with Electric Fence, and ran, the program crashes: > gmake test./dsp_lab Electric Fence Copyright (C) Bruce Perens <bruce@perens.com> Copyright (C) Hayati Ayguen <hayati.ayguen@epost.de>, Procitec GmbH gmake: *** [run] Segmentation Fault To examine which line causes the problem, run the code under a debugger, for example ddd (Data Display Debugger) or gdb (GNU Debugger): > gdb./dsp_lab GNU gdb Copyright 2004 Free Software Foundation, Inc. (gdb) run Starting program: dsp_lab Electric Fence Copyright (C) Bruce Perens <bruce@perens.com> Copyright (C) Hayati Ayguen <hayati.ayguen@epost.de>, Procitec GmbH Program received signal SIGSEGV, Segmentation fault. 0x00011b6c in main () at dsp_lab.c:31 31 for (i=0; i<=10; i++) my_array[i] = 0; (gdb) display i 1: i = 10 (gdb) quit The debugger displays immediately in the above example that the line 31 in dsp_lab.c causes the segmentation fault. You can then display the value of the variable i and see that it points beyond the end of the array. You should remember that even if a code works on a workstation, it might nevertheless have errors which show up only on the DSP. If you test the code on big endian computers (for example, Sun Sparc), you must write code which also works on the C67x DSP, which is little endian by default. Therefore testing on the DSP is also necessary. For more information about Electric Fence, go to the homepage at 25

26 D DEBUGGING TECHNIQUES D. Debugging Techniques Look for warning messages For good code, the compiler should not display any warning messages. If it does, the program still gets compiled and you can run it. If you understand where the warning message comes from and know that it is harmless, you can ignore it. If you do not understand, you should examine the reason. Watch for invalid memory accesses Make sure that the program does not read from arrays before they are initialized, and even more importantly, that it does not write outside of arrays. C compiler does not do array bounds checking, but you can insert that manually into the code using if-statements or use Electric Fence. You should also use the macros COPY_BUFFER and ZERO_BUFFER in the utils.h file when possible. Divide and conquer Divide your code into small modules and test and debug them independently. For example, always verify first that complex number multiplication, sine generation, FFT, and IFFT work before combining them into interpolation and decimation routine. Verify that index permutation works before debugging whole FFT/IFFT function. Use debugger or print statements to view values With the debugger, you can examine variables and memory contents and run the program one line at a time. Alternatively, you can use LOG_printf() function to display variable values. Verify index calculations DSP algorithms are unique because they usually access data always in the same order. First verify that the memory accesses are into correct locations (for example, the ai and bi variables in the FFT). Use the function fft_check_butterfly() in the utils.h file to verify the FFT indices. Use simple data When the indices are correctly calculated, input some very simple data to the algorithm. The initial try should be full of zeros, which should also produce zeros in most cases. A good second try is a single nonzero number followed by zeros. Follow the propagation of the number in the code and do the same calculations by hand. Use random data 26

27 D DEBUGGING TECHNIQUES If it works for simple data, you should nevertheless verify the output also for more complicated data. You can use the array rand512 in the dsp_lab template which includes 512 random values between -10 and 10. Use Matlab Matlab has build-in commands for FFT and IFFT. Verify that your routine gives the same output for the same input as the Matlab functions. You could implement the algorithms also in Matlab. This would allow you to print intermediate results from the Matlab code and the C code and then see if they match. Run code on workstation computers The DSP has no memory protection and bugs in program may lead to confusing results. The compiler is relatively little tested. The debugger is slow to use, since it communicates via parallel cable. Therefore, debugging on a workstation is much easier. Memory protection discovers immediately most bad memory accesses and can even tell the exact location in the code. Debugging is faster and the tools are more reliable. Watch for memory usage If your algorithm works on workstation computer, but not on the DSP board, check the program memory usage. The DSP architecture limits the maximum data size of your program. In the small memory model, this is only 32 kilobytes. Even more important is the stack size limit, because if the stack overflows, you will get random crashes. 27

28 E TIPS E. Tips Check if the development computer, that you are using, has additional instructions attached on top of it. If the Code Composer Studio or the DSK start behaving incorrectly, try closing CCS and switching the power off from the DSK for a while (this may take several minutes). Try also lifting the lid and pressing the reset button on the board. Computer programs should be also used for computing filter coefficients. See help for Matlab functions filter, freqz, fft, ifft, and filtdemo (or eqfir and fft in Scilab). The samples are initially 16-bit signed integer numbers from the A/Dconverter. Convert these to floating point, and keep them as floating point values during all signal processing to avoid rounding errors. Convert the samples only once, at the end, back to 16-bit integers. To transfer filter coefficients from Matlab into C-program, on UNIX systems you can use the following commands: 1. Save column matrix containing the coefficients into file in Matlab: save coeff.txt coeff -ascii 2. Add commas after each line in UNIX shell: sed s/$/,/g <coeff.txt >coeff.c 3. Copy and paste the coefficients into your C-program. The DSP has very small stack, by default only one kilobyte. Do not define large arrays that are allocated from stack. If you define large arrays in the beginning of a function, define them static or enlarge the stack. If the stack overflows, it will cause random crashes. Do not use malloc() when working with the DSK-board: it requires special memory setup. Use malloc() only when debugging with Electric Fence. Use different names for different variables, even when the variables are local to different functions. Using same variable names may confuse the CCS debugger. 2